@stevenvo780/st-lang 4.7.0 → 4.9.0

package/dist/tooling/mathlib/group.js

@@ -0,0 +1,89 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Group theory
+// Axiomas: asociatividad, identidad, inversos, conmutatividad.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssociative = isAssociative;
+exports.isCommutative = isCommutative;
+exports.hasIdentity = hasIdentity;
+exports.hasInverses = hasInverses;
+exports.verifyGroup = verifyGroup;
+exports.verifyAbelianGroup = verifyAbelianGroup;
+/**
+ * (a · b) · c = a · (b · c) para todo a,b,c en el muestreo.
+ */
+function isAssociative(m, elements, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        for (const b of elements) {
+            for (const c of elements) {
+                const left = m.op(m.op(a, b), c);
+                const right = m.op(a, m.op(b, c));
+                if (!eq(left, right))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * a · b = b · a para todo a,b. Falla rápido si encuentra contraejemplo.
+ */
+function isCommutative(m, elements, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        for (const b of elements) {
+            if (!eq(m.op(a, b), m.op(b, a)))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Para todo a: id · a = a ∧ a · id = a.
+ */
+function hasIdentity(m, elements, id, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        if (!eq(m.op(id, a), a))
+            return false;
+        if (!eq(m.op(a, id), a))
+            return false;
+    }
+    return true;
+}
+/**
+ * Para todo a: a · a⁻¹ = id ∧ a⁻¹ · a = id.
+ */
+function hasInverses(g, elements, eq = (a, b) => a === b) {
+    for (const a of elements) {
+        const inv = g.inverse(a);
+        if (!eq(g.op(a, inv), g.identity))
+            return false;
+        if (!eq(g.op(inv, a), g.identity))
+            return false;
+    }
+    return true;
+}
+/**
+ * Verifica los 4 axiomas de grupo: clausura (implícita en el tipo),
+ * asociatividad, identidad e inversos. Reporta qué axiomas fallaron.
+ */
+function verifyGroup(g, elements, eq = (a, b) => a === b) {
+    const failures = [];
+    if (!isAssociative(g, elements, eq))
+        failures.push('asociatividad');
+    if (!hasIdentity(g, elements, g.identity, eq))
+        failures.push('identidad');
+    if (!hasInverses(g, elements, eq))
+        failures.push('inversos');
+    return { valid: failures.length === 0, failures };
+}
+/**
+ * Verifica que un grupo es abeliano (verifyGroup + conmutatividad).
+ */
+function verifyAbelianGroup(g, elements, eq = (a, b) => a === b) {
+    const base = verifyGroup(g, elements, eq);
+    if (!isCommutative(g, elements, eq))
+        base.failures.push('conmutatividad');
+    return { valid: base.failures.length === 0, failures: base.failures };
+}
+//# sourceMappingURL=group.js.map

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

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

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

@@ -0,0 +1,8 @@
+export type { AlgebraicStructure, AlgebraAxiom, PartialOrder, TotalOrder, Magma, Semigroup, Monoid, Group, AbelianGroup, Ring, Lemma, VerificationResult, } from './types';
+export { isReflexive, isAntisymmetric, isTransitive, isLattice, verifyPartialOrder } from './order';
+export { isAssociative, isCommutative, hasIdentity, hasInverses, verifyGroup, verifyAbelianGroup, } from './group';
+export { verifyRing, isField } from './ring';
+export { intAdditiveGroup, intRing, rationalsField, rational, rationalEq, rationalDiv, zModN, zModNElements, zModNDiv, sym3, sym3Elements, perm3Eq, } from './instances';
+export type { Rational, Perm3 } from './instances';
+export { STANDARD_LEMMAS } from './lemmas';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/index.ts"],"names":[],"mappings":"AAMA,YAAY,EACV,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,KAAK,EACL,SAAS,EACT,MAAM,EACN,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,KAAK,EACL,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEpG,OAAO,EACL,aAAa,EACb,aAAa,EACb,WAAW,EACX,WAAW,EACX,WAAW,EACX,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAE7C,OAAO,EACL,gBAAgB,EAChB,OAAO,EACP,cAAc,EACd,QAAQ,EACR,UAAU,EACV,WAAW,EACX,KAAK,EACL,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,OAAO,GACR,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/dist/tooling/mathlib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+// ============================================================
+// ST Mathlib — Subset curado de definiciones algebraicas.
+// Inspirado en Lean mathlib. Soporta order theory, group theory,
+// ring theory + instancias estándar (Z, Q, Z/nZ, S_3) + lemas.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STANDARD_LEMMAS = exports.perm3Eq = exports.sym3Elements = exports.sym3 = exports.zModNDiv = exports.zModNElements = exports.zModN = exports.rationalDiv = exports.rationalEq = exports.rational = exports.rationalsField = exports.intRing = exports.intAdditiveGroup = exports.isField = exports.verifyRing = exports.verifyAbelianGroup = exports.verifyGroup = exports.hasInverses = exports.hasIdentity = exports.isCommutative = exports.isAssociative = exports.verifyPartialOrder = exports.isLattice = exports.isTransitive = exports.isAntisymmetric = exports.isReflexive = void 0;
+var order_1 = require("./order");
+Object.defineProperty(exports, "isReflexive", { enumerable: true, get: function () { return order_1.isReflexive; } });
+Object.defineProperty(exports, "isAntisymmetric", { enumerable: true, get: function () { return order_1.isAntisymmetric; } });
+Object.defineProperty(exports, "isTransitive", { enumerable: true, get: function () { return order_1.isTransitive; } });
+Object.defineProperty(exports, "isLattice", { enumerable: true, get: function () { return order_1.isLattice; } });
+Object.defineProperty(exports, "verifyPartialOrder", { enumerable: true, get: function () { return order_1.verifyPartialOrder; } });
+var group_1 = require("./group");
+Object.defineProperty(exports, "isAssociative", { enumerable: true, get: function () { return group_1.isAssociative; } });
+Object.defineProperty(exports, "isCommutative", { enumerable: true, get: function () { return group_1.isCommutative; } });
+Object.defineProperty(exports, "hasIdentity", { enumerable: true, get: function () { return group_1.hasIdentity; } });
+Object.defineProperty(exports, "hasInverses", { enumerable: true, get: function () { return group_1.hasInverses; } });
+Object.defineProperty(exports, "verifyGroup", { enumerable: true, get: function () { return group_1.verifyGroup; } });
+Object.defineProperty(exports, "verifyAbelianGroup", { enumerable: true, get: function () { return group_1.verifyAbelianGroup; } });
+var ring_1 = require("./ring");
+Object.defineProperty(exports, "verifyRing", { enumerable: true, get: function () { return ring_1.verifyRing; } });
+Object.defineProperty(exports, "isField", { enumerable: true, get: function () { return ring_1.isField; } });
+var instances_1 = require("./instances");
+Object.defineProperty(exports, "intAdditiveGroup", { enumerable: true, get: function () { return instances_1.intAdditiveGroup; } });
+Object.defineProperty(exports, "intRing", { enumerable: true, get: function () { return instances_1.intRing; } });
+Object.defineProperty(exports, "rationalsField", { enumerable: true, get: function () { return instances_1.rationalsField; } });
+Object.defineProperty(exports, "rational", { enumerable: true, get: function () { return instances_1.rational; } });
+Object.defineProperty(exports, "rationalEq", { enumerable: true, get: function () { return instances_1.rationalEq; } });
+Object.defineProperty(exports, "rationalDiv", { enumerable: true, get: function () { return instances_1.rationalDiv; } });
+Object.defineProperty(exports, "zModN", { enumerable: true, get: function () { return instances_1.zModN; } });
+Object.defineProperty(exports, "zModNElements", { enumerable: true, get: function () { return instances_1.zModNElements; } });
+Object.defineProperty(exports, "zModNDiv", { enumerable: true, get: function () { return instances_1.zModNDiv; } });
+Object.defineProperty(exports, "sym3", { enumerable: true, get: function () { return instances_1.sym3; } });
+Object.defineProperty(exports, "sym3Elements", { enumerable: true, get: function () { return instances_1.sym3Elements; } });
+Object.defineProperty(exports, "perm3Eq", { enumerable: true, get: function () { return instances_1.perm3Eq; } });
+var lemmas_1 = require("./lemmas");
+Object.defineProperty(exports, "STANDARD_LEMMAS", { enumerable: true, get: function () { return lemmas_1.STANDARD_LEMMAS; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tooling/mathlib/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,0DAA0D;AAC1D,iEAAiE;AACjE,+DAA+D;AAC/D,+DAA+D;;;AAiB/D,iCAAoG;AAA3F,oGAAA,WAAW,OAAA;AAAE,wGAAA,eAAe,OAAA;AAAE,qGAAA,YAAY,OAAA;AAAE,kGAAA,SAAS,OAAA;AAAE,2GAAA,kBAAkB,OAAA;AAElF,iCAOiB;AANf,sGAAA,aAAa,OAAA;AACb,sGAAA,aAAa,OAAA;AACb,oGAAA,WAAW,OAAA;AACX,oGAAA,WAAW,OAAA;AACX,oGAAA,WAAW,OAAA;AACX,2GAAA,kBAAkB,OAAA;AAGpB,+BAA6C;AAApC,kGAAA,UAAU,OAAA;AAAE,+FAAA,OAAO,OAAA;AAE5B,yCAaqB;AAZnB,6GAAA,gBAAgB,OAAA;AAChB,oGAAA,OAAO,OAAA;AACP,2GAAA,cAAc,OAAA;AACd,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,wGAAA,WAAW,OAAA;AACX,kGAAA,KAAK,OAAA;AACL,0GAAA,aAAa,OAAA;AACb,qGAAA,QAAQ,OAAA;AACR,iGAAA,IAAI,OAAA;AACJ,yGAAA,YAAY,OAAA;AACZ,oGAAA,OAAO,OAAA;AAIT,mCAA2C;AAAlC,yGAAA,eAAe,OAAA"}

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

@@ -0,0 +1,29 @@
+import type { AbelianGroup, Group, Ring } from './types';
+export declare const intAdditiveGroup: AbelianGroup<bigint>;
+export declare const intRing: Ring<bigint>;
+export interface Rational {
+    num: bigint;
+    den: bigint;
+}
+export declare function rational(num: bigint, den: bigint): Rational;
+export declare function rationalEq(a: Rational, b: Rational): boolean;
+export declare const rationalsField: Ring<Rational>;
+/**
+ * División en Q. `undefined` solo cuando b = 0/1 (división por cero).
+ */
+export declare function rationalDiv(a: Rational, b: Rational): Rational | undefined;
+export declare function zModN(n: bigint): Ring<bigint>;
+/**
+ * Lista los n representantes canónicos {0, 1, ..., n-1}.
+ */
+export declare function zModNElements(n: bigint): bigint[];
+/**
+ * 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.
+ */
+export declare function zModNDiv(n: bigint): (a: bigint, b: bigint) => bigint | undefined;
+export type Perm3 = [number, number, number];
+export declare const sym3Elements: Perm3[];
+export declare function perm3Eq(a: Perm3, b: Perm3): boolean;
+export declare const sym3: Group<Perm3>;
+//# sourceMappingURL=instances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../src/tooling/mathlib/instances.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAKzD,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,MAAM,CAIjD,CAAC;AAKF,eAAO,MAAM,OAAO,EAAE,IAAI,CAAC,MAAM,CAMhC,CAAC;AAQF,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAaD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAO3D;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAE5D;AAED,eAAO,MAAM,cAAc,EAAE,IAAI,CAAC,QAAQ,CAMzC,CAAC;AAEF;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAG1E;AAUD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAS7C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAIjD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAQhF;AAMD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C,eAAO,MAAM,YAAY,EAAE,KAAK,EAO/B,CAAC;AAeF,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAEnD;AAED,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,KAAK,CAI7B,CAAC"}

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"}