Albert Rich  wrote:   
   > On Wednesday, March 11, 2020 at 6:22:34 AM UTC-10, anti...@math.uni.wroc.pl   
   wrote:   
   > > [...]   
   > >   
   > > And of course, having no better method one could use Rubi way:   
   > > add lookup table and retrive precomputed answer from the table.   
   > >   
   > > --   
   > >                               Waldek Hebisch   
   >   
   > Rubi does NOT use a lookup table of specific precomputed integrals.  Rather   
   it uses generic reduction and terminal rules to iteratively integrate large   
   classes of expressions.   
      
   Well, sorry but in what sense terminal rules used by Rubi are different   
   from lookup table?  Note that reasonable lookup table will store   
   parametrized integrals and lookup will extract (match) parameteres   
   from integrand.  And when table entry needs side conditions then   
   of course that side condition is included in the table.   
      
   Concering generic rules, I was able to find only one really   
   generic rule in Rubi: splitting sums (possibly using Apart).   
   Can you name any other really generic rule?   
      
   And, speaking about reductions, most reductions implement   
   easy cases of Risch algorithm and could be replaced by   
   by algorithm which is much shorter than collection of rules.   
      
      
   >  For example, when Martin presents a specific example Rubi cannot integrate,   
   it usually leads to a generic rule able to produce optimal antiderivatives for   
   the whole class of integrands for which the example is a special case.   
   >   
   > Instead of using rule-based integration when there is ?no better method?, I   
   contend it should be used BEFORE resorting to advanced methods like Risch.   
      
   There are a few good reasons to run Risch first:   
      
   - any computation can return bogus result due to division by zero.   
     ATM Risch gives strongest method to recognize zero.   
   - if there are no complications Risch is very fast and gives nice   
     results, so there is no reason to code other methods for such   
     cases   
   - there are things which are very simple for Risch that are   
     awkward (if not impossible) for rules, like ratinal functions   
     with irreducible denominators   
   - Risch performs generic reductions, so the rest can be handled   
     by lookup (termial rules).   
      
   Good rule of software engineegering is that smaller/simpler   
   code is better than bigger/more complicated.  Since we need   
   Risch for cases it handles well, it makes sense to use   
   other methods _only_ for cases that Risch can not handle   
   well.  For example, of about 3500 terminal tests from past   
   version of Rubi testsuite FriCAS could do about 75%.  So   
   those rule are in a sense redundant.  And of remaing 25%   
   most corresponds to currently unimplemented extentions of   
   Risch algorithm.  Implementing appropriate extentions   
   will handle much more integrals than correspoinging rules.   
      
   >  There are numerous advantages of a properly implemented rule-based   
   integrator:   
   >   
   > 1. If a rule does apply, the optimal antiderivative will quickly and   
   reliably be found.   
      
   I just checked in FriCAS set of random 10000 exp-log functions.  8 hit   
   a bug, something like 15 turned out to be algebraic and ended up in   
   unimplemented part of Risch algorithm, the other work.  Total time   
   about 100s, that is on average 10ms per integral.  I would guess   
   that Rubi will have trouble with many of those integrals.   
      
   > 2. Rule-based systems can show the rules applied and the resulting   
   intermediate steps.   
   > 3. The rules are self-contained and easily verified by differentiation.   
      
   Easily? I looked at hypergeometric rules and you need to know   
   various special identities to verify the rules.  Differentiation   
   rule alone is not enough.   
      
   > 4. The individual rules are elementary in nature and thus comprehensible to   
   mere humans, like first year calculus students.   
      
   I would not dare to teach hypergeometric identities to first year   
   calculus students.   
      
   Oversimplified description of Rich algorithm is "Integrate by part   
   when this makes integrand simpler, otherwise you need special   
   methods".  Now, "Integrate by part when this makes integrand simpler"   
   appiles equally well to Rubi, except that Risch makes rather   
   precise definition of "simpler".  Difference is in "special   
   methods".  Here Rubi mostly depends on terminal rules (IIUC   
   there are also substitution rules).  In Risch this part is   
   more involved.   Rubi is simpler here like giving a theorem   
   without a proof is usualy simpler than giving theorem with   
   a proof.  Pedagogically, skipping some proofs may be justified   
   and similarly Rubi may have some pedagogical advantages.   
   OTOH first year calculus students can understand easier   
   parts of Risch theory and benefits are probaly similar to   
   seeing Rubi rules.   
      
      
   --   
                                 Waldek Hebisch   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)