## Freitag, 14. Juni 2013

### Constructing Algebraic Expressions

Constructing Expressions

# Constructing Expressions

Gsoc finally starts monday. And for the start I want to have a good idea of how the user interface of expresso should look like, for this I want to discuss the best way of aktually constructing expresso expressions :).

## 1 Representation of expresso expressions

Because core.logic currently doesn't play nicely with custom types and algebraic expressions fit nicely with normal clojure s-expressions I plan to represent algebraic expressions just as that. However, that doesn't mean it is straightforward to construct them - expresso has to know the full qualified function symbol to differentiate between - for example - clojure.core/* and the core.matrix * which behave differently. Also other mathematical properties should be stored about the functions - I plan to use metadata for it.

## 2 How should using expresso feel like

Hopefully as seamless as possible.

One approach would be a macro - create-expression. It would construct the enhanced form of the s-expression from the s-expression it gets. This, however has some drawbacks. First the user either needs to use ~ to aktually get the data in the expressions. Or you have to have map as argument which would map from symbols to values. Further than that, because it is a macro, it can't be used in higher order functions.

```(let [matrix [[1 0 1]
[0 1 0]
[1 0 1]]]
(simplify (construct-expression (* 5 (determinant ~matrix))))
;or
(simplify (construct-expression (* 5 (determinant x)) {'x matrix})))
```

The other approach would be to have construction functions in an own namespace, with concise names, just like core.matrix did with the operators namespace.

```(ns test
(:use [expresso.construction])
(:refer-clojure :exclude [* - + == /]))
(let [matrix [[1 0 1]
[0 1 0]
[1 0 1]]]
(simplify (* 5 (determinant matrix))))
```

Mike Anderson also posted some interesting usage examples (with a possible syntax) on the clojure mailing list:

```; 1. Solving simultaneous equations expressed in arrays:

(solve [x y] (== [x y] (* [[3 0] [0 10]] [y 1])))
=> [30 10]

;2a. Derivatives of array expressions:

(derivative [x] (* [x 2] [3 (* x x)]))
=> [3 (* 4 x)]

;2b. Derivatives that are themselves vectors / arrays:

(derivative [[x y]] (* [x 2] [3 (* x x)]))
=> [[3 (* 4 x)] 0]

;3. Simplification of computations on arrays:

(simplify (trace [[x y] [z (- 5 x)]]))
=> 5

;4. Simplification of array-level expressions

(simplify (* 10 A (some-identity-matrix) (inverse A) B))
=> (* 10 B)
```

What would be your favorite way of using expresso?

## 3 expresso on core.matrix expressions

Considering the close relation between expresso and core.matrix it is very likely that expresso (especially the optimizer) will be used on core.matrix expressions. Mike's examples also point in this direction. What about making expresso an implementation of core.matrix ? It would not calculate the results of matrix operations, but create the expressions under the hood. That way one could just switch the implementation of core.matrix to make the matrix expression available to expresso.

For the core.matrix folks: Do you think that is possible? There are certainly a few caveats in it but it seems to be the perfect way of using expresso in a core.matrix context.

Date: 2013-06-14T23:09+0200

Org version 7.8.09 with Emacs version 23

Validate XHTML 1.0

#### 1 Kommentar:

1. This goes a bit further than straight symbolic computation, but it's worth reading if you haven't:

http://www.iro.umontreal.ca/~lisa/pointeurs/theano_scipy2010.pdf