universal-physics-tensor 0.5.1 → 0.7.0

package/dist/dimensional/gauge-field.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Gauge-field AST primitives for Wheeler-Feynman absorber-theory
+ * time-symmetric electrodynamics.
+ *
+ * Wheeler-Feynman absorber theory (Wheeler & Feynman 1945
+ * Rev. Mod. Phys. 17:157; Wheeler & Feynman 1949
+ * Rev. Mod. Phys. 21:425) uses TIME-SYMMETRIC electrodynamics:
+ * radiation reaction arises from the half-retarded +
+ * half-advanced potential combination
+ *
+ *   A_μ(x) = (1/2) [A_μ^ret(x) + A_μ^adv(x)].
+ *
+ * Under the absorber boundary condition (every emitted disturbance
+ * is fully absorbed by future matter), this symmetric form is
+ * physically equivalent to retarded-only Maxwell.
+ *
+ * Two primitives are provided:
+ *
+ *   1. `GaugeFieldNode` — tags an EM gauge field with its
+ *      "arrow of time": retarded (Liénard-Wiechert advanced
+ *      Green's function), advanced (retarded Green's function
+ *      — past-directed), or symmetric (half-half combination).
+ *      The consumer supplies the dimension (SI: V·s/m =
+ *      { L:1, M:1, T:-2, I:-1 }) or works with the ratio which
+ *      is dimensionless.
+ *
+ *   2. `TimeSymmetryPredicateNode` — asserts that the
+ *      dimensionless time-symmetry residual
+ *      |A_ret − A_adv| / |A_ret + A_adv| is bounded by ε.
+ *      Identically 0 under the absorber boundary condition.
+ *      This is a PREDICATE node (like `EinsteinFieldEquationNode`)
+ *      — not a value-producing expression.
+ *
+ * Phase 1 demonstrator pattern: follows
+ * `src/dimensional/klein-gordon-equation.ts` (field-equation-helpers
+ * pattern, Phase 1 of TensorEquationNode generalization).
+ *
+ * @see docs/architecture/v0.7-be-x-reencoding-design-note.md §BE-50
+ * @see src/bridges/equations/be-50-wheeler-feynman.ts
+ * @module dimensional/gauge-field
+ */
+import type { Dimension } from './types.js';
+/**
+ * Arrow-of-time tag for an electromagnetic gauge potential.
+ *
+ * - `'retarded'`  — propagator uses the retarded Green's function
+ *   (∝ Liénard-Wiechert advanced solution); causal, future-directed.
+ * - `'advanced'`  — propagator uses the advanced Green's function
+ *   (∝ Liénard-Wiechert retarded solution); anti-causal, past-directed.
+ * - `'symmetric'` — half-retarded + half-advanced combination
+ *   (Wheeler-Feynman's A_μ = (1/2)[A_μ^ret + A_μ^adv]).
+ *
+ * @public
+ */
+export type ArrowOfTime = 'retarded' | 'advanced' | 'symmetric';
+/**
+ * AST node for an electromagnetic gauge potential A_μ with an explicit
+ * arrow-of-time tag.
+ *
+ * The `dim` field carries the SI dimension of the gauge field. For the
+ * Wheeler-Feynman time-symmetry ratio, the dimension of the numerator
+ * and denominator cancel, yielding a dimensionless result — but the
+ * `dim` field is required so the validator can confirm that both the
+ * retarded and advanced fields in a `TimeSymmetryPredicateNode` share
+ * the same dimension (the ratio is well-defined only if they do).
+ *
+ * Canonical SI dim of the magnetic vector potential A_μ:
+ *   [A] = V·s/m = kg·m/(A·s²) = { L: 1, M: 1, T: -2, I: -1 }
+ *
+ * @public
+ */
+export interface GaugeFieldNode {
+    /** Discriminator: `'gauge-field'`. */
+    readonly kind: 'gauge-field';
+    /** Human-readable field name (e.g., `'A_ret'`, `'A_adv'`, `'A_mu'`). */
+    readonly name: string;
+    /**
+     * Arrow-of-time tag. Documents whether this field was computed using
+     * the retarded Green's function, the advanced Green's function, or
+     * the symmetric half-half combination.
+     */
+    readonly arrowOfTime: ArrowOfTime;
+    /**
+     * SI dimension of the gauge field. Both retarded and advanced fields
+     * must share the same dimension for the time-symmetry ratio to be
+     * well-defined (dimensionless by cancellation).
+     */
+    readonly dim: Dimension;
+}
+/**
+ * AST predicate node for the Wheeler-Feynman time-symmetry condition.
+ *
+ * Asserts that the dimensionless time-symmetry residual
+ *
+ *   |A_ret − A_adv| / |A_ret + A_adv| ≤ ε
+ *
+ * is bounded by `epsilon`. Under the absorber boundary condition
+ * (Wheeler & Feynman 1945), this residual is identically 0 on
+ * physical states. A non-zero `epsilon` documents the allowable
+ * deviation (e.g., a Cramer 1986 experimental bound of 10⁻²).
+ *
+ * This is a PREDICATE node (like `EinsteinFieldEquationNode`) —
+ * not a value-producing expression. Numerical evaluation of the
+ * residual for specific field amplitudes is handled separately by
+ * `evaluateWFTimeSymmetry` in `src/bridges/equations/be-50-wheeler-feynman.ts`.
+ *
+ * @public
+ */
+export interface TimeSymmetryPredicateNode {
+    /** Discriminator: `'time-symmetry-predicate'`. */
+    readonly kind: 'time-symmetry-predicate';
+    /**
+     * The retarded gauge potential A_μ^ret.
+     * Must have `arrowOfTime: 'retarded'`.
+     */
+    readonly retarded: GaugeFieldNode;
+    /**
+     * The advanced gauge potential A_μ^adv.
+     * Must have `arrowOfTime: 'advanced'`.
+     */
+    readonly advanced: GaugeFieldNode;
+    /**
+     * Bound on the time-symmetry residual: |A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.
+     * Must be strictly positive and finite.
+     * Set to a small value (e.g., 1e-3) to encode an experimental bound,
+     * or to `Number.EPSILON` to assert near-exact absorber-theory symmetry.
+     */
+    readonly epsilon: number;
+}
+/**
+ * Validate a `GaugeFieldNode`.
+ *
+ * Three predicates:
+ *   1. `name` must be a non-empty string.
+ *   2. `arrowOfTime` must be one of `'retarded'`, `'advanced'`, `'symmetric'`.
+ *   3. `dim` must be a valid `Dimension` object (all 7 SI exponents present
+ *      as finite numbers).
+ *
+ * Throws `Error` with `'gauge-field'` in the message on any failure.
+ *
+ * @public
+ */
+export declare function validateGaugeField(node: GaugeFieldNode): void;
+/**
+ * Result of validating a `TimeSymmetryPredicateNode`.
+ *
+ * @public
+ */
+export interface TimeSymmetryPredicateValidationResult {
+    /**
+     * The shared dimension of the retarded and advanced gauge fields.
+     * The ratio |A_ret − A_adv| / |A_ret + A_adv| is dimensionless
+     * because this dimension cancels.
+     */
+    readonly fieldDim: Dimension;
+    /** The validated epsilon bound (> 0, finite). */
+    readonly epsilon: number;
+}
+/**
+ * Validate a `TimeSymmetryPredicateNode`.
+ *
+ * Four predicates (following the field-equation-helpers pattern):
+ *
+ *   1. **Arrow-of-time tags** — `retarded.arrowOfTime` must be
+ *      `'retarded'`; `advanced.arrowOfTime` must be `'advanced'`.
+ *   2. **Per-field validity** — both `GaugeFieldNode`s pass
+ *      `validateGaugeField`.
+ *   3. **Dimension equality** — `retarded.dim` and `advanced.dim`
+ *      must match (so the ratio is dimensionless by cancellation).
+ *      Uses `validateComponentDimension` from field-equation-helpers.
+ *   4. **Epsilon bound** — `epsilon` must be strictly positive and
+ *      finite (`epsilon > 0` and `Number.isFinite(epsilon)`).
+ *
+ * Error messages contain `'symmetry'` for arrow-of-time mismatches
+ * and `'dimension'` for dim-equality failures (error-keyword
+ * discipline shared with EinsteinFieldEquationNode and
+ * KleinGordonEquationNode).
+ *
+ * @public
+ */
+export declare function validateTimeSymmetryPredicate(node: TimeSymmetryPredicateNode): TimeSymmetryPredicateValidationResult;
+//# sourceMappingURL=gauge-field.d.ts.map

package/dist/dimensional/gauge-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gauge-field.d.ts","sourceRoot":"","sources":["../../src/dimensional/gauge-field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,yBAAyB;IACxC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CA0B7D;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,yBAAyB,GAC9B,qCAAqC,CAkDvC"}

package/dist/dimensional/gauge-field.js

@@ -0,0 +1,134 @@
+/**
+ * Gauge-field AST primitives for Wheeler-Feynman absorber-theory
+ * time-symmetric electrodynamics.
+ *
+ * Wheeler-Feynman absorber theory (Wheeler & Feynman 1945
+ * Rev. Mod. Phys. 17:157; Wheeler & Feynman 1949
+ * Rev. Mod. Phys. 21:425) uses TIME-SYMMETRIC electrodynamics:
+ * radiation reaction arises from the half-retarded +
+ * half-advanced potential combination
+ *
+ *   A_μ(x) = (1/2) [A_μ^ret(x) + A_μ^adv(x)].
+ *
+ * Under the absorber boundary condition (every emitted disturbance
+ * is fully absorbed by future matter), this symmetric form is
+ * physically equivalent to retarded-only Maxwell.
+ *
+ * Two primitives are provided:
+ *
+ *   1. `GaugeFieldNode` — tags an EM gauge field with its
+ *      "arrow of time": retarded (Liénard-Wiechert advanced
+ *      Green's function), advanced (retarded Green's function
+ *      — past-directed), or symmetric (half-half combination).
+ *      The consumer supplies the dimension (SI: V·s/m =
+ *      { L:1, M:1, T:-2, I:-1 }) or works with the ratio which
+ *      is dimensionless.
+ *
+ *   2. `TimeSymmetryPredicateNode` — asserts that the
+ *      dimensionless time-symmetry residual
+ *      |A_ret − A_adv| / |A_ret + A_adv| is bounded by ε.
+ *      Identically 0 under the absorber boundary condition.
+ *      This is a PREDICATE node (like `EinsteinFieldEquationNode`)
+ *      — not a value-producing expression.
+ *
+ * Phase 1 demonstrator pattern: follows
+ * `src/dimensional/klein-gordon-equation.ts` (field-equation-helpers
+ * pattern, Phase 1 of TensorEquationNode generalization).
+ *
+ * @see docs/architecture/v0.7-be-x-reencoding-design-note.md §BE-50
+ * @see src/bridges/equations/be-50-wheeler-feynman.ts
+ * @module dimensional/gauge-field
+ */
+import { validateComponentDimension } from './field-equation-helpers.js';
+// ---------------------------------------------------------------------------
+// Validators
+// ---------------------------------------------------------------------------
+/**
+ * Validate a `GaugeFieldNode`.
+ *
+ * Three predicates:
+ *   1. `name` must be a non-empty string.
+ *   2. `arrowOfTime` must be one of `'retarded'`, `'advanced'`, `'symmetric'`.
+ *   3. `dim` must be a valid `Dimension` object (all 7 SI exponents present
+ *      as finite numbers).
+ *
+ * Throws `Error` with `'gauge-field'` in the message on any failure.
+ *
+ * @public
+ */
+export function validateGaugeField(node) {
+    if (typeof node.name !== 'string' || node.name.trim().length === 0) {
+        throw new Error(`GaugeFieldNode: gauge-field name must be a non-empty string ` +
+            `(got ${JSON.stringify(node.name)}).`);
+    }
+    const validArrows = ['retarded', 'advanced', 'symmetric'];
+    if (!validArrows.includes(node.arrowOfTime)) {
+        throw new Error(`GaugeFieldNode: gauge-field arrowOfTime must be 'retarded', 'advanced', ` +
+            `or 'symmetric' (got ${JSON.stringify(node.arrowOfTime)}).`);
+    }
+    const dim = node.dim;
+    const axes = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'];
+    for (const ax of axes) {
+        if (typeof dim[ax] !== 'number' || !Number.isFinite(dim[ax])) {
+            throw new Error(`GaugeFieldNode: gauge-field dim.${ax} must be a finite number ` +
+                `(got ${JSON.stringify(dim[ax])} for field '${node.name}').`);
+        }
+    }
+}
+/**
+ * Validate a `TimeSymmetryPredicateNode`.
+ *
+ * Four predicates (following the field-equation-helpers pattern):
+ *
+ *   1. **Arrow-of-time tags** — `retarded.arrowOfTime` must be
+ *      `'retarded'`; `advanced.arrowOfTime` must be `'advanced'`.
+ *   2. **Per-field validity** — both `GaugeFieldNode`s pass
+ *      `validateGaugeField`.
+ *   3. **Dimension equality** — `retarded.dim` and `advanced.dim`
+ *      must match (so the ratio is dimensionless by cancellation).
+ *      Uses `validateComponentDimension` from field-equation-helpers.
+ *   4. **Epsilon bound** — `epsilon` must be strictly positive and
+ *      finite (`epsilon > 0` and `Number.isFinite(epsilon)`).
+ *
+ * Error messages contain `'symmetry'` for arrow-of-time mismatches
+ * and `'dimension'` for dim-equality failures (error-keyword
+ * discipline shared with EinsteinFieldEquationNode and
+ * KleinGordonEquationNode).
+ *
+ * @public
+ */
+export function validateTimeSymmetryPredicate(node) {
+    // Predicate 1a: retarded field's arrow-of-time must be 'retarded'.
+    if (node.retarded.arrowOfTime !== 'retarded') {
+        throw new Error(`TimeSymmetryPredicateNode: symmetry mismatch — retarded field ` +
+            `'${node.retarded.name}' must have arrowOfTime: 'retarded' ` +
+            `(got '${node.retarded.arrowOfTime}'). The time-symmetry predicate ` +
+            `requires A_ret to carry the retarded arrow-of-time tag.`);
+    }
+    // Predicate 1b: advanced field's arrow-of-time must be 'advanced'.
+    if (node.advanced.arrowOfTime !== 'advanced') {
+        throw new Error(`TimeSymmetryPredicateNode: symmetry mismatch — advanced field ` +
+            `'${node.advanced.name}' must have arrowOfTime: 'advanced' ` +
+            `(got '${node.advanced.arrowOfTime}'). The time-symmetry predicate ` +
+            `requires A_adv to carry the advanced arrow-of-time tag.`);
+    }
+    // Predicate 2: both GaugeFieldNodes pass individual validation.
+    validateGaugeField(node.retarded);
+    validateGaugeField(node.advanced);
+    // Predicate 3: retarded.dim and advanced.dim must match.
+    // Uses validateComponentDimension from field-equation-helpers — same
+    // helper used by KleinGordonEquationNode and EinsteinFieldEquationNode.
+    validateComponentDimension('TimeSymmetryPredicateNode', `advanced field '${node.advanced.name}' dim`, node.advanced.dim, node.retarded.dim, `A_ret and A_adv must share the same dimension so that the ratio ` +
+        `|A_ret − A_adv| / |A_ret + A_adv| is dimensionless by cancellation.`);
+    // Predicate 4: epsilon must be strictly positive and finite.
+    if (!Number.isFinite(node.epsilon) || node.epsilon <= 0) {
+        throw new Error(`TimeSymmetryPredicateNode: epsilon must be a strictly positive finite ` +
+            `number (got ${node.epsilon}). epsilon bounds the time-symmetry residual ` +
+            `|A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.`);
+    }
+    return {
+        fieldDim: node.retarded.dim,
+        epsilon: node.epsilon,
+    };
+}
+//# sourceMappingURL=gauge-field.js.map

package/dist/dimensional/gauge-field.js.map

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

package/dist/dimensional/killing-validators.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Killing-vector machinery (v0.6.0 Phase 1, Tasks 1.1–1.2).
+ *
+ * A Killing vector ξ^μ generates an isometry of the metric. The defining
+ * equation is the Killing equation
+ *
+ *     ∇_μ ξ_ν + ∇_ν ξ_μ = 0
+ *
+ * (Carroll Eq. 3.174). Validation here is symbolic (rank + variance only);
+ * the operator-valued check happens at lowering time in
+ * `src/numerical/killing.ts::verifyKillingEquation`.
+ *
+ * @module dimensional/killing-validators
+ */
+import type { Dimension } from './types.js';
+import type { TensorSymbolNode } from './tensor.js';
+import type { MetricTensorNode } from './metric-validators.js';
+/**
+ * AST node for a Killing vector ξ^μ. Rank-1 upper-variance tensor with
+ * an attached metric reference (the metric whose isometry ξ generates).
+ *
+ * Component-dim is free (typically `[L·T⁻¹]` for spatial Killing fields,
+ * dimensionless for time-translation if c=1 normalization, or `[L]` for
+ * dimensionally-pure spatial isometries).
+ *
+ * @public
+ */
+export interface KillingVectorNode {
+    readonly kind: 'killing-vector';
+    readonly vector: TensorSymbolNode;
+    readonly metric: MetricTensorNode;
+}
+interface KillingVectorValidationResult {
+    readonly dim: Dimension;
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * Validate a `killing-vector` node.
+ *
+ * Throws:
+ *   - Error if vector is not rank-1 (Killing fields are rank-1 by definition).
+ *   - Error if vector variance is not 'upper' (canonical Killing form is upper;
+ *     lower form is obtained by metric-lowering at lowering-time).
+ */
+export declare function validateKillingVector(node: KillingVectorNode): KillingVectorValidationResult;
+/**
+ * AST node for the conserved charge Q = ξ^μ p_μ along a geodesic
+ * (Carroll Eq. 3.175).
+ *
+ * **Sign convention**: the node encodes the raw contraction `ξ^μ p_μ`.
+ * In (-,+,+,+) signature with the timelike Killing vector ξ^μ_t = (1,0,0,0),
+ * `p_t < 0` for forward-time motion of massive particles, so the "physical
+ * energy" of common usage is `E = -Q` (Carroll Eq. 8.30). The PC-1.5
+ * diagnostic uses magnitude `|ΔQ / Q|` to be sign-agnostic.
+ *
+ * @public
+ */
+export interface ConservedChargeNode {
+    readonly kind: 'conserved-charge';
+    /** The Killing vector ξ^μ (rank-1, upper variance). */
+    readonly killing: KillingVectorNode;
+    /**
+     * The covariant momentum p_μ (rank-1, lower variance). Must have the same
+     * index label as `killing.vector` so that the contraction ξ^μ p_μ is
+     * well-formed.
+     */
+    readonly momentum: TensorSymbolNode;
+}
+interface ConservedChargeValidationResult {
+    readonly dim: Dimension;
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * Validate a `conserved-charge` node.
+ *
+ * Throws:
+ *   - Error if momentum is not rank-1.
+ *   - Error if the Killing-vector index label does not match the momentum
+ *     index label (they must contract on the same label).
+ *   - Error if momentum variance is not 'lower' (Q = ξ^μ p_μ requires the
+ *     upper Killing field to contract with the lower momentum).
+ *
+ * Returns a scalar result (empty freeIndices) with dimension
+ * `dim(ξ) × dim(p)` via the `multiply` algebra helper.
+ */
+export declare function validateConservedCharge(node: ConservedChargeNode): ConservedChargeValidationResult;
+export {};
+//# sourceMappingURL=killing-validators.d.ts.map

package/dist/dimensional/killing-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"killing-validators.d.ts","sourceRoot":"","sources":["../../src/dimensional/killing-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC;AAGD,UAAU,6BAA6B;IACrC,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,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,GACtB,6BAA6B,CAe/B;AAMD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;CACrC;AAGD,UAAU,+BAA+B;IACvC,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;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,GACxB,+BAA+B,CAsBjC"}

package/dist/dimensional/killing-validators.js

@@ -0,0 +1,66 @@
+/**
+ * Killing-vector machinery (v0.6.0 Phase 1, Tasks 1.1–1.2).
+ *
+ * A Killing vector ξ^μ generates an isometry of the metric. The defining
+ * equation is the Killing equation
+ *
+ *     ∇_μ ξ_ν + ∇_ν ξ_μ = 0
+ *
+ * (Carroll Eq. 3.174). Validation here is symbolic (rank + variance only);
+ * the operator-valued check happens at lowering time in
+ * `src/numerical/killing.ts::verifyKillingEquation`.
+ *
+ * @module dimensional/killing-validators
+ */
+import { multiply } from './algebra.js';
+/**
+ * Validate a `killing-vector` node.
+ *
+ * Throws:
+ *   - Error if vector is not rank-1 (Killing fields are rank-1 by definition).
+ *   - Error if vector variance is not 'upper' (canonical Killing form is upper;
+ *     lower form is obtained by metric-lowering at lowering-time).
+ */
+export function validateKillingVector(node) {
+    if (node.vector.indices.length !== 1) {
+        throw new Error(`KillingVectorNode: expected rank-1 vector, got rank-${node.vector.indices.length}`);
+    }
+    const idx = node.vector.indices[0];
+    if (idx.variance !== 'upper') {
+        throw new Error(`KillingVectorNode: expected upper variance, got '${idx.variance}'`);
+    }
+    const freeIndices = new Map();
+    freeIndices.set(idx.label, { upper: 1, lower: 0 });
+    return { dim: node.vector.dim, freeIndices };
+}
+/**
+ * Validate a `conserved-charge` node.
+ *
+ * Throws:
+ *   - Error if momentum is not rank-1.
+ *   - Error if the Killing-vector index label does not match the momentum
+ *     index label (they must contract on the same label).
+ *   - Error if momentum variance is not 'lower' (Q = ξ^μ p_μ requires the
+ *     upper Killing field to contract with the lower momentum).
+ *
+ * Returns a scalar result (empty freeIndices) with dimension
+ * `dim(ξ) × dim(p)` via the `multiply` algebra helper.
+ */
+export function validateConservedCharge(node) {
+    if (node.momentum.indices.length !== 1) {
+        throw new Error(`ConservedChargeNode: expected rank-1 momentum, got rank-${node.momentum.indices.length}`);
+    }
+    const xiLabel = node.killing.vector.indices[0].label;
+    const pLabel = node.momentum.indices[0].label;
+    if (xiLabel !== pLabel) {
+        throw new Error(`ConservedChargeNode: index label mismatch — Killing '${xiLabel}' vs momentum '${pLabel}'`);
+    }
+    if (node.momentum.indices[0].variance !== 'lower') {
+        throw new Error(`ConservedChargeNode: momentum must have lower variance to contract with upper Killing field`);
+    }
+    // dim(Q) = dim(ξ) × dim(p)
+    const dim = multiply(node.killing.vector.dim, node.momentum.dim);
+    // Q = ξ^μ p_μ is a full contraction — no free indices remain (scalar).
+    return { dim, freeIndices: new Map() };
+}
+//# sourceMappingURL=killing-validators.js.map

package/dist/dimensional/killing-validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"killing-validators.js","sourceRoot":"","sources":["../../src/dimensional/killing-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAwBxC;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAuB;IAEvB,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CACb,uDAAuD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACnC,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,oDAAoD,GAAG,CAAC,QAAQ,GAAG,CACpE,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4C,CAAC;IACxE,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IACnD,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC;AAC/C,CAAC;AAoCD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAyB;IAEzB,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,2DAA2D,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,CAC1F,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACrD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC9C,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CACb,wDAAwD,OAAO,kBAAkB,MAAM,GAAG,CAC3F,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,6FAA6F,CAC9F,CAAC;IACJ,CAAC;IACD,2BAA2B;IAC3B,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACjE,uEAAuE;IACvE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;AACzC,CAAC"}

package/dist/dimensional/klein-gordon-equation.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 type { Dimension } from './types.js';
+/**
+ * Scalar field node — a typed wrapper around a rank-0 (scalar) AST
+ * value with explicit dimension + symmetry markers. Minimal so the
+ * Klein-Gordon predicate validator can check shape without
+ * recursing into the field's internal AST.
+ *
+ * @public
+ */
+export interface ScalarFieldNode {
+    /** Discriminator: 'scalar-field'. */
+    readonly kind: 'scalar-field';
+    /** Human-readable field name (e.g., 'phi', 'sigma'). */
+    readonly name: string;
+    /** SI dimension of the scalar field value. */
+    readonly dim: Dimension;
+    /** Symmetry tag — 'scalar' for un-indexed scalar fields. */
+    readonly symmetry: 'scalar';
+}
+/**
+ * AST node for `(□ + m²) φ = J`.
+ *
+ * Fields:
+ *   - `field`       — φ (ScalarFieldNode). The free field whose
+ *                     dynamics this equation pins.
+ *   - `mass`        — m² (scalar with dim [L^-2]). Required.
+ *   - `source`      — J (ScalarFieldNode | null). Null for the
+ *                     homogeneous Klein-Gordon (free-field) form.
+ *   - `coupling`    — tag 'klein-gordon' (no inline numeric).
+ *
+ * Per-component dim of every term: `[field.dim · L^-2]` (the wave
+ * operator + mass term + source all share this composite dimension).
+ *
+ * @public
+ */
+export interface KleinGordonEquationNode {
+    readonly kind: 'klein-gordon-equation';
+    readonly field: ScalarFieldNode;
+    readonly mass: ScalarFieldNode;
+    readonly source: ScalarFieldNode | null;
+    readonly coupling: 'klein-gordon';
+}
+/**
+ * Result of validating a `KleinGordonEquationNode`. Mirrors
+ * `EinsteinFieldEquationValidationResult` shape.
+ *
+ * @public
+ */
+export interface KleinGordonEquationValidationResult {
+    /** Composite per-component dim: `[field.dim · L^-2]`. */
+    readonly dim: Dimension;
+    /** Empty free-indices map (rank-0 equation). */
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * 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 declare function validateKleinGordonEquation(node: KleinGordonEquationNode): KleinGordonEquationValidationResult;
+//# sourceMappingURL=klein-gordon-equation.d.ts.map

package/dist/dimensional/klein-gordon-equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"klein-gordon-equation.d.ts","sourceRoot":"","sources":["../../src/dimensional/klein-gordon-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mCAAmC;IAClD,yDAAyD;IACzD,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;CACrE;AAsBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,uBAAuB,GAC5B,mCAAmC,CAgErC"}