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.

There is also an interesting Haskell implementation of the pattern matching engine by Yonghao Jin at https://github.com/jyh1/mmaclone.

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.

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.

There is also an interesting Haskell implementation of the pattern matching engine by Yonghao Jin at https://github.com/jyh1/mmaclone.

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.

There is also an interesting Haskell implementation of the pattern matching engine by Yonghao Jin at https://github.com/jyh1/mmaclone.