nerdamer 1.1.13 → 2.0.0-rc.2

package/output/algebra/polynomial/modularGcd.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * @module modularGcd
+ *
+ * Greatest common divisors for sparse polynomials over a modular field.
+ *
+ * External references consulted for finite-field Euclidean GCD and recursive
+ * evaluation/interpolation:
+ * - SymPy finite-field polynomial GCD:
+ *   https://github.com/sympy/sympy/blob/120ee85f346f6292b763cc195afda4f907260d4a/sympy/polys/galoistools.py
+ * - SymPy sparse univariate modular GCD bridge:
+ *   https://github.com/sympy/sympy/blob/120ee85f346f6292b763cc195afda4f907260d4a/sympy/polys/zippel.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modularGcdUnivariate = modularGcdUnivariate;
+exports.modularGcdFiniteField = modularGcdFiniteField;
+exports.modularGcdBivariate = modularGcdBivariate;
+exports.modularGcdTrivariate = modularGcdTrivariate;
+const errors_1 = require("../../core/errors");
+const primeFactor_1 = require("../../core/functions/bigint/primeFactor");
+const ModularSparsePolynomial_1 = require("./ModularSparsePolynomial");
+// SymPy gives failed sparse interpolation data a small number of fresh attempts
+// before abandoning the current modular image.
+const MODULAR_GCD_RECONSTRUCTION_ATTEMPTS = 3n;
+/**
+ * Computes polynomial content in one selected coefficient variable.
+ *
+ * Terms are grouped by their complete exponent vector outside coefficientVariable.
+ * The grouping key is used only for identity and is never parsed back into exponents.
+ */
+function modularContentInVariable(polynomial, coefficientVariable) {
+    polynomial.degree(coefficientVariable);
+    if (polynomial.isZero()) {
+        return ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus);
+    }
+    const groups = new Map();
+    for (const term of polynomial.terms()) {
+        const groupExponents = [...term.exponents];
+        groupExponents[coefficientVariable] = 0n;
+        const key = groupExponents.join(',');
+        const coefficientExponents = new Array(polynomial.variableCount).fill(0n);
+        coefficientExponents[coefficientVariable] = term.exponents[coefficientVariable];
+        const group = groups.get(key) ?? [];
+        group.push({
+            coefficient: term.coefficient,
+            exponents: coefficientExponents,
+        });
+        groups.set(key, group);
+    }
+    let content = ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus);
+    for (const terms of groups.values()) {
+        const coefficient = new ModularSparsePolynomial_1.ModularSparsePolynomial(polynomial.variableCount, polynomial.modulus, terms);
+        content = content.isZero()
+            ? coefficient.monic('lex')
+            : modularGcdUnivariate(content, coefficient, coefficientVariable);
+        if (content.isConstant()) {
+            return ModularSparsePolynomial_1.ModularSparsePolynomial.constant(polynomial.variableCount, polynomial.modulus, 1n);
+        }
+    }
+    return content.monic('lex');
+}
+/** Removes polynomial content in one selected coefficient variable. */
+function modularPrimitivePartInVariable(polynomial, coefficientVariable) {
+    if (polynomial.isZero()) {
+        return {
+            content: ModularSparsePolynomial_1.ModularSparsePolynomial.zero(polynomial.variableCount, polynomial.modulus),
+            primitive: polynomial,
+        };
+    }
+    const content = modularContentInVariable(polynomial, coefficientVariable);
+    const primitive = polynomial.divideExact(content);
+    if (primitive === null) {
+        throw new RangeError((0, errors_1.message)('polyModularContentExactDivision'));
+    }
+    return { content, primitive };
+}
+/**
+ * Returns the coefficient polynomial at the lexicographically greatest monomial
+ * in polynomialVariables. The result depends only on coefficientVariable.
+ */
+function modularLeadingCoefficientInVariables(polynomial, polynomialVariables, coefficientVariable) {
+    polynomial.degree(coefficientVariable);
+    for (const variableIndex of polynomialVariables) {
+        polynomial.degree(variableIndex);
+    }
+    const terms = polynomial.terms();
+    if (terms.length === 0) {
+        return null;
+    }
+    let leading = terms[0];
+    for (let termIndex = 1; termIndex < terms.length; termIndex++) {
+        const term = terms[termIndex];
+        for (const variableIndex of polynomialVariables) {
+            if (term.exponents[variableIndex] === leading.exponents[variableIndex]) {
+                continue;
+            }
+            if (term.exponents[variableIndex] > leading.exponents[variableIndex]) {
+                leading = term;
+            }
+            break;
+        }
+    }
+    const coefficientTerms = [];
+    for (const term of terms) {
+        let matches = true;
+        for (const variableIndex of polynomialVariables) {
+            if (term.exponents[variableIndex] !== leading.exponents[variableIndex]) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches) {
+            continue;
+        }
+        const exponents = new Array(polynomial.variableCount).fill(0n);
+        exponents[coefficientVariable] = term.exponents[coefficientVariable];
+        coefficientTerms.push({
+            coefficient: term.coefficient,
+            exponents,
+        });
+    }
+    return new ModularSparsePolynomial_1.ModularSparsePolynomial(polynomial.variableCount, polynomial.modulus, coefficientTerms);
+}
+/**
+ * Returns the monomial support over selected variables.
+ *
+ * Keys are used only for set membership and are never decoded back into exponents.
+ */
+function monomialSupport(polynomial, variables) {
+    const support = new Set();
+    for (const term of polynomial.terms()) {
+        support.add(variables.map(variableIndex => term.exponents[variableIndex]).join(','));
+    }
+    return support;
+}
+/**
+ * Computes the monic GCD of two univariate polynomials over the same modular field.
+ *
+ * The polynomial ring may retain additional variable coordinates, but neither input
+ * may depend on variables other than variableIndex.
+ */
+function modularGcdUnivariate(left, right, variableIndex) {
+    if (left.variableCount !== right.variableCount || left.modulus !== right.modulus) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqSamePolynomialRing') }));
+    }
+    left.degree(variableIndex);
+    right.degree(variableIndex);
+    for (const activeVariable of left.variables()) {
+        if (activeVariable !== variableIndex) {
+            throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD inputs', requirement: (0, errors_1.message)('polyReqUnivariatePolynomial') }));
+        }
+    }
+    for (const activeVariable of right.variables()) {
+        if (activeVariable !== variableIndex) {
+            throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD inputs', requirement: (0, errors_1.message)('polyReqUnivariatePolynomial') }));
+        }
+    }
+    let a = new ModularSparsePolynomial_1.ModularSparsePolynomial(left.variableCount, left.modulus, left.terms());
+    let b = new ModularSparsePolynomial_1.ModularSparsePolynomial(right.variableCount, right.modulus, right.terms());
+    while (!b.isZero()) {
+        const division = a.divideWithRemainder(b, 'lex');
+        a = b;
+        b = division.remainder;
+    }
+    return a.isZero() ? a : a.monic('lex');
+}
+/**
+ * Computes a modular GCD recursively by specializing the last selected variable.
+ *
+ * The caller supplies the variable order used by the recursive polynomial view.
+ * Ring coordinates not listed in variables must be dormant.
+ */
+function modularGcdRecursive(left, right, variables) {
+    if (variables.length === 1) {
+        return modularGcdUnivariate(left, right, variables[0]);
+    }
+    if (left.isZero()) {
+        return right.isZero() ? right : right.monic('lex');
+    }
+    if (right.isZero()) {
+        return left.monic('lex');
+    }
+    const interpolationVariable = variables[variables.length - 1];
+    const polynomialVariables = variables.slice(0, -1);
+    const leftParts = modularPrimitivePartInVariable(left, interpolationVariable);
+    const rightParts = modularPrimitivePartInVariable(right, interpolationVariable);
+    const contentGcd = modularGcdUnivariate(leftParts.content, rightParts.content, interpolationVariable);
+    const leftLeading = modularLeadingCoefficientInVariables(leftParts.primitive, polynomialVariables, interpolationVariable);
+    const rightLeading = modularLeadingCoefficientInVariables(rightParts.primitive, polynomialVariables, interpolationVariable);
+    if (leftLeading === null || rightLeading === null) {
+        return null;
+    }
+    const scaling = modularGcdUnivariate(leftLeading, rightLeading, interpolationVariable);
+    const leftInterpolationDegree = leftParts.primitive.degree(interpolationVariable) ?? 0n;
+    const rightInterpolationDegree = rightParts.primitive.degree(interpolationVariable) ?? 0n;
+    const maxGcdDegree = leftInterpolationDegree < rightInterpolationDegree
+        ? leftInterpolationDegree
+        : rightInterpolationDegree;
+    const leftLeadingDegree = leftLeading.degree(interpolationVariable) ?? 0n;
+    const rightLeadingDegree = rightLeading.degree(interpolationVariable) ?? 0n;
+    const scalingDegree = scaling.degree(interpolationVariable) ?? 0n;
+    const requiredSamples = maxGcdDegree + 2n;
+    const badPointBound = leftLeadingDegree + rightLeadingDegree + scalingDegree;
+    const availablePoints = left.modulus - 1n;
+    const requestedPoints = requiredSamples * MODULAR_GCD_RECONSTRUCTION_ATTEMPTS + badPointBound;
+    const scanLimit = availablePoints < requestedPoints ? availablePoints : requestedPoints;
+    let expectedDegrees = null;
+    let expectedSupport = null;
+    let acceptedSamples = 0n;
+    let reconstructionAttempts = 0n;
+    let samples = [];
+    for (let value = 1n; value <= scanLimit; value++) {
+        const leftLeadingValue = leftLeading.evaluateVariable(interpolationVariable, value);
+        const rightLeadingValue = rightLeading.evaluateVariable(interpolationVariable, value);
+        const scalingValue = scaling.evaluateVariable(interpolationVariable, value).constantTerm();
+        if (leftLeadingValue.constantTerm() === 0n ||
+            rightLeadingValue.constantTerm() === 0n ||
+            scalingValue === 0n) {
+            continue;
+        }
+        const evaluatedLeft = leftParts.primitive.evaluateVariable(interpolationVariable, value);
+        const evaluatedRight = rightParts.primitive.evaluateVariable(interpolationVariable, value);
+        if (evaluatedLeft.isZero() || evaluatedRight.isZero()) {
+            continue;
+        }
+        const image = modularGcdRecursive(evaluatedLeft, evaluatedRight, polynomialVariables);
+        if (image === null) {
+            continue;
+        }
+        if (image.isConstant() && !image.isZero()) {
+            return contentGcd;
+        }
+        const imageDegrees = polynomialVariables.map(variableIndex => image.degree(variableIndex) ?? 0n);
+        if (expectedDegrees === null) {
+            expectedDegrees = imageDegrees;
+        }
+        else {
+            let degreeComparison = 0;
+            for (let index = 0; index < imageDegrees.length; index++) {
+                if (imageDegrees[index] < expectedDegrees[index]) {
+                    degreeComparison = -1;
+                    break;
+                }
+                if (imageDegrees[index] > expectedDegrees[index]) {
+                    degreeComparison = 1;
+                    break;
+                }
+            }
+            if (degreeComparison < 0) {
+                expectedDegrees = imageDegrees;
+                expectedSupport = null;
+                samples = [];
+                acceptedSamples = 0n;
+                reconstructionAttempts = 0n;
+            }
+            else if (degreeComparison > 0) {
+                continue;
+            }
+        }
+        const imageSupport = monomialSupport(image, polynomialVariables);
+        if (expectedSupport === null) {
+            expectedSupport = imageSupport;
+        }
+        else {
+            const imageContainsExpected = [...expectedSupport].every(key => imageSupport.has(key));
+            const currentSupport = expectedSupport;
+            const expectedContainsImage = [...imageSupport].every(key => currentSupport.has(key));
+            if (imageContainsExpected && !expectedContainsImage) {
+                expectedSupport = imageSupport;
+                samples = [];
+                acceptedSamples = 0n;
+                reconstructionAttempts = 0n;
+            }
+            else if (!imageContainsExpected) {
+                continue;
+            }
+        }
+        samples.push({
+            value,
+            polynomial: image.scale(scalingValue),
+        });
+        acceptedSamples++;
+        if (acceptedSamples < requiredSamples) {
+            continue;
+        }
+        const interpolated = ModularSparsePolynomial_1.ModularSparsePolynomial.interpolateVariable(interpolationVariable, samples);
+        const reconstructed = modularPrimitivePartInVariable(interpolated, interpolationVariable).primitive;
+        const candidate = reconstructed.multiply(contentGcd).monic('lex');
+        if (left.divideExact(candidate) !== null && right.divideExact(candidate) !== null) {
+            return candidate;
+        }
+        reconstructionAttempts++;
+        if (reconstructionAttempts >= MODULAR_GCD_RECONSTRUCTION_ATTEMPTS) {
+            return null;
+        }
+        samples = [];
+        acceptedSamples = 0n;
+    }
+    return null;
+}
+/**
+ * Computes a multivariate GCD over a prime field using recursive
+ * evaluation and interpolation.
+ *
+ * variables must follow polynomial-ring order and contain every active variable
+ * in both inputs exactly once. Dormant ring coordinates may be omitted.
+ */
+function modularGcdFiniteField(left, right, variables) {
+    if (left.variableCount !== right.variableCount || left.modulus !== right.modulus) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqSamePolynomialRing') }));
+    }
+    if (variables.length === 0) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Modular polynomial GCD', requirement: (0, errors_1.message)('polyReqAtLeastOneVariable') }));
+    }
+    if (!(0, primeFactor_1.isPrimeBig)(left.modulus)) {
+        throw new RangeError((0, errors_1.message)('polyRequires', { operation: 'Multivariate modular GCD', requirement: (0, errors_1.message)('polyReqPrimeModulus') }));
+    }
+    const selected = new Set();
+    let previousVariable = -1;
+    for (const variableIndex of variables) {
+        left.degree(variableIndex);
+        right.degree(variableIndex);
+        if (selected.has(variableIndex)) {
+            throw new RangeError((0, errors_1.message)('polyVariablesUnique', { operation: 'Modular polynomial GCD' }));
+        }
+        if (variableIndex <= previousVariable) {
+            throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Modular polynomial GCD' }));
+        }
+        selected.add(variableIndex);
+        previousVariable = variableIndex;
+    }
+    for (const activeVariable of [...left.variables(), ...right.variables()]) {
+        if (!selected.has(activeVariable)) {
+            throw new RangeError((0, errors_1.message)('polyInputsSelectedOnly', { operation: 'Modular polynomial GCD' }));
+        }
+    }
+    return modularGcdRecursive(left, right, variables);
+}
+/**
+ * Computes a bivariate GCD over a prime field by evaluation and interpolation.
+ */
+function modularGcdBivariate(left, right, mainVariable, interpolationVariable) {
+    if (mainVariable >= interpolationVariable) {
+        throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Bivariate modular GCD' }));
+    }
+    return modularGcdFiniteField(left, right, [mainVariable, interpolationVariable]);
+}
+/**
+ * Computes a trivariate GCD over a prime field by recursively specializing the
+ * last selected variable and reconstructing from bivariate GCD images.
+ *
+ * The selected variables must follow their polynomial-ring order. Other ring
+ * coordinates may remain dormant.
+ */
+function modularGcdTrivariate(left, right, mainVariable, secondaryVariable, interpolationVariable) {
+    if (mainVariable >= secondaryVariable ||
+        secondaryVariable >= interpolationVariable) {
+        throw new RangeError((0, errors_1.message)('polyVariablesRingOrder', { operation: 'Trivariate modular GCD' }));
+    }
+    return modularGcdFiniteField(left, right, [
+        mainVariable,
+        secondaryVariable,
+        interpolationVariable,
+    ]);
+}

package/output/algebra/polynomialize.d.ts

@@ -0,0 +1,20 @@
+import type { Expression } from '../core/classes/expression/Expression';
+import type { Vector } from '../core/classes/vector/Vector';
+import type { MapObjectType } from '../core/functions/subst';
+/**
+ * Attempts to put the expression in polynomial form.
+ *
+ * @param expression The expression to normalize and polynomialize.
+ * @param map Existing u-substitutions to preserve across related expressions.
+ * @returns Polynomial numerator and denominator plus the substitution map.
+ */
+export declare function polynomialize(expression: Expression, map?: MapObjectType): {
+    numerator: Expression;
+    denominator: Expression;
+    map: MapObjectType;
+};
+export declare function polynomialize<T extends Expression | Vector>(expression: Expression, map: MapObjectType | undefined, callback: (e: Expression, map: MapObjectType) => T): {
+    numerator: T;
+    denominator: T;
+    map: MapObjectType;
+};

package/output/algebra/polynomialize.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomialize = polynomialize;
+const subst_1 = require("../core/functions/subst");
+const simplify_1 = require("./simplify/simplify");
+function polynomialize(expression, map, callback) {
+    map ??= {};
+    // Ordinary polynomial input is already in the exact domain required below.
+    // Avoid routing it through the full simplifier, which ends by factoring and can
+    // recursively re-enter polynomial GCD preprocessing.
+    let x = expression.isPolynomialLike() ? expression : (0, simplify_1.simplify)(expression);
+    // Substitute out all functions
+    [x, map] = (0, subst_1.uSubFN)(x, map);
+    // Substitute out all exponential functions
+    [x, map] = (0, subst_1.uSubEXP)(x, map);
+    // Constants although numeric are irrationals and need to be removed.
+    [x, map] = (0, subst_1.uSubConstants)(x, map);
+    // Extract the numerator and denominator
+    const num = x.getNumerator();
+    const den = x.getDenominator();
+    return {
+        numerator: callback ? callback(num, map) : num,
+        denominator: callback ? callback(den, map) : den,
+        map,
+    };
+}

package/output/algebra/simplify/complexsimp.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Simplifies a complex number. Assumes expression is in the form a*i+b
+ *
+ * @param x
+ */
+export declare function complexSimplify(x: Expression): Expression;

package/output/algebra/simplify/complexsimp.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complexSimplify = complexSimplify;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const expand_1 = require("../../core/functions/expand/expand");
+/**
+ * Simplifies a complex number. Assumes expression is in the form a*i+b
+ *
+ * @param x
+ */
+function complexSimplify(x) {
+    const p = x.getPower();
+    // Only handle (a*i+b)^(-1) -> a/(a^2+b^2) - b/(a^2+b^2)*i
+    if (!p.isInteger() || !p.isMinusOne() /* or p.text() !== '-1' */) {
+        return x;
+    }
+    // base = (a*i+b)
+    const base = (0, expand_1.expand)(x.invert());
+    const re = base.realPart();
+    const im = base.imagPart();
+    const d = re.pow((0, shortcuts_1.two)()).plus(im.pow((0, shortcuts_1.two)()));
+    return re.div(d).minus(im.div(d).times(Expression_1.Expression.Img()));
+}

package/output/algebra/simplify/factorCommon.d.ts

@@ -0,0 +1,13 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Factors out the greatest common power from each base in a sum expression.
+ *
+ * For example:
+ *   x^(3/2) + x^(1/2)         → x^(1/2) * (x + 1)
+ *   x^3 + x^2                  → x^2 * (x + 1)
+ *   2*x^(5/2) + 3*x^(3/2)     → x^(3/2) * (2*x + 3)
+ *   x^2*y + x*y^2              → x*y * (x + y)
+ *
+ * Only applies to sums. Non-sum expressions are returned unchanged.
+ */
+export declare function factorCommonPower(x: Expression): Expression;

package/output/algebra/simplify/factorCommon.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorCommonPower = factorCommonPower;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+/**
+ * Extracts a map of {base_value → power} from a single term of a sum.
+ *
+ * For a simple variable like x^(3/2), returns { 'x': 3/2 as Expression }
+ * For a product like 2*x^(3/2)*y^2, returns { 'x': 3/2, 'y': 2 }
+ * For a constant like 5, returns {}
+ *
+ * The coefficient (numeric multiplier) is not included in the map.
+ */
+function extractBasePowers(term) {
+    const map = new Map();
+    if (term.isNUM()) {
+        // Pure number — no bases to extract
+        return map;
+    }
+    if (term.isProduct()) {
+        for (const element of term.elementsArray()) {
+            if (!element.isNUM()) {
+                const base = element.getBase();
+                const key = base.text();
+                const power = element.getPower();
+                // Accumulate: a product might have the same base appear once,
+                // but just in case, add powers
+                const existing = map.get(key);
+                map.set(key, existing !== undefined ? existing.plus(power) : power);
+            }
+        }
+    }
+    else {
+        const base = term.getBase();
+        const key = base.text();
+        map.set(key, term.getPower());
+    }
+    return map;
+}
+/**
+ * Factors out the greatest common power from each base in a sum expression.
+ *
+ * For example:
+ *   x^(3/2) + x^(1/2)         → x^(1/2) * (x + 1)
+ *   x^3 + x^2                  → x^2 * (x + 1)
+ *   2*x^(5/2) + 3*x^(3/2)     → x^(3/2) * (2*x + 3)
+ *   x^2*y + x*y^2              → x*y * (x + y)
+ *
+ * Only applies to sums. Non-sum expressions are returned unchanged.
+ */
+function factorCommonPower(x) {
+    if (!x.isSum()) {
+        return x;
+    }
+    const m = x.getMultiplier();
+    const p = x.getPower();
+    const terms = x.elementsArray();
+    // Edge case: single term or empty
+    if (terms.length < 2) {
+        return x;
+    }
+    // Step 1: Extract base → power maps for each term
+    const termMaps = [];
+    let hasConstantTerm = false;
+    for (const term of terms) {
+        const map = extractBasePowers(term);
+        termMaps.push(map);
+        if (map.size === 0) {
+            hasConstantTerm = true;
+        }
+    }
+    // If there's a constant term (no bases), no common base can be factored
+    if (hasConstantTerm) {
+        return x;
+    }
+    // Step 2: Find bases common to ALL terms
+    const commonBases = new Set(termMaps[0].keys());
+    for (let i = 1; i < termMaps.length; i++) {
+        for (const key of commonBases) {
+            if (!termMaps[i].has(key)) {
+                commonBases.delete(key);
+            }
+        }
+    }
+    // Nothing common to factor out
+    if (commonBases.size === 0) {
+        return x;
+    }
+    // Step 3: For each common base, find the minimum power across all terms
+    const minPowers = new Map();
+    for (const base of commonBases) {
+        let minPow = termMaps[0].get(base);
+        if (minPow === undefined) {
+            continue;
+        }
+        for (let i = 1; i < termMaps.length; i++) {
+            const pow = termMaps[i].get(base);
+            if (pow === undefined) {
+                minPow = undefined;
+                break;
+            }
+            // Use lt to compare — take the smaller power
+            if (pow.lt(minPow)) {
+                minPow = pow;
+            }
+        }
+        // Only factor out positive powers
+        if (minPow !== undefined && minPow.sign() === 1) {
+            minPowers.set(base, minPow);
+        }
+    }
+    // Nothing positive to factor out
+    if (minPowers.size === 0) {
+        return x;
+    }
+    // Step 4: Build the common factor and the reduced sum
+    let commonFactor = (0, shortcuts_1.one)();
+    for (const [base, power] of minPowers) {
+        commonFactor = commonFactor.times(Expression_1.Expression.create(base).pow(power));
+    }
+    // Step 5: Divide each term by the common factor to get the inner sum
+    let innerSum = (0, shortcuts_1.zero)();
+    for (const term of terms) {
+        innerSum = innerSum.plus(term.div(commonFactor));
+    }
+    // Step 6: Reconstruct with outer multiplier and power
+    let result = commonFactor.times(innerSum);
+    if (!p.isOne()) {
+        result = result.pow(p);
+    }
+    if (!m.isOne()) {
+        result = result.times(m);
+    }
+    return result;
+}

package/output/algebra/simplify/funcsimp.d.ts

@@ -0,0 +1,26 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Simplifies factorial ratios in a product expression.
+ *
+ *   n! · (n+k)!^(-1) → 1 / ((n+1)(n+2)...(n+k))    when k > 0
+ *   (n+k)! · n!^(-1) → (n+1)(n+2)...(n+k)           when k > 0
+ *
+ * Works by finding pairs of factorials where one has power 1 and the other
+ * has power -1, computing their argument difference, and replacing with
+ * the product of consecutive integers.
+ */
+export declare function simplifyFactorials(x: Expression): Expression;
+/**
+ * Combines logarithmic terms in a sum expression when their arguments are
+ * provably positive real values. Unknown-sign logarithms are left unchanged
+ * so these real-domain identities do not cross principal complex branches.
+ *
+ * Power lifting + combination:
+ *   log(x) + log(y)         → log(x·y)             [combine, coeff=1]
+ *   2·log(x) + 3·log(y)    → log(x²·y³)           [lift then combine]
+ *   (1/2)·log(x)           → (1/2)·log(x)          [rational, standalone: keep]
+ *   (1/2)·log(x) + (1/3)·log(y) → log(x^(1/2)·y^(1/3))  [rational, combining: lift]
+ *   a·log(u) + a·log(v)    → a·log(u·v)            [symbolic, group by coeff]
+ *   log(a) - log(b)         → log(a/b)             [sign handling]
+ */
+export declare function simplifyLogs(x: Expression): Expression;