@stevenvo780/st-lang 4.8.0 → 4.9.0

package/dist/tooling/mathlib/instances.js

@@ -0,0 +1,139 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Instancias estándar
+// Z aditivo, anillo Z, racionales como campo, Z/nZ, S_3.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sym3 = exports.sym3Elements = exports.rationalsField = exports.intRing = exports.intAdditiveGroup = void 0;
+exports.rational = rational;
+exports.rationalEq = rationalEq;
+exports.rationalDiv = rationalDiv;
+exports.zModN = zModN;
+exports.zModNElements = zModNElements;
+exports.zModNDiv = zModNDiv;
+exports.perm3Eq = perm3Eq;
+// ------------------------------------------------------------
+// (Z, +): grupo abeliano aditivo de enteros.
+// ------------------------------------------------------------
+exports.intAdditiveGroup = {
+    op: (a, b) => a + b,
+    identity: 0n,
+    inverse: (a) => -a,
+};
+// ------------------------------------------------------------
+// (Z, +, ·): anillo conmutativo con unidad.
+// ------------------------------------------------------------
+exports.intRing = {
+    add: (a, b) => a + b,
+    mul: (a, b) => a * b,
+    zero: 0n,
+    one: 1n,
+    neg: (a) => -a,
+};
+function gcd(a, b) {
+    let x = a < 0n ? -a : a;
+    let y = b < 0n ? -b : b;
+    while (y !== 0n) {
+        const t = y;
+        y = x % y;
+        x = t;
+    }
+    return x === 0n ? 1n : x;
+}
+function rational(num, den) {
+    if (den === 0n)
+        throw new Error('rational: denominador cero');
+    const sign = den < 0n ? -1n : 1n;
+    const n = num * sign;
+    const d = den * sign;
+    const g = gcd(n < 0n ? -n : n, d);
+    return { num: n / g, den: d / g };
+}
+function rationalEq(a, b) {
+    return a.num === b.num && a.den === b.den;
+}
+exports.rationalsField = {
+    add: (a, b) => rational(a.num * b.den + b.num * a.den, a.den * b.den),
+    mul: (a, b) => rational(a.num * b.num, a.den * b.den),
+    zero: { num: 0n, den: 1n },
+    one: { num: 1n, den: 1n },
+    neg: (a) => ({ num: -a.num, den: a.den }),
+};
+/**
+ * División en Q. `undefined` solo cuando b = 0/1 (división por cero).
+ */
+function rationalDiv(a, b) {
+    if (b.num === 0n)
+        return undefined;
+    return rational(a.num * b.den, a.den * b.num);
+}
+// ------------------------------------------------------------
+// Z/nZ: enteros módulo n. Es campo sii n es primo.
+// ------------------------------------------------------------
+function mod(a, n) {
+    const r = a % n;
+    return r < 0n ? r + n : r;
+}
+function zModN(n) {
+    if (n <= 0n)
+        throw new Error('zModN: n debe ser positivo');
+    return {
+        add: (a, b) => mod(a + b, n),
+        mul: (a, b) => mod(a * b, n),
+        zero: 0n,
+        one: mod(1n, n),
+        neg: (a) => mod(-a, n),
+    };
+}
+/**
+ * Lista los n representantes canónicos {0, 1, ..., n-1}.
+ */
+function zModNElements(n) {
+    const out = [];
+    for (let i = 0n; i < n; i++)
+        out.push(i);
+    return out;
+}
+/**
+ * División modular: busca b tal que a · b ≡ 1 (mod n) por fuerza bruta
+ * sobre el dominio finito. Devuelve undefined si no existe inverso.
+ */
+function zModNDiv(n) {
+    return (a, b) => {
+        if (b === 0n)
+            return undefined;
+        for (let x = 0n; x < n; x++) {
+            if (mod(b * x, n) === 1n)
+                return mod(a * x, n);
+        }
+        return undefined;
+    };
+}
+exports.sym3Elements = [
+    [0, 1, 2], // identidad
+    [1, 0, 2], // transposición (0 1)
+    [2, 1, 0], // transposición (0 2)
+    [0, 2, 1], // transposición (1 2)
+    [1, 2, 0], // ciclo (0 1 2)
+    [2, 0, 1], // ciclo (0 2 1)
+];
+function composePerm3(a, b) {
+    // (a ∘ b)(i) = a(b(i))
+    return [a[b[0]], a[b[1]], a[b[2]]];
+}
+function invertPerm3(a) {
+    const out = [0, 0, 0];
+    out[a[0]] = 0;
+    out[a[1]] = 1;
+    out[a[2]] = 2;
+    return out;
+}
+function perm3Eq(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+exports.sym3 = {
+    op: composePerm3,
+    identity: [0, 1, 2],
+    inverse: invertPerm3,
+};
+//# sourceMappingURL=instances.js.map

package/dist/tooling/mathlib/instances.js.map

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

package/dist/tooling/mathlib/lemmas.d.ts

@@ -0,0 +1,3 @@
+import type { Lemma } from './types';
+export declare const STANDARD_LEMMAS: Lemma[];
+//# sourceMappingURL=lemmas.d.ts.map

package/dist/tooling/mathlib/lemmas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lemmas.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/lemmas.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAsB,KAAK,EAAE,MAAM,SAAS,CAAC;AAMzD,eAAO,MAAM,eAAe,EAAE,KAAK,EA4DlC,CAAC"}

package/dist/tooling/mathlib/lemmas.js

@@ -0,0 +1,72 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Lemas estándar
+// Afirmaciones reutilizables con criterio de aplicabilidad.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STANDARD_LEMMAS = void 0;
+function hasOps(structure, ...names) {
+    return names.every((n) => structure.operations.has(n));
+}
+exports.STANDARD_LEMMAS = [
+    {
+        name: 'group.identity_unique',
+        statement: 'En un grupo, la identidad es única.',
+        applicableTo: (s) => hasOps(s, 'op'),
+        proof: "Si e y e' son ambas identidades, e = e · e' = e'.",
+    },
+    {
+        name: 'group.inverse_unique',
+        statement: 'En un grupo, el inverso de cada elemento es único.',
+        applicableTo: (s) => hasOps(s, 'op'),
+        proof: 'Si b y c son inversos de a, b = b · e = b · (a · c) = (b · a) · c = e · c = c.',
+    },
+    {
+        name: 'group.cancellation_left',
+        statement: 'a · b = a · c ⇒ b = c.',
+        applicableTo: (s) => hasOps(s, 'op'),
+        proof: 'Multiplicando a la izquierda por a⁻¹.',
+    },
+    {
+        name: 'group.inverse_of_product',
+        statement: '(a · b)⁻¹ = b⁻¹ · a⁻¹.',
+        applicableTo: (s) => hasOps(s, 'op'),
+        proof: 'Por verificación directa: (a · b)(b⁻¹ · a⁻¹) = a · (b · b⁻¹) · a⁻¹ = a · a⁻¹ = e.',
+    },
+    {
+        name: 'group.double_inverse',
+        statement: '(a⁻¹)⁻¹ = a.',
+        applicableTo: (s) => hasOps(s, 'op'),
+        proof: 'El inverso de a⁻¹ es a, porque a⁻¹ · a = e.',
+    },
+    {
+        name: 'ring.zero_times_anything',
+        statement: '0 · a = a · 0 = 0.',
+        applicableTo: (s) => hasOps(s, 'add', 'mul'),
+        proof: '0 · a = (0 + 0) · a = 0 · a + 0 · a; cancelando, 0 · a = 0.',
+    },
+    {
+        name: 'ring.neg_one_times',
+        statement: '(-1) · a = -a.',
+        applicableTo: (s) => hasOps(s, 'add', 'mul'),
+        proof: 'a + (-1) · a = (1 + -1) · a = 0 · a = 0, así que (-1) · a = -a.',
+    },
+    {
+        name: 'ring.neg_neg',
+        statement: '-(-a) = a.',
+        applicableTo: (s) => hasOps(s, 'add'),
+        proof: 'Propiedad del grupo abeliano aditivo.',
+    },
+    {
+        name: 'order.reflexive_implies_self_join',
+        statement: 'En un poset reflexivo, sup{a,a} = a.',
+        applicableTo: (s) => hasOps(s, 'leq') || s.axioms.some((ax) => ax.name === 'reflexive'),
+    },
+    {
+        name: 'field.no_zero_divisors',
+        statement: 'En un campo, a · b = 0 ⇒ a = 0 ∨ b = 0.',
+        applicableTo: (s) => hasOps(s, 'add', 'mul'),
+        proof: 'Si a ≠ 0, multiplicando por a⁻¹ se obtiene b = 0.',
+    },
+];
+//# sourceMappingURL=lemmas.js.map

package/dist/tooling/mathlib/lemmas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lemmas.js","sourceRoot":"","sources":["../../../src/tooling/mathlib/lemmas.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,8BAA8B;AAC9B,4DAA4D;AAC5D,+DAA+D;;;AAI/D,SAAS,MAAM,CAAC,SAAsC,EAAE,GAAG,KAAe;IACxE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC;AAEY,QAAA,eAAe,GAAY;IACtC;QACE,IAAI,EAAE,uBAAuB;QAC7B,SAAS,EAAE,qCAAqC;QAChD,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;QACpC,KAAK,EAAE,mDAAmD;KAC3D;IACD;QACE,IAAI,EAAE,sBAAsB;QAC5B,SAAS,EAAE,oDAAoD;QAC/D,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;QACpC,KAAK,EAAE,gFAAgF;KACxF;IACD;QACE,IAAI,EAAE,yBAAyB;QAC/B,SAAS,EAAE,wBAAwB;QACnC,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;QACpC,KAAK,EAAE,uCAAuC;KAC/C;IACD;QACE,IAAI,EAAE,0BAA0B;QAChC,SAAS,EAAE,wBAAwB;QACnC,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;QACpC,KAAK,EAAE,mFAAmF;KAC3F;IACD;QACE,IAAI,EAAE,sBAAsB;QAC5B,SAAS,EAAE,cAAc;QACzB,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;QACpC,KAAK,EAAE,6CAA6C;KACrD;IACD;QACE,IAAI,EAAE,0BAA0B;QAChC,SAAS,EAAE,oBAAoB;QAC/B,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC;QAC5C,KAAK,EAAE,6DAA6D;KACrE;IACD;QACE,IAAI,EAAE,oBAAoB;QAC1B,SAAS,EAAE,gBAAgB;QAC3B,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC;QAC5C,KAAK,EAAE,iEAAiE;KACzE;IACD;QACE,IAAI,EAAE,cAAc;QACpB,SAAS,EAAE,YAAY;QACvB,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;QACrC,KAAK,EAAE,uCAAuC;KAC/C;IACD;QACE,IAAI,EAAE,mCAAmC;QACzC,SAAS,EAAE,sCAAsC;QACjD,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,WAAW,CAAC;KACxF;IACD;QACE,IAAI,EAAE,wBAAwB;QAC9B,SAAS,EAAE,yCAAyC;QACpD,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC;QAC5C,KAAK,EAAE,mDAAmD;KAC3D;CACF,CAAC"}

package/dist/tooling/mathlib/order.d.ts

@@ -0,0 +1,29 @@
+import type { PartialOrder } from './types';
+/**
+ * Para todo a en `elements`: a ≤ a.
+ */
+export declare function isReflexive<T>(po: PartialOrder<T>, elements: T[]): boolean;
+/**
+ * Para todo a,b: a ≤ b ∧ b ≤ a ⇒ a = b.
+ * La igualdad se decide con `===` para tipos primitivos; para
+ * tipos compuestos se acepta un `eq` custom.
+ */
+export declare function isAntisymmetric<T>(po: PartialOrder<T>, elements: T[], eq?: (a: T, b: T) => boolean): boolean;
+/**
+ * Para todo a,b,c: a ≤ b ∧ b ≤ c ⇒ a ≤ c.
+ */
+export declare function isTransitive<T>(po: PartialOrder<T>, elements: T[]): boolean;
+/**
+ * Un poset es lattice si cada par {a,b} tiene supremo (join) e
+ * ínfimo (meet) dentro de `elements`. Esto verifica existencia
+ * estructural usando el orden parcial (no requiere ops explícitas).
+ */
+export declare function isLattice<T>(po: PartialOrder<T>, elements: T[], eq?: (a: T, b: T) => boolean): boolean;
+/**
+ * Reporte completo del orden parcial sobre el conjunto dado.
+ */
+export declare function verifyPartialOrder<T>(po: PartialOrder<T>, elements: T[], eq?: (a: T, b: T) => boolean): {
+    valid: boolean;
+    failures: string[];
+};
+//# sourceMappingURL=order.d.ts.map

package/dist/tooling/mathlib/order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/order.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,OAAO,CAK1E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,CAAC,EAAE,EACb,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GAC9C,OAAO,CAOT;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,OAAO,CAS3E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,CAAC,EAAE,EACb,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GAC9C,OAAO,CAoBT;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,CAAC,EAAE,EACb,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GAC9C;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAMxC"}

package/dist/tooling/mathlib/order.js

@@ -0,0 +1,91 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Order theory
+// Reflexividad, antisimetría, transitividad y lattice check.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReflexive = isReflexive;
+exports.isAntisymmetric = isAntisymmetric;
+exports.isTransitive = isTransitive;
+exports.isLattice = isLattice;
+exports.verifyPartialOrder = verifyPartialOrder;
+/**
+ * Para todo a en `elements`: a ≤ a.
+ */
+function isReflexive(po, elements) {
+    for (const a of elements) {
+        if (!po.leq(a, a))
+            return false;
+    }
+    return true;
+}
+/**
+ * Para todo a,b: a ≤ b ∧ b ≤ a ⇒ a = b.
+ * La igualdad se decide con `===` para tipos primitivos; para
+ * tipos compuestos se acepta un `eq` custom.
+ */
+function isAntisymmetric(po, elements, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        for (const b of elements) {
+            if (po.leq(a, b) && po.leq(b, a) && !eq(a, b))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Para todo a,b,c: a ≤ b ∧ b ≤ c ⇒ a ≤ c.
+ */
+function isTransitive(po, elements) {
+    for (const a of elements) {
+        for (const b of elements) {
+            for (const c of elements) {
+                if (po.leq(a, b) && po.leq(b, c) && !po.leq(a, c))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Un poset es lattice si cada par {a,b} tiene supremo (join) e
+ * ínfimo (meet) dentro de `elements`. Esto verifica existencia
+ * estructural usando el orden parcial (no requiere ops explícitas).
+ */
+function isLattice(po, elements, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        for (const b of elements) {
+            // join (supremo): existe c tal que a ≤ c, b ≤ c, y para todo d cota superior, c ≤ d.
+            const upperBounds = elements.filter((c) => po.leq(a, c) && po.leq(b, c));
+            if (upperBounds.length === 0)
+                return false;
+            const join = upperBounds.find((c) => upperBounds.every((d) => po.leq(c, d)));
+            if (!join)
+                return false;
+            // meet (ínfimo): existe c tal que c ≤ a, c ≤ b, y para todo d cota inferior, d ≤ c.
+            const lowerBounds = elements.filter((c) => po.leq(c, a) && po.leq(c, b));
+            if (lowerBounds.length === 0)
+                return false;
+            const meet = lowerBounds.find((c) => lowerBounds.every((d) => po.leq(d, c)));
+            if (!meet)
+                return false;
+            // Sanity: join único y meet único (usando eq).
+            void eq; // eq se acepta para overload con tipos compuestos; no se usa en short-circuit.
+        }
+    }
+    return true;
+}
+/**
+ * Reporte completo del orden parcial sobre el conjunto dado.
+ */
+function verifyPartialOrder(po, elements, eq = (a, b) => a === b) {
+    const failures = [];
+    if (!isReflexive(po, elements))
+        failures.push('reflexividad');
+    if (!isAntisymmetric(po, elements, eq))
+        failures.push('antisimetría');
+    if (!isTransitive(po, elements))
+        failures.push('transitividad');
+    return { valid: failures.length === 0, failures };
+}
+//# sourceMappingURL=order.js.map

package/dist/tooling/mathlib/order.js.map

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

package/dist/tooling/mathlib/ring.d.ts

@@ -0,0 +1,15 @@
+import type { Ring, VerificationResult } from './types';
+/**
+ * Verifica los axiomas de anillo (con identidad multiplicativa):
+ *   - (R, +, 0) grupo abeliano.
+ *   - (R, ·, 1) monoide (asociatividad + identidad).
+ *   - · distribuye sobre + por ambos lados.
+ */
+export declare function verifyRing<T>(r: Ring<T>, elements: T[], eq?: (a: T, b: T) => boolean): VerificationResult;
+/**
+ * Un anillo conmutativo R es campo si todo elemento no nulo tiene
+ * inverso multiplicativo dentro del conjunto. `div` debe devolver
+ * un T para argumentos válidos o `undefined` cuando no existe inverso.
+ */
+export declare function isField<T>(r: Ring<T>, elements: T[], div: (a: T, b: T) => T | undefined, eq?: (a: T, b: T) => boolean): boolean;
+//# sourceMappingURL=ring.d.ts.map

package/dist/tooling/mathlib/ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ring.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/ring.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EACV,QAAQ,EAAE,CAAC,EAAE,EACb,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GAC9C,kBAAkB,CAiDpB;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EACV,QAAQ,EAAE,CAAC,EAAE,EACb,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,EAClC,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GAC9C,OAAO,CAYT"}

package/dist/tooling/mathlib/ring.js

@@ -0,0 +1,91 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Ring theory
+// Verificación de axiomas de anillo y check de campo.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyRing = verifyRing;
+exports.isField = isField;
+const group_1 = require("./group");
+/**
+ * Verifica los axiomas de anillo (con identidad multiplicativa):
+ *   - (R, +, 0) grupo abeliano.
+ *   - (R, ·, 1) monoide (asociatividad + identidad).
+ *   - · distribuye sobre + por ambos lados.
+ */
+function verifyRing(r, elements, eq = (a, b) => a === b) {
+    const failures = [];
+    // Grupo abeliano aditivo.
+    const addMagma = { op: r.add };
+    if (!(0, group_1.isAssociative)(addMagma, elements, eq))
+        failures.push('asociatividad aditiva');
+    if (!(0, group_1.hasIdentity)(addMagma, elements, r.zero, eq))
+        failures.push('identidad aditiva (0)');
+    if (!(0, group_1.hasInverses)({ op: r.add, identity: r.zero, inverse: r.neg }, elements, eq)) {
+        failures.push('inversos aditivos');
+    }
+    if (!(0, group_1.isCommutative)(addMagma, elements, eq))
+        failures.push('conmutatividad aditiva');
+    // Monoide multiplicativo.
+    const mulMagma = { op: r.mul };
+    if (!(0, group_1.isAssociative)(mulMagma, elements, eq))
+        failures.push('asociatividad multiplicativa');
+    if (!(0, group_1.hasIdentity)(mulMagma, elements, r.one, eq))
+        failures.push('identidad multiplicativa (1)');
+    // Distributividad: a·(b+c) = a·b + a·c  y  (a+b)·c = a·c + b·c.
+    for (const a of elements) {
+        for (const b of elements) {
+            for (const c of elements) {
+                const left = r.mul(a, r.add(b, c));
+                const right = r.add(r.mul(a, b), r.mul(a, c));
+                if (!eq(left, right)) {
+                    failures.push('distributividad por izquierda');
+                    break;
+                }
+            }
+            if (failures.includes('distributividad por izquierda'))
+                break;
+        }
+        if (failures.includes('distributividad por izquierda'))
+            break;
+    }
+    for (const a of elements) {
+        for (const b of elements) {
+            for (const c of elements) {
+                const left = r.mul(r.add(a, b), c);
+                const right = r.add(r.mul(a, c), r.mul(b, c));
+                if (!eq(left, right)) {
+                    failures.push('distributividad por derecha');
+                    break;
+                }
+            }
+            if (failures.includes('distributividad por derecha'))
+                break;
+        }
+        if (failures.includes('distributividad por derecha'))
+            break;
+    }
+    return { valid: failures.length === 0, failures };
+}
+/**
+ * Un anillo conmutativo R es campo si todo elemento no nulo tiene
+ * inverso multiplicativo dentro del conjunto. `div` debe devolver
+ * un T para argumentos válidos o `undefined` cuando no existe inverso.
+ */
+function isField(r, elements, div, eq = (a, b) => a === b) {
+    // Conmutatividad multiplicativa (requerido para campo).
+    if (!(0, group_1.isCommutative)({ op: r.mul }, elements, eq))
+        return false;
+    // Todo elemento no cero tiene inverso multiplicativo.
+    for (const a of elements) {
+        if (eq(a, r.zero))
+            continue;
+        const inv = div(r.one, a);
+        if (inv === undefined)
+            return false;
+        if (!eq(r.mul(a, inv), r.one))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=ring.js.map

package/dist/tooling/mathlib/ring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ring.js","sourceRoot":"","sources":["../../../src/tooling/mathlib/ring.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,2BAA2B;AAC3B,sDAAsD;AACtD,+DAA+D;;AAW/D,gCAqDC;AAOD,0BAiBC;AAtFD,mCAAiF;AAGjF;;;;;GAKG;AACH,SAAgB,UAAU,CACxB,CAAU,EACV,QAAa,EACb,KAA8B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IAE/C,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,0BAA0B;IAC1B,MAAM,QAAQ,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;IAC/B,IAAI,CAAC,IAAA,qBAAa,EAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IACnF,IAAI,CAAC,IAAA,mBAAW,EAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IACzF,IAAI,CAAC,IAAA,mBAAW,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC;QAChF,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACrC,CAAC;IACD,IAAI,CAAC,IAAA,qBAAa,EAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAEpF,0BAA0B;IAC1B,MAAM,QAAQ,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;IAC/B,IAAI,CAAC,IAAA,qBAAa,EAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;IAC1F,IAAI,CAAC,IAAA,mBAAW,EAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;IAE/F,gEAAgE;IAChE,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;gBACzB,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACnC,MAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC9C,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;oBACrB,QAAQ,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;oBAC/C,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,+BAA+B,CAAC;gBAAE,MAAM;QAChE,CAAC;QACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,+BAA+B,CAAC;YAAE,MAAM;IAChE,CAAC;IAED,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;gBACzB,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACnC,MAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC9C,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;oBACrB,QAAQ,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;oBAC7C,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,6BAA6B,CAAC;gBAAE,MAAM;QAC9D,CAAC;QACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,6BAA6B,CAAC;YAAE,MAAM;IAC9D,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;AACpD,CAAC;AAED;;;;GAIG;AACH,SAAgB,OAAO,CACrB,CAAU,EACV,QAAa,EACb,GAAkC,EAClC,KAA8B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IAE/C,wDAAwD;IACxD,IAAI,CAAC,IAAA,qBAAa,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC;QAAE,OAAO,KAAK,CAAC;IAE9D,sDAAsD;IACtD,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC;YAAE,SAAS;QAC5B,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAC1B,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QACpC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;IAC9C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/tooling/mathlib/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Estructura algebraica genérica: un dominio de elementos + un
+ * diccionario de operaciones + una lista de axiomas declarados.
+ *
+ * `elements` puede ser un arreglo finito (para grupos finitos como S_3)
+ * o un generador indexado (para anillos infinitos como Z donde se
+ * muestrea un subconjunto representativo).
+ */
+export interface AlgebraicStructure<T> {
+    name: string;
+    elements: T[] | ((idx: number) => T);
+    operations: Map<string, (...args: T[]) => T>;
+    axioms: AlgebraAxiom[];
+}
+/**
+ * Un axioma con su fórmula informal (template) y un verificador
+ * computacional opcional que decide si los elementos lo cumplen.
+ */
+export interface AlgebraAxiom {
+    name: string;
+    formula: string;
+    verifier?: (elements: unknown[], ops: Map<string, unknown>) => boolean;
+}
+export interface PartialOrder<T> {
+    leq(a: T, b: T): boolean;
+}
+export interface TotalOrder<T> extends PartialOrder<T> {
+    compare(a: T, b: T): -1 | 0 | 1;
+}
+export interface Magma<T> {
+    op: (a: T, b: T) => T;
+}
+export interface Semigroup<T> extends Magma<T> {
+    readonly _semigroup?: true;
+}
+export interface Monoid<T> extends Semigroup<T> {
+    identity: T;
+}
+export interface Group<T> extends Monoid<T> {
+    inverse: (a: T) => T;
+}
+export interface AbelianGroup<T> extends Group<T> {
+    readonly _abelian?: true;
+}
+export interface Ring<T> {
+    add: (a: T, b: T) => T;
+    mul: (a: T, b: T) => T;
+    zero: T;
+    one: T;
+    neg: (a: T) => T;
+}
+export interface Lemma {
+    name: string;
+    statement: string;
+    applicableTo: (structure: AlgebraicStructure<unknown>) => boolean;
+    proof?: string;
+}
+export interface VerificationResult {
+    valid: boolean;
+    failures: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tooling/mathlib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/types.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC;IACrC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IAC7C,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;CACxE;AAMD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACjC;AAMD,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;CACvB;AAID,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,CAAC,CAAC;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,CAAC;CACb;AAED,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACzC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;CAC1B;AAMD,MAAM,WAAW,IAAI,CAAC,CAAC;IACrB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACvB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,CAAC;IACR,GAAG,EAAE,CAAC,CAAC;IACP,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;CAClB;AAMD,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,SAAS,EAAE,kBAAkB,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}

package/dist/tooling/mathlib/types.js

@@ -0,0 +1,7 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Tipos base para estructuras algebraicas
+// Inspirado en Lean mathlib, subset mínimo para enseñanza.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/tooling/mathlib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/tooling/mathlib/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uDAAuD;AACvD,2DAA2D;AAC3D,+DAA+D"}

package/dist/type-theory/effects/core.d.ts

@@ -0,0 +1,27 @@
+import type { Eff, Effect, Handler } from './types';
+/** Inyecta un valor puro en la mónada. */
+export declare function pure<A>(value: A): Eff<never, A>;
+/**
+ * Construye una computación que ejecuta una operación `tag` con `input`
+ * y entrega su resultado al consumidor. La continuación es la identidad:
+ * "haz la operación y devuelve su salida".
+ */
+export declare function perform<EName extends string, I, O>(tag: EName, input: I): Eff<Effect<EName, I, O>, O>;
+/** Bind monádico (>>= en notación de Haskell). */
+export declare function bind<E, A, B>(eff: Eff<E, A>, fn: (a: A) => Eff<E, B>): Eff<E, B>;
+/** Alias funtorial: aplica una función pura al resultado. */
+export declare function map<E, A, B>(eff: Eff<E, A>, fn: (a: A) => B): Eff<E, B>;
+/** Secuencia una lista de computaciones y colecta sus resultados. */
+export declare function sequence<E, A>(effs: ReadonlyArray<Eff<E, A>>): Eff<E, A[]>;
+/**
+ * Interpreta un efecto concreto. Recorre el árbol: las hojas `pure`
+ * pasan tal cual; los nodos `impure` cuyo `tag` coincida con el
+ * handler son delegados a `handle`; el resto se propaga.
+ */
+export declare function handle<E1, E2, A>(eff: Eff<E1, A>, handler: Handler<string, unknown, unknown, E2, A>): Eff<E2, A>;
+/**
+ * Extrae el valor de una computación 100% pura. Lanza si quedan efectos
+ * sin interpretar — útil tras componer todos los handlers.
+ */
+export declare function run<A>(eff: Eff<never, A>): A;
+//# sourceMappingURL=core.d.ts.map

package/dist/type-theory/effects/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/type-theory/effects/core.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEpD,0CAA0C;AAC1C,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAChD,GAAG,EAAE,KAAK,EACV,KAAK,EAAE,CAAC,GACP,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAO7B;AAED,kDAAkD;AAClD,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAShF;AAED,6DAA6D;AAC7D,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAEvE;AAED,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAK1E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAC9B,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EACf,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,GAChD,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAeZ;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,CAG5C"}