logic

Logic, from zero

Propositions, proofs, and rigorous reasoning — the thinking layer beneath algorithms.

6 units·19 lessons·~5 h

Statements, connectives, truth tables

Every program condition is a proposition; AND/OR/NOT and implication are the whole grammar of correct branching.

01 Statements and truth: what a proposition really is 16 min 02 AND, OR, NOT: truth tables, De Morgan, and the art of negating conditions 17 min 03 Implication and equivalence: if-then, vacuous truth, and guard clauses 17 min

Arguments, quantifiers, induction

Valid argument forms, ∀/∃, and induction — the exact tools that make loop invariants and recursion click.

01 Valid arguments: modus ponens, modus tollens, and the fallacies that fool debuggers 16 min 02 Quantifiers: for-all, there-exists, and why 'all tests pass' can lie 16 min 03 Induction and loop invariants: proving code correct for every n 17 min

Sets and relations

A set is membership, nothing more: build sets, relate them, and see types and collections in code as sets with structure.

01 Sets and membership: in or not in 14 min 02 Set operations and Venn diagrams: union, intersection, difference, complement 15 min 03 Relations: ordered pairs and the grid of who relates to whom 15 min 04 Equivalence and order: classes, partitions, and what you can compare 16 min

Proof techniques

Four moves prove almost everything: direct chains, contrapositive flips, contradiction corners, counterexample kills — code review uses all four.

01 Direct proof and the contrapositive: chaining implications, and when to flip them 16 min 02 Proof by contradiction: assume it is false, derive the impossible 16 min 03 Counterexamples and claims: who carries the burden of proof 14 min

Recursion and recurrences

A recursive definition is a base case plus a smaller-self rule; unroll the recurrence to count the work, induction proves it right.

01 Recursive definitions: base cases, smaller selves, and the contract behind the leap of faith 16 min 02 Unrolling recurrences: linear and quadratic cost 12 min 03 03-recursion-and-induction

Combinatorial reasoning

Counting is two rules used carefully: multiply independent choices, add disjoint cases; pigeonhole and invariants finish the toolkit.

01 Counting principles: multiply the and-thens, add the eithers 16 min 02 The pigeonhole principle: guaranteed collisions, and the craft of choosing the holes 15 min 03 Invariants in practice: proving a goal unreachable without searching 17 min

Build with this track

Guided projects that exercise what you learn here.

◆ Projects

Truth-Table Prover

Turn the logic you learned on paper into a working engine: parse a propositional formula into a tree, walk every assignment to build its truth table, and decide whether it is a tautology, satisfiable, or equivalent to another formula. Logic is where rigor becomes mechanical — and writing the machine that checks an argument is the surest way to understand why the argument holds. By the end you'll have a small but honest theorem checker that you trust because you built every step.

Next track

React, zero to senior

How React actually renders — reconciliation, state batching, effects, memoization — past tutorial level.