Questions on some rules (which came up in preparation of a Maxima port)

[MSoegtropIMC]

Dear Rubi Team,

I started a port of Rubi to Maxima, which is based on the idea of the late Albert Rich to automatically convert the rule base to a decision tree - which should then be easily portable to various systems including Maxima. The plan is to write the converter in OCaml, because I think it is easier to do this in a strictly typed language supporting algebraic data types. Also I plan to port it to Coq some day.

As first step I wrote a parser for the subset of Mathematica used in Rubi rules in Menhir (OCaml's yacc). I know that Mathematica parsers exist, but it is easier this way and it also helps me to find out what subset of Mathematica is actually used in Rubi.

I came across a few rules which look questionable to me.

First there are quite a few rules which use \[Star] where I would expect ASCII * aka. Times. E.g.:

Rubi/Rubi/IntegrationRules/1 Algebraic functions/1.1 Binomial products/1.1.2 Quadratic/1.1.2.1 (a+b x^2)^p.m

Line 24 in 61e9c18

b^IntPart[p]*(b*x^2)^FracPart[p]/x^(2*FracPart[p]) \[Star] Int[x^(2*p),x] /;

Is this a typo (when the file is loaded, the rendering is hard to distinguish from ASCII *) or is this some trick I need to understand? In the latter case, can you please explain it?

Second there are a few rules which use float numbers while almost all rules user integers / rationals: E.g. the x_^2. in:

Rubi/Rubi/IntegrationRules/1 Algebraic functions/1.1 Binomial products/1.1.2 Quadratic/1.1.2.4 (e x)^m (a+b x^2)^p (c+d x^2)^q.m

Line 94 in 61e9c18

Int[(e_.*x_)^m_.*(b_.*x_^2.)^p_*(c_+d_.*x_^2)^q_.,x_Symbol] :=

Is this intentional?

Best regards,

Michael

[stblake]

Hi Michael, It's great to hear that someone is taking up the challenge of compiling Rubi's rules into a decision tree! Regarding \[Star] - I believe it was Albert's way of having an inert Times[] to prevent things like partial simplification/expansion, for example In[878]:= -1*(a + b) Out[878]= -a - b So Star[] should probably parse to Times[]. It will be interesting to see what bugs this introduces/eliminates. It is hard to know if patterns containing Real numbers are intentional or accidental. I would guess accidental as it wouldn't fit with the rest of the design of the Rubi rules. All this guesswork is because Rubi was poorly documented. You should also be aware that Nasser has a list of Rubi rules which cause infinite recursion. Almost certainly these rules should be removed from Rubi prior to compiling your decision tree. Cheers, Sam Blake

…

On Thu, Jun 20, 2024 at 5:50 AM MSoegtropIMC ***@***.***> wrote: Dear Rubi Team, I started a port of Rubi to Maxima, which is based on the idea of the late Albert Rich to automatically convert the rule base to a decision tree - which should then be easily portable to various systems including Maxima. The plan is to write the converter in OCaml, because I think it is easier to do this in a strictly typed language supporting algebraic data types. Also I plan to port it to Coq some day. As first step I wrote a parser for the subset of Mathematica used in Rubi rules in Menhir (OCaml's yacc). I know that Mathematica parsers exist, but it is easier this way and it also helps me to find out what subset of Mathematica is actually used in Rubi. I came across a few rules which look questionable to me. First there are quite a few rules which use \[Star] where I would expect ASCII * aka. Times. E.g.: https://github.com/RuleBasedIntegration/Rubi/blob/61e9c18ea248061cd83c67882f7c91a73cef912d/Rubi/IntegrationRules/1%20Algebraic%20functions/1.1%20Binomial%20products/1.1.2%20Quadratic/1.1.2.1%20(a%2Bb%20x%5E2)%5Ep.m#L24 Is this a typo (when the file is loaded, the rendering is hard to distinguish from ASCII *) or is this some trick I need to understand? In the latter case, can you please explain it? Second there are a few rules which use float numbers while almost all rules user integers / rationals: E.g. the x_^2. in: https://github.com/RuleBasedIntegration/Rubi/blob/61e9c18ea248061cd83c67882f7c91a73cef912d/Rubi/IntegrationRules/1%20Algebraic%20functions/1.1%20Binomial%20products/1.1.2%20Quadratic/1.1.2.4%20(e%20x)%5Em%20(a%2Bb%20x%5E2)%5Ep%20(c%2Bd%20x%5E2)%5Eq.m#L94 Is this intentional? Best regards, Michael — Reply to this email directly, view it on GitHub <#53>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB5ALCRW6ND4G36T5EMHOALZIHOKBAVCNFSM6AAAAABJST2JW2VHI2DSMVQWIX3LMV43ASLTON2WKOZSGM3DGMBTG43DSOI> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[arthurcnorman]

See https://reference.wolfram.com/language/ref/character/Star.html for what Mathematica says [Star] means. How that participated in sunsequent Mathematica transformations is not my expertise, but in my activity parting the Rubi rulke-set for Reduce I encountered the same syntax.
If you are working on a Maxima port and I am in parallel looking at Reduce then it could well make sense for us to exchange experiences and problems encountered - I have a medium length list of thoughts. But the level of detail in what we might be exchanging would seem to me to mean that would be best done by direct email between us not through this forum.

I can parse all the Rubi rules (and indeed test examples) from the mathematica syntax they come in into LIsp prefix form with operators such as "/;" and so on. I have been experimenting with various transformations there but the details of where I am are very fluid and are messy enough that I am not going to post details here to bore everybody else. But if you are active on a project a bit of joining forces might be a good plan? Arthur Norman
(find me if you need via the reduce-algebra project on sourceforge).

[axkr]

I started a port of Rubi to Maxima, which is based on the idea of the late Albert Rich to automatically convert the rule base to a decision tree - which should then be easily portable to various systems including Maxima.

I'm also planning to create a generator for converting rules into a Java source code method:

• Compiling rules into a decision tree as Java source code

I have some uncommitted changes creating a simplified decision tree (discrimination net).
I think the Rubi rules are to complicated for the first step and I will try to support only simple pattern-matching rules for "builtin-function" at the beginning.

Maybe we can work together on the level of "best used data structures" or "known papers" for this topic?

[MSoegtropIMC]

@arthurcnorman @axkr : thank you - indeed it makes sense to work together on this!

@arthurcnorman: are you fine with the basic approach of creating a decision tree / discrimination network offline with a common tool and exporting this into various languages? The advantage of this method I see is that it should be easier to port than reimplementing Mathematica pattern matching and it should also be much faster (if one does the creation of the tree/net offline once).

@axkr: I also had the plan to first look into what MatchPy does (the paper you linked), just as an offline solution. The SymPy Rubi port reportedly also uses MatchPy, but it is said that the online generation of the tree / net is too slow. One could think about generating Maxima / Java code using MatchPy, so that the generation time would not be an issue.

Where do we want to continue to discuss this? I think it would make sense to have a public discussion and IMHO it makes sense to have the discussion somewhere under Rubi, but maybe under Rubi-5 since this was the main intention of Rubi-5 and there might be fewer people who are subscribed to all issues.

Does someone from the Rubi team object?

[stblake]

Here's an interesting use of GPT4o parsing a Rubi rule into Maple syntax. (I do not have Maple so I cannot test the resulting code... ) *Prompt: * *Can you code this integration rule in Maple syntax? Int[(a_ + b_.*x_ + c_.*x_^2)^p_, x_Symbol] := 2*((a + b*x + c*x^2)^(p + 1)/ ((2*p + 1)*(b + 2*c*x))) /; FreeQ[{a, b, c, p}, x] && b^2 - 4*a*c == 0 && p <= -1* Certainly! Here’s how you can implement the given integration rule in Maple syntax. The rule can be encoded as a custom integration procedure using Maple’s pattern matching and conditional logic. First, let’s restate the rule: \[ \int (a + bx + cx^2)^p \, dx = \frac{2(a + bx + cx^2)^{p+1}}{(2p + 1)(b + 2cx)} \] given that \( b^2 - 4ac = 0 \) and \( p \leq -1 \). ### Maple Code ```maple with(inttrans): with(int): IntegrationRule := proc(f, x) local a, b, c, p, integrand, integrandPattern, result; # Define the pattern for the integrand integrandPattern := (a_ + b_ * x + c_ * x^2)^p_; # Check if the integrand matches the pattern and conditions if type(f, integrandPattern) then # Extract the coefficients and exponent a := op(1, f); b := op(2, f); c := op(3, f); p := op(4, f); # Check the conditions: FreeQ[{a, b, c, p}, x] && b^2 - 4*a*c = 0 && p <= -1 if not depends(a, x) and not depends(b, x) and not depends(c, x) and not depends(p, x) and b^2 - 4*a*c = 0 and p <= -1 then # Apply the integration rule result := 2 * ((a + b * x + c * x^2)^(p + 1)) / ((2 * p + 1) * (b + 2 * c * x)); return result; else return 'unknown'; end if; else return 'unknown'; end if; end proc; # Example usage f := (3 + 6 * x + 3 * x^2)^(-2); IntegrationRule(f, x); ``` ### Explanation: 1. **Load Necessary Packages:** The `inttrans` and `int` packages are loaded to use integration functions. 2. **Define the Procedure:** `IntegrationRule` is a procedure that takes an integrand `f` and a variable `x`. 3. **Pattern Matching:** The integrand pattern `(a_ + b_ * x + c_ * x^2)^p_` is defined to match the given form. 4. **Condition Checking:** The procedure checks if: - `a`, `b`, `c`, and `p` are free of the variable `x`. - The condition \( b^2 - 4ac = 0 \) holds. - The exponent \( p \leq -1 \). 5. **Apply the Integration Rule:** If all conditions are met, the integration rule is applied and the result is returned. If any condition is not met, the procedure returns `'unknown'`. ### Example Usage: - An example usage is provided with the integrand \( (3 + 6x + 3x^2)^{-2} \). - The procedure `IntegrationRule` is called with this integrand and the variable `x`. This implementation should work for the specified rule and conditions in Maple. If you need further customization or have additional rules to implement, similar procedures can be created following this structure.

…

On Fri, Jun 21, 2024 at 2:39 AM MSoegtropIMC ***@***.***> wrote: @arthurcnorman <https://github.com/arthurcnorman> @axkr <https://github.com/axkr> : thank you - indeed it makes sense to work together on this! @arthurcnorman <https://github.com/arthurcnorman>: are you fine with the basic approach of creating a decision tree / discrimination network offline with a common tool and exporting this into various languages? The advantage of this method I see is that it should be easier to port than reimplementing Mathematica pattern matching and it should also be much faster (if one does the creation of the tree/net offline once). @axkr <https://github.com/axkr>: I also had the plan to first look into what MatchPy does (the paper you linked), just as an offline solution. The SymPy Rubi port reportedly also uses MatchPy, but it is said that the online generation of the tree / net is too slow. One could think about generating Maxima / Java code using MatchPy, so that the generation time would not be an issue. Where do we want to continue to discuss this? I think it would make sense to have a public discussion and IMHO it makes sense to have the discussion somewhere under Rubi, but maybe under Rubi-5 since this was the main intention of Rubi-5 and there might be fewer people who are subscribed to all issues. Does someone from the Rubi team object? — Reply to this email directly, view it on GitHub <#53 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB5ALCWDQSD5PC7PVBTVAA3ZIMAT7AVCNFSM6AAAAABJST2JW2VHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDCOBRGEYTINJWGY> . You are receiving this because you commented.Message ID: ***@***.***>

[stblake]

It looks dubious to me, but I don't have Maple any more. The online documentation says about the op() function .... *If the first argument to the op function is a positive integer i, then the ith operand of e is returned.* In the example, it seems that the ChatGPT program uses if type(f, integrandPattern) then # Extract the coefficients and exponent a := op(1, f); b := op(2, f); c := op(3, f); p := op(4, f) ... to match the pattern. is this the way matching works in Maple??? My own experiments (with Copilot, mostly) suggest that it is happy to provide buggy programs (in Lisp!) which have a whiff of some nearby idea. On Thu, Jun 20, 2024 at 4:52 PM Sam Blake ***@***.***> wrote:

…

Here's an interesting use of GPT4o parsing a Rubi rule into Maple syntax. (I do not have Maple so I cannot test the resulting code... ) *Prompt: * *Can you code this integration rule in Maple syntax? Int[(a_ + b_.*x_ + c_.*x_^2)^p_, x_Symbol] := 2*((a + b*x + c*x^2)^(p + 1)/ ((2*p + 1)*(b + 2*c*x))) /; FreeQ[{a, b, c, p}, x] && b^2 - 4*a*c == 0 && p <= -1* Certainly! Here’s how you can implement the given integration rule in Maple syntax. The rule can be encoded as a custom integration procedure using Maple’s pattern matching and conditional logic. First, let’s restate the rule: \[ \int (a + bx + cx^2)^p \, dx = \frac{2(a + bx + cx^2)^{p+1}}{(2p + 1)(b + 2cx)} \] given that \( b^2 - 4ac = 0 \) and \( p \leq -1 \). ### Maple Code ```maple with(inttrans): with(int): IntegrationRule := proc(f, x) local a, b, c, p, integrand, integrandPattern, result; # Define the pattern for the integrand integrandPattern := (a_ + b_ * x + c_ * x^2)^p_; # Check if the integrand matches the pattern and conditions if type(f, integrandPattern) then # Extract the coefficients and exponent a := op(1, f); b := op(2, f); c := op(3, f); p := op(4, f); # Check the conditions: FreeQ[{a, b, c, p}, x] && b^2 - 4*a*c = 0 && p <= -1 if not depends(a, x) and not depends(b, x) and not depends(c, x) and not depends(p, x) and b^2 - 4*a*c = 0 and p <= -1 then # Apply the integration rule result := 2 * ((a + b * x + c * x^2)^(p + 1)) / ((2 * p + 1) * (b + 2 * c * x)); return result; else return 'unknown'; end if; else return 'unknown'; end if; end proc; # Example usage f := (3 + 6 * x + 3 * x^2)^(-2); IntegrationRule(f, x); ``` ### Explanation: 1. **Load Necessary Packages:** The `inttrans` and `int` packages are loaded to use integration functions. 2. **Define the Procedure:** `IntegrationRule` is a procedure that takes an integrand `f` and a variable `x`. 3. **Pattern Matching:** The integrand pattern `(a_ + b_ * x + c_ * x^2)^p_` is defined to match the given form. 4. **Condition Checking:** The procedure checks if: - `a`, `b`, `c`, and `p` are free of the variable `x`. - The condition \( b^2 - 4ac = 0 \) holds. - The exponent \( p \leq -1 \). 5. **Apply the Integration Rule:** If all conditions are met, the integration rule is applied and the result is returned. If any condition is not met, the procedure returns `'unknown'`. ### Example Usage: - An example usage is provided with the integrand \( (3 + 6x + 3x^2)^{-2} \). - The procedure `IntegrationRule` is called with this integrand and the variable `x`. This implementation should work for the specified rule and conditions in Maple. If you need further customization or have additional rules to implement, similar procedures can be created following this structure. On Fri, Jun 21, 2024 at 2:39 AM MSoegtropIMC ***@***.***> wrote: > @arthurcnorman <https://github.com/arthurcnorman> @axkr > <https://github.com/axkr> : thank you - indeed it makes sense to work > together on this! > > @arthurcnorman <https://github.com/arthurcnorman>: are you fine with the > basic approach of creating a decision tree / discrimination network offline > with a common tool and exporting this into various languages? The advantage > of this method I see is that it should be easier to port than > reimplementing Mathematica pattern matching and it should also be much > faster (if one does the creation of the tree/net offline once). > > @axkr <https://github.com/axkr>: I also had the plan to first look into > what MatchPy does (the paper you linked), just as an offline solution. The > SymPy Rubi port reportedly also uses MatchPy, but it is said that the > online generation of the tree / net is too slow. One could think about > generating Maxima / Java code using MatchPy, so that the generation time > would not be an issue. > > Where do we want to continue to discuss this? I think it would make sense > to have a public discussion and IMHO it makes sense to have the discussion > somewhere under Rubi, but maybe under Rubi-5 since this was the main > intention of Rubi-5 and there might be fewer people who are subscribed to > all issues. > > Does someone from the Rubi team object? > > — > Reply to this email directly, view it on GitHub > <#53 (comment)>, > or unsubscribe > <https://github.com/notifications/unsubscribe-auth/AB5ALCWDQSD5PC7PVBTVAA3ZIMAT7AVCNFSM6AAAAABJST2JW2VHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDCOBRGEYTINJWGY> > . > You are receiving this because you commented.Message ID: > ***@***.***> >

[stblake]

Has anyone here looked at this? https://github.com/axkr/symja_android_library/wiki/Porting-Rubi-Integration-rules-to-Symja (It was just pointed out on the Maxima discussion list. Some of Mathematica is implemented.. This page gets you a web interface https://matheclipse.org/ which answers some questions right. Int[a*x^2,{x,r,s}] works. ) RJF

[axkr]

Has anyone here looked at this?

yes, despite the name, the https://matheclipse.org/ is the Symja demo page.
If you know some Java you can install it locally:

• https://github.com/axkr/symja_android_library/wiki/Installation

[stblake]

Wow, I love the web interface! I was surprised to see this time-out: Integrate[1/(x^5+1), x] Error: 𝖳𝗂𝗆𝖾𝗈𝗎𝗍 𝖾𝗑𝖼𝖾𝖾𝖽𝖾𝖽. 𝖢𝖺𝗅𝖼𝗎𝗅𝖺𝗍𝗂𝗈𝗇 𝖺𝖻𝗈𝗋𝗍𝖾𝖽!

…

On Mon, Jun 24, 2024 at 7:49 AM Axel Kramer ***@***.***> wrote: Has anyone here looked at this? yes, despite the name, the https://matheclipse.org/ is the Symja demo page. If you know some Java you can install it locally: - https://github.com/axkr/symja_android_library/wiki/Installation — Reply to this email directly, view it on GitHub <#53 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB5ALCQYUXQV3RDR73SCHPTZI47HVAVCNFSM6AAAAABJST2JW2VHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDCOBVGMZTGMZRGY> . You are receiving this because you commented.Message ID: ***@***.***>

[robert-dodier]

@arthurcnorman About exchanging ideas with others working on integration rules, I would like to very strongly encourage you to conduct the discussion in a public forum, whatever is convenient for you, even if at this time only one other person is participating. Whatever you discover or encounter is potentially useful to others, even if it is not clear to anyone at present what form that will take.

All the best, Robert Dodier (developer and project administrator for Maxima)

[axkr]

I was surprised to see this time-out: Integrate[1/(x^5+1), x] Error: 𝖳𝗂𝗆𝖾𝗈𝗎𝗍 𝖾𝗑𝖼𝖾𝖾𝖽𝖾𝖽. 𝖢𝖺𝗅𝖼𝗎𝗅𝖺𝗍𝗂𝗈𝗇 𝖺𝖻𝗈𝗋𝗍𝖾𝖽!

Yes the demo on google appengine is very slow and times out after 30 seconds.

Locally on my machine, I get this result:

[axkr]

@arthurcnorman About exchanging ideas with others working on integration rules, I would like to very strongly encourage you to conduct the discussion in a public forum, whatever is convenient for you, even if at this time only one other person is participating. Whatever you discover or encounter is potentially useful to others, even if it is not clear to anyone at present what form that will take.

the maintainers of the github Rubi organization can enable "discussions" for this purpose in their organization:

• https://docs.github.com/en/organizations/managing-organization-settings/enabling-or-disabling-github-discussions-for-an-organization

or in a specific Rubi repo:

• https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/enabling-or-disabling-github-discussions-for-a-repository

For chatting I personally prefer Discord nowadays:

• https://discord.gg/tYknzr2qam

[stblake]

Suggestion for speeding up (Mathematica's version) of Rubi by maybe 30-40%.. It seemed to me that pattern matching should be way faster when there are better "anchors" in the match. Thus if we substitute a particular name, say VAR for the variable of integration, all the rules are simpler. A rule that now looks like Int [a_.*x_^2+ ....., x_Symbol] ..... could be replaced by Int[a_.* VAR^2+.....] In some simple tests I get about 33% faster, though I am just testing matching speed. (this trick is used in Moses's SIN integration system in Maxima. SIN relies heavily on pattern matching.) RJF

…

> Message ID: ***@***.***> >

[stblake]

Albert probably would probably have hated the inelegant hackery, but perhaps another way to do that would be have only one public rule for Int [expression_? ExpressionQ, var_SymbolQ] := IntAux [expression, var], then change the name of the other rules to private IntAux which would then not have to verify that the first argument is not, for example a Boolen or the second argument an Integer.

…

On Tue, Jun 25, 2024 at 8:05 AM Richard Fateman ***@***.***> wrote: Suggestion for speeding up (Mathematica's version) of Rubi by maybe 30-40%.. It seemed to me that pattern matching should be way faster when there are better "anchors" in the match. Thus if we substitute a particular name, say VAR for the variable of integration, all the rules are simpler. A rule that now looks like Int [a_.*x_^2+ ....., x_Symbol] ..... could be replaced by Int[a_.* VAR^2+.....] In some simple tests I get about 33% faster, though I am just testing matching speed. (this trick is used in Moses's SIN integration system in Maxima. SIN relies heavily on pattern matching.) RJF > >> Message ID: ***@***.***> >> >

[stblake]

On Tue, Jun 25, 2024 at 11:41 AM David Stoutemyer ***@***.***> wrote: Albert probably would probably have hated the inelegant hackery, but perhaps another way to do that would be have only one public rule for Int [expression_? ExpressionQ, var_SymbolQ] := IntAux [expression, var],

I'm suggesting a bigger improvement in speed, at least in principle. Yes, those IntAux rules would not have to check (again) that var is a symbol, but those rules would still have to check the names. Thus making up a rule as an example... for x^2 -> x^3/3.... IntAux[ a_.*var_^2+b_,var_] := a*var^3/3+b /; FreeQ[{a,b},var] what if the application is IntAux[ u^2+5*v^2+7*w^2+ 2*x^2+4*y^2+5*z^2, w] the pattern matcher, unless clever enough to match args out of order and set var==w first, will wander around trying var==u, var==v, var... etc. So it is better to do this: Int [expression_? ExpressionQ, var_SymbolQ] := IntAux [expression /. var-> VAR] and then IntAux would see u^2+5*v^2+7*VAR^2+ 2*x^2+4*y^2+5*z^2. Much easier to match with IntAux[ a_.*VAR^2+b_] := a*VAR^3/3+b /; FreeQ[{a,b},VAR] one glitch .. if we generate some error message from IntAux and friends, those programs will not know the external name of the variable of integration. They will only know VAR. So we have to save the external name. Easy to do at top level.. Int [expression_? ExpressionQ, var_SymbolQ] := (SavedVAR=var ; IntAux [expression /. var-> VAR]) .............. RJF then change the name of the other rules to private IntAux which would then

…

not have to verify that the first argument is not, for example a Boolen or the second argument an Integer. On Tue, Jun 25, 2024 at 8:05 AM Richard Fateman ***@***.***> wrote: > Suggestion for speeding up (Mathematica's version) of Rubi by maybe > 30-40%.. > > It seemed to me that pattern matching should be way faster when there are > better "anchors" in the match. Thus if we substitute a particular name, > say VAR > for the variable of integration, all the rules are simpler. A rule that > now looks like > > Int [a_.*x_^2+ ....., x_Symbol] ..... > could be replaced by > Int[a_.* VAR^2+.....] > > In some simple tests I get about 33% faster, though I am just testing > matching speed. > (this trick is used in Moses's SIN integration system in Maxima. SIN > relies heavily on pattern matching.) > RJF > >> >>> Message ID: ***@***.***> >>> >>