# Command Flow

Command flow follows a first in last out functional ruling with standard relational operators are evaluated first, then *superoperators*, then *metaoperators*. When *wildcards* are used, they generate code at the *superoperator* level which is evaluated.

## Line Break `;`

Including `;`

in a command will break the command into two or more separate commands.

## Type of Operators

`logicalparse`

takes four types operators. Generators, standard operators, superoperators, and metaoperators.

*Generators*: `∈`

and `in`

are used to create or add to a `LogicalCombo`

.

```
abstractlogic> a, b, c, d ∈ 0:2 [clear]
Clear Workspace
a, b, c, d ∈ 0:2 Feasible Outcomes: 81 Perceived Outcomes: 81 ✓ :1 0 0 2
```

*Standard Operators*: Take the form of one or two symbol operators and are often easily identified: `>, <, =, ==, !=`

though there are many non-standard operators worth taking a look at.

*Superoperators*: Evaluate the returns from operator expressions and hold three characters or lowercase strings `==>, <==, <=>, ===, !==, |||, &&&, ^^^, !=>`

as well as `iff`

, `if`

, `then`

, `and`

, `or`

, and `xor`

*Metaoperators*: Are made up of four characters or UPPERCASE characters `===>, <===, <==>, ====, !===, ||||, &&&&, ^^^^, !==>`

## Order of Operations

For most non-trivial problems order of operations is going to be very important for programming `AbstractReasoning`

problems.

*Standard operators* are evaluated first with their values returned first to *superoperators* if they exist and then to *metaoperators*.

Lets take a look at a example set, "a, b, c ∈ 1:3". Let's say we wanted to specify that if a is less than b then c must greater than b ("a < b <=> c > b").

```
julia> logicalparse("a, b, c ∈ 1:3; a < b <=> c > b") |> showfeasible
a, b, c ∈ 1:3 feasible outcomes 27 ✓ :2 3 1
11×3 Array{Int64,2}:
1 1 1
1 2 3
2 1 1
...
3 3 1
3 3 2
3 3 3
```
From the array above we can see that when a is less than b, c is greater than b and when a is not less than b, c is not greater than b.
The above statement uses a *superoperator* the `<=>` which is identical to `===` and `iff`. A *metaoperator* could functionally do the same as a *superoperator* in this case. But more complex conditional assertions might exist.
Lets imagine same scenario as before: (if a is less than b then c must greater than b) then (a must be the same as b and c) "a < b <=> c > b ===> a = b, c".
### Chaining Operators
Operators evaluated at the same level are always evaluated from left to right.
Initializing the repl (`julia> =`).
The `✓` is shorthand for `abstract logic> check ... [silent]`
calls silent check same
```

julia abstractlogic> a ∈ 1 a ∈ 1 Feasible Outcomes: 1 Perceived Outcomes: 1 ✓✓ :1

abstractlogic> ✓ true ==> false false

abstractlogic> ✓ true &&& false ==> false true

abstractlogic> ✓ true &&& false ==> false &&& false false

```
Formulating a problem. Let's say we would like a constraint specifies the only time
`a` is less than or equal to `b` or `c`, is when `a`, `b`, and `c` are all equal.
```

julia abstractlogic> a, b, c ∈ 1:3; a <= b ||| a <= c ==> a = b, c [clear] Clear Workspace

a, b, c ∈ 1:3 Feasible Outcomes: 27 Perceived Outcomes: 27 ✓ :3 3 2 a <= b ||| a <= c ==> a = b, c Feasible Outcomes: 8 Perceived Outcomes: 27 ✓ :3 2 2

abstractlogic> show a b c – – – 1 1 1 2 1 1 2 2 2 3 1 1 3 1 2 3 2 1 3 2 2 3 3 3

```
## A Note On Wildcards
Wildcards `{{i}}` are spawned and evaluated at the level right above *superoperator* but below *metaoperators*. This allows mismatching wildcard functions to be handled on either side of a *metaoperator*. Let's say you only wanted values that either ascended monotonically or descended monotonically. You could do that using `{{i}} < {{<i}}` saying that all values to the right of `i` must be greater or `{{i}} > {{<i}}` saying that all values to the right of `i` must be smaller.
```

julia julia> myset = logicalparse("a, b, c, d, e ∈ 1:6") a, b, c, d, e ∈ 1:6 feasible outcomes 7776 ✓ :6 2 6 3 4

julia> logicalparse("{{i}} < {{<i}} |||| {{i}} > {{<i}}", myset) |> showfeasible logicalparse("{{i}} < {{<i}} |||| {{i}} > {{<i}}", myset) |> showfeasible {{i}} < {{<i}} |||| {{i}} > {{<i}}

b < a c < a

...

e > c e > d

feasible outcomes 12 ✓ :1 2 3 5 6 12×5 Array{Int64,2}: 1 2 3 4 5 1 2 3 4 6 1 2 3 5 6 ... 6 5 4 2 1 6 5 4 3 1 6 5 4 3 2 ```