# Solve

rascal-0.33.7

#### Synopsis​

Solve a set of equalities by fixed-point iteration.

#### Syntax​

``solve(Var₁, Var₂, ..., Varₙ)  Statementsolve(Var₁, Var₂, ..., Varₙ; Exp)  Statementsolve(Var₁, Var₂, ..., Varₙ) {  Statements}solve(Var₁, Var₂, ..., Varₙ; Exp) {  Statements}``

#### Types​

• Var₁ to Varₙ can be any type
• Exp is an `int`

#### Description​

Rascal provides a solve statement for performing arbitrary fixed-point computations. This means, repeating a certain computation as long as it causes changes. This can, for instance, be used for the solution of sets of simultaneous linear equations but has much wider applicability.

The solve statement consists of the variables for which a fixed point will be computed and a statement. Optionally, an expression Exp directly following the list of variables gives an upper bound on the number of iterations.

Statement can use and modify the listed variables Varᵢ. The statement is executed, assigning new values to the variables Varᵢ, and this is repeated as long as the value of any of the variables was changed compared to the previous repetition. Note that this computation will only terminate if the variables range over a so-called bounded monotonic lattice, in which values can only become larger until a fixed upper bound or become smaller until a fixed lower bound.

#### Examples​

Let's consider transitive closure as an example (transitive closure is already available as built-in operator, we use it here just as a simple illustration). Transitive closure of a relation is usually defined as:

``R+ = R + (R o R) + (R o R o R) + ...``

In other words, it is the union of successive Compositions of `R` with itself. For a given relation `R` this can be expressed as follows:

``rascal>rel[int,int] R = {<1,2>, <2,3>, <3,4>};rel[int,int]: {  <1,2>,  <3,4>,  <2,3>}rascal>T = R;rel[int,int]: {  <1,2>,  <3,4>,  <2,3>}rascal>solve (T) {>>>>>>>  T = T + (T o R);>>>>>>>}rel[int,int]: {  <3,4>,  <1,3>,  <1,2>,  <1,4>,  <2,3>,  <2,4>}``

#### Benefits​

• in combination with the relational calculus operators and setcomprehensions, `solve` provides the power of any data-log-like query
• `solve` fits nicely into the structured programming paradigm, it avoids writing complex while loops and conditionals.
• the efficiency of `solve` floats on persistent data-structures for sets and relations under-the-hood.

#### Pitfalls​

• `solve` encapsulates fixed-point computations in a lexical scope that is not openly extensible
• `solve` typically runs the code block once too often for optimality, only to check that nothing has changed
• when `solve` reaches the iteration bound, the state of the variables may be well-defined by the code block, but the final fixedpoint has probably not been reached and no exception is thrown to indicate this. If you need to distinguish reaching a fixedpoint from reaching the bound, you should use your own counter and increment it inside of the block.