/ Rubi Public

Rubi for Mathematica

# RuleBasedIntegration/Rubi

Switch branches/tags
Nothing to show

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

## Files

Failed to load latest commit information.
Type
Name
Commit time

# Rubi - Rule-based Integration

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.

## Documentation

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.

## Repository structure and development

### General

1. 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
2. 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 the `Rubi/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.

### How showing integration steps works

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

1. Stop at each step
2. 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.

### Formatted output

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.

Rubi for Mathematica

## Releases 6

Version 4.16.1.0 Latest
Dec 20, 2018

## Packages 0

No packages published