propositional_logic 0.2.0

generate truth tables for compound propositions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

# Propositional Logic

![crates.io](https://img.shields.io/crates/v/propositional_logic.svg)
[![CI](https://github.com/AnthonyMichaelTDM/propositional-logic-rs/actions/workflows/rust.yml/badge.svg)](https://github.com/AnthonyMichaelTDM/propositional-logic-rs/actions/workflows/rust.yml)

A rust library for generating the truth table of any single compound proposition.

only has one dependency: [cli_table](https://crates.io/crates/cli_table)

## Usage

### truth_table! macro

this macro only creates and returns the truth table.

```rust
use propositional_logic::prelude::*;
use cli_table::{print_stdout, TableStruct};

let compound_proposition = |p, q, r| -> bool { iff(q, (p && !q) || (!p && q)) && r };

// giving it a function (any function with boolean input and output works, technically)
let table: TableStruct = truth_table!(|p, q, r| => compound_proposition);

// giving it an inline proposition (similar to a closure)
let table: TableStruct = truth_table!(|p, q, r| => inline_compound_proposition -> {
   iff(q, (p && !q) || (!p && q)) && r
});

// giving it both (you can give it as many as you want)
let table: TableStruct = truth_table!(|p, q, r| => {
   compound_proposition,
   inline_compound_proposition -> {
      iff(q, (p && !q) || (!p && q)) && r
   }
});

assert!(print_stdout(table).is_ok());
```

Outputs:

```text
+-------+-------+-------+----------------------+-----------------------------+
| p     | q     | r     | compound_proposition | inline_compound_proposition |
+-------+-------+-------+----------------------+-----------------------------+
| true  | true  | true  |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
| true  | true  | false |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
| true  | false | true  |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
| true  | false | false |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
| false | true  | true  |                 true |                        true |
+-------+-------+-------+----------------------+-----------------------------+
| false | true  | false |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
| false | false | true  |                 true |                        true |
+-------+-------+-------+----------------------+-----------------------------+
| false | false | false |                false |                       false |
+-------+-------+-------+----------------------+-----------------------------+
```

### print_truth_table! macro

```rust
use propositional_logic::prelude::*;

let compound_proposition = |p, q| -> bool { iff(q, p) };

// giving it a function (any function with boolean input and output works, technically)
print_truth_table!(|p, q| => compound_proposition);
println!();
// giving it an inline proposition (similar to a closure)
print_truth_table!(|p| => inline_compound_proposition -> {
   not(p)
});
println!();
// giving it both (you can give it as many as you want, but every item must have a comma at the end (even the last one))
print_truth_table!(|p,q| => {
   compound_proposition,
   inline_compound_proposition -> {
      not(p)
   },
});
```

Output:

```text
+-------+-------+----------------------+
| p     | q     | compound_proposition |
+-------+-------+----------------------+
| true  | true  |                 true |
+-------+-------+----------------------+
| true  | false |                false |
+-------+-------+----------------------+
| false | true  |                false |
+-------+-------+----------------------+
| false | false |                 true |
+-------+-------+----------------------+

+-------+-----------------------------+
| p     | inline_compound_proposition |
+-------+-----------------------------+
| true  |                       false |
+-------+-----------------------------+
| false |                        true |
+-------+-----------------------------+

+-------+-------+----------------------+-----------------------------+
| p     | q     | compound_proposition | inline_compound_proposition |
+-------+-------+----------------------+-----------------------------+
| true  | true  |                 true |                       false |
+-------+-------+----------------------+-----------------------------+
| true  | false |                false |                       false |
+-------+-------+----------------------+-----------------------------+
| false | true  |                false |                        true |
+-------+-------+----------------------+-----------------------------+
| false | false |                 true |                        true |
+-------+-------+----------------------+-----------------------------+
```