nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/partfrac.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partfrac = partfrac;
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const Matrix_1 = require("../core/classes/matrix/Matrix");
+const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const utils_1 = require("../core/classes/polynomial/utils");
+const factor_1 = require("./factor/factor");
+/**
+ * Decomposes a rational expression P(x)/Q(x) into partial fractions.
+ *
+ * @remarks
+ * The routine extracts `P(x)/Q(x)`, performs polynomial long division for an improper
+ * fraction, factors `Q` over the supported exact polynomial domain, and solves the
+ * undetermined coefficients by exact evaluation and row reduction. Repeated linear
+ * factors and irreducible quadratic factors are supported. An irreducible factor of
+ * higher degree, a singular coefficient system, a denominator independent of the
+ * selected variable, or a factorization that does not expose a useful decomposition
+ * leaves the original expression unchanged.
+ *
+ * @param x - Rational expression to decompose.
+ * @param variable - Main variable; defaults to the first variable reported by the expression.
+ * @returns A new decomposition when one is found, otherwise the original parsed expression.
+ */
+function partfrac(x, variable) {
+    const expr = Expression_1.Expression.create(x);
+    let result = expr;
+    // Determine the variable
+    const vars = expr.variables();
+    const v = variable ? String(variable) : vars[0];
+    if (v && vars.length > 0) {
+        // Extract numerator and denominator.
+        const { num, den } = extractNumDen(expr, v);
+        // Proceed only if the denominator depends on the variable
+        if (den.hasVariable(v)) {
+            const pNum = new Polynomial_1.Polynomial(num, [v]);
+            const pDen = new Polynomial_1.Polynomial(den, [v]);
+            const degNum = pNum.deg();
+            const degDen = pDen.deg();
+            // Step 1: If improper fraction, do polynomial long division
+            let polyPart = (0, shortcuts_1.zero)();
+            let remainder = num;
+            if (degNum >= degDen) {
+                const [quotient, rem] = (0, utils_1.divide)(num, den);
+                polyPart = quotient;
+                remainder = rem;
+            }
+            if (Expression_1.Expression.create(remainder).isZero()) {
+                // Remainder is zero — the expression is a polynomial
+                result = polyPart;
+            }
+            else if (degDen <= 1) {
+                // Denominator is linear or constant — no further decomposition possible.
+                // If we performed long division, return polyPart + remainder/den.
+                if (!polyPart.isZero()) {
+                    result = polyPart.plus(remainder.div(den));
+                }
+            }
+            else {
+                // Step 2: Factor the denominator
+                const factors = (0, factor_1.polyFactorExpressions)(den);
+                const factorList = collectFactors(factors, v);
+                // Only decompose if factoring produced multiple factors or a repeated factor
+                const canDecompose = factorList.length > 1 || (factorList.length === 1 && factorList[0].power > 1);
+                if (canDecompose) {
+                    // Step 3: Set up and solve partial fractions for remainder/den
+                    const decomposition = decompose(remainder, den, factorList, v);
+                    if (decomposition !== undefined) {
+                        result = polyPart.isZero() ? decomposition : polyPart.plus(decomposition);
+                    }
+                }
+            }
+        }
+    }
+    // A successful decomposition is mathematically equal to its input by definition.
+    // Use canonical text here to detect an unchanged shape rather than semantic equality.
+    return result.text() === expr.text() ? expr : result;
+}
+/**
+ * Extracts the numerator and denominator from an expression.
+ * For P/Q, returns { num: P, den: Q }.
+ *
+ * Rational expressions are typically stored as products where denominator
+ * factors have negative powers: P * Q^(-1).
+ */
+function extractNumDen(expr, _v) {
+    // Use getNumerator/getDenominator if available
+    try {
+        const num = expr.getNumerator();
+        const den = expr.getDenominator();
+        if (den && !den.isOne()) {
+            return { num, den };
+        }
+    }
+    catch {
+        // Fall through to manual extraction
+    }
+    // Manual extraction: examine the product structure
+    // If the expression is a product, separate positive-power and negative-power factors
+    if (expr.isProduct()) {
+        let num = (0, shortcuts_1.one)();
+        let den = (0, shortcuts_1.one)();
+        for (const element of expr.elementsArray()) {
+            if (element.getPower().isNegative()) {
+                // Negative power → denominator factor
+                den = den.times(element.invert());
+            }
+            else {
+                num = num.times(element);
+            }
+        }
+        // Apply the overall multiplier
+        num = num.times(Expression_1.Expression.fromRational(expr.getMultiplier()));
+        return { num, den };
+    }
+    // Not a product — check if it has a negative power overall
+    if (expr.getPower().sign() === -1) {
+        return { num: Expression_1.Expression.fromRational(expr.getMultiplier()), den: expr.invert() };
+    }
+    // No denominator
+    return { num: expr, den: (0, shortcuts_1.one)() };
+}
+/**
+ * Collects factors from the factor() result, grouping repeated factors.
+ * Extracts embedded powers from expressions like (x-1)^3 so that the
+ * base (x-1) is stored with degree 1 and power 3.
+ */
+function collectFactors(factors, v) {
+    const result = [];
+    const seen = new Map(); // text → index in result
+    for (const factor of factors) {
+        let f = factor;
+        // Skip constant factors (no variable)
+        if (!f.hasVariable(v)) {
+            continue;
+        }
+        // Extract embedded power from the expression (e.g., (x-1)^3 → base=(x-1), power=3)
+        let expPower = 1;
+        const p = f.getPower();
+        if (p.isInteger()) {
+            const n = Number(p.getNumerator());
+            if (n > 1) {
+                expPower = n;
+                f = f.getBase();
+            }
+        }
+        const key = f.text();
+        const deg = new Polynomial_1.Polynomial(f, [v]).deg();
+        if (seen.has(key)) {
+            // Repeated factor — accumulate power
+            result[seen.get(key)].power += expPower;
+        }
+        else {
+            seen.set(key, result.length);
+            result.push({ expr: f, power: expPower, degree: deg });
+        }
+    }
+    return result;
+}
+/**
+ * Decomposes remainder/den into partial fractions given the factored denominator.
+ *
+ * For each linear factor (ax+b)^k:
+ *   A₁/(ax+b) + A₂/(ax+b)² + ... + Aₖ/(ax+b)^k
+ *
+ * For each irreducible quadratic factor (ax²+bx+c)^k:
+ *   (B₁x+C₁)/(ax²+bx+c) + ... + (Bₖx+Cₖ)/(ax²+bx+c)^k
+ *
+ * Uses evaluation at strategic points to solve for coefficients.
+ */
+function decompose(numerator, denominator, factors, v) {
+    // Build the list of partial fraction terms and count unknowns.
+    // Each term is: coefficient(s) / factor^power
+    // For linear: 1 unknown per power level
+    // For quadratic: 2 unknowns per power level (Bx + C)
+    const terms = [];
+    let totalUnknowns = 0;
+    let supported = true;
+    for (const f of factors) {
+        for (let k = 1; k <= f.power; k++) {
+            if (f.degree === 1) {
+                terms.push({
+                    factor: f.expr,
+                    power: k,
+                    degree: f.degree,
+                    unknownIndex: totalUnknowns,
+                    numUnknowns: 1,
+                });
+                totalUnknowns += 1;
+            }
+            else if (f.degree === 2) {
+                terms.push({
+                    factor: f.expr,
+                    power: k,
+                    degree: f.degree,
+                    unknownIndex: totalUnknowns,
+                    numUnknowns: 2,
+                });
+                totalUnknowns += 2;
+            }
+            else {
+                // Higher-degree irreducible factors — not supported yet
+                supported = false;
+            }
+        }
+    }
+    if (!supported) {
+        return undefined;
+    }
+    // We need to solve: P(x)/Q(x) = Σ terms
+    // Multiply both sides by Q(x):
+    // P(x) = Σ (coefficients_i × Q(x) / factor_i^power_i)
+    //
+    // Strategy: evaluate at `totalUnknowns` distinct values of x to get a linear system,
+    // then solve it.
+    // Collect evaluation points: roots of linear factors + additional integer points
+    const evalPoints = [];
+    for (const f of factors) {
+        if (f.degree === 1) {
+            // Linear factor ax + b: root is x = -b/a
+            const root = findLinearRoot(f.expr, v);
+            if (root !== undefined) {
+                evalPoints.push(root);
+            }
+        }
+    }
+    // Add additional integer points to get enough equations
+    let pointVal = 0;
+    while (evalPoints.length < totalUnknowns) {
+        const candidate = Expression_1.Expression.Number(pointVal);
+        // Make sure this isn't a root of the denominator (would give division by zero)
+        const denAtPoint = evaluateAt(denominator, v, candidate);
+        if (!denAtPoint.isZero()) {
+            // Also make sure it's not already in our list
+            const isDuplicate = evalPoints.some(p => p.eq(candidate));
+            if (!isDuplicate) {
+                evalPoints.push(candidate);
+            }
+        }
+        pointVal = pointVal <= 0 ? -pointVal + 1 : -pointVal;
+    }
+    // Build and solve the linear system by evaluation.
+    // For each eval point xᵢ:
+    //   P(xᵢ) = Σⱼ unknowns_j × basisⱼ(xᵢ)
+    // where basisⱼ(x) is what multiplies the j-th unknown after clearing denominators.
+    const rows = [];
+    const rhs = [];
+    const cofactors = terms.map(term => computeCofactor(denominator, term.factor, term.power));
+    for (let i = 0; i < totalUnknowns; i++) {
+        const x = evalPoints[i];
+        const numVal = evaluateAt(numerator, v, x);
+        rhs.push(numVal);
+        const row = [];
+        for (let j = 0; j < terms.length; j++) {
+            const term = terms[j];
+            // The basis for this term: Q(x) / factor^power, evaluated at x
+            const cofactor = evaluateAt(cofactors[j], v, x);
+            if (term.numUnknowns === 1) {
+                row.push(cofactor);
+            }
+            else {
+                // Quadratic: (Bx + C) contributes B*x*cofactor + C*cofactor
+                row.push(x.times(cofactor)); // coefficient of B
+                row.push(cofactor); // coefficient of C
+            }
+        }
+        rows.push(row);
+    }
+    // Solve the system
+    const solution = solveLinearSystem(rows, rhs);
+    if (solution === undefined) {
+        return undefined;
+    }
+    // Build the result expression from the solved coefficients
+    let result = (0, shortcuts_1.zero)();
+    for (const term of terms) {
+        const denomPart = term.power === 1 ? term.factor : term.factor.pow(Expression_1.Expression.Number(term.power));
+        if (term.numUnknowns === 1) {
+            const A = solution[term.unknownIndex];
+            if (!A.isZero()) {
+                result = result.plus(A.div(denomPart));
+            }
+        }
+        else {
+            const B = solution[term.unknownIndex];
+            const C = solution[term.unknownIndex + 1];
+            // (Bx + C) / factor^power
+            const numPart = B.times(Expression_1.Expression.create(v)).plus(C);
+            if (!numPart.isZero()) {
+                result = result.plus(numPart.div(denomPart));
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Finds the root of a linear expression ax + b, returning -b/a.
+ */
+function findLinearRoot(expr, v) {
+    // A linear expression ax + b: evaluate at x=0 to get b, at x=1 to get a+b
+    const atZero = evaluateAt(expr, v, (0, shortcuts_1.zero)());
+    const atOne = evaluateAt(expr, v, (0, shortcuts_1.one)());
+    const a = atOne.plus(atZero.times((0, shortcuts_1.minusOne)())); // a = f(1) - f(0)
+    if (a.isZero()) {
+        return undefined;
+    }
+    // root = -b/a = -f(0)/a
+    return atZero.times((0, shortcuts_1.minusOne)()).div(a);
+}
+/**
+ * Evaluates a polynomial expression at a specific rational value of the variable.
+ * Returns the result as an Expression.
+ */
+function evaluateAt(expr, v, value) {
+    return expr.subst(v, value);
+}
+/**
+ * Computes Q(x) / factor(x)^power.
+ * This is the "cofactor" — the part of the denominator that remains after removing this term's factor.
+ */
+function computeCofactor(denominator, fac, power) {
+    // Q / factor^power
+    const facPow = power === 1 ? fac : fac.pow(Expression_1.Expression.Number(power));
+    const [quotient] = (0, utils_1.divide)(denominator, facPow);
+    return quotient;
+}
+/**
+ * Solves a linear system Ax = b using Gaussian elimination with partial pivoting.
+ * Works with Expression arithmetic (exact rational arithmetic).
+ *
+ * @param A The coefficient matrix (array of rows)
+ * @param b The right-hand side vector
+ * @returns The solution vector, or undefined if the system is singular
+ */
+function solveLinearSystem(A, b) {
+    const n = b.length;
+    if (n === 0) {
+        return [];
+    }
+    // This solver is used to recover exact coefficients for partial fractions.
+    // Use Matrix.rref() so we don't duplicate row-reduction logic.
+    // Require a unique solution (square, full-rank). Otherwise return undefined.
+    const A_mat = new Matrix_1.Matrix(...A);
+    const b_col = new Matrix_1.Matrix(...b.map(v => [v]));
+    const aug = A_mat.augment(b_col).rref();
+    const rows = aug.rows();
+    const cols = aug.cols();
+    const unknowns = cols - 1;
+    if (rows !== n || unknowns !== n) {
+        return undefined;
+    }
+    // Inconsistency: [0 ... 0 | nonzero]
+    for (let i = 0; i < rows; i++) {
+        let allZero = true;
+        for (let j = 0; j < unknowns; j++) {
+            if (!aug.elements[i][j].isZero()) {
+                allZero = false;
+                break;
+            }
+        }
+        if (allZero && !aug.elements[i][unknowns].isZero()) {
+            return undefined;
+        }
+    }
+    // Extract solution from pivots. Expect [I | x] up to row ordering.
+    const solution = new Array(n);
+    const pivotCols = new Set();
+    for (let i = 0; i < rows; i++) {
+        let pivot = -1;
+        for (let j = 0; j < unknowns; j++) {
+            if (!aug.elements[i][j].isZero()) {
+                pivot = j;
+                break;
+            }
+        }
+        if (pivot === -1) {
+            continue;
+        }
+        if (!aug.elements[i][pivot].eq('1')) {
+            return undefined;
+        }
+        if (pivotCols.has(pivot)) {
+            return undefined;
+        }
+        pivotCols.add(pivot);
+        solution[pivot] = aug.elements[i][unknowns];
+    }
+    if (pivotCols.size !== n) {
+        return undefined;
+    }
+    for (let i = 0; i < n; i++) {
+        if (!solution[i]) {
+            return undefined;
+        }
+    }
+    return solution;
+}

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,24 @@
+"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 ??= {};
+    // First simplify the expression
+    let x = (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;