[Axiom-developer] [Summer of Code] add a project

[daly]

Changes http://wiki.axiom-developer.org/SummerOfCode/diff
--

++added:
<p> Mathematica has a free 'reader' program which is designed to
  show their notebooks. The format for the reader is standard ascii.
  We could develop an Axiom output format that would allow us to 
  create notebooks from Axiom taking advantage of the features of
  the Mathematics notebook.


++added:
<li>V. RESEARCH PROBLEMS<br>

<p> Reading Soiffer's PhD thesis (The Design of a User Interface for
Computer Algebra Systems) raises an interesting research question.

<p>Assume you're given a standard page size (8 1/2 x 11, A4, display size)
and you have an equation to format in some understandable way 
how can you format the equation to fit on one page.

<p> The underlying "assumption" is that equations longer than one page are
unreadable and useless.

<p>There are a variety of techniques:
<ul>
<li> line breaks when the equation hits the edge
<li>common subexpression elimination when it can occur
<pre>
    
    R = (x+y) * (z+(x*y)) ==>

    let M = (x+y)
        R = M * (z+M)

    so that you can "name" common subexpressions and lift them
</pre>
<li>function reification
<pre>

    "name" a subexpression that requires a parameter, 
    lift it out, and substitute a parameterized term.
    in a tree or DAG representation this is node-naming

</pre>
<li>term reification
<pre>
   
    "name" a term, lift it out, and substitute
    in a tree or DAG representation this is node-naming

</pre>
<li>term summarization
<pre>
    
    replacing a (reordered) subset of the terms by a summation

</pre>
<li>eliding leading, trailing, or middle terms 
<pre>

     term + term + ... + term

</pre>
<li>linearizing terms
<pre>

    terms, such as fractions, can be rewritten in linear form to 
    save lines

</pre>
<li> constant naming
<pre>

     long constants replaced by short names:

     R = 3.77612876767 * foo ==>

     let M = 3.77612876767
         R = M * foo

</pre>
<li>pattern naming
<pre>

    turn 2D template structures (powers/ratios/matricies/polys) into
    "named" template structures and substitute

    +-   -+   +-   -+ 
    | 1 2 |   | 5 6 |
    |     | * |     |
    | 3 4 |   | 7 8 |
    +-   -+   +-   -+

    turns into 

    A = Matrix((1 2) (3 4))
    B = Matrix((5 6) (7 8))
    MatrixProduct(A,B)  

</pre>
<li>operator names for all template structures and linear versions
<li>"outer structure" recognition
<pre>

   is it fundamentally a matrix? a polynomial? an integral?
   the layout techniques could differ based on the outer structure

</pre>
<li> "inner structure" eliding
<pre>

   clip out "heavy" element in a matrix so it does not cause
   wide columns

</pre>
<li>*depth*, *width*, *height* maximums as parameters
</ul>

<p>Ultimately it seems this boils down to a question of embedding a
tree or a DAG into a planar graph. or perhaps this is an extension
of the TeX layout algorithm with each weights assigned to the boxes?
compute the weight (area?) of a node in the tree or DAG and do some
sort of weight-reduction?


++added:



--
forwarded from http://wiki.axiom-developer.org/address@hidden