WIP: Logic week

Author: illicitonion

Diff for: common-content/en/energisers/binary/index.md

@@ -0,0 +1,36 @@
++++
+title="Binary Line-Up"
+emoji="⬜ ⬛"
+time=20
+[tasks]
+1="Convert decimal to binary using people"
+2="Practice quick mental math with powers of 2"
+[build]
+render = 'never'
+list = 'local'
+publishResources = false
++++
+
+### ⬜ ⬜ ⬛ ⬜
+
+Let's count in binary using human beans!
+
+Assign roles randomly. 1️⃣ One person will be the **caller**, 4️⃣ four people will be the **beans** and #️⃣ the rest will be the **counters**.
+
+First four **beans**, line up facing away from the group. **Counters**, get in any kind of order so you know who is next.
+
+The **caller** will say a number between 1 and 15.
+For example, 8: 😀 ⬜ ⬜ ⬜
+
+First **counter**, you will turn the beans around to represent the binary number. If you get it right, go back in the counter group and let the next person count. If you get it wrong, you must become another bean, and the range of numbers will increase!
+
+<details>
+<summary>Example of range increase</summary>
+
+🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧 Round 1: Numbers 1-15 (4 beans)  
+🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧 Round 2: Numbers 1-31 (5 beans)  
+🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧 Round 3: Numbers 1-63 (6 beans)  
+🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧🧑🏽‍🔧 Round 4: Numbers 1-127 (7 beans)  
+...And so on until only one counter remains!
+
+</details>

Diff for: common-content/en/module/logic/_index.md

@@ -0,0 +1,8 @@
++++
+title="Logic"
+description="Mental models for logical reasoning"
+emoji="🧑🏾‍💻"
+layout="block-viewer"
+hide_from_overview="true"
+noindex="true"
++++

Diff for: common-content/en/module/logic/abduction/index.md

@@ -0,0 +1,51 @@
++++
+title = "Abduction"
+time = 60
+emoji= "🔎"
+[build]
+render = 'never'
+list = 'local'
+publishResources = false
+[objectives]
+1="Define abduction"
+2="Use evidence to reason to the best explanation"
++++
+
+> Abduction is reasoning to the best explanation for all the evidence we observe
+
+```mermaid
+flowchart TD
+    ev1[Evidence 1] --> h1[Hypothesis A]
+    ev2[Evidence 2] --> h1
+    ev3[Evidence 3] --> h1
+    ev1 --> h2[Hypothesis B]
+    ev2 --> h2
+    ev3 -.-> h2
+    h1 --> be[Best Explanation]
+    h2 -.- be
+    style h2 stroke-dasharray: 5 5
+    style ev3 stroke-dasharray: 5 5
+```
+
+In [Sherlock Holmes: Consulting Detective](https://www.spacecowboys.fr/case3-the-murderess), we think like detectives. Each case presents us with mysterious evidence that needs explaining. 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_ a woman was found dead in her apartment  
+> _And_ her jewelry was untouched  
+> _And_ there were no signs of forced entry  
+> _Then_ the killer likely knew the victim (but we can't be certain)
+
+Each lead we follow adds new evidence. A witness statement might support our theory, contradict it, or suggest a completely different explanation. We must:
+
+- Keep track of all evidence
+- Form multiple possible theories
+- Test each theory against _all_ the evidence
+- Choose the explanation that best fits everything we know
+- Be ready to revise our theory when new evidence appears
+
+It's quite a lot like problem solving we've done before, isn't it? Now go solve a case:
+
+{{<blocklink
+  src="https://www.spacecowboys.fr/case3-the-murderess"
+  name="Sherlock Holmes: Consulting Detective - Case 3"
+  caption="Use abductive reasoning to best explain the evidence"
+  time="5" >}}

Diff for: common-content/en/module/logic/binary-logic/index.md

@@ -0,0 +1,51 @@
++++
+title = "Boolean Logic"
+time = 45
+emoji = "🎭"
+[build]
+  render = 'never'
+  list = 'local'
+  publishResources = false
+[objectives]
+    1="Define binary logic and its role in computing"
+    2="Express logical statements as truth tables"
++++
+
+> 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:
+
+{{<columns>}}
+
+| Is Raining | Has Umbrella | Is Wet |
+| ---------- | ------------ | ------ |
+| F          | F            | F      |
+| F          | T            | F      |
+| T          | F            | T      |
+| T          | T            | F      |
+
+Truth tables show all possible combinations and all possible outcomes.
+<--->
+
+> _Given_ A is true (1)  
+> _And_ B is true (1)  
+> _Then_ A AND B is true (1)
+
+{{</columns>}}
+
+In computers, we use binary logic to derive conclusions from data. Each bit can represent a logical state: {{<tooltip title="true">}}Represented as 1 in binary{{</tooltip>}} or {{<tooltip title="false">}}Represented as 0 in binary{{</tooltip>}}.
+
+| Raining | Umbrella | Wet |
+| ------- | -------- | --- |
+| 0       | 0        | 0   |
+| 0       | 1        | 0   |
+| 1       | 0        | 1   |
+| 1       | 1        | 0   |
+
+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"

Diff for: common-content/en/module/logic/bisection/bisection.svg

@@ -0,0 +1,37 @@
++++
+title = "Bisection"
+time = 10
+emoji= "✂️"
+[build]
+  render = 'never'
+  list = 'local'
+  publishResources = false
+[objectives]
+    1="Define bisection search"
+    2="Apply binary search to guess a number"
++++
+
+> In bisection, we start with a large problem space and cut it in half with each guess.
+
+![bisection.svg](bisection.svg)
+
+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](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/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](https://git-scm.com/docs/git-bisect) for this purpose.
+
+{{<blocklink
+  src="https://www.mathsisfun.com/games/guess_number.html"
+  name="Higher or Lower"
+  caption="Guess the number efficiently"
+  time="2" >}}

Diff for: common-content/en/module/logic/bisection/index.md

@@ -0,0 +1,40 @@
++++
+title = "Deduction"
+time = 25
+emoji= "🚥"
+[build]
+  render = 'never'
+  list = 'local'
+  publishResources = false
+[objectives]
+    1="Define deduction"
+    2="Use deduction to solve a matrix puzzle"
++++
+
+> Deduction is reasoning from **general** rules to a **specific** conclusion that is _definitely_ true
+
+```mermaid
+flowchart LR
+    d1[Rule 1: If A then B]
+    d2[Rule 2: We have A]
+    d1 --> dc[Therefore we must have B]
+    d2 --> dc
+```
+
+In [Murdle](https://murdle.com/), we use deduction to solve murders. Given general rules about the crime scene and specific clues, we can {{<tooltip title="deduce">}}Use rules you know are true to prove something specific _must_ also be true.{{</tooltip>}} 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.
+
+{{<blocklink
+  src="https://murdle.com/"
+  name="Murdle"
+  caption="A deductive logic puzzle game"
+  time="5" >}}

Diff for: common-content/en/module/logic/deduction/index.md

@@ -0,0 +1,52 @@
++++
+title="Docendo Discimus"
+emoji="🎤"
+time=60
+[build]
+  render = 'never'
+  list = 'local'
+  publishResources = false
+
++++
+
+This sprint you should have prepared to teach one of the following topics:
+
+<details>
+<summary>Topics</summary>
+
+- **Deduction**
+- **Induction**
+- **Abduction**
+- **Falsification**
+- **The Problem Domain**
+- **Bisection**
+- **Binary Logic**
+</details>
+
+## ⏰ Timekeeper
+
+The timekeeper will keep the groups on track.
+
+## 📚 Instructions
+
+Split into pairs. Each person will have 3 minutes to present their topic. After the lesson, you and your student will discuss the topic for 3 minutes. Then the student will become the teacher and present their own topic.
+
+## 🧑🏾‍🤝‍🧑🏻 Pairs
+
+### 1. Model
+
+You will explain your topic to your student. You will have 3 minutes to communicate, in whatever way you have prepared. You can use a drawing, a game, a conversation, or anything you like that will help you communicate the concept, except a computer!
+
+### 2. Check understanding
+
+After your lesson, you and your student check your understanding for another 3 minutes. Then you will switch roles.
+
+### 3. Add yourself to another group
+
+At the end of both lessons, join another pair. Pick one of your topics and explain it to the other pair. They will do the same for you. At the end of both lessons, join another group of four and repeat the process.
+
+## 💡 Tips:
+
+- **Practice** your lesson before class.
+- **Keep it simple**. Just choose one concept to explain.
+- **Keep it short**. Three minutes is enough.

Diff for: common-content/en/module/logic/demo/index.md

@@ -0,0 +1,72 @@
++++
+title = "Falsification"
+time = 45
+emoji= "❌"
+[build]
+  render = 'never'
+  list = 'local'
+  publishResources = false
+[objectives]
+    1="Define Popper's falsification principle"
+    2="Use elimination to reduce possibilities"
++++
+
+> Falsification is an efficient _reduction_ strategy. It means making predictions that **eliminate** possibilities, rather than gathering evidence that supports them
+
+{{<columns>}}
+
+```mermaid
+stateDiagram-v2
+    state "All Possibilities" as AP {
+        state "Theory Space" as T1 {
+            state "Remaining" as T2 {
+                state "Survivors" as T3
+            }
+        }
+    }
+```
+
+<--->
+
+> _Given_ many possible rules  
+> _Make_ a prediction that could eliminate some  
+> _When_ the prediction fails  
+> _Then_ we can discard those possibilities
+
+{{</columns>}}
+
+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](https://www.looneylabs.com/games/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](https://simple.wikipedia.org/wiki/Falsifiability):
+
+```mermaid
+flowchart TD
+    T["🦢 Theory: All Swans Are White"]
+    O["Observe Next Swan"]
+    D{"What Color?"}
+    W["Theory Holds..."]
+    F["Theory Falsified!"]
+
+    T --> O
+    O --> D
+    D -->|⬜ White| W
+    D -->|⬛ Black| F
+    W -->|"Keep testing"| O
+
+```
+
+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](https://www.koryheath.com/zendo/). For this game you need a group, so post in Slack to find others to play with.
+
+{{<blocklink
+  src="https://www.perlkonig.com/zendo/"
+  name="Zendo"
+  caption="Eliminate to learn"
+  time="20" >}}