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

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.

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>  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