You can use defworld library not only for interactive storytelling, but also for rule-based application. In this example, I explain how to build a linear equation solver using defworld.

A linear equation is an equation in which each term is either a constant or the product of a constant and a single variable, e.g. 2x + 3 = 5. Solving methods are quite easy: subtract a same number from both side or divide both side by a same number repeatedly until the unknown remains solely on left side and a constant on right side.

Let’s define the terminal condition, first.

```
Rule('x = b', [
Not(solution()), # not yet solved
equation(x, b) # x = b
],[
solved(b) # the solution is b
]),
```

`solution` is a `defworld.patterns.Template` for the solution, defined
by the following:

```
solution = Template('solution', Entity)
```

`equation` is a `defworld.patterns.Template` for an
`defworld.patterns.Entity` represents the equation.

```
equation = Template('equation', Entity)
```

`solved` is also a function returns an `defworld.patterns.Entity`.

```
@Func
def solved(x):
print x.value
return solution(value=x)
```

This function is called when the rule ‘x = b’ is fired. That’s why `solved`
is decorated by `defworld.patterns.Func`.

To sum up, the ‘x = b’ rule is fired when the equation is not yet solved and is in the form of ‘x = b’. Once the rule is fired, the solution is appended on the agent’s working memory and printed out.

If there is an equation *x + 2 = 5*, you just subtract 2 from both side to
solve this equation. In this section, I show you how to implement this rule.

```
Rule('expr + a = b', [
Not(solution()), # not yet solved
equation(add(expr, a), b) # expr + a = b
],[
equation(expr, Sub(b, a)) # expr = b - a
]),
```

That’s it. `add` is a function returns a `defworld.patterns.Fact`
represents addition, defined by the following:

```
add = Template('add')
```

`Sub` is a function decorated by `defworld.patterns.Func` which
returns the difference between two value.

This is the full source code.

```
from defworld.agent import Agent
from defworld.basic import Var
from defworld.patterns import Entity, Func, Not, Rule, Template
if __name__ == '__main__':
solution = Template('solution', Entity)
a = Var('a')
b = Var('b')
expr = Var('expr')
x = Entity('unknown')
product = Template('product')
add = Template('add')
equation = Template('equation', Entity)
@Func
def Div(a, b):
return a/b
@Func
def Sub(a, b):
return a-b
@Func
def solved(x):
print x.value
return solution(x)
agent = Agent([
equation(add(product(2,x), 3), 5) # 2x + 3 = 5
],[
Rule('x = b', [
Not(solution()), # not yet solved
equation(x, b) # x = b
],[
solved(b) # the solution is b
]),
Rule('a * expr = b', [
Not(solution()), # not yet solved
equation(product(a, expr), b) # a * expr = b
],[
equation(expr, Div(b, a)) # expr = b / a
]),
Rule('expr + a = b', [
Not(solution()), # not yet solved
equation(add(expr, a), b) # expr + a = b
],[
equation(expr, Sub(b, a)) # expr = b - a
]),
])
agent.match()
agent.run() # print 1
```