@stevenvo780/st-lang 4.11.0 → 4.12.0

package/dist/reasoning/constructive-analysis/cauchy.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Constructive Cauchy sequences with explicit modulus of convergence.
+ *
+ * In Bishop's school, a "Cauchy sequence" without a modulus is not enough
+ * data to extract a limit constructively — one needs an explicit
+ * `modulus(eps)` returning an index N(eps) such that
+ *   for all m, n >= N(eps), |x_m - x_n| < eps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cauchyFrom = exports.limit = exports.isCauchy = void 0;
+const constructive_reals_1 = require("../constructive-reals");
+/**
+ * Sound (one-sided) check: returns true if the modulus genuinely
+ * witnesses Cauchy-ness at precision `eps` for the first few terms.
+ *
+ * Constructively we cannot inspect "all m, n >= N" — we sample a window
+ * and verify the bound holds. If the modulus is correct this will
+ * return true; if it is a counterexample for some sampled pair, false.
+ *
+ * `sampleWindow` controls how many terms past N we inspect. Default 8
+ * is enough to expose almost all wrong moduli.
+ */
+const isCauchy = (seq, epsPrecision, sampleWindow = 8) => {
+    if (!Number.isInteger(epsPrecision) || epsPrecision <= 0) {
+        throw new RangeError('[cauchy] epsPrecision must be a positive integer');
+    }
+    const N = seq.modulus(epsPrecision);
+    if (!Number.isInteger(N) || N < 0)
+        return false;
+    for (let i = 0; i <= sampleWindow; i++) {
+        for (let j = i + 1; j <= sampleWindow; j++) {
+            const diff = (0, constructive_reals_1.abs)((0, constructive_reals_1.sub)(seq.approx(N + i), seq.approx(N + j)));
+            // We want diff < 1/eps. Pick precision p such that
+            // approxLT(diff, 1/eps, p) is sensitive enough. p = 4 * eps works.
+            if (!(0, constructive_reals_1.approxLT)(diff, (0, constructive_reals_1.fromFloat)(1 / epsPrecision), 4 * epsPrecision)) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+exports.isCauchy = isCauchy;
+/**
+ * Limit of a Cauchy sequence with modulus.
+ *
+ * `bits` (the CReal precision argument) is the number of binary fractional
+ * bits required. We need |limit - approx| < 2^{-bits}.
+ *
+ * Strategy: find index N such that the N-th term x_N is within 2^{-(bits+1)}
+ * of the true limit. By the triangle inequality, evaluating x_N at (bits+1)
+ * binary bits gives a result within 2^{-bits} of the limit.
+ *
+ * The modulus(eps) guarantees |x_m - x_n| < 1/eps for m,n >= N(eps).
+ * We need 1/eps <= 2^{-(bits+1)}, so eps >= 2^{bits+1}.
+ */
+const limit = (seq) => ({
+    approx: (bits) => {
+        if (!Number.isInteger(bits) || bits <= 0) {
+            throw new RangeError('[cauchy.limit] precision must be a positive integer');
+        }
+        const eps = Math.pow(2, bits + 1);
+        const N = seq.modulus(eps);
+        return seq.approx(N).approx(bits + 1);
+    }
+});
+exports.limit = limit;
+/**
+ * Convenience: builds a Cauchy seq from a generator + a known rate `1/f(eps)`.
+ * `f(eps)` must return an integer N with |x_m - x_n| < 1/eps for m, n >= N.
+ */
+const cauchyFrom = (term, modulus) => ({
+    approx: term,
+    modulus
+});
+exports.cauchyFrom = cauchyFrom;
+//# sourceMappingURL=cauchy.js.map

package/dist/reasoning/constructive-analysis/cauchy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cauchy.js","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/cauchy.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,8DAAkF;AAalF;;;;;;;;;;GAUG;AACI,MAAM,QAAQ,GAAG,CACtB,GAA0B,EAC1B,YAAoB,EACpB,YAAY,GAAG,CAAC,EACP,EAAE;IACX,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,UAAU,CAAC,kDAAkD,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAChD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,IAAA,wBAAG,EAAC,IAAA,wBAAG,EAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,mDAAmD;YACnD,mEAAmE;YACnE,IAAI,CAAC,IAAA,6BAAQ,EAAC,IAAI,EAAE,IAAA,8BAAS,EAAC,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC;gBACnE,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AArBW,QAAA,QAAQ,YAqBnB;AAEF;;;;;;;;;;;;GAYG;AACI,MAAM,KAAK,GAAG,CAAC,GAA0B,EAAS,EAAE,CAAC,CAAC;IAC3D,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;QACvB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,UAAU,CAAC,qDAAqD,CAAC,CAAC;QAC9E,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC;QAClC,MAAM,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC3B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IACxC,CAAC;CACF,CAAC,CAAC;AATU,QAAA,KAAK,SASf;AAEH;;;GAGG;AACI,MAAM,UAAU,GAAG,CACxB,IAA0B,EAC1B,OAAgC,EACT,EAAE,CAAC,CAAC;IAC3B,MAAM,EAAE,IAAI;IACZ,OAAO;CACR,CAAC,CAAC;AANU,QAAA,UAAU,cAMpB"}

package/dist/reasoning/constructive-analysis/compact.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Constructive Heine-Borel: every covering of a compact interval [a, b]
+ * by open rational intervals has a finite subcover.
+ *
+ * Bishop's proof is fully constructive: enumerate the cover, and use
+ * uniform continuity of the indicator-as-membership predicate via the
+ * Lebesgue number lemma. We give a direct algorithmic version: walk
+ * from `a` to `b` taking the rightmost reachable endpoint of any
+ * interval that contains the current frontier; if we can always
+ * advance, we accept; if we get stuck, we reject.
+ *
+ * The intervals are pairs `[lo, hi]` of CReals; the cover is "open" in
+ * the sense `lo < x < hi` (we work with the open interior).
+ */
+import { type CReal } from '../constructive-reals';
+export interface ConstructiveOpenCover {
+    intervals: ReadonlyArray<readonly [CReal, CReal]>;
+}
+/**
+ * Returns true if `cover` constructively covers `[a, b]` and the algorithm
+ * found a finite subcover (which in this case is just a subset of the
+ * given finite list, so trivially finite — the question is whether the
+ * cover suffices).
+ *
+ * Approach: scan with a frontier `x` initialized to `a`. At each step we
+ * search for an interval `(lo, hi)` with `lo < x < hi` (or `lo < x` and
+ * `x <= a + tol` at the start) and advance `x := hi`. If we reach
+ * `x >= b`, we accept. If we cannot advance, we reject.
+ *
+ * `tol` is a tiny tolerance for the frontier to handle the fact that we
+ * read CReals as JS numbers. Default 1e-12 (well above floating noise
+ * for the precision range we use).
+ */
+export declare const hasFiniteSubcover: (cover: ConstructiveOpenCover, compact: readonly [CReal, CReal], tol?: number) => boolean;
+//# sourceMappingURL=compact.d.ts.map

package/dist/reasoning/constructive-analysis/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/compact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAY,MAAM,uBAAuB,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,qBAAqB,EAC5B,SAAS,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,EAChC,YAAW,KACV,OAuBF,CAAC"}

package/dist/reasoning/constructive-analysis/compact.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Constructive Heine-Borel: every covering of a compact interval [a, b]
+ * by open rational intervals has a finite subcover.
+ *
+ * Bishop's proof is fully constructive: enumerate the cover, and use
+ * uniform continuity of the indicator-as-membership predicate via the
+ * Lebesgue number lemma. We give a direct algorithmic version: walk
+ * from `a` to `b` taking the rightmost reachable endpoint of any
+ * interval that contains the current frontier; if we can always
+ * advance, we accept; if we get stuck, we reject.
+ *
+ * The intervals are pairs `[lo, hi]` of CReals; the cover is "open" in
+ * the sense `lo < x < hi` (we work with the open interior).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFiniteSubcover = void 0;
+const constructive_reals_1 = require("../constructive-reals");
+/**
+ * Returns true if `cover` constructively covers `[a, b]` and the algorithm
+ * found a finite subcover (which in this case is just a subset of the
+ * given finite list, so trivially finite — the question is whether the
+ * cover suffices).
+ *
+ * Approach: scan with a frontier `x` initialized to `a`. At each step we
+ * search for an interval `(lo, hi)` with `lo < x < hi` (or `lo < x` and
+ * `x <= a + tol` at the start) and advance `x := hi`. If we reach
+ * `x >= b`, we accept. If we cannot advance, we reject.
+ *
+ * `tol` is a tiny tolerance for the frontier to handle the fact that we
+ * read CReals as JS numbers. Default 1e-12 (well above floating noise
+ * for the precision range we use).
+ */
+const hasFiniteSubcover = (cover, compact, tol = 1e-12) => {
+    const [aR, bR] = compact;
+    const a = (0, constructive_reals_1.toNumber)(aR);
+    const b = (0, constructive_reals_1.toNumber)(bR);
+    if (!(b >= a))
+        return false;
+    const ivs = cover.intervals.map(([loR, hiR]) => ({
+        lo: (0, constructive_reals_1.toNumber)(loR),
+        hi: (0, constructive_reals_1.toNumber)(hiR)
+    }));
+    let x = a;
+    // Ensure start is covered: some interval has lo < a < hi (or a == b edge).
+    let safety = ivs.length + 2;
+    while (x < b - tol && safety-- > 0) {
+        let bestHi = x;
+        for (const iv of ivs) {
+            if (iv.lo < x + tol && iv.hi > x + tol && iv.hi > bestHi) {
+                bestHi = iv.hi;
+            }
+        }
+        if (bestHi <= x + tol)
+            return false; // stuck
+        x = bestHi;
+    }
+    return x >= b - tol;
+};
+exports.hasFiniteSubcover = hasFiniteSubcover;
+//# sourceMappingURL=compact.js.map

package/dist/reasoning/constructive-analysis/compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.js","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/compact.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH,8DAA6D;AAM7D;;;;;;;;;;;;;;GAcG;AACI,MAAM,iBAAiB,GAAG,CAC/B,KAA4B,EAC5B,OAAgC,EAChC,GAAG,GAAG,KAAK,EACF,EAAE;IACX,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC;IACzB,MAAM,CAAC,GAAG,IAAA,6BAAQ,EAAC,EAAE,CAAC,CAAC;IACvB,MAAM,CAAC,GAAG,IAAA,6BAAQ,EAAC,EAAE,CAAC,CAAC;IACvB,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5B,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAC/C,EAAE,EAAE,IAAA,6BAAQ,EAAC,GAAG,CAAC;QACjB,EAAE,EAAE,IAAA,6BAAQ,EAAC,GAAG,CAAC;KAClB,CAAC,CAAC,CAAC;IACJ,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,2EAA2E;IAC3E,IAAI,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;QACnC,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;YACrB,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC;gBACzD,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC;YACjB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,IAAI,CAAC,GAAG,GAAG;YAAE,OAAO,KAAK,CAAC,CAAC,QAAQ;QAC7C,CAAC,GAAG,MAAM,CAAC;IACb,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AACtB,CAAC,CAAC;AA3BW,QAAA,iBAAiB,qBA2B5B"}

package/dist/reasoning/constructive-analysis/continuity.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Constructive (uniform) continuity on a compact interval.
+ *
+ * Bishop's framework: a function f : [a, b] -> R is continuous iff it
+ * comes with an explicit modulus of uniform continuity
+ *   omega : Q_>0 -> Q_>0
+ * such that |x - y| < omega(eps) implies |f(x) - f(y)| < eps,
+ * for all x, y in [a, b].
+ *
+ * On a general (non-compact) domain, "pointwise" continuity is the wrong
+ * notion constructively. We only model uniform continuity on intervals.
+ *
+ * Modulus convention: we use `modulus(epsPrecision) -> deltaPrecision`,
+ * both positive integers, encoding `1/eps -> 1/delta`. So
+ *   modulus(k) = m  means  |x - y| < 1/m  =>  |f(x) - f(y)| < 1/k.
+ */
+import { type CReal } from '../constructive-reals';
+export interface ConstructiveContinuous {
+    /** The function itself. */
+    fn: (x: CReal) => CReal;
+    /**
+     * Modulus of uniform continuity.
+     * Given `epsPrecision = k`, returns `deltaPrecision = m` with
+     *   |x - y| < 1/m  =>  |f(x) - f(y)| < 1/k.
+     */
+    modulus: (epsPrecision: number) => number;
+}
+/**
+ * Sound sampling-based check that the modulus is correct on `[a, b]`.
+ *
+ * Constructively, "for all x, y in [a, b]" is not decidable. Instead we
+ * sample `samples` pairs of points at distance ~1/m within [a, b] and
+ * verify the implication holds at each one. If the modulus is correct
+ * this returns true; a wrong modulus gets exposed on any failing sample.
+ */
+export declare const isUniformlyContinuousOn: (f: ConstructiveContinuous, interval: readonly [CReal, CReal], epsPrecision?: number, samples?: number) => boolean;
+/**
+ * Composition of uniformly continuous functions.
+ *
+ * If g has modulus `omega_g` and f has modulus `omega_f`, then `f . g`
+ * has modulus `omega_g . omega_f`:
+ *   |x - y| < 1 / omega_g(omega_f(eps))
+ *     => |g(x) - g(y)| < 1/omega_f(eps)
+ *     => |f(g(x)) - f(g(y))| < 1/eps.
+ */
+export declare const composition: (f: ConstructiveContinuous, g: ConstructiveContinuous) => ConstructiveContinuous;
+/**
+ * Constant function. Modulus is trivial (any positive integer works).
+ */
+export declare const constant: (c: CReal) => ConstructiveContinuous;
+/**
+ * Identity. Lipschitz-1, modulus(eps) = eps.
+ */
+export declare const identity: () => ConstructiveContinuous;
+/**
+ * Lipschitz function from a JS callback with known Lipschitz constant L.
+ * Useful for tests. Modulus(eps) = ceil(L * eps).
+ *
+ * The caller is responsible for the Lipschitz bound being correct.
+ */
+export declare const lipschitz: (fn: (x: CReal) => CReal, lipschitzConstant: number) => ConstructiveContinuous;
+//# sourceMappingURL=continuity.d.ts.map

package/dist/reasoning/constructive-analysis/continuity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuity.d.ts","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/continuity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,KAAK,EAMX,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,CAAC;IACxB;;;;OAIG;IACH,OAAO,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAClC,GAAG,sBAAsB,EACzB,UAAU,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,EACjC,qBAAkB,EAClB,gBAAY,KACX,OA+BF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GACtB,GAAG,sBAAsB,EACzB,GAAG,sBAAsB,KACxB,sBAGD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,KAAK,KAAG,sBAGlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ,QAAO,sBAG1B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,IAAI,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,EACvB,mBAAmB,MAAM,KACxB,sBAQF,CAAC"}

package/dist/reasoning/constructive-analysis/continuity.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Constructive (uniform) continuity on a compact interval.
+ *
+ * Bishop's framework: a function f : [a, b] -> R is continuous iff it
+ * comes with an explicit modulus of uniform continuity
+ *   omega : Q_>0 -> Q_>0
+ * such that |x - y| < omega(eps) implies |f(x) - f(y)| < eps,
+ * for all x, y in [a, b].
+ *
+ * On a general (non-compact) domain, "pointwise" continuity is the wrong
+ * notion constructively. We only model uniform continuity on intervals.
+ *
+ * Modulus convention: we use `modulus(epsPrecision) -> deltaPrecision`,
+ * both positive integers, encoding `1/eps -> 1/delta`. So
+ *   modulus(k) = m  means  |x - y| < 1/m  =>  |f(x) - f(y)| < 1/k.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lipschitz = exports.identity = exports.constant = exports.composition = exports.isUniformlyContinuousOn = void 0;
+const constructive_reals_1 = require("../constructive-reals");
+/**
+ * Sound sampling-based check that the modulus is correct on `[a, b]`.
+ *
+ * Constructively, "for all x, y in [a, b]" is not decidable. Instead we
+ * sample `samples` pairs of points at distance ~1/m within [a, b] and
+ * verify the implication holds at each one. If the modulus is correct
+ * this returns true; a wrong modulus gets exposed on any failing sample.
+ */
+const isUniformlyContinuousOn = (f, interval, epsPrecision = 100, samples = 32) => {
+    if (!Number.isInteger(epsPrecision) || epsPrecision <= 0) {
+        throw new RangeError('[continuity] epsPrecision must be a positive integer');
+    }
+    if (!Number.isInteger(samples) || samples <= 0) {
+        throw new RangeError('[continuity] samples must be a positive integer');
+    }
+    const [aR, bR] = interval;
+    const a = (0, constructive_reals_1.toNumber)(aR);
+    const b = (0, constructive_reals_1.toNumber)(bR);
+    if (!(b > a))
+        return false;
+    const m = f.modulus(epsPrecision);
+    if (!Number.isInteger(m) || m <= 0)
+        return false;
+    const delta = 1 / (m + 1);
+    const epsBound = (0, constructive_reals_1.fromFloat)(1 / epsPrecision);
+    for (let i = 0; i < samples; i++) {
+        const t = i / Math.max(1, samples - 1);
+        const x = a + t * (b - a);
+        // Pair x with x + delta/2, clipped into [a, b]. Distance < 1/m.
+        let y = x + delta / 2;
+        if (y > b)
+            y = x - delta / 2;
+        if (y < a)
+            y = (a + b) / 2;
+        const fx = f.fn((0, constructive_reals_1.fromFloat)(x));
+        const fy = f.fn((0, constructive_reals_1.fromFloat)(y));
+        const diff = (0, constructive_reals_1.abs)((0, constructive_reals_1.sub)(fx, fy));
+        // We need diff < 1/eps. Use precision 4 * eps for sound comparison.
+        if (!(0, constructive_reals_1.approxLT)(diff, epsBound, 4 * epsPrecision)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.isUniformlyContinuousOn = isUniformlyContinuousOn;
+/**
+ * Composition of uniformly continuous functions.
+ *
+ * If g has modulus `omega_g` and f has modulus `omega_f`, then `f . g`
+ * has modulus `omega_g . omega_f`:
+ *   |x - y| < 1 / omega_g(omega_f(eps))
+ *     => |g(x) - g(y)| < 1/omega_f(eps)
+ *     => |f(g(x)) - f(g(y))| < 1/eps.
+ */
+const composition = (f, g) => ({
+    fn: (x) => f.fn(g.fn(x)),
+    modulus: (eps) => g.modulus(f.modulus(eps))
+});
+exports.composition = composition;
+/**
+ * Constant function. Modulus is trivial (any positive integer works).
+ */
+const constant = (c) => ({
+    fn: () => c,
+    modulus: () => 1
+});
+exports.constant = constant;
+/**
+ * Identity. Lipschitz-1, modulus(eps) = eps.
+ */
+const identity = () => ({
+    fn: (x) => x,
+    modulus: (eps) => eps
+});
+exports.identity = identity;
+/**
+ * Lipschitz function from a JS callback with known Lipschitz constant L.
+ * Useful for tests. Modulus(eps) = ceil(L * eps).
+ *
+ * The caller is responsible for the Lipschitz bound being correct.
+ */
+const lipschitz = (fn, lipschitzConstant) => {
+    if (!(lipschitzConstant > 0) || !Number.isFinite(lipschitzConstant)) {
+        throw new RangeError('[continuity.lipschitz] L must be finite positive');
+    }
+    return {
+        fn,
+        modulus: (eps) => Math.max(1, Math.ceil(lipschitzConstant * eps))
+    };
+};
+exports.lipschitz = lipschitz;
+//# sourceMappingURL=continuity.js.map

package/dist/reasoning/constructive-analysis/continuity.js.map

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

package/dist/reasoning/constructive-analysis/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bishop-style constructive real analysis.
+ *
+ * Re-exports the four pillars:
+ *   - Cauchy sequences with explicit modulus (`./cauchy`)
+ *   - Uniform continuity on compact intervals (`./continuity`)
+ *   - Bishop integral (`./integral`)
+ *   - Heine-Borel compactness (`./compact`)
+ *   - Intermediate value + mean value approximations (`./ivt`)
+ *
+ * All operations are constructive: no LEM, no unrestricted choice, and
+ * every claim of convergence/continuity is backed by an explicit
+ * modulus function. The CReal primitive lives in
+ * `../constructive-reals`.
+ */
+export type { ConstructiveCauchySeq } from './cauchy';
+export { isCauchy, limit, cauchyFrom } from './cauchy';
+export type { ConstructiveContinuous } from './continuity';
+export { isUniformlyContinuousOn, composition, constant, identity, lipschitz } from './continuity';
+export { bishopIntegral } from './integral';
+export type { ConstructiveOpenCover } from './compact';
+export { hasFiniteSubcover } from './compact';
+export { intermediateValueTheorem, meanValueConstructive } from './ivt';
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/constructive-analysis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,SAAS,EACV,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC"}

package/dist/reasoning/constructive-analysis/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Bishop-style constructive real analysis.
+ *
+ * Re-exports the four pillars:
+ *   - Cauchy sequences with explicit modulus (`./cauchy`)
+ *   - Uniform continuity on compact intervals (`./continuity`)
+ *   - Bishop integral (`./integral`)
+ *   - Heine-Borel compactness (`./compact`)
+ *   - Intermediate value + mean value approximations (`./ivt`)
+ *
+ * All operations are constructive: no LEM, no unrestricted choice, and
+ * every claim of convergence/continuity is backed by an explicit
+ * modulus function. The CReal primitive lives in
+ * `../constructive-reals`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meanValueConstructive = exports.intermediateValueTheorem = exports.hasFiniteSubcover = exports.bishopIntegral = exports.lipschitz = exports.identity = exports.constant = exports.composition = exports.isUniformlyContinuousOn = exports.cauchyFrom = exports.limit = exports.isCauchy = void 0;
+var cauchy_1 = require("./cauchy");
+Object.defineProperty(exports, "isCauchy", { enumerable: true, get: function () { return cauchy_1.isCauchy; } });
+Object.defineProperty(exports, "limit", { enumerable: true, get: function () { return cauchy_1.limit; } });
+Object.defineProperty(exports, "cauchyFrom", { enumerable: true, get: function () { return cauchy_1.cauchyFrom; } });
+var continuity_1 = require("./continuity");
+Object.defineProperty(exports, "isUniformlyContinuousOn", { enumerable: true, get: function () { return continuity_1.isUniformlyContinuousOn; } });
+Object.defineProperty(exports, "composition", { enumerable: true, get: function () { return continuity_1.composition; } });
+Object.defineProperty(exports, "constant", { enumerable: true, get: function () { return continuity_1.constant; } });
+Object.defineProperty(exports, "identity", { enumerable: true, get: function () { return continuity_1.identity; } });
+Object.defineProperty(exports, "lipschitz", { enumerable: true, get: function () { return continuity_1.lipschitz; } });
+var integral_1 = require("./integral");
+Object.defineProperty(exports, "bishopIntegral", { enumerable: true, get: function () { return integral_1.bishopIntegral; } });
+var compact_1 = require("./compact");
+Object.defineProperty(exports, "hasFiniteSubcover", { enumerable: true, get: function () { return compact_1.hasFiniteSubcover; } });
+var ivt_1 = require("./ivt");
+Object.defineProperty(exports, "intermediateValueTheorem", { enumerable: true, get: function () { return ivt_1.intermediateValueTheorem; } });
+Object.defineProperty(exports, "meanValueConstructive", { enumerable: true, get: function () { return ivt_1.meanValueConstructive; } });
+//# sourceMappingURL=index.js.map

package/dist/reasoning/constructive-analysis/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAGH,mCAAuD;AAA9C,kGAAA,QAAQ,OAAA;AAAE,+FAAA,KAAK,OAAA;AAAE,oGAAA,UAAU,OAAA;AAGpC,2CAMsB;AALpB,qHAAA,uBAAuB,OAAA;AACvB,yGAAA,WAAW,OAAA;AACX,sGAAA,QAAQ,OAAA;AACR,sGAAA,QAAQ,OAAA;AACR,uGAAA,SAAS,OAAA;AAGX,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAGvB,qCAA8C;AAArC,4GAAA,iBAAiB,OAAA;AAE1B,6BAAwE;AAA/D,+GAAA,wBAAwB,OAAA;AAAE,4GAAA,qBAAqB,OAAA"}

package/dist/reasoning/constructive-analysis/integral.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Constructive Bishop integral on a compact interval.
+ *
+ * For uniformly continuous f on [a, b], the integral
+ *   I = ∫_a^b f(x) dx
+ * is computed as the limit of Riemann sums. The explicit modulus of
+ * uniform continuity gives us the rate.
+ *
+ * Specifically: given a partition of mesh h, and any choice of sample
+ * points, the Riemann sum S_h satisfies
+ *   |S_h - I| <= (b - a) * sup{ |f(x) - f(y)| : |x - y| <= h }
+ *
+ * If we want |S_h - I| < 1/N, pick eps with eps * (b - a) < 1/N, i.e.
+ * eps > N * (b - a). Then choose h < 1/omega_f(eps).
+ */
+import { type CReal } from '../constructive-reals';
+import type { ConstructiveContinuous } from './continuity';
+/**
+ * Bishop integral of `f` over `[from, to]`.
+ *
+ * `precision` is a positive integer N; the result is a rational `q` with
+ *   |q - ∫_from^to f| < 1/N.
+ *
+ * Implementation: midpoint rule with mesh < 1/m where
+ *   m = omega_f(ceil(N * length) + 1)
+ *
+ * which guarantees the bound above. We then wrap the rational in a CReal
+ * for compositionality (the same precision N is exposed as 1/N error).
+ */
+export declare const bishopIntegral: (f: ConstructiveContinuous, from: CReal, to: CReal, precision: number) => CReal;
+//# sourceMappingURL=integral.d.ts.map

package/dist/reasoning/constructive-analysis/integral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integral.d.ts","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/integral.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAuB,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GACzB,GAAG,sBAAsB,EACzB,MAAM,KAAK,EACX,IAAI,KAAK,EACT,WAAW,MAAM,KAChB,KAwBF,CAAC"}

package/dist/reasoning/constructive-analysis/integral.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Constructive Bishop integral on a compact interval.
+ *
+ * For uniformly continuous f on [a, b], the integral
+ *   I = ∫_a^b f(x) dx
+ * is computed as the limit of Riemann sums. The explicit modulus of
+ * uniform continuity gives us the rate.
+ *
+ * Specifically: given a partition of mesh h, and any choice of sample
+ * points, the Riemann sum S_h satisfies
+ *   |S_h - I| <= (b - a) * sup{ |f(x) - f(y)| : |x - y| <= h }
+ *
+ * If we want |S_h - I| < 1/N, pick eps with eps * (b - a) < 1/N, i.e.
+ * eps > N * (b - a). Then choose h < 1/omega_f(eps).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bishopIntegral = void 0;
+const constructive_reals_1 = require("../constructive-reals");
+/**
+ * Bishop integral of `f` over `[from, to]`.
+ *
+ * `precision` is a positive integer N; the result is a rational `q` with
+ *   |q - ∫_from^to f| < 1/N.
+ *
+ * Implementation: midpoint rule with mesh < 1/m where
+ *   m = omega_f(ceil(N * length) + 1)
+ *
+ * which guarantees the bound above. We then wrap the rational in a CReal
+ * for compositionality (the same precision N is exposed as 1/N error).
+ */
+const bishopIntegral = (f, from, to, precision) => {
+    if (!Number.isInteger(precision) || precision <= 0) {
+        throw new RangeError('[bishopIntegral] precision must be a positive integer');
+    }
+    const a = (0, constructive_reals_1.toNumber)(from);
+    const b = (0, constructive_reals_1.toNumber)(to);
+    if (a === b)
+        return (0, constructive_reals_1.fromFloat)(0);
+    const sign = b > a ? 1 : -1;
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    const length = hi - lo;
+    // Need eps such that eps * length < 1/precision.
+    // Use eps = ceil(precision * length) + 1 as positive integer threshold.
+    const eps = Math.max(1, Math.ceil(precision * length) + 1);
+    const m = f.modulus(eps);
+    // Mesh: 1/(m+1). Number of subintervals: N := ceil(length * (m+1)) + 1.
+    const N = Math.max(1, Math.ceil(length * (m + 1)) + 1);
+    const h = length / N;
+    let sum = 0;
+    for (let i = 0; i < N; i++) {
+        const xi = lo + (i + 0.5) * h; // midpoint
+        sum += (0, constructive_reals_1.toNumber)(f.fn((0, constructive_reals_1.fromFloat)(xi)), Math.max(eps, 1_000));
+    }
+    return (0, constructive_reals_1.fromFloat)(sign * sum * h);
+};
+exports.bishopIntegral = bishopIntegral;
+//# sourceMappingURL=integral.js.map

package/dist/reasoning/constructive-analysis/integral.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integral.js","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/integral.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,8DAAwE;AAGxE;;;;;;;;;;;GAWG;AACI,MAAM,cAAc,GAAG,CAC5B,CAAyB,EACzB,IAAW,EACX,EAAS,EACT,SAAiB,EACV,EAAE;IACT,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,UAAU,CAAC,uDAAuD,CAAC,CAAC;IAChF,CAAC;IACD,MAAM,CAAC,GAAG,IAAA,6BAAQ,EAAC,IAAI,CAAC,CAAC;IACzB,MAAM,CAAC,GAAG,IAAA,6BAAQ,EAAC,EAAE,CAAC,CAAC;IACvB,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAA,8BAAS,EAAC,CAAC,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE,CAAC;IACvB,iDAAiD;IACjD,wEAAwE;IACxE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3D,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,wEAAwE;IACxE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IACrB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW;QAC1C,GAAG,IAAI,IAAA,6BAAQ,EAAC,CAAC,CAAC,EAAE,CAAC,IAAA,8BAAS,EAAC,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,IAAA,8BAAS,EAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;AACnC,CAAC,CAAC;AA7BW,QAAA,cAAc,kBA6BzB"}

package/dist/reasoning/constructive-analysis/ivt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Constructive Intermediate Value Theorem and Mean Value approximation.
+ *
+ * Classically: if f is continuous on [a, b] and f(a) <= target <= f(b),
+ * then there exists c in [a, b] with f(c) = target. Constructively the
+ * exact statement is unprovable without LEM (deciding equality on R is
+ * not decidable), but the *approximate* IVT is fully constructive:
+ *
+ *   Given precision N, we can compute c in [a, b] with |f(c) - target| < 1/N.
+ *
+ * Algorithm (bisection with explicit witness):
+ *   - require f(a) and f(b) to bracket `target` (with a tolerance);
+ *   - bisect, picking the half where the target still lies between the
+ *     endpoints' images at sufficient precision;
+ *   - stop when |f(c) - target| < 1/N (witnessed at precision 4N).
+ *
+ * Mean value (constructive): for uniformly continuous f, the average
+ * value `(1/(b-a)) * ∫_a^b f` is a real in the closure of the image of f.
+ * The constructive MVT-approximation finds c in [a, b] with
+ *   |f(c) - average| < 1/N.
+ */
+import { type CReal } from '../constructive-reals';
+import type { ConstructiveContinuous } from './continuity';
+/**
+ * Returns a CReal `c` with |f(c) - target| < 1/precision, or null if no
+ * such c is bracketed in [a, b] at the given precision.
+ *
+ * Requires f(a) <= target <= f(b) or the reverse (we don't assume a
+ * specific direction; we use a generalized sign test).
+ */
+export declare const intermediateValueTheorem: (f: ConstructiveContinuous, a: CReal, b: CReal, target: CReal, precision: number) => CReal | null;
+/**
+ * Constructive mean value approximation: find c in [a, b] with
+ *   |f(c) - (1/(b-a)) * ∫_a^b f(x) dx| < 1/precision,
+ * if such c is bracketed at this precision; null otherwise.
+ *
+ * Strategy: compute the average via Bishop integral, then call IVT to
+ * locate c.
+ */
+export declare const meanValueConstructive: (f: ConstructiveContinuous, a: CReal, b: CReal, precision: number) => CReal | null;
+//# sourceMappingURL=ivt.d.ts.map

package/dist/reasoning/constructive-analysis/ivt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ivt.d.ts","sourceRoot":"","sources":["../../../src/reasoning/constructive-analysis/ivt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,KAAK,KAAK,EAMX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAK3D;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,GAAG,sBAAsB,EACzB,GAAG,KAAK,EACR,GAAG,KAAK,EACR,QAAQ,KAAK,EACb,WAAW,MAAM,KAChB,KAAK,GAAG,IAmDV,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,GAAG,sBAAsB,EACzB,GAAG,KAAK,EACR,GAAG,KAAK,EACR,WAAW,MAAM,KAChB,KAAK,GAAG,IAcV,CAAC"}