Hatt is a command-line program which prints truth tables
for expressions in classical propositional logic, and a
library allowing its parser, evaluator and truth table
generator to be used in other programs.

# Hatt

Hatt is a command-line program which prints truth tables for expressions in
classical propositional logic, and a library allowing its parser, evaluator and
truth table generator to be used in other programs.

## Installation

Hatt is available from Hackage. To install it with `cabal-install`

, update
your list of known packages and then install Hatt.

```
$ cabal update
$ cabal install hatt
```

To build it from source, `cd`

into the directory containing the Hatt source
files, including `hatt.cabal`

, and run `cabal install`

.

## Valid Hatt expressions

The following are all valid expression forms which can be parsed by Hatt, where
ϕ and ψ are metalinguistic variables standing in for any valid expression.

- Variables:
`P`

, `Q`

, `a`

, `b`

etc.---basically anything in the character
class `[a-zA-Z]`

- Negation:
`~ϕ`

- Conjunction:
`(ϕ & ψ)`

- Disjunction:
`(ϕ | ψ)`

- Conditional:
`(ϕ -> ψ)`

- Biconditional:
`(ϕ <-> ψ)`

For top-level formulae where the primary connective is a binary one, parentheses
are not required. For example, the expression `a | b`

is valid and will be
parsed correctly.

There is currently no support for operator precedence, so nested expressions
must be parenthesised correctly for the parser to make sense of them.

## Using the `hatt`

command-line program

The default mode is interactive: you start the program, enter expressions at
the prompt, and their truth tables are printed. Here's an example session.

```
$ hatt
Entering interactive mode. Type `help` if you don't know what to do!
> (A | B)
A B | (A | B)
-------------
T T | T
T F | T
F T | T
F F | F
> (p -> (q & ~r))
p q r | (p -> (q & ~r))
-----------------------
T T T | F
T T F | T
T F T | F
T F F | F
F T T | T
F T F | T
F F T | T
F F F | T
> (e <-> f)
e f | (e <-> f)
---------------
T T | T
T F | F
F T | F
F F | T
> exit
```

The `--evaluate`

flag lets you pass a single expression to be evaluated
directly.

```
$ hatt --evaluate="(P -> (Q | ~R))"
P Q R | (P -> (Q | ~R))
-----------------------
T T T | F
T T F | F
T F T | F
T F F | F
F T T | F
F T F | F
F F T | T
F F F | F
```

By default, `hatt`

will print ASCII representations of expressions. If you have
a Unicode-capable terminal, try passing the `--pretty`

option to pretty-print
expressions using the the more common logical symbols.

```
$ hatt --evaluate="(P -> (Q | ~R))" --pretty
P Q R | (P → (Q ∨ ¬R))
----------------------
T T T | F
T T F | F
T F T | F
T F F | F
F T T | F
F T F | F
F F T | T
F F F | F
```

You can enable pretty-printing while in interactive mode by using the `pretty`

command.

If you pass the `--coloured`

flag, `hatt`

will colour the truth values in the
tables which it prints: green for true, red for false. You can enable colouring
during interactive mode by using the `colour`

command.

## Using Hatt in other programs

Hatt exposes the `Data.Logic.Propositional`

module, which provides a simple API
for parsing, evaluating, and printing truth tables.