It is possible that people interested in this thread would benefit by 
reading
the PhD theses of  Joel Moses,  and also James Slagle.

Briefly, Moses viewed the problem as 3 stages.  A simple algorithm 
(derivative-divides)
which can be written very compactly if you have the right tools.
2.  a pattern-matching problem,  but only about 13 patterns,
each attached to an algorithm.
3. a kind of Risch-like program  (prior to Risch's publications).

attaching more patterns and methods to stage 2 would be plausible.
Maybe Rubi.  
implementing a better stage 3  (or calling FriCAS!) would be plausible too.

One problem with Rubi "converted" to sympy or Maxima or ....   is that
(at least in the past) it relied, in non-obvious ways, on Mathematica 
semantics.
This resulted in loops.  I have read in and run parts of the Rubi rule-set 
in
Maxima; I think dozens if not hundreds of test cases.  But this was years 
ago.

Albert Rich promised, some time ago to (auto-?) write 
 Rubi-as-"if-then-else", 
for consumption by other systems. Still waiting.

Oh, about Slagle.

His program, earlier than Moses'  viewed integration as an AI
problem involving hill-climbing, breaking up problems into sub-problems,
etc.

Other than the academic interest in 'anti-differentiation'  it is not
clear that this is such an important problem in (say) physics or 
engineering.
Definite integration problems can be done by quadrature programs,
and of course the vast majority of symbolic integration problems
(from calculus texts) can be done by almost any reasonable computer
algebra system.

The more challenging (and fun) stuff is probably apparent to anyone
who has taken a course in complex variables/ conformal mapping/ special 
functions.

I am guess that this is not what most Sage fans have studied.
Probably pursuing these kinds of problems would involve mostly
Maxima  (and FriCAS if it is there)  and maybe sympy;  though that
last one may be wrong -- I don't follow sympy much.

RJF





On Tuesday, February 28, 2017 at 11:10:49 AM UTC-8, parisse wrote:
>
>
>
> Le mardi 28 février 2017 18:32:19 UTC+1, mmarco a écrit :
>>
>> If it makes sense to use integration by parts or not deppends heavily on 
>> the actual expression. I suspect that, if you try to make a sane criterion 
>> te decide when to apply it, you could end up with something very 
>> complicated as well. Ther is reason why there are so many rules in RUBI 
>> (although I heard that the author is considering reorganizing them in a 
>> decission tree, which might simplify things to some extent).
>>
>
> The only reason I could see for that number of rules is that rubi works 
> like a student who does not want to understand "the big picture" about 
> integration but has a fabulous memory and remembers all the integrals from 
> all known textbooks. But perhaps I'm wrong, that's why I was asking how it 
> cooperates with classical methods, like partial fraction decomposition or 
> integration by part, change of variables etc. I'm just not convinced by 
> that number of rules and the fact that some of them are not grouped in an 
> algorithm.
>

-- 
You received this message because you are subscribed to the Google Groups 
"sage-devel" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sage-devel+unsubscr...@googlegroups.com.
To post to this group, send email to sage-devel@googlegroups.com.
Visit this group at https://groups.google.com/group/sage-devel.
For more options, visit https://groups.google.com/d/optout.

Reply via email to