# Expressions

An expression can come in different types. Boolean expressions are the most common. They describe a condition that is either fulfilled, or it is not. Or, using [boolean](https://docs.atfinity.io/rule-language/broken-reference) terms, the expression evaluates to true or false. There is no grey area, no room for interpretation.

### Simple Expressions

#### Example 1

An example of a simple [RuLa](https://docs.atfinity.io/rule-language/what-is-the-rule-language) expression is:

```
e is Entity
e.expected_aum >= 10000000
```

Breaking it down:

* `e` refers to an entity. In order to be able to use it in an expression, you first have to [declare](https://docs.atfinity.io/rule-language/declarations) it in the condition.
* `expected_aum` is the [information](https://docs.atfinity.io/guides/glossary/information) stored in the [field](https://docs.atfinity.io/rule-language/broken-reference) 'Expected Assets under Management'.
* `>=` is the [operator](https://docs.atfinity.io/rule-language/operators), comparing whether the value on its left is equal to, or greater than, ten million.

Let's say the `e`, the entity, in the case where this expression is used is a small financial advisory firm in Lyon. The expression evaluates to 'true' if the firm, after a record-breaking year all around, is expected to have ten million or more in assets under management.

This could trigger the need for extra documents to be included, if your organization treats corporate clients with more than ten million in assets under management differently than smaller firms. You might, for example, want to offer this client extra services.

This expression guarantees that the trigger will activate under the right circumstances in this case.

#### Example 2

```
p is Person
p.nationalities contains us
```

* This expression is 'true' if the person `p` in the case has the US nationality. Again, to be able to use `p` here, first declared in the condition that it as `p is Person`.
* `contains` is the operator.

This expression, for example, can be used to ensure a stack of documents from the US tax agency is included in the case for each client with US nationality.

#### Example 3

```
p is Person
p.domicile = de
```

* This expression is 'true' when the person `p` has residency in Germany.
* As always, be sure to declare `p is Person` in the condition first, in order to be able to use `p` here.

### Composed Condition

Atfinity's dynamic grows even more powerful when you combine expressions into a single condition. This allows you to have the system evaluate multiple circumstances, instead of just a single one, and act on the outcome.

#### Example

```
p is Person
p.nationalities contains us
or
p.tax_domicile = us
```

* Again, be sure to have made a declaration first, in this case `p is Person` .
* This condition contains two expressions, which the system will both evaluate.
* Just as `contains` and `=` are the operators comparing the values to their left and right, `or` is the operator comparing the two expressions that come before and after it.
* The entire condition will evaluate to `true` when at least one of the expressions is true. Continuing on our previous example, this composed condition ensures the US tax documents will be included in the case if the client has US nationality, or pays taxes in the US - regardless of nationality.
* If you would want that outcome only if both expressions evaluate to `true`, use the operator `and` in between them.