This is a Mathematica implementation of the rule-based integrator called Rubi developed by Albert D. Rich. Rubi is a large set of transformation rules that allows to determine the antiderivative of an expression by applying matching integration rules step by step until the final solution is found. In principle, Rubi is independent of the implementation, because the integration rules could theoretically be used in any sufficiently advanced language that supports symbolic pattern-matching and replacement rules.
Rubi out-performs Maple and Mathematica (the two major commercial computer algebra systems) on a grueling integration test suite, consisting of over 70 thousand integrands and optimal antiderivatives. One major advantage of Rubi is that it can provide the exact steps that are required to determine an antiderivative. Since Rubi rules follow a decision tree, the transformation and the required conditions can be provided for each integration step.
The user documentation of the Rubi project can be found under rulebasedintegration.org. For an installation- and usage-guide, please see the Mathematica Package section on rulebasedintegration.org.
Certain development specific information about this Mathematica package can be found in the Rubi GitHub Wiki. There, you will also find how you can contribute to the project. Since the Wiki is at the moment not complete, please also visit the current Rubi website.
- The Rubi repository includes all notebooks containing the Rubi rules under the
IntegrationRuleNotebooks
directory. This directory contains many sub-folders which reflect the separation of rules into logical sections (like rules for algebraic functions or rules for exponentials). The advantage of the notebooks is that they contain detailed information about integration rules like references to the literature and further information - The
Rubi
folder contains the Mathematica package and wrapper code that (1) provides required utility functions (2) loads the integration rules in the correct order (3) provides features to show formatted integration steps and integration statistics. This folder contains all Rubi rules from the notebook that were automatically extracted into densely packed package files under theRubi/IntegrationRules
folder. These.m
files are not meant to be edited or looked at!
To extract the rules from the notebooks, we provide a helper package RubiPackageTools.m
that can be used in the following
way from within Mathematica
<< "/path/to/Rubi/RubiPackageTools.m"
BuildIntegrationRules[]
This will extract all rules from the notebooks into .m
files and place them into the
correct location under Rubi/IntegrationRules
. The created package files are loaded from within Rubi.m
with the
LoadRules[]
functions. Again, the order in which the rules are loaded in Rubi.m
is vitally important to get a
working Rubi package.
The file Rubi/ShowStepRoutines.m
contains most of the functionality to provide step-by-step integration.
It works by changing all Rubi rules for Int
so that they
- Stop at each step
- Provide important information about the current step
In its core, it works by injecting code that employs Hold
to stop evaluation.
Here is a simple example how this can be done
sum[0] = 0;
sum[n_] := n + sum[n - 1];
changeRule[HoldPattern[rhs_ :> lhs_]] := rhs :> HoldForm[lhs];
DownValues[sum] = changeRule /@ DownValues[sum];
Now we have to restart the evaluation in each recursive call to sum
, but we can print out intermediate steps easily
FixedPoint[(Print[#]; ReleaseHold[#]) &, sum[4]]
Rubi's Steps
, Step
and Stats
functions work similarly, but instead of directly printing the information, they
are collected with Sow
and Reap
and later formatted and printed.
The main content of the ShowStepRoutines.m
is code to turn the Int
rules into a readable form.
When using Steps[Int[expr, x]]
(or Step
), Rubi collects a list of steps where each element is either RubiRule[..]
or RubiIntermediateResult[..]
. The Stats
function collects its information inside RubiStats[..]
.
Formatting of these expressions is completely handled inside Rubi/ShowStepFormatting.m
.
This file contains definitions how to format a single e.g. RubiRule
expression and the final representation is built
in the function PrintRubiSteps[..]
.
The representation of the statistics is directly attached to the Stats
symbol in its FormatValues
. At the moment
it uses Mathematica's built-in BoxForm`ArrangeSummaryBox[..]
that is also used for e.g. CompiledFunction
,
InterpolatingFunction
, etc.