is the programming language of the MathematicaPackage
, which is a ComputerAlgebraSystem
As of the release of Mathematica 10, the language it uses is now called "Wolfram", to decouple it from the Mathematica application so that the company can use it in other products without directly associating them with Mathematica.
Most people tend to call such a thing a FunctionalProgrammingLanguage.
[except mathematica has a lot of maths functions and knowledge predefined. It is similar to the older macsyma system you can do simplification, differentiation, integration, matrix operations, find eigenvalues/vectors etc etc. Typically that is not given to you in a FunctionalLanguage
like Scheme or ML. You can certainly write those functions using a FunctionalLanguage
(macsyma was originally coded in lisp) but that is what the authors of Mathematica have spent many man-years doing. Other computer algebra systems (some free, some commercial) are at http://www.xs4all.nl/~apinkus/informatie.html
A program in the MathematicaLanguage
is fundamentally a collection of RewriteRules
. Each rule consists of a left-hand side (a pattern) and a right-hand side (an expression, usually in terms of variables bound by their appearance as pattern match variables in the LHS). During evaluation, an expression that matches the rule's LHS pattern may be replaced by the RHS expression (with substitution of pattern match variables). The pattern language is quite expressive and flexible and the pattern matcher that tests the applicability of rules to expressions is quite powerful (and heavily optimized). When more than one rewriting rule is applicable to an expression being evaluated, the pattern matcher ranks the rules by best fit to the candidate expression, and the best match is taken.
comes from a lineage that includes Macsyma, Maple, Derive. Also an OpenSource
Scheme/Lisp version of Macsyma is available, see MaximaPackage
A problem with these is that they don't show the steps easily and don't do proofs. TheoremProving
is a whole other area of study using programs like HOL, OTTER etc. One should be able to take a college level maths text i.e. Schaum's Outline of Calculus
or Schaum's Outline of General Topology
and use a single tool to do most of the problems (you can't take it with you in the exam, but being able to manipulate any problem with a software tool when studying would be helpful). In Mathematica, for instance, you can differentiate a*x^n but you can't prove that d(a*x^n)/dx = n*a*x^(n-1), which would be a problem you would be just as likely to see in the text.
Research on proofs with Mathematica resulted in the Analytica system see
A simple way to explore proofs or "in between" steps where Mathematica does not let you trace is to use the PrologLanguage
. By modifying a Path searching program (easily found on internet or in prolog books a basic one is only about 10 lines long not including the graph definition) and changing the code so instead of looking for edges e(Node1,Node2), let it look for rule(Lhs,Rhs). So define a set of rule() predicates for the problem you are interested in ie an integration rule could be rule(integrate(A*X^N,d(X)),A*X^(N+1)/(N+1)+c). Path programs traverse nodes from source to destination typically
path(Node1,Node2,Path). Path is output as a list [node1,...,node2] the other args are input. Your rule definitions will let you see a set of rule applications from problem to solution instead of a list of nodes as the path. For more detailed approaches to proofs see AutomatedTheoremProving