# Belnapian

Belnapian is a library that provides basic types and operations for
[multiple-valued logics](https://en.wikipedia.org/wiki/Many-valued_logic).

## 3-Valued Logic

For [3-valued logics](https://en.wikipedia.org/wiki/Three-valued_logic), we
provide the `TernaryTruth` type:
```rust
pub enum TernaryTruth {
    False,
    True,
    Unknown,
}
```

Belnapian also provides the basic operations `and`, `or`, `not` and `xor`,
but it does not provide "implication" connectives, as they differ between
different 3-valued logic systems such as Kleene logic, RM3 logic, or
[Łukasiewicz logic](https://en.wikipedia.org/wiki/%C5%81ukasiewicz_logic).

My personal recommendation on using these "truth values" is to treat them not as
the actual truth values attributed to a proposition, but to treat them as our
subjective knowledge of them (hence the term "Unknown", which implies the need
of a sentient being not-knowing something).

## 4-Valued Belnap Logic

Belnapian, unsurprisingly, also provides basic support for
[Belnap's 4-valued logic](https://en.wikipedia.org/wiki/Four-valued_logic#Belnap).

As in the case of support for 3-valued logics, this library only provides basic
building blocks, and not any kind of fully fledged inference system.

```rust
pub enum Belnapian {
    // The `Neither` truth value is useful to identify propositions to
    // which we cannot assign any classical truth value. This often
    // happens when the proposition is not well-formed or when it is
    // self-contradictory.
    Neither,

    False,
    True,

    // We can understand `Both` as a superposition of `True` and
    // `False`. A natural case where it makes sense to assign this
    // truth value is when we have a proposition that, given our
    // current set of axioms, could be either `True` or `False`
    // (remember Gödel's incompleteness theorems).
    //
    // In other words, in case that a proposition (or its negation) is
    // independent of our axioms and could be added as a new axiom
    // without causing any inconsistency, then we can assign the
    // `Both` truth value to it.
    Both,
}
```

In constrast to the case of the 3-valued logics with an `Unknown` value, the
`Both` and `Neither` truth values aren't necessarily tied to our subjective
knowledge of the truth value for a given proposition.

Assuming that we operate with a well-known set of axioms, we could use them to
talk about the "real" underlying truth value for a given proposition.

## 15-Valued Extended Belnap Logic (with Unknown values)

The most important feature of the Belnapian library is its support for a
15-valued logic combining Belnap's 4-valued logic with subjective unknown
values.

```rust
pub enum EBelnapian {
    Known(Belnapian),
    Unknown(Unknown),
}

// The enum variants' names are ugly, but once we know what they
// represent, it becomes much easier to use & understand them.
pub enum Unknown {
    NF__, // Could be Neither or False
    N_T_,
    _FT_, // Could be False or True
    NFT_,
    N__B,
    _F_B,
    NF_B,
    __TB, // Could be True or Both
    N_TB,
    _FTB,
    NFTB,
}
```

Once we have more than 2 "objective" truth values, our unknowns can represent
more than one set of possible values (in 3-valued logic, the `Unknown` value
represents the set `{False, True}`).

Our "unknown values" represent the sets present in the power set of
`{Neither, False, True, Both}`, except for the null set `ø` and the singletons
`{Neither}`, `{False}`, `{True}`, and `{Both}` (that is, `2⁴-5 = 16-5 = 11`
values).

The amazing aspect of these "unknown values" is that we can still apply classic
logic operations to them and obtain useful results. This library relies on
pre-computed tables to save you a ton of time when dealing with uncertainty in
logic calculations.