mcard-js 2.1.12 → 2.1.13

package/dist/ptr/lambda/AlphaConversion.js

@@ -0,0 +1,244 @@
+/**
+ * Alpha Conversion (α-conversion)
+ *
+ * Renames bound variables in Lambda terms while preserving meaning.
+ *
+ * Rule: λx.M ≡α λy.M[x:=y]  (where y is fresh)
+ *
+ * Alpha conversion is the basis of variable renaming and is essential
+ * for avoiding variable capture during beta reduction.
+ *
+ * @module mcard-js/ptr/lambda/AlphaConversion
+ */
+import { loadTerm, storeTerm, mkVar, mkAbs, mkApp, isAbs } from './LambdaTerm';
+import { freeVariables } from './FreeVariables';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+// ─────────────────────────────────────────────────────────────────────────────
+// Alpha Conversion
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Alpha-rename: Rename the bound variable of an abstraction
+ *
+ * λx.M → λy.M[x:=y]
+ *
+ * @param collection - Card collection for term storage
+ * @param absHash - Hash of the abstraction term
+ * @param newParam - New name for the bound variable
+ * @returns IO<Either<error, newHash>>
+ */
+export function alphaRename(collection, absHash, newParam) {
+    return IO.of(async () => {
+        const term = await loadTerm(collection, absHash);
+        if (!term) {
+            return Either.left(`Term not found: ${absHash}`);
+        }
+        if (!isAbs(term)) {
+            return Either.left(`Alpha conversion only applies to abstractions, got ${term.tag}`);
+        }
+        // If same name, no change needed
+        if (term.param === newParam) {
+            return Either.right(absHash);
+        }
+        // Check that new name doesn't capture free variables in body
+        const bodyFV = await freeVariables(collection, term.body).run();
+        if (bodyFV.isJust && bodyFV.value.has(newParam)) {
+            return Either.left(`Cannot α-rename to '${newParam}': would capture free variable in body`);
+        }
+        // Substitute old param with new param in body
+        const newBodyHash = await substituteVar(collection, term.body, term.param, newParam);
+        // Create new abstraction
+        const newAbs = mkAbs(newParam, newBodyHash);
+        const resultHash = await storeTerm(collection, newAbs);
+        return Either.right(resultHash);
+    });
+}
+/**
+ * Substitute a variable with another variable name throughout a term
+ *
+ * M[x:=y] - replaces all free occurrences of x with y
+ */
+async function substituteVar(collection, termHash, oldVar, newVar) {
+    const term = await loadTerm(collection, termHash);
+    if (!term) {
+        throw new Error(`Term not found: ${termHash}`);
+    }
+    switch (term.tag) {
+        case 'Var':
+            if (term.name === oldVar) {
+                // Replace with new variable
+                const newTerm = mkVar(newVar);
+                return storeTerm(collection, newTerm);
+            }
+            // Different variable, unchanged
+            return termHash;
+        case 'Abs':
+            if (term.param === oldVar) {
+                // Bound variable shadows, stop substitution
+                return termHash;
+            }
+            // Recurse into body
+            const newBody = await substituteVar(collection, term.body, oldVar, newVar);
+            if (newBody === term.body) {
+                // No change
+                return termHash;
+            }
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        case 'App':
+            const newFunc = await substituteVar(collection, term.func, oldVar, newVar);
+            const newArg = await substituteVar(collection, term.arg, oldVar, newVar);
+            if (newFunc === term.func && newArg === term.arg) {
+                // No change
+                return termHash;
+            }
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Alpha Equivalence
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if two terms are alpha-equivalent
+ *
+ * Two terms are α-equivalent if they differ only in the names of bound variables.
+ *
+ * Note: If hashes are equal, terms are definitionally identical (stronger than α-equiv).
+ */
+export function alphaEquivalent(collection, hash1, hash2) {
+    return IO.of(async () => {
+        // Same hash = identical terms
+        if (hash1 === hash2) {
+            return Either.right(true);
+        }
+        const term1 = await loadTerm(collection, hash1);
+        const term2 = await loadTerm(collection, hash2);
+        if (!term1)
+            return Either.left(`Term not found: ${hash1}`);
+        if (!term2)
+            return Either.left(`Term not found: ${hash2}`);
+        const equiv = await checkAlphaEquiv(collection, term1, term2, new Map(), new Map());
+        return Either.right(equiv);
+    });
+}
+/**
+ * Internal alpha-equivalence check with variable renaming maps
+ */
+async function checkAlphaEquiv(collection, term1, term2, rename1, // Maps var name in term1 to de Bruijn index
+rename2 // Maps var name in term2 to de Bruijn index
+) {
+    if (term1.tag !== term2.tag) {
+        return false;
+    }
+    switch (term1.tag) {
+        case 'Var': {
+            const t2 = term2;
+            const idx1 = rename1.get(term1.name);
+            const idx2 = rename2.get(t2.name);
+            if (idx1 !== undefined && idx2 !== undefined) {
+                // Both are bound variables - compare by binding depth
+                return idx1 === idx2;
+            }
+            if (idx1 === undefined && idx2 === undefined) {
+                // Both are free variables - compare by name
+                return term1.name === t2.name;
+            }
+            // One bound, one free - not equivalent
+            return false;
+        }
+        case 'Abs': {
+            const t2 = term2;
+            // Extend renaming maps with new binding
+            const depth = rename1.size;
+            const newRename1 = new Map(rename1);
+            const newRename2 = new Map(rename2);
+            newRename1.set(term1.param, depth);
+            newRename2.set(t2.param, depth);
+            // Load and compare bodies
+            const body1 = await loadTerm(collection, term1.body);
+            const body2 = await loadTerm(collection, t2.body);
+            if (!body1 || !body2)
+                return false;
+            return checkAlphaEquiv(collection, body1, body2, newRename1, newRename2);
+        }
+        case 'App': {
+            const t2 = term2;
+            const func1 = await loadTerm(collection, term1.func);
+            const func2 = await loadTerm(collection, t2.func);
+            const arg1 = await loadTerm(collection, term1.arg);
+            const arg2 = await loadTerm(collection, t2.arg);
+            if (!func1 || !func2 || !arg1 || !arg2)
+                return false;
+            const funcEquiv = await checkAlphaEquiv(collection, func1, func2, rename1, rename2);
+            if (!funcEquiv)
+                return false;
+            return checkAlphaEquiv(collection, arg1, arg2, rename1, rename2);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Alpha Normalization (De Bruijn-like canonical form)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Alpha-normalize a term using canonical variable names
+ *
+ * All bound variables are renamed to a₀, a₁, a₂... based on binding depth.
+ * This produces a canonical representative of the α-equivalence class.
+ */
+export function alphaNormalize(collection, termHash) {
+    return IO.of(async () => {
+        const result = await normalizeWithDepth(collection, termHash, new Map(), 0);
+        if (result === null) {
+            return Either.left(`Term not found: ${termHash}`);
+        }
+        return Either.right(result);
+    });
+}
+/**
+ * Internal normalization with depth tracking
+ */
+async function normalizeWithDepth(collection, termHash, bindings, // original name -> canonical name
+depth) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return null;
+    switch (term.tag) {
+        case 'Var': {
+            const canonicalName = bindings.get(term.name);
+            if (canonicalName) {
+                // Bound variable - use canonical name
+                const newVar = mkVar(canonicalName);
+                return storeTerm(collection, newVar);
+            }
+            // Free variable - keep original name
+            return termHash;
+        }
+        case 'Abs': {
+            // Generate canonical name for this binding depth
+            const canonicalName = `a${depth}`;
+            // Extend bindings
+            const newBindings = new Map(bindings);
+            newBindings.set(term.param, canonicalName);
+            // Normalize body
+            const newBody = await normalizeWithDepth(collection, term.body, newBindings, depth + 1);
+            if (newBody === null)
+                return null;
+            const newAbs = mkAbs(canonicalName, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await normalizeWithDepth(collection, term.func, bindings, depth);
+            const newArg = await normalizeWithDepth(collection, term.arg, bindings, depth);
+            if (newFunc === null || newArg === null)
+                return null;
+            // If unchanged, return original
+            if (newFunc === term.func && newArg === term.arg) {
+                return termHash;
+            }
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+//# sourceMappingURL=AlphaConversion.js.map

package/dist/ptr/lambda/AlphaConversion.js.map

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

package/dist/ptr/lambda/BetaReduction.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Beta Reduction (β-reduction)
+ *
+ * The computational heart of Lambda Calculus - function application.
+ *
+ * Rule: (λx.M) N →β M[x:=N]
+ *
+ * A term of the form (λx.M) N is called a "beta-redex" (reducible expression).
+ * Beta reduction substitutes the argument N for all free occurrences of x in M.
+ *
+ * IMPORTANT: Must handle capture avoidance - if N contains free variables
+ * that would become bound in M, we must α-rename first.
+ *
+ * @module mcard-js/ptr/lambda/BetaReduction
+ */
+import { CardCollection } from '../../model/CardCollection';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+import { Maybe } from '../../monads/Maybe';
+/**
+ * Check if a term is a beta-redex: (λx.M) N
+ */
+export declare function isRedex(collection: CardCollection, termHash: string): IO<boolean>;
+/**
+ * Find the leftmost-outermost redex (normal order reduction)
+ * Returns Maybe<hash of redex>
+ */
+export declare function findLeftmostRedex(collection: CardCollection, termHash: string): IO<Maybe<string>>;
+/**
+ * Find the leftmost-innermost redex (applicative order reduction)
+ */
+export declare function findInnermostRedex(collection: CardCollection, termHash: string): IO<Maybe<string>>;
+/**
+ * Perform a single beta reduction step on a redex
+ *
+ * (λx.M) N →β M[x:=N]
+ *
+ * @param collection - Card collection
+ * @param redexHash - Hash of the application term (λx.M) N
+ * @returns Either<error, resultHash>
+ */
+export declare function betaReduce(collection: CardCollection, redexHash: string): IO<Either<string, string>>;
+export type ReductionStrategy = 'normal' | 'applicative' | 'lazy';
+/**
+ * Perform one reduction step using the specified strategy
+ */
+export declare function reduceStep(collection: CardCollection, termHash: string, strategy?: ReductionStrategy): IO<Maybe<string>>;
+export interface NormalizationResult {
+    normalForm: string;
+    steps: number;
+    reductionPath: string[];
+}
+/**
+ * Normalize a term to its normal form (no more redexes)
+ *
+ * @param collection - Card collection
+ * @param termHash - Starting term
+ * @param strategy - Reduction strategy
+ * @param maxSteps - Maximum reduction steps (prevent infinite loops)
+ * @returns Either<error, NormalizationResult>
+ */
+export declare function normalize(collection: CardCollection, termHash: string, strategy?: ReductionStrategy, maxSteps?: number): IO<Either<string, NormalizationResult>>;
+/**
+ * Check if a term is in normal form (has no redexes)
+ */
+export declare function isNormalForm(collection: CardCollection, termHash: string): IO<boolean>;
+/**
+ * Check if a term has a normal form (is normalizing)
+ *
+ * Note: This is undecidable in general, so we use a bounded check
+ */
+export declare function hasNormalForm(collection: CardCollection, termHash: string, maxSteps?: number): IO<boolean>;
+//# sourceMappingURL=BetaReduction.d.ts.map

package/dist/ptr/lambda/BetaReduction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BetaReduction.d.ts","sourceRoot":"","sources":["../../../src/ptr/lambda/BetaReduction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAgB5D,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAM3C;;GAEG;AACH,wBAAgB,OAAO,CACnB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,OAAO,CAAC,CAQb;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAInB;AAmCD;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAInB;AAuCD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACtB,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,MAAM,GAClB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkC5B;AA+GD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,aAAa,GAAG,MAAM,CAAC;AAElE;;GAEG;AACH,wBAAgB,UAAU,CACtB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,iBAA4B,GACvC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CA8CnB;AA8DD,MAAM,WAAW,mBAAmB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACrB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,iBAA4B,EACtC,QAAQ,GAAE,MAAa,GACxB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CA2BzC;AAED;;GAEG;AACH,wBAAgB,YAAY,CACxB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,GACjB,EAAE,CAAC,OAAO,CAAC,CAEb;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CACzB,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,MAAa,GACxB,EAAE,CAAC,OAAO,CAAC,CAGb"}

package/dist/ptr/lambda/BetaReduction.js

@@ -0,0 +1,322 @@
+/**
+ * Beta Reduction (β-reduction)
+ *
+ * The computational heart of Lambda Calculus - function application.
+ *
+ * Rule: (λx.M) N →β M[x:=N]
+ *
+ * A term of the form (λx.M) N is called a "beta-redex" (reducible expression).
+ * Beta reduction substitutes the argument N for all free occurrences of x in M.
+ *
+ * IMPORTANT: Must handle capture avoidance - if N contains free variables
+ * that would become bound in M, we must α-rename first.
+ *
+ * @module mcard-js/ptr/lambda/BetaReduction
+ */
+import { loadTerm, storeTerm, mkAbs, mkApp, isAbs, isApp } from './LambdaTerm';
+import { freeVariables, generateFresh } from './FreeVariables';
+import { alphaRename } from './AlphaConversion';
+import { IO } from '../../monads/IO';
+import { Either } from '../../monads/Either';
+import { Maybe } from '../../monads/Maybe';
+// ─────────────────────────────────────────────────────────────────────────────
+// Beta Redex Detection
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if a term is a beta-redex: (λx.M) N
+ */
+export function isRedex(collection, termHash) {
+    return IO.of(async () => {
+        const term = await loadTerm(collection, termHash);
+        if (!term || !isApp(term))
+            return false;
+        const func = await loadTerm(collection, term.func);
+        return func !== null && isAbs(func);
+    });
+}
+/**
+ * Find the leftmost-outermost redex (normal order reduction)
+ * Returns Maybe<hash of redex>
+ */
+export function findLeftmostRedex(collection, termHash) {
+    return IO.of(async () => {
+        return findRedexNormalOrder(collection, termHash);
+    });
+}
+async function findRedexNormalOrder(collection, termHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return Maybe.nothing();
+    switch (term.tag) {
+        case 'Var':
+            // Variables are not redexes
+            return Maybe.nothing();
+        case 'Abs':
+            // Look inside the body
+            return findRedexNormalOrder(collection, term.body);
+        case 'App': {
+            // Check if this application is a redex
+            const func = await loadTerm(collection, term.func);
+            if (func && isAbs(func)) {
+                // This is a redex!
+                return Maybe.just(termHash);
+            }
+            // Not a redex - search in func first (leftmost), then arg
+            const funcRedex = await findRedexNormalOrder(collection, term.func);
+            if (funcRedex.isJust)
+                return funcRedex;
+            return findRedexNormalOrder(collection, term.arg);
+        }
+    }
+}
+/**
+ * Find the leftmost-innermost redex (applicative order reduction)
+ */
+export function findInnermostRedex(collection, termHash) {
+    return IO.of(async () => {
+        return findRedexApplicativeOrder(collection, termHash);
+    });
+}
+async function findRedexApplicativeOrder(collection, termHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        return Maybe.nothing();
+    switch (term.tag) {
+        case 'Var':
+            return Maybe.nothing();
+        case 'Abs':
+            return findRedexApplicativeOrder(collection, term.body);
+        case 'App': {
+            // Search in subterms first (innermost)
+            const funcRedex = await findRedexApplicativeOrder(collection, term.func);
+            if (funcRedex.isJust)
+                return funcRedex;
+            const argRedex = await findRedexApplicativeOrder(collection, term.arg);
+            if (argRedex.isJust)
+                return argRedex;
+            // Then check if this is a redex
+            const func = await loadTerm(collection, term.func);
+            if (func && isAbs(func)) {
+                return Maybe.just(termHash);
+            }
+            return Maybe.nothing();
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Beta Reduction
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Perform a single beta reduction step on a redex
+ *
+ * (λx.M) N →β M[x:=N]
+ *
+ * @param collection - Card collection
+ * @param redexHash - Hash of the application term (λx.M) N
+ * @returns Either<error, resultHash>
+ */
+export function betaReduce(collection, redexHash) {
+    return IO.of(async () => {
+        const app = await loadTerm(collection, redexHash);
+        if (!app) {
+            return Either.left(`Term not found: ${redexHash}`);
+        }
+        if (!isApp(app)) {
+            return Either.left(`Beta reduction requires application term, got ${app.tag}`);
+        }
+        const func = await loadTerm(collection, app.func);
+        if (!func) {
+            return Either.left(`Function not found: ${app.func}`);
+        }
+        if (!isAbs(func)) {
+            return Either.left(`Not a beta-redex: function is ${func.tag}, not abstraction`);
+        }
+        // Perform substitution: M[x:=N]
+        const resultHash = await substituteWithCapture(collection, func.body, // M
+        func.param, // x
+        app.arg // N (as hash)
+        );
+        return Either.right(resultHash);
+    });
+}
+/**
+ * Substitute a variable with a term (by hash), handling capture avoidance
+ *
+ * M[x:=N] - replaces all free occurrences of x in M with N
+ */
+async function substituteWithCapture(collection, termHash, variable, replacementHash) {
+    const term = await loadTerm(collection, termHash);
+    if (!term) {
+        throw new Error(`Term not found: ${termHash}`);
+    }
+    switch (term.tag) {
+        case 'Var':
+            // If this is the variable we're substituting, return the replacement
+            if (term.name === variable) {
+                return replacementHash;
+            }
+            // Otherwise unchanged
+            return termHash;
+        case 'Abs': {
+            // If bound variable shadows, stop substitution
+            if (term.param === variable) {
+                return termHash;
+            }
+            // Check for variable capture:
+            // If the bound variable (term.param) is free in the replacement,
+            // we must α-rename to avoid capture
+            const replacementFV = await freeVariables(collection, replacementHash).run();
+            if (replacementFV.isJust && replacementFV.value.has(term.param)) {
+                // Capture would occur! Need to α-rename first
+                const allVars = new Set(replacementFV.value);
+                // Also avoid variables in the body
+                const bodyFV = await freeVariables(collection, term.body).run();
+                if (bodyFV.isJust) {
+                    for (const v of bodyFV.value)
+                        allVars.add(v);
+                }
+                allVars.add(variable);
+                // Generate fresh name
+                const freshName = generateFresh(term.param, allVars);
+                // α-rename the abstraction
+                const renameResult = await alphaRename(collection, termHash, freshName).run();
+                if (renameResult.isLeft) {
+                    throw new Error(`Alpha rename failed: ${renameResult.left}`);
+                }
+                // Now substitute in the renamed term
+                return substituteWithCapture(collection, renameResult.right, variable, replacementHash);
+            }
+            // No capture - recurse into body
+            const newBody = await substituteWithCapture(collection, term.body, variable, replacementHash);
+            if (newBody === term.body) {
+                return termHash;
+            }
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await substituteWithCapture(collection, term.func, variable, replacementHash);
+            const newArg = await substituteWithCapture(collection, term.arg, variable, replacementHash);
+            if (newFunc === term.func && newArg === term.arg) {
+                return termHash;
+            }
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+/**
+ * Perform one reduction step using the specified strategy
+ */
+export function reduceStep(collection, termHash, strategy = 'normal') {
+    return IO.of(async () => {
+        // Find redex using strategy
+        let redexMaybe;
+        switch (strategy) {
+            case 'normal':
+            case 'lazy':
+                redexMaybe = await findRedexNormalOrder(collection, termHash);
+                break;
+            case 'applicative':
+                redexMaybe = await findRedexApplicativeOrder(collection, termHash);
+                break;
+        }
+        if (redexMaybe.isNothing) {
+            // No redex found - already in normal form
+            return Maybe.nothing();
+        }
+        const redexHash = redexMaybe.value;
+        // If the redex is the whole term, just reduce it
+        if (redexHash === termHash) {
+            const result = await betaReduce(collection, redexHash).run();
+            if (result.isLeft) {
+                throw new Error(result.left);
+            }
+            return Maybe.just(result.right);
+        }
+        // Otherwise, need to reduce the subterm and reconstruct
+        const reduced = await betaReduce(collection, redexHash).run();
+        if (reduced.isLeft) {
+            throw new Error(reduced.left);
+        }
+        const rebuilt = await rebuildWithReduced(collection, termHash, redexHash, reduced.right);
+        return Maybe.just(rebuilt);
+    });
+}
+/**
+ * Rebuild a term after reducing a subterm
+ */
+async function rebuildWithReduced(collection, termHash, redexHash, reducedHash) {
+    if (termHash === redexHash) {
+        return reducedHash;
+    }
+    const term = await loadTerm(collection, termHash);
+    if (!term)
+        throw new Error(`Term not found: ${termHash}`);
+    switch (term.tag) {
+        case 'Var':
+            return termHash;
+        case 'Abs': {
+            const newBody = await rebuildWithReduced(collection, term.body, redexHash, reducedHash);
+            if (newBody === term.body)
+                return termHash;
+            const newAbs = mkAbs(term.param, newBody);
+            return storeTerm(collection, newAbs);
+        }
+        case 'App': {
+            const newFunc = await rebuildWithReduced(collection, term.func, redexHash, reducedHash);
+            const newArg = await rebuildWithReduced(collection, term.arg, redexHash, reducedHash);
+            if (newFunc === term.func && newArg === term.arg)
+                return termHash;
+            const newApp = mkApp(newFunc, newArg);
+            return storeTerm(collection, newApp);
+        }
+    }
+}
+/**
+ * Normalize a term to its normal form (no more redexes)
+ *
+ * @param collection - Card collection
+ * @param termHash - Starting term
+ * @param strategy - Reduction strategy
+ * @param maxSteps - Maximum reduction steps (prevent infinite loops)
+ * @returns Either<error, NormalizationResult>
+ */
+export function normalize(collection, termHash, strategy = 'normal', maxSteps = 1000) {
+    return IO.of(async () => {
+        let current = termHash;
+        let steps = 0;
+        const path = [termHash];
+        while (steps < maxSteps) {
+            const stepResult = await reduceStep(collection, current, strategy).run();
+            if (stepResult.isNothing) {
+                // No more reductions - reached normal form
+                return Either.right({
+                    normalForm: current,
+                    steps,
+                    reductionPath: path
+                });
+            }
+            current = stepResult.value;
+            path.push(current);
+            steps++;
+        }
+        return Either.left(`Normalization did not terminate within ${maxSteps} steps (possible infinite loop)`);
+    });
+}
+/**
+ * Check if a term is in normal form (has no redexes)
+ */
+export function isNormalForm(collection, termHash) {
+    return findLeftmostRedex(collection, termHash).map(m => m.isNothing);
+}
+/**
+ * Check if a term has a normal form (is normalizing)
+ *
+ * Note: This is undecidable in general, so we use a bounded check
+ */
+export function hasNormalForm(collection, termHash, maxSteps = 1000) {
+    return normalize(collection, termHash, 'normal', maxSteps)
+        .map(result => result.isRight);
+}
+//# sourceMappingURL=BetaReduction.js.map