Meta Operators

# Metaoperators

Metaoperators allow AbstractLogic to the conditional truth of the superoperators and operator expressions below them. Common type of expressions to be evaluated in this way are if (`===>` or `<===`) and if and only if (`<==>`/`====`) statements. Generally metaoperators can be identified by noting that they have four symbols together making up the operator or are strings in UPPERCASE.

When AbstractLogic encounters a metaoperator it evaluates any expressions on either side of the metaoperator before attempting to evaluate the joint metaoperator. These expressions are returned as `true` or `false`. Then it follows the rules of the metaoperators to evaluate the joint expression.

In many cases using a metaoperator will return the exact same results as a superoperator, yet when hierarchical evaluation is required metaoperators provide a valuable tool.

A Simple example. (Activate the `abstractlogic repl` by typing `=` in console).

``````abstractlogic> a ∈ 1
a ∈ 1                    feasible outcomes 1 ✓✓          :1

abstractlogic> true &&& false |||| false ||| true
true &&& false |||| false ||| true       feasible outcomes 1 ✓✓          :1``````

AbstractLogic evaluated the command as follows `(true & false) | (false | true)` which became `(false) | (true)` which became `true`.

Note Metaoperators are less visually appealing when compared with superoperators and should be refrained from in favor of superoperators when they are available.

## Operators

Notationally `x`, `y`, and `z` will refer to operations composed of at least one operator or superoperator.

#### `x &&&& y`

Both x and y must be `true`. Command end operator `;` is often preferred to joint evaluators since it is more efficient. In `x ; y` efficiency is gained by evaluating `x` first, reducing the feasible set, then evaluating `y`. Note `x AND y` is an equivalent expression.

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b &&&& b > c
a > b &&&& b > c                  feasible outcomes 1 ✓✓          :3 2 1``````

#### `x |||| y`

either x or y must be `true`. If both are `false` then total expression will return false. Note `x OR y` is equivalent

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b |||| b > c
a > b |||| b > c                  feasible outcomes 17 ✓          :2 2 1``````

#### `x !=== y`

Either x or y must be `true` but not both. If both are `false` or both are `true` then it will return false. Note `x XOR y` and `x ^^^^ y` are equivalent (`x` and `y` can only be `true` or `false`)

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b !=== b > c
a > b !=== b > c                  feasible outcomes 16 ✓          :3 3 2``````

#### `x ==== y`

If `x = true` then `y = true` or if `x = false` then `y = false`. Note `x IFF y` and `x <==> y` are equivalent

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b ==== b > c
a > b ==== b > c                  feasible outcomes 11 ✓          :1 3 3``````

#### `x ===> y`

If `x = true` then `y` must be `true`. Note `IF x THEN y` is equivalent

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b ===> b > c
a > b ===> b > c                  feasible outcomes 19 ✓          :3 3 3``````

#### `x !==> y`

If `x = false` then `y` must be `true`.

###### Example
``````abstractlogic> a,b,c ∈ 1:3; a > b !==> b > c

a,b,c ∈ 1:3              Feasible Outcomes: 27   Perceived Outcomes: 27 ✓        :1 3 3
a > b !==> b > c         Feasible Outcomes: 17   Perceived Outcomes: 27 ✓        :1 3 2``````

#### `x <=== y`

If `y = true` then `x` must be `true`. Note `x IF y` is equivalent

###### Example
``````abstractlogic> a,b,c ∈ 1:3
a,b,c ∈ 1:3              feasible outcomes 27 ✓          :1 1 3
abstractlogic> a > b <=== b > c
a > b <=== b > c                  feasible outcomes 19 ✓          :3 1 1``````

### Chaining Operators

Metaoperators can be chained and when evaluated are evaluated from left to right.

Note `true` and `false` are replaced dynamically in AbstractLogic with `1==1` and `1==0`.

Activate the `abstractlogic repl` by typing `=` in console.

``````abstractlogic> a,b ∈ 1,2
a,b ∈ 1,2                feasible outcomes 4 ✓           :2 1

abstractlogic> true
true                     feasible outcomes 4 ✓           :2 1

abstractlogic> false
false                    feasible outcomes 0 X            [empty set]

abstractlogic> back
Last command: "true" - Feasible Outcomes: 4     :1 1

abstractlogic> true |||| false &&&& true
true |||| false &&&& true        feasible outcomes 4 ✓           :1 1

abstractlogic> true !=== false
true !=== false                  feasible outcomes 4 ✓           :2 1

abstractlogic> true !=== false !=== true
true !=== false !=== true        feasible outcomes 0 X            [empty set]``````

Note Wildcards are spawned on the level below metaoperators. This allows multiple sets of wildcards to be evaluated separately.