Is there an open source implementation of Mathematica-the-language?
I've been collecting these links for a while, so this question is a good excuse for a link dump. I'm not sure which project is the "best", but I think that mathics and symja are two of the more active and developed projects.
Lisp:
MockMMA is probably the first implementation of the Mathematica language. It was written by Richard Fateman who had a bit of a scuffle with Wolfram Research over the code.
Python:
Mathics (which you mentioned in the question) is primarily a syntax layer ontop of sympy and sage, not an independent implementation of the Mathematica language.
Pythonica is an abandoned python implementation of Mathematica.
Java:
symja is a pure Java library for symbolic mathematics that uses Mathematica notation and supports Rubi Integration rules.
omath is an project that is still under development that will have a Mathematica like syntax, but does not aim to blindly copy Mathematica.
Go:
expreduce an experimental computer algebra system written in Go.
The omath page also has some interesting links to papers describing some of the Mathematica language's algorithms:
Matching in flat theories by Temur Kutsia.
A detailed description of Mathematica's flat pattern matching. (But quite technical!) (original link)
Mathematica as a Rewrite Language by Bruno Buchberger.
On the implementation of a rule-based programming system and some of its applications by Mircea Marin and Temur Kutsia. These people obviously understand Mathematica's pattern matching enumeration system forwards and backwards.
Discussions about whether computer languages can be copyrighted, 1, 2, 3.
Yes.
According to Mathematica's creator, Stephen Wolfram, Mathematica is just an implementation of a language that as of 2013 has been named Wolfram
Two other implementations have been developed by a Kernel Developer at Wolfram Research (poeschko.com).
One is called Mathador, which is implemented in C++ and is no longer maintained, but the source may be of interest to you.
The other is called Mathics and is currently (as of 2013) being maintained. It is implemented in Python, uses the SymPy package to perform symbolic computations, and has a web browser interface. You can check it out online at mathics.net.
Expreduce
Expreduce is a new MIT-licensed project that has a fairly complete implementation of the language semantics. Further, it has a nice collection of definitions that provide CAS functionality, along with documentation to match. There is also a large testing suite for verification. It aims to have a small core with most of the functionality implemented in the language itself using the rewrite rule paradigm. The kernel is written in Go. Here are some examples of what can be computed:
In[1]:= D[Cos[Log[Sin[x]]+x]+x,x]
Out[1]= (1 + (-1 * (1 + Cot[x]) * Sin[(x + Log[Sin[x]])]))
In[2]:= Integrate[5*E^(3*x),{x,2,a}] // Expand
Out[2]= ((-5/3 * E^6) + (5/3 * E^(3 * a)))
The CAS functionality uses a collection of rewrite rules. For example, the product rule for derivatives is implemented using only one line:
D[a_*b_,x_] := D[a,x]*b + a*D[b,x]
The implementation is currently lacking in visualizations and the functionality of Solve among other things. Right now it is just a terminal, but perhaps there will be a Jupyter notebook interface for it in the future. It has virtually no dependencies. Since it does not call out to another open source CAS, there are many operations that it cannot do. Fortunately, the rule paradigm allows for fast development of new features. It could also benefit by getting the Risch algorithm for integration. Right now the integrations are mostly solved using heuristics.
mmaclone
There is also an interesting Haskell implementation of the pattern matching engine by Yonghao Jin at https://github.com/jyh1/mmaclone.