Create a BooleanFunction with two arguments by indexing:

Compute its value for particular arguments:

The function remains unevaluated for symbolic arguments:

BooleanFunction can be used just like any other Boolean operator:

Any Boolean expression can be converted to a BooleanFunction expression:

Including combinations of BooleanFunction expressions:

A BooleanFunction expression that is equivalent to True or False automatically simplifies:

BooleanFunction is a canonical representation, and equivalence can be tested using SameQ:

Create a truth table in standard order:

Create an equivalent BooleanFunction expression:

Show that they are equivalent:

Alternatively, show that the resulting truth tables are the same:

Create a complete list of truth rules:

Create the corresponding BooleanFunction expression:

The ordering of truth rules for complete lists has no effect:

Use _ to indicate "don't cares" in a truth table:

Create a BooleanFunction:

The resulting truth table matches the original specification:

Use _ and __ to indicate "don't cares" in truth rules:

Create a BooleanFunction:

The original rules completely specify the function and the resulting truth tables are identical:

Use lists of lists to indicate a vector-valued truth table:

Create a BooleanFunction:

The resulting output matches the original specification:

Use vector-valued truth rules:

Create a BooleanFunction:

The resulting truth rules match the original specification:

Truth tables can also be given using 0 in place of False and 1 in place of True:

The resulting truth tables are identical:

Convert any Boolean expression to a BooleanFunction expression:

Show that they are equivalent:

Construct a BooleanFunction expression in a specified standard form:

Convert expressions involving any Boolean operators:

Show that they are equivalent:

Convert a BooleanFunction expression to other standard forms:

A number of different standard forms:

As well as a truth table:

Or truth rules:

Specify BooleanFunction using CellularAutomaton:

Enumerate all 2-variable Boolean functions:

All 3-variable Boolean functions:

Randomly sample 50 functions of 4 variables:

Compare the sizes of Boolean functions in their standard and minimized forms:

Three variables:

Four variables, the first 1000 functions:

Create new Boolean primitives corresponding to ≤, ≥, <, and >:

These are closely related:

Implies is equivalent to x<=y:

Define a relation for Boolean functions f≼g iff f[u]≤g[u]:

Here you have x≼x∨y as reflected in the truth tables:

Using standard inequalities:

For all Boolean functions f and g, f∧g≼f≼f∨g:

This proves that f≼g iff f∧g⇔f:

And similarly f≼g iff f∨g⇔g:

Or that f≼g and g≼h implies f≼h:

Generate the rule 30 elementary cellular automaton rule:

Simulate it:

Compare to the standard encoding: