Welcome to Logic. For this module, we will get out of VSCode and build mental models we can use anywhere to reason more effectively.

You will need

📓 Notebook and pen
🧠 Your wonderful brain
🔍 And you will still need the curriculum and Google, that’s not banned, don’t worry.

Learning by teaching

In this prep you will build a series of mental models necessary for logical reasoning. You likely already know some of these pieces. We will start to build each model by playing a game. Pay attention, because…

In class this week you will be teaching something. You will be explaining one of these mental models. You will not use a computer to explain this, but something else. This could be a drawing, a game, a conversation, or anything you like that will help you communicate the concept, except a computer!

You should make sure you understand all these models, but choose just one to teach in class.

Mental models

1. Deduction: Reasoning from general rules to a specific conclusion that is definitely true
2. Induction: Reasoning from specific examples to form general patterns that are probably true
3. Abduction: Reasoning to the best explanation for all the evidence we observe
4. Falsification: Testing a theory by trying to prove it wrong
5. Problem Domain: Identifying the bounded space that contains all possible solutions to a problem
6. Bisection: Reasoning by reducing a problem space to the smallest possible size
7. Binary Logic: Reasoning with only two possible states (true or false)

Your task

Your core prep for this sprint is to learn about all of these mental models. You will do this by reading, and by playing games that use them.

You will need to prepare to teach other people about one of these mental models. Make sure to coordinate on Slack so that people are teaching different mental models.

Deduction is reasoning from general rules to a specific conclusion that is definitely true

In Murdle, we use deduction to solve murders. Given general rules about the crime scene and specific clues, we can deduce 🧶 🧶 deduce Use rules you know are true to prove something specific must also be true. who the murderer must be.

Given the body was found in the kitchen
And only Miss Saffron had been in the kitchen
Then Miss Saffron must be the murderer

This is deduction: starting with general rules and arriving at a specific conclusion that must be true. Unlike guessing or inferring patterns, deduction gives us certainty. If our premises are true, our conclusion must be true.

In Murdle, every puzzle can be solved through pure deduction. There’s no need to guess. The clues and rules will lead you to a single possible murderer.

Go play Murdle.

Murdle

🔗 A deductive logic puzzle game

Induction is reasoning from specific examples to form general patterns that are probably true

In Sushi Go, we use induction to build winning strategies. By observing specific outcomes across multiple hands, we form general theories about what works. For example:

Given collecting 3 tempura scored 10 points
And collecting 2 tempura scored 5 points
And collecting 1 tempura scored 0 points
Then tempura probably works best in pairs

Unlike deduction which gives certainty, induction helps us form educated guesses about patterns. The more examples we see, the more confident we can be in our general conclusions - but we can never be 100% certain.

In Sushi Go, every game teaches us something new about card combinations, timing, and player behavior. Through repeated play, we inductively learn strategies like:

• Watching what others collect helps predict what cards will come around
• Early puddings often pay off in the final round
• Chopsticks are most valuable when saved for high-scoring combinations

Play a few rounds of Sushi Go and practice inductive reasoning. Don’t spend a long time reading the rules, just play through a few rounds to get the idea. Try to:

1. Notice specific scoring patterns
2. Look for recurring situations
3. Form general theories about good strategies

Sushi Go

🔗 Pattern finding

Abduction is reasoning to the best explanation for all the evidence we observe

Unlike deduction which proves only what must be true, or induction which only finds patterns that are probably true, abduction seeks the most complete explanation.

Given we guessed STARE
And we got 🟨⬜🟨⬜🟩
Then LAPSE might be the answer (but we can’t be certain)

In Wordle, we think like word detectives. We have an initial constraint: it must be an English word of five letters.

We have five attempts. Each guess we make gives us some feedback and allows us to eliminate some hypotheses, or guesses. A yellow square might support our theory about which letters are in the word, contradict it, or suggest a completely different explanation. We must:

• Keep track of all feedback squares
• Form multiple possible word theories
• Test each word against all the evidence
• Choose the word that best fits everything we know
• Make a guess even though we can’t know for sure whether we’re right
• Revise our guess when new evidence appears

It’s quite a lot like problem solving we’ve done before, isn’t it? This process of seeking the best explanation mirrors how we approach complex problems in many fields:

🧑🏽‍⚕️ Doctors diagnosing illnesses from symptoms
🕵🏿 Detectives solving cases from clues
🧑🏿‍🔬 Scientists developing theories from observations
🧑🏻‍🔧 Engineers troubleshooting system failures

We need a strategy, but experience also matters. In Wordle, the more English words we know, and the more we know about words, the better our guesses. In engineering, the more we know about building software, the faster we can find our problems.

Now go solve today’s puzzle:

Today's Wordle

🔗 Use abductive reasoning to best explain the evidence

The problem domain is a bounded space that contains all possible solutions to a problem. Everything outside the problem domain is impossible or irrelevant.

Before we can solve a problem, we need to understand what’s possible. In Twenty Questions we start with everything in the universe, then ask questions to reduce our problem space. We might start with “Is it alive?” to constrain our domain to animals, then “Is it a mammal?” to reduce further.

Twenty Questions

🔗 Ask questions to reduce possibilities

Falsification is an efficient reduction strategy. It means making predictions that eliminate possibilities, rather than gathering evidence that supports them

This is a subtle distinction: dis confirmation is the mental model we must build here. In 20 Questions we discovered our problem space by confirming and disconfirming our guesses. In Zendo, we will try to discover the rule governing pyramid patterns not by confirming our guesses, but by eliminating what’s impossible

Here’s a classic example:

Popper explains that each additional white swan appears to confirm our wrong idea that all swans are white. A single black swan disproves it, and ends the loop. This strategy shows us that:

1. Only gathering confirming evidence leaves too many possibilities, or too large a problem domain
2. However, each failed prediction narrows our search space by discarding possibilities
3. We learn more from being wrong than being right

It is more efficient to find a way to disprove your hypothesis or falsify your proposition, if you can. This is because you only need to disprove something once to discard it, but you may apparently verify a hypothesis many times in many different ways and still be wrong.

Now, practice eliminating possibilities in Zendo. For this game you need a group, so post in Slack to find others to play with.

Zendo

🔗 Eliminate to learn

In bisection, we start with a large problem space and cut it in half with each guess.

In software development, bisection helps us find exactly when a change occurred. For example:

Given our code worked last week but not today
When we test the middle version and it works
Then the problem must be in the newer half

With each test, we:

1. Select the middle version
2. Test if it works
3. Eliminate half the versions
4. Repeat until we find the exact change

This binary search technique is remarkably efficient. Even with thousands of versions, we’ll find the problematic change in just a few tests. Git and other version control systems include built-in bisect tools for this purpose.

Higher or Lower

🔗 Guess the number efficiently

Boolean logic uses only true or false to reason about the world.

In the real world, we use logic to make decisions all the time. For example: if it’s raining and you don’t have an umbrella, you will get wet. This can be represented as a truth table:

In computers, we use binary logic to derive conclusions from data. Each bit can represent a logical state: true 🧶 🧶 true Represented as 1 in binary or false 🧶 🧶 false Represented as 0 in binary .

This is fundamental to how computers work. Every operation a computer performs, from simple addition to complex decision-making, ultimately comes down to chains of basic logical operations on 1s and 0s.

Try building some truth tables yourself in your notebook. Here are some examples to get you started:

• “You can get a loyalty reward if you have the app AND have made 10 purchases”
• “The alarm will sound if the door is open OR motion is detected, UNLESS the system is disabled”
• “Trainees pass the course if they complete coursework AND attend class AND complete their steps”

Now we’re going to solve a puzzle together. We’re going to think through a few different ways to approach it. This is a well-known puzzle and it’s certainly possible to google the answer. However, we’d suggest: don’t do that - you would steal from yourself the opportunity of learning this important idea.

Conditions:

🍾 You have 1000 wine bottles, one of which is poisoned.
🐀 You have 500 rats you can use to test the wine.
⌛ The poison is lethal and will kill within 1 hour.

New condition

You now have just 10 rats to test the wine.

New condition

The birthday party is now in 1 hour, so you only have time for one test!

At its heart, our rat puzzle demonstrates how binary data encoding works. Each rat represents one binary digit (a bit). They either live (1) or die (0). With 10 rats, we have 10 bits of information.

🧮 The Power of Binary

• 1 bit can represent 2^1 = 2 possibilities (0 or 1)
• 2 bits can represent 2^2 = 4 possibilities (00, 01, 10, 11)
• 3 bits → 2^3 = 8 possibilities
• 10 bits → 2^10 = 1024 possibilities!

🎯 Key Insight

This is why 10 rats are enough for 1000 bottles. Each possible combination of rat survival/death can uniquely identify one bottle number. We’re seeing the same principle that allows computers to encode vast amounts of information using just 1s and 0s.

🐀 Memory Locations

Just like how computers use binary addressing to locate specific memory locations, we’re using our “rat bits” to encode the location (bottle number) of our poison. Each bit helps narrow down the possibilities until we have a unique address.