# Logic

> Clear reasoning from the ground up - true/false, if-then, proof, and spotting bad arguments. The thinking that sits under all code and math.

10 guides.

- [What Logic Actually Is](https://themissingmanual.dev/guides/what-logic-actually-is) _(beginner)_ - Logic is the skill of working out what follows from what - the quiet foundation under every line of code, every proof, and every argument you'll ever need to judge. This is where it starts.
- [Propositional Logic](https://themissingmanual.dev/guides/propositional-logic) _(beginner)_ - The algebra of true and false: how AND, OR, and NOT combine statements, how truth tables prove what a compound claim really does, and the equivalences (like De Morgan's laws) that let you rewrite and negate conditions with confidence.
- [Implication & Conditionals](https://themissingmanual.dev/guides/implication-and-conditionals) _(beginner)_ - 'If P then Q' is the most misunderstood idea in logic. This guide nails what it really means (and when it's true), untangles converse/inverse/contrapositive, and makes the difference between necessary and sufficient conditions finally click.
- [Predicate Logic & Quantifiers](https://themissingmanual.dev/guides/predicate-logic-and-quantifiers) _(beginner)_ - Propositional logic treats whole statements as atoms. Predicate logic looks inside them - at properties of things and the words 'for all' and 'there exists' - which is how you say precise things about whole collections at once.
- [Boolean Algebra & Logic Gates](https://themissingmanual.dev/guides/boolean-algebra-and-logic-gates) _(beginner)_ - The same AND/OR/NOT you already know, turned into an algebra you can compute with - and then etched into hardware as logic gates. This is the bridge from 'true and false' all the way down to how a CPU adds two numbers.
- [What a Proof Is](https://themissingmanual.dev/guides/what-a-proof-is) _(beginner)_ - A proof isn't intimidating ceremony - it's an argument so airtight it leaves no room for doubt: a chain of valid steps from things you already accept to the thing you're claiming. Here's how proofs actually work, including the famous techniques.
- [Critical Thinking & Fallacies](https://themissingmanual.dev/guides/critical-thinking-and-fallacies) _(beginner)_ - A fallacy is an argument that feels convincing but is logically broken. Learning to name the common ones - and the habits of clear thinking that beat them - is the most practical self-defense there is against being misled.
- [Formal Methods and Specification](https://themissingmanual.dev/guides/formal-methods-and-specification) _(intermediate)_ - Describe what a system must do, and why it is correct, before you build it: state machines, invariants, and specify-before-you-code.
- [Short-Circuit Evaluation](https://themissingmanual.dev/guides/short-circuit-evaluation) _(beginner)_ - Why && and || stop evaluating the moment the answer is already determined, and how that becomes both a useful coding pattern and a source of subtle bugs.
- [Model Checking in Practice](https://themissingmanual.dev/guides/model-checking-in-practice) _(advanced)_ - Write a real spec, understand exhaustive state-space exploration, and see a genuine concurrency bug a model checker catches before code exists.