The practical math behind tech and STEM work: numbers, algebra, functions, geometry, logic and counting, with short code exercises.

Math for Tech & STEM

## Why this matters

Every `if` statement in a program, every search filter, every safety interlock on a machine and every logic gate in a chip runs on the same small set of rules. Boolean logic, named after the mathematician George Boole, is how you reason precisely about conditions that are either true or false. Getting it right prevents bugs like "the alarm never fires" or "everyone can see the admin page".

## The core idea

A **proposition** is a statement that is either true or false: "the tests pass", "the user is an admin", "the temperature is above 80 °C". We combine propositions with three basic operators:

| Operator | Meaning | Maths | JavaScript | Python |
|---|---|---|---|---|
| **AND** | both must be true | p ∧ q | `p && q` | `p and q` |
| **OR** | at least one is true | p ∨ q | `p \|\| q` | `p or q` |
| **NOT** | flips true and false | ¬p | `!p` | `not p` |

OR in logic is **inclusive**: "p OR q" is true when both are true. Everyday English sometimes means "one or the other but not both"; that is a different operator called XOR (exclusive or).

## Truth tables

A **truth table** lists every possible combination of inputs and the result. With two inputs there are 2 × 2 = 4 rows; with three inputs, 2³ = 8 rows.

| p | q | p AND q | p OR q | NOT p |
|---|---|---|---|---|
| T | T | T | T | F |
| T | F | F | T | F |
| F | T | F | T | T |
| F | F | F | F | T |

Read it row by row. AND is true in only one row; OR is false in only one row.

## Worked example 1: a deploy rule

A team's rule: "deploy only if the tests pass AND the change is approved AND it is NOT Friday."

`canDeploy = testsPass && approved && !isFriday`

Three inputs means 8 rows. Only one row gives true: tests pass = T, approved = T, Friday = F. Writing the table out is a reliable way to confirm a rule says exactly what you meant.

## Worked example 2: order of operations

Like arithmetic, logic has precedence: **NOT** first, then **AND**, then **OR**. So

`a || b && c` means `a || (b && c)`, not `(a || b) && c`.

With a = T, b = F, c = F: the first is T || F = **T**; the second would be T && F = **F**. Different answers. Use parentheses whenever you combine AND and OR; readers (including future you) will thank you.

## De Morgan's laws

Two rules let you push a NOT through parentheses:

- NOT (p AND q) = (NOT p) OR (NOT q)
- NOT (p OR q) = (NOT p) AND (NOT q)

Example: "it is not true that the site is up and fast" means "the site is down, or it is slow (or both)". These laws are handy for simplifying conditions in code:

```javascript
// These two conditions are equivalent
if (!(isLoggedIn && isAdmin)) { /* deny */ }
if (!isLoggedIn || !isAdmin)  { /* deny */ }
```

You can prove a law with a truth table: compute both sides for all four rows and confirm they match.

## Building a truth table in code

```javascript
const values = [true, false];
for (const p of values) {
  for (const q of values) {
    console.log(p, q, p && q, p || q);
  }
}
```

Nested loops visit every combination, which is exactly what a truth table is.

## From logic to hardware

Inside a processor, AND, OR and NOT are physical **logic gates** built from transistors. Combining gates gives circuits that add numbers, compare values and store bits. The same truth tables describe both your `if` statements and the chip running them.

## Common mistakes

- **Treating OR as exclusive.** Inclusive OR is true when both inputs are true.
- **Mixing AND and OR without parentheses**, then relying on precedence by accident.
- **Negating a compound condition incorrectly**, such as writing `!a && !b` when you meant `!(a && b)`.
- **Using `=` (assignment) instead of `===` (comparison)** in a JavaScript condition.

## Quick recap

- Propositions are true or false; AND, OR and NOT combine them.
- A truth table lists every input combination: 2ⁿ rows for n inputs.
- Precedence: NOT, then AND, then OR. Use parentheses anyway.
- De Morgan: NOT(p AND q) = NOT p OR NOT q, and NOT(p OR q) = NOT p AND NOT q.

## Try it

In the **Do** tab, write the deploy rule as a JavaScript function. A helper that builds the full truth table is already written so you can see all 8 rows.


Evaluate AND, OR and NOT statements and build truth tables for compound conditions.

Logic and truth tables

Boolean Logic & Logic Gates: Crash Course Computer Science #3

## Why this matters

Computers store everything, from numbers and text to images and programs, as patterns of bits: 0s and 1s. You will meet binary and its compact cousin hexadecimal in colour codes (`#FF8800`), memory addresses, network masks (`255.255.255.0`), file permissions, error codes and debugging tools. Being able to convert between bases makes those numbers readable instead of mysterious.

## Place value, revisited

Our everyday decimal system is **base 10**: each place is worth 10 times the place to its right.

347 = 3 × 100 + 4 × 10 + 7 × 1

Any whole number can be written in another base by changing what each place is worth.

## Binary: base 2

Binary uses only the digits 0 and 1, and each place is worth **twice** the one to its right:

| place value | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|
| bits of 1011 | | | | | 1 | 0 | 1 | 1 |

1011₂ = 8 + 0 + 2 + 1 = **11** in decimal.

A single binary digit is a **bit**. Eight bits make a **byte**, which can hold 2⁸ = 256 different values, from 0 (00000000) to 255 (11111111).

### Binary to decimal: the doubling method

Read the bits left to right. Start at 0; for each bit, **double** the running total and **add** the bit.

For 1011: 0 → 0×2+1 = 1 → 1×2+0 = 2 → 2×2+1 = 5 → 5×2+1 = **11**.

This method needs no table of powers and is exactly how a computer program does it.

### Decimal to binary: repeated division

Divide by 2 and record the remainders; read them **bottom to top**.

Convert 13:

- 13 ÷ 2 = 6 remainder **1**
- 6 ÷ 2 = 3 remainder **0**
- 3 ÷ 2 = 1 remainder **1**
- 1 ÷ 2 = 0 remainder **1**

Reading upward: 13 = **1101₂**. Check: 8 + 4 + 0 + 1 = 13.

## Hexadecimal: base 16

Long binary strings are hard to read, so programmers group bits into fours. Four bits have 16 possible values, which is base 16, or **hex**. Hex needs 16 digits, so after 0 to 9 it uses letters: A = 10, B = 11, C = 12, D = 13, E = 14, F = 15.

| decimal | binary | hex |
|---|---|---|
| 9 | 1001 | 9 |
| 10 | 1010 | A |
| 15 | 1111 | F |
| 255 | 1111 1111 | FF |

Binary to hex: split into groups of four from the right and convert each group. 1101 0110₂ = D6₁₆.

Hex to decimal: use place values of 16. 2F₁₆ = 2 × 16 + 15 = **47**.

## Worked example: a web colour

The colour `#FF8800` is three bytes: red FF, green 88, blue 00.

- FF = 15 × 16 + 15 = 255 (full red)
- 88 = 8 × 16 + 8 = 136 (about half green)
- 00 = 0 (no blue)

That is a bright orange, `rgb(255, 136, 0)`.

## In code

Languages write other bases with prefixes: `0b` for binary and `0x` for hex.

```javascript
console.log(0b1011);                 // 11
console.log(0xff);                   // 255
console.log((13).toString(2));       // "1101"
console.log((214).toString(16));     // "d6"
console.log(parseInt("2F", 16));     // 47
```

Python has the same ideas: `bin(13)`, `hex(214)` and `int("2F", 16)`.

## Common mistakes

- **Reading remainders top to bottom.** In repeated division, the last remainder is the most significant bit.
- **Thinking 10 in binary means ten.** 10₂ is two. Write the base as a subscript or prefix when it might be unclear.
- **Grouping hex digits from the left.** Group bits in fours from the **right**, padding with zeros on the left.
- **Mixing up bits and bytes.** 8 bits = 1 byte.

## Quick recap

- Binary is base 2: places are worth 1, 2, 4, 8, 16, ...
- Binary to decimal: double and add, left to right. Decimal to binary: divide by 2, read remainders upward.
- Hex is base 16, digits 0 to F; one hex digit = four bits, one byte = two hex digits.

## Try it

In the **Do** tab, finish a binary-to-decimal converter using the doubling method. A decimal-to-hex helper is already written so you can chain them.


Convert numbers between decimal, binary and hexadecimal, and see where each appears in computing.

Binary and hexadecimal

Binary Explained in 01100100 Seconds

Number Systems Introduction - Decimal, Binary, Octal & Hexadecimal

## Why this matters

"How many?" questions sit underneath probability, security and computing. How many passwords of a given length exist? How many ways can a five-person team be picked from twelve people? How many test cases cover every combination of settings? Counting techniques answer these without listing every case, which is often impossible.

## Sets

A **set** is a collection of distinct items, written in braces: A = {1, 2, 3, 4}. Order does not matter and duplicates are ignored.

- **Union** A ∪ B: items in A or B (or both).
- **Intersection** A ∩ B: items in both.
- **Difference** A − B: items in A but not B.

With A = {1, 2, 3, 4} and B = {3, 4, 5}: A ∪ B = {1, 2, 3, 4, 5}, A ∩ B = {3, 4}, A − B = {1, 2}.

The **inclusion-exclusion** rule counts a union without double counting:

|A ∪ B| = |A| + |B| − |A ∩ B|

If 30 students take Python, 20 take SQL and 8 take both, then 30 + 20 − 8 = **42** take at least one.

Python has sets built in:

```python
a = {1, 2, 3, 4}
b = {3, 4, 5}
print(a | b, a & b, a - b)   # {1, 2, 3, 4, 5} {3, 4} {1, 2}
```

## The multiplication principle

If one choice has m options and a second, independent choice has n options, together there are **m × n** outcomes.

- A meal deal with 4 mains and 3 drinks: 4 × 3 = 12 combinations.
- A 4-digit PIN: 10 × 10 × 10 × 10 = 10⁴ = **10,000** PINs.
- An 8-character password from 62 letters and digits: 62⁸ ≈ 2.18 × 10¹⁴. Each extra character multiplies the count by 62, which is why length matters so much for security.

## Factorials

The number of ways to arrange n different items in a line is

**n! = n × (n − 1) × ... × 2 × 1**

Five books on a shelf: 5! = 120 orders. By definition 0! = 1. Factorials grow very fast: 10! = 3,628,800.

## Permutations: order matters

Choosing k items from n **where order matters** (first, second, third place):

**P(n, k) = n! / (n − k)!**

Gold, silver and bronze among 8 runners: P(8, 3) = 8 × 7 × 6 = **336**.

## Combinations: order does not matter

Choosing k items from n **where order does not matter** (a team, a hand of cards):

**C(n, k) = n! / (k! × (n − k)!)**

This is the permutation count divided by k!, because each group of k can be arranged in k! orders that we now treat as the same.

A 3-person committee from 8 people: C(8, 3) = 336 / 3! = 336 / 6 = **56**.

C(n, k) is also written "n choose k".

## Worked example: which formula?

Ask: **does swapping two chosen items give a different outcome?**

- Picking a president and a treasurer from 10 club members: Ada as president and Ben as treasurer is different from the reverse. Order matters: P(10, 2) = **90**.
- Picking 2 members to attend a conference: {Ada, Ben} is the same as {Ben, Ada}. Order does not matter: C(10, 2) = **45**.

## Worked example: lottery odds

A lottery draws 6 numbers from 49, order irrelevant. C(49, 6) = **13,983,816**, so one ticket has about a 1 in 14 million chance.

## In code

```python
import math

print(math.factorial(5))   # 120
print(math.perm(8, 3))     # 336
print(math.comb(8, 3))     # 56
print(math.comb(49, 6))    # 13983816
```

The `itertools` module can list the actual arrangements (`itertools.permutations`, `itertools.combinations`) when n is small enough to print.

## Common mistakes

- **Using permutations when order does not matter**, overcounting by a factor of k!.
- **Adding instead of multiplying** for independent choices.
- **Double counting** in a union; subtract the overlap.
- **Forgetting that 0! = 1**, which makes C(n, 0) = C(n, n) = 1.

## Quick recap

- Sets: union, intersection, difference; |A ∪ B| = |A| + |B| − |A ∩ B|.
- Independent choices multiply.
- Arrangements of n items: n!.
- Order matters: P(n, k) = n! / (n − k)!. Order does not: C(n, k) = n! / (k!(n − k)!).

## Try it

In the **Do** tab, write the combinations formula using `math.factorial`. A permutations function is already written for comparison.


Use sets, the multiplication principle, permutations and combinations to count outcomes.

Sets and counting

Permutations and Combinations Tutorial

How to Use Permutations and Combinations

Boolean logic and truth tables, binary and hexadecimal, and counting with sets, permutations and combinations.