Support for basic arithmetic on constant values

[hackaugusto]

When describing a large system, like the stark verifier, there are a few constants that are related to each other. For example the memory addresses and their offsets. In these cases it is interesting to support basic arithmetic on the constants.

The idea is to both use these expressions as documentation, since they can express the relation among the constants, and as a tool to prevent bugs, since the assembler would compute the values for us.

[hackaugusto]

There are two questions I think are important to answer before knowing it is possible to implement the above:

1. How is division handled? For example, when computing the number of words required to fit x elements a division by 4 is required. This division on the field element won't produce the expected output, perhaps an operator like // in python, that performs automatic rouding would be useful.
2. How would such a feature interact with serialization/deserialization of the binary representation of the assembly? Should the binary representation have only the computed values, or should it restore to the original expressions?

[bobbinth]

This would be a very useful feature. My thoughts on the two questions above:

1. I like the idea of using // for integer division (and we can probably use / for field element division).
2. Currently, this doesn't really matter as constants are not serialized at all (they are all inlined). If we do implement constant serialization, my preference would be to serialize computed values rather than expressions.

One other thing we should decide on is expression features and format. I'm assuming we want to support the usual operands: +, -, *, \, and \\. I'm assuming we'd also want to support parenthesis.

One restriction we have with the current parser is that we can't allow any whitespace in expressions. So, it would have to look something like:

const.A=3
const.B=A+2
const.C=A*B

But I think this should be OK.

[bobbinth]

Closed by #1026.