Symbolic Unfolded

The project’s technical reference names the evidence behind an answer: an interval bound under stated assumptions, a sampled check, an exact construction or a search result. Exact ℚ and ℚ(α) sits outside this list: it returns an exact value within its supported domain or refuses.

The parser establishes precedence and associativity before building ExpressionNode objects. MathematicalExpression owns the root and includes the capability modules that act on it. Operations share this representation rather than each implementing an independent parser. The web/VM layer serializes the resulting tree, formula, steps and method information for the interface.

The ordinary Polynomial type uses floating-point coefficients. The separate ExactPolynomial type exists because converting a Rational to float at construction would lose the very information needed for an exact GCD or zero test. Choosing the arithmetic representation changes what can be computed exactly, as well as how values are displayed.

Numerical methods dominate practical computation, but an analytical result offers things sampling does not: an exact derivative has no discretization error, a closed form shows structure, and an expression can be simplified before it is evaluated many times. Where a fully analytical treatment is out of reach, a pipeline that is symbolic where possible and numerical where necessary is the direction this project is meant to explore, with semi-analytical rendering and simulation as longer-term interests.

Systems such as SymPy, Mathematica and Maple are powerful, but their internals are hard to inspect from outside. Building the engine directly shows where the difficulty lies. The earlier showcase said that parsing is straightforward and integration is hard. The second part held; the first did not. A later audit found that the original parser inverted associativity (5 − 2 + 1 evaluated to 2 and 2^3^2 to 64), crashed on a leading minus and silently dropped the variable in 2x. All three are fixed and covered by regression tests.

Each function name the parser accepts has a derivative case, and an operator with no case returns 0. An earlier build had no case for abs, so d/dx |x| silently became 0; because every ln|u| antiderivative contains an absolute value, that also disabled the antiderivative check for a whole family of correct integrals until it was fixed.

The float evaluator handles sech, csch, coth and both spellings of the inverse hyperbolic functions. Readable and pastable output retains their arguments, so a derivative such as −sech(x) tanh(x) can be copied back into the input and evaluated. Real-domain violations return no finite real value; poles remain non-finite rather than silently becoming zero.

Derivative results carry no automatic verdict badge. Focused regression probes compare derivatives with independent finite differences and verify that displayed expressions survive copying back into the parser. These checks support the implementation; they do not prove every symbolic rewrite. The large derivative in the still above agrees with central differences at x = 3.0, 4.2 and 7.1 to within 1e-9 relative.

simplify runs the standard or experimental pass while the previous pass reported a change, up to 30 iterations. It stops early if a pass claims a change but the printed expression is unchanged, and records each changed iteration for the steps panel.

Several rewrites once changed the value of an expression: a constant fold turned 0 − 1 into −2, which made d/dx(1/x) come out as −2·x^−2, and a normalizer step dropped the constant in c/(k·x^n). A general like-term collector added later evaluates the old and new subtrees at sample points and abandons the rewrite if they disagree. A fuzz probe simplifies 5,585 random expressions from a fixed seed and requires the value at three points to stay the same; it also found a polynomial division that never terminated on 12.25/(y − 2), since fixed.

Division-form substitution is tried early for expressions such as ln(x)/x, before rewriting division into a product and a negative power. General substitution, table lookup and rational structure likewise have deliberate positions in the cascade. Some phases return a candidate; others rewrite the working expression and continue or recurse.

Depth and call-count guards bound the recursive search. Finalization also prevents a partially solved tree from losing an integral marker through later simplification and being displayed as a complete antiderivative. These are explicit termination and result-shape safeguards, not completeness guarantees. The strategy trace shows which methods actually ran for the current expression.

The technical reference lists the phases in the following order. The raw-form, table, substitution and product-family phases return only a result they completed; normalization and the identity rewrite change the working expression and continue; distribution and product-to-sum restart the cascade; from inverse trigonometric functions onward, the first phase whose shape test matches returns, falling back to the standard integrator inside that phase if its method fails.

• Division substitution on the raw form, for example ln(x)/x
• Special-function forms on the raw form: erf, Si, Ci, Ei, li, Fresnel
• Normalization and algebraic simplification (rewrite)
• Table lookup
• General substitution for products
• Special product families
• Trigonometric identity rewrite
• Distribution of a product over a sum, then re-integration
• Product-to-sum rewriting of trigonometric products
• Inverse trigonometric functions and powers of ln
• Rational functions: long division, completing the square, partial fractions
• Trigonometric power reduction
• Quadratic radicals and trigonometric substitution
• Smart substitution
• Integration by parts, choosing u in LIATE order
• Standard integrator as the fallback: sum, difference and constant-multiple rules, the power rule ∫x^n dx = x^(n+1)/(n+1) with ∫1/x dx = ln|x|, and direct trigonometric, exponential and logarithmic forms

The earlier showcase described integration as term rewriting: a chess engine explores moves, a ray tracer samples light paths, and this integrator explores algebraic transformations, each applying local rewrites and judging whether the result is better. As an analogy for exploring a space of transformations, that still describes the intent.

The analogy has limits. The cascade runs its phases in a fixed order and does not backtrack: the same input takes the same path every time. The early phases (raw-form substitution, special functions, the table, general substitution, product families) pass to the next phase when they find nothing; distribution and product-to-sum rewrite the integrand and restart the cascade; but once a later phase such as rational functions, trigonometric powers or by parts recognizes the shape, its result is returned, and if its method fails it hands the integrand to the standard integrator rather than to the next phase. Recursive calls share the depth and call budgets, and no alternative path is retried. The only sampling in indefinite integration is the antiderivative check, which draws its 15 points from a fixed seed. The rewrite-rule code in the earlier showcase was labelled conceptual; the source implements rules as explicit branches on node shape, and the looping rewrite system is the simplifier.

Risch gives a decision framework for elementary antiderivatives under its algebraic assumptions. Within a supported setting, the algorithm can find an elementary antiderivative or establish that none exists. Implementing that contract across expression classes and branch conventions is a different task from assembling a useful collection of successful integration rules.

This engine deliberately exposes a bounded sequence of substitutions, decompositions, identities and reductions. Its randomized antiderivative check differentiates a candidate and compares values at sampled points. That check can detect errors; it does not turn the rule search into a complete decision procedure or an identity proof.

The earlier showcase called the integrator Risch-like. The project’s own audit dropped that description: Hermite reduction, Rothstein–Trager and a Liouville decision framework are absent, the ExperimentalRisch name is historical, and an unevaluated marker means the patterns ran out rather than that no elementary antiderivative exists. The exact lane now provides the rational GCDs, resultants and algebraic extensions that Rothstein–Trager would need, but that method is not implemented; 1/(x^4+1) remains unsolved because it needs factoring with irrational coefficients.

The definite-integral guard searches for problematic interior behavior and examines shrinking one-sided contributions. A convergent integrable singularity can have shrinking slivers; a logarithmic or power divergence need not. The guard prevents the simple F(b)−F(a) route from blindly crossing a pole.

This remains a numerical guard with a declared domain, not a general decision procedure for convergence. In particular, endpoint behavior and unusual functions require care. The interface should retain a divergence or principal-value label rather than flatten every outcome into one apparently ordinary number.

Interval evaluation carries lower and upper bounds through the same expression tree. Repeated occurrences of one variable are treated through their interval ranges, which can overestimate the result: x−x over [0,1] gives a wide interval even though the true value is zero. Subdivision narrows that dependency error; branch-and-bound can eliminate regions from an optimization search using their lower bounds.

The implementation uses adjacent floating-point values to widen basic-operation bounds, and two-ULP widening for library transcendental results. That last step assumes an error bound for the platform’s math library; it is not a replacement for a correctly rounded or independently certified transcendental library. Dense sample containment is a useful regression check, not proof of that platform-wide assumption. Unsupported functions and invalid domains are refused, while unbounded intervals remain visibly uninformative.

The earlier showcase presented create_rational_fraction as a way to keep exact rational values: a numerator and denominator become a single number when the quotient terminates as a decimal, and stay a division node otherwise. The helper is unchanged, but its effect is presentational. By its own rule 1/2 terminates and becomes 0.5, contrary to the showcase’s example; only denominators such as 3 stay as a division.

The leaves are floating-point numbers either way. With the default final simplification, ∫x^2 reads 0.3333 × x^3 and ∫x reads 0.5 × x^2 in the readable output, while the LaTeX printer shows the fractions 1/3 and 1/2 by rationalizing each number within 1e-10 with a denominator of at most 1000. Exact coefficients exist only in the separate rational and algebraic lane described above.

The browser still downloads its interpreter and presentation dependencies. Some workloads synchronously occupy the VM and can block interaction until they finish. The source includes targeted parser, improper-integral, residue, exact-arithmetic, interval, discovery and geometry probes. The results cited here come from the documented test runs; numerical portability across all browsers has not been established.

The earlier showcase chose Ruby for concise syntax and metaprogramming, so the code could stay close to the notation. In the source this appears as composition: MathematicalExpression includes the tree printer, derivative and integration operations, the cascade, vector calculus, simplification, the normalizer, the integration technique modules, verification, the two tracers, series, Lebesgue, definite integration and residues. No engine class inherits from another; the only subclass is the interval module’s error type.

The cascade asks respond_to? before each optional phase. That keeps phases independent, but a module that is loaded and not included is skipped without an error, which the technical reference records happening twice. The project’s assessment of a C++ and WebAssembly port rates the core as moderate work and the full engine as months, because the cascade relies on dynamic dispatch and duck-typed tree walking.

ExpressionNode holds isleaf, data, left, right, parent and type. deep_clone copies a subtree and relinks each child’s parent, so a rule can assemble a new tree from copies without altering its input. connect attaches a child on the left or right and sets its parent. constant_wrt? recurses to decide whether a subtree depends on a variable, which lets integration and simplification pull constants out.

evaluate is a post-order traversal: numeric leaves return themselves, variable leaves read the supplied values, and each operator combines its evaluated children. Division by zero returns infinity; ln and sqrt return NaN outside their domains; cot, sec, csc, sinh, cosh, tanh and the inverse trigonometric functions are included, as are sech, csch, coth and the inverse hyperbolic functions with real-domain checks, and the special functions are integrated numerically. evaluate_interval and evaluate_exact, defined in the interval and exact modules, walk the same tree with bounds or rationals instead of floats.

The product-rule case computes u′ and v′ recursively, builds u′ × copy(v) and copy(u) × v′ as two new product nodes, joins them under a sum node and appends a step with the rule text and the from and to expressions. Logarithmic differentiation builds a copy of f^g times the sum of g′ × ln(copy(f)) and copy(g) × f′ ÷ copy(f). The binomial expansion in the experimental simplifier builds u^2, 2 × u × v and v^2 from copies, joins them and replaces the original power node.

Each of these makes the same three moves: recurse into children, build new nodes from copies, record a step. Integration is the exception to the uniform pattern: it is an ordered list of phases, each deciding from the shape of the tree whether it applies.

The text-tree printer recurses with a growing prefix: the root line, then each child under ├─[L]─ or └─[R]─, with numbers in 【 】, known variables in < > and operators in ⟨ ⟩, under a legend. For 2·x^2 + 3·x the root ⟨+⟩ has a left ⟨*⟩ over 【2】 and a ⟨^⟩ node whose children are x and 【2】, and a right ⟨*⟩ over 【3】 and x. The interface registers no variables with the printer, so there x prints as 【x】.

to_latex prints integers without decimals, turns other numbers into fractions when a rational with denominator at most 1000 matches within 1e-10, writes division as \frac, powers with braces, functions with \left and \right, and special functions with \operatorname, adding parentheses by precedence. Its output is less idealized than the earlier showcase’s examples: sin(x)^2 + cos(x)^2 becomes {\sin\left(x\right)}^{2} + {\cos\left(x\right)}^{2}, and x^2 + 2*x + 1 becomes {x}^{2} + 2 \cdot x + 1.

Both the readable printer and LaTeX once omitted the parentheses around the right operand of a minus, so a − (b + c) was shown as a − b + c. Numeric checks passed because they read the tree, not the string, and seven by-parts results in the harness were displayed wrong. A round-trip probe now parses printed output back and requires the same value.

The earlier showcase quoted StepVisualizer, a small module in the integrator whose print_pattern, print_method, print_step and print_result wrap a label in ANSI colours and pass it to the debug log. The four methods it quoted are unchanged; the module now also has print_header, print_footer and print_recursive. Lines such as “[Risch] Detected rational function” in the recordings came from that log, which the interface shows as Console Output.

integration_tracer.rb records a decision tree of attempted techniques during a run and renders it as an ASCII tree, a Mermaid flowchart or a complexity-by-depth plot; its verbose mode drives Live Solve. strategy_reporter.rb is a lighter flat logger; it also defines a technique recommender for failed runs, which the interface does not call.