------------------------------------------------------------ " | coverage of the most significant work going on in computer science | " ------------------------------------------------------------ articles have | proofs | ------------------------------------------------------------ could do | truth table | for such ------------------------------------------------------------ | 64 | rows, lots of columns — would be excessive work ------------------------------------------------------------ can simplify e.g. |f ∧ Q| to | f | ------------------------------------------------------------ because no matter what value of Q is (t or f), the value of |f ∧ Q| is | f | ------------------------------------------------------------ so |(f ∧ Q) → P| simplifies to |( | f | ) → P| ------------------------------------------------------------ but then |f → P| further simplifies to | t | ------------------------------------------------------------ simplifies | /* "false and" */ | to ------------------------------------------------------------ which simplifies | /* "if false" */ | to ------------------------------------------------------------ ≡ &/&/ by the | then-true | simplification ------------------------------------------------------------ [ | t | ] * [R = f] ------------------------------------------------------------ ≡ &/&/ by the | iff-false | simplification ------------------------------------------------------------ t * [ | !R | ] ------------------------------------------------------------ ≡ &/&/ by the | true-and | simplification ------------------------------------------------------------ | !R | ------------------------------------------------------------ ≡ &/&/ by the | not-not | simplification ------------------------------------------------------------ (P * | P | ) ? (Q / f) ------------------------------------------------------------ ≡ &/&/ by the | and-two | simplification ------------------------------------------------------------ ( | P | ) ? (Q / f) ------------------------------------------------------------ ≡ &/&/ by the | or-false | simplification ------------------------------------------------------------ ( P ) ? ( | Q | ) ------------------------------------------------------------ ≡ &/&/ by the | contrapositive | simplification ------------------------------------------------------------ !( | P ? Q | ) * (P ? Q) ------------------------------------------------------------ ≡ &/&/ by the | not-and | simplification ------------------------------------------------------------ | f | ------------------------------------------------------------ is | rewriting | using equivalences ------------------------------------------------------------ ≡ // by | if-or rewriting | ------------------------------------------------------------ | !(P ∧ Q) ∨ P | ------------------------------------------------------------ ≡ // by | DeMorgan's | ------------------------------------------------------------ | (!P ∨ !Q) | ∨ P ------------------------------------------------------------ ≡ // by | commutativity | ------------------------------------------------------------ | P ∨ (!P ∨ !Q) | ------------------------------------------------------------ ≡ // by | associativity | ------------------------------------------------------------ | (P ∨ !P) ∨ !Q | ------------------------------------------------------------ ≡ // by | the "@or-not@" simplification | ------------------------------------------------------------ | t | ∨ !Q ------------------------------------------------------------ ≡ // by | the "@true-or@" simplification | ------------------------------------------------------------ | t | ------------------------------------------------------------ ≡ // by | if-or rewriting | ------------------------------------------------------------ (P → Q) ↔ ( | !(!Q) ∨ !P | ) ------------------------------------------------------------ ≡ // by | the "@not-not@" simplification | ------------------------------------------------------------ (P → Q) ↔ ( | Q | ∨ !P ) ------------------------------------------------------------ ≡ // by | commutativity | ------------------------------------------------------------ (P → Q) ↔ ( | !P ∨ Q | ) ------------------------------------------------------------ ≡ // by | if-or rewriting right-to-left | ------------------------------------------------------------ (P → Q) ↔ | (P → Q) | ------------------------------------------------------------ ⇒ // by | the "@iff two@" simplification | ------------------------------------------------------------ ====================================================================

(Copyright © 2009 by Hugh McGuire   — for thoughts about this, see   http://www.cis.gvsu.edu/~mcguire/teaching/copyright_thoughts.html .)