🔹 Module One · Welcome to Racket & Thinking Like a Computer

Certified Racket AI Specialist · Foundation

📖 Module Introduction

Hello, young explorer! 👋 Have you ever wondered how your video games work, or how a calculator knows that 2+2=4? In this module, we are going to learn the language of computers. We will use a special language called Racket. Racket is like a magic wand that lets us tell a computer what to do. By the end of this module, you will be able to write your very first computer programs, just like a real AI specialist! We'll start from the very beginning, so don't worry if you have never programmed before. This is your first step to becoming a Racket AI Specialist.

We will learn what a computer is, how it thinks, and how we can give it instructions using Racket. Think of it like learning a new language — but instead of talking to people, you will be talking to machines. And the best part? Machines always do exactly what you tell them (even if you make a mistake!).

🎯 Learning Objectives

By the end of this module, you will be able to:

• ✔️ Explain what a computer is and what a program does.
• ✔️ Understand why we use Racket for AI.
• ✔️ Write your first Racket expressions (like 1+1).
• ✔️ Use numbers and text in Racket.
• ✔️ Spot the difference between a command and a question.
• ✔️ Think like a programmer — break big problems into small pieces.
• ✔️ Show confidence to continue learning more!

📚 Warm-up Story · The Robot Chef

Imagine you have a robot chef named Racky. Racky is super smart, but it only understands a special language. If you say, "Racky, please make me some jollof rice," Racky will just stare at you. But if you say exactly what to do, step by step, like: "Racky, take a pot. Put oil. Add tomatoes. Add rice. Cook for 20 minutes." — then Racky will make perfect jollof rice!

That is exactly what programming is. We give the computer (our robot) a list of clear, simple steps. The computer follows them without getting tired or bored. In this module, we will learn how to give instructions to the computer using Racket.

Let's meet Racket, the language that helps us talk to the computer. Just like learning "hello" and "goodbye" in a new language, we'll start with small words and build up to big, amazing programs.

   +-----------------+
   |   You (coder)   |
   +--------+--------+
            |
            |  (write Racket code)
            V
   +-----------------+
   |   Computer      |
   |  (Racket reads  |
   |   and follows)  |
   +-----------------+
            |
            V
   +-----------------+
   |  Result: answer,|
   |  drawing, game  |
   +-----------------+
  

🧩 Main Lessons

Lesson 1 · What is a Computer, Really?

Definition: A computer is a machine that follows instructions to do work. It can add numbers, show pictures, and play music — but only if we tell it how.

Why it matters: To be an AI specialist, you must understand what a computer can and cannot do.

Simple explanation: Think of a computer as a very fast, very dumb worker. It does exactly what you say, no more, no less. If you say "add 2 and 3", it answers 5. If you say "make a cake", it doesn't know what that means (unless you give it a cake recipe).

Real-life example: A calculator is a small computer. You press 2+3, it shows 5.

School example: In math class, your teacher gives you a problem; you solve it. A computer needs every single step.

Home example: When you set the microwave to 2 minutes and press start, the microwave follows that instruction exactly.

Nigerian example: Think of a POS machine. When you enter your PIN and amount, the machine follows the instructions to give you cash.

Illustration:

   [Your instruction]  --->  [Computer]  --->  [Result]
       "2 + 3"         --->    adds      --->     5
  

Lesson 2 · What is a Programming Language?

Definition: A programming language is a special way to write instructions that a computer can understand.

Why important: We cannot speak "computer" directly, so we use a programming language as a translator.

Simple explanation: Just like we use English, Yoruba, or Hausa to talk to people, we use a programming language to talk to computers. Racket is one of these languages.

Real-life: English, French, and Spanish are languages for people. Python, Racket, Java are languages for computers.

School: In your school, you might learn English, Maths, and Science. In programming, you learn a language like Racket.

Home: Your mum speaks to you in your mother tongue; you speak to the computer in Racket.

Nigerian: In Nigeria, we have many languages: Yoruba, Igbo, Hausa. Racket is just another language — but for computers.

Illustration:

   +-------------+      +----------------+      +-----------+
   |  You write  | ---> |  Racket reads  | ---> | Computer  |
   |  (+ 2 3)    |      |  and translates|      | answers 5 |
   +-------------+      +----------------+      +-----------+
  

Lesson 3 · Getting to Know Racket

Definition: Racket is a friendly programming language that is great for learning and for building smart AI systems.

Why Racket? It is simple, powerful, and teaches you to think clearly — exactly what an AI specialist needs.

Simple explanation: Racket is like a toy box. It has lots of tools (functions) to play with numbers, words, and even draw pictures.

Real-life: Many top universities use Racket to teach computer science.

School: Imagine if your maths teacher gave you a magic pen that could solve any problem. That's Racket.

Home: If you wanted to teach your younger sibling how to count, you would use simple words. Racket uses simple words too.

Nigerian: Racket is like the "Ube" (Pear) of programming languages — sweet, nutritious, and everyone can enjoy it.

Illustration:

   Racket language
         |
         V
   +-------------+
   |  ( + 5 3 )  |   -- means add 5 and 3
   +-------------+
         |
         V
      answer: 8
  

Lesson 4 · Numbers and Math in Racket

Definition: Numbers are the most basic things we use in Racket. We can add, subtract, multiply, and divide.

Why important: AI often uses math to make decisions — like scoring a game or predicting the weather.

Simple explanation: In Racket, we write math like this: (+ 2 3) means 2+3. The + is the operation, and the numbers are after it.

Real-life: When you buy a snack for 50 Naira and give 100 Naira, the cashier subtracts: 100 - 50 = 50.

School: In class, you write 3 + 4 = 7. In Racket, we write (+ 3 4) and it gives 7.

Home: If you have 5 oranges and eat 2, you have 3 left. In Racket: (- 5 2) → 3.

Nigerian: If you buy 10 sachets of water and share 4, you have 6 left. Racket: (- 10 4).

Illustration:

   (+ 2 3)   →   5
   (- 9 4)   →   5
   (* 2 3)   →   6
   (/ 10 2)  →   5
  

Lesson 5 · Words (Strings) in Racket

Definition: A string is a piece of text, like "Hello" or "Racket is fun". In Racket, we put quotes around strings.

Why it matters: AI systems often need to understand and generate text — like chatbots.

Simple explanation: If you want to say your name, you write "Chidi" in Racket. The quotes tell Racket this is a word, not a math instruction.

Real-life: When you send a text message, that's a string.

School: Your teacher might write "Good job!" on your work. That's a string.

Home: You might say "I love rice" — in Racket that is "I love rice".

Nigerian: "Jollof rice is delicious" — Racket stores it as "Jollof rice is delicious".

Illustration:

   "Hello"   →  a string
   "123"     →  a string (not a number)
   (+ 2 3)   →  math
   (+ "2" 3) →  error (can't mix string and number)
  

Lesson 6 · The Racket Way of Thinking

Definition: In Racket, we write everything in a "prefix" style — the operator (like + or -) comes first, then the values.

Why it's cool: This makes Racket very consistent. Every instruction looks similar: (verb thing1 thing2 ...).

Simple explanation: Instead of saying "2 plus 3", we say "plus 2 3" — like Yoda from Star Wars! "Add you must, 2 and 3."

Real-life: Imagine giving commands to a robot: "Walk forward 2 steps" is like (walk 2).

School: When your teacher says "Read page 10", that's (read page 10) in Racket style.

Home: "Eat 3 bananas" → (eat 3 bananas).

Nigerian: "Buy 5 loaves of bread" → (buy 5 bread).

Illustration:

   English style:  2 + 3
   Racket style:   (+ 2 3)

   English:        "Hello" + " World"
   Racket:         (string-append "Hello" " World")
  

Lesson 7 · Storing Things with Variables

Definition: A variable is like a box that holds a value. You can put a number or a string inside, and give it a name.

Why important: Variables let us remember things, so we can use them again later.

Simple explanation: Imagine you have a box labelled "age" and you put 10 inside. Now whenever you say age, Racket knows you mean 10.

Real-life: Your school bag has a name tag — that's like a variable. The contents are the value.

School: Your locker number stores your books.

Home: A jar labelled "sweets" — if you put 5 sweets in, the label tells you.

Nigerian: A "kolo" (piggy bank) with "savings" — when you put money in, the name tells you what it is.

Illustration:

   (define age 10)   ; creates a variable called age with value 10
   age   → 10
   (define name "Ade") ; variable name holds "Ade"
   name  → "Ade"
  

Lesson 8 · Making Decisions (if statements)

Definition: An if statement lets the computer make choices: if something is true, do one thing; otherwise, do something else.

Why important: AI needs to make decisions — like if it's raining, carry an umbrella.

Simple explanation: If you are hungry, eat. Otherwise, play. Racket can do this too.

Real-life: If the traffic light is red, stop; if green, go.

School: If you score above 70, you get an A. Otherwise, you get a B.

Home: If you finish your homework, you can watch TV.

Nigerian: If the price of beans is cheap, buy more; otherwise, buy less.

Illustration:

   (if (< 5 10) "smaller" "bigger")  → "smaller"
   (if (> 5 10) "bigger" "smaller")  → "smaller"
  

Lesson 9 · Creating Your Own Commands (Functions)

Definition: A function is a new command that you create. You give it a name and tell it what to do.

Why it matters: Functions let you reuse code. Once you make a command, you can use it many times.

Simple explanation: Imagine you invent a dance called "The Racket". You teach it to your friend once, then they can do it anytime.

Real-life: A recipe is like a function. Once you write it, you can cook the dish many times.

School: A maths formula like area = length × width is a function.

Home: A chore routine: "tidy room" means pick up toys, make bed.

Nigerian: "Make Jollof" — a function that includes steps: fry, add rice, cook.

Illustration:

   (define (square x) (* x x))   ; define a function to square a number
   (square 5)  → 25
   (square 3)  → 9
  

Lesson 10 · Lists – Putting Things in Order

Definition: A list is a collection of things, like a shopping list. In Racket, we use ' (1 2 3).

Why important: AI often works with groups of data — like all the scores of a game.

Simple explanation: It's like a queue in school — everyone stands in a line.

Real-life: A grocery list: eggs, milk, bread.

School: A list of students in your class.

Home: A list of chores: sweep, dust, clean.

Nigerian: A list of items to buy at the market: yam, pepper, onions.

Illustration:

   '(1 2 3 4)          ; a list of numbers
   '("apple" "banana") ; a list of strings
   (first '(1 2 3))    → 1
   (rest '(1 2 3))     → (2 3)
  

Lesson 11 · Putting It All Together – Our First AI Program

We now know enough to write a tiny AI: a program that greets you and tells you if you can watch TV. Let's combine variables, if, and functions!

   (define name "Zainab")
   (define age 10)
   (define (can-watch-tv? age) (if (> age 8) "Yes, you may" "No, too young"))
   (string-append "Hello " name ", " (can-watch-tv? age))
   → "Hello Zainab, Yes, you may"
  

This is a real program! It uses a variable, a function, and an if statement. You just built a tiny AI!

📖 Key Vocabulary

• Computer: A machine that follows instructions.
• Program: A set of instructions for the computer.
• Racket: A programming language we use to talk to computers.
• String: Text inside quotes, like "hello".
• Variable: A box with a name that stores a value.
• Function: A custom command you create.
• List: A collection of items in order.
• If statement: A way to make decisions in code.

🧠 Important Concepts

• Precision: Computers are dumb — they need exact instructions.
• Order: Instructions run one after another.
• Abstraction: Hiding details inside functions.
• Reuse: Functions let us reuse code again and again.

📘 Step-by-Step Explanations

How to write your first Racket program:

1. Open Racket (DrRacket).
2. Type (+ 5 6) in the interactions window.
3. Press Enter. See 11 appear!
4. Now type (define age 12).
5. Type age — Racket shows 12.
6. Type (define (double x) (* x 2)).
7. Type (double 5) — you get 10!

🌍 Real-life Examples

• ATMs: they follow instructions to dispense cash.
• Traffic lights: they use decision logic (if green, go).
• Spell-checkers: they look at lists of words.

🇳🇬 Nigerian Examples

• Mobile banking apps: they use functions to transfer money.
• Jollof rice recipe: a function that makes food.
• School attendance: a list of student names.

🎈 Fun Examples

• If you have 10 candies and eat 3, how many left? Racket: (- 10 3)
• Make a variable called "bestFood" and set it to "Pizza".
• Write a function called "shout" that takes a word and adds "!!!" at the end.

🏠 Everyday Examples

• A recipe: functions.
• A to-do list: lists.
• An alarm clock: if time = 7am, ring.

🧑‍🏫 Teacher Notes

Encourage learners to type every example themselves. Relate everything to daily life. Use physical objects (like boxes for variables). Emphasize that mistakes are normal — debugging is part of the fun.

👪 Parent Tips

Ask your child to teach you what they learned. Let them show you how Racket adds numbers. Celebrate every small success. Learning to code is like learning a sport — practice, patience, and fun!

🌟 Interesting Facts

• The first computer was as big as a room!
• Racket was created by a team at a university.
• AI can now play chess better than any human.

🤔 Did You Know?

Racket was originally made for teaching, so it's perfect for beginners like you. And many AI researchers use it to test new ideas!

🧾 Remember This

• Computers follow instructions exactly.
• Racket uses prefix notation: operator first.
• Variables store things.
• Functions let you create new commands.
• Lists hold groups of things.

⚠️ Common Mistakes

• Forgetting the quote around strings: "hello" not hello.
• Using = instead of equal? for comparing.
• Mixing up the order: (+ 2 3) is correct, (2 + 3) is not.
• Forgetting to close parentheses: (+ 2 3 is missing a ).

✅ Best Practices

• Always use descriptive names for variables: age not x.
• Break big problems into small functions.
• Test each small part before moving on.

📊 ASCII Illustrations

   +--------+      +--------+      +--------+
   |  Input | ---> | Racket | ---> | Output |
   +--------+      +--------+      +--------+
       ( + 5 3 )   computes         8
  

   Flow of a program:
   Start → Get Input → Process → Show Result → End
  

📋 Comparison Table

📌 End-of-Module Summary

Wow! You've learned so much. You now know what a computer is, how to talk to it using Racket, how to use numbers and words, how to store things in variables, make decisions with if, create your own functions, and group things in lists. You've written your first tiny AI program. You are on your way to becoming a Certified Racket AI Specialist!

❓ Frequently Asked Questions (10)

1. What is Racket? — A programming language for beginners and experts.
2. Is Racket hard? — No! It's very friendly.
3. Do I need a fast computer? — No, any computer works.
4. Can I use Racket for games? — Yes, you can.
5. Is Racket free? — Yes, completely free.
6. What is a string? — Text inside quotes.
7. What is a variable? — A named box for a value.
8. What does (define) do? — It creates a variable or function.
9. Can I make mistakes? — Yes, and it's okay. That's how we learn.
10. What's next? — We'll learn more in Module Two!

📝 Review Questions (15)

1. What is a computer?
2. What is a programming language?
3. What does (+ 3 4) do?
4. How do you write "hello" in Racket?
5. What is a variable?
6. How do you create a variable named age with value 12?
7. What is a function?
8. Write a function that doubles a number.
9. What is a list?
10. How do you make a list of (1 2 3) in Racket?
11. What does (if (> 5 3) "yes" "no") return?
12. What is a string?
13. Why is Racket good for beginners?
14. What does (rest '(a b c)) return?
15. Write a program that adds 5 and 7.

✏️ Fill-in-the-Blank

1. A ______ is a machine that follows instructions.
2. In Racket, text is written inside ______.
3. The command to create a variable is ______.
4. A ______ holds multiple values in order.
5. The (if) statement helps us make ______.

✅ True or False

1. Computers can think for themselves. (False)
2. Racket uses prefix notation. (True)
3. Strings are numbers. (False)
4. Functions can reuse code. (True)
5. Lists are not useful in AI. (False)

🔘 Multiple Choice (15)

1. What does (+ 2 3) return? A) 5 B) 23 C) error D) 6 → A
2. How do you write a string? A) "hello" B) hello C) 'hello D) (hello) → A
3. Which creates a variable? A) (define x 5) B) (set x 5) C) (var x 5) D) (x 5) → A
4. What is a function? A) A machine B) A command you make C) A number D) A list → B
5. Which is a list? A) (1 2 3) B) [1 2 3] C) {1 2 3} D) "1 2 3" → A (with quote)
6. What does (if (< 3 5) "small" "big") return? A) small B) big C) error D) 5 → A
7. What is Racket? A) A game B) A programming language C) A food D) A country → B
8. What does (first '(a b c)) return? A) a B) b C) c D) (a b c) → A
9. What is a variable? A) A box with a name B) A number C) A string D) A list → A
10. Can functions call other functions? A) Yes B) No C) Maybe D) Never → A
11. What does (string-append "Hello" " World") do? A) Adds numbers B) Joins text C) Multiplies D) Error → B
12. Which is NOT a Racket operator? A) + B) - C) * D) ÷ → D (uses /)
13. What do we need to close after an expression? A) Parentheses B) Brackets C) Curly braces D) Quotes → A
14. Is Racket free? A) Yes B) No C) Maybe D) Expensive → A
15. What does (rest '(1 2 3)) return? A) 1 B) (2 3) C) (1 2) D) 3 → B

🔗 Matching Exercises

Answers: 1-B, 2-A, 3-C, 4-D

📝 Short Answer

1. Explain what a computer does in your own words.
2. Why do we use Racket?
3. Give an example of a function you could make.

📖 Scenario-based Exercises

Scenario: You are building a simple bot for a shop. It should take the item price and quantity and calculate the total. How would you do it in Racket?

Answer: (define (total price qty) (* price qty))

👥 Group Activity

In groups of 3, pretend you are a computer. One person gives instructions like "(+ 4 5)", another computes the answer, and the third checks if it's correct. Take turns.

🧑‍💻 Individual Activity

Write a Racket expression that adds 10 and 20, multiplies the result by 2, and stores it in a variable called "result".

💬 Classroom Discussion Questions

• Why is it important to give clear instructions to a computer?
• Can you think of a real-life example where a computer makes a decision?
• How is learning Racket similar to learning a new language?

🛠️ Mini Project

Create a simple "greeting bot" that asks for your name and says hello. Use a variable, a string, and display a message. (You can use (display) or just return a string.)

📋 Practical Assignment

Write a Racket program that takes your age and tells you if you are old enough to ride a rollercoaster (age > 12).

🏆 Challenge Exercise

Write a function that takes a list of numbers and returns the sum of all the numbers. (Hint: you can use recursion or the built-in (apply + list).)

🔑 Quiz Answers

Multiple choice answers: 1-A, 2-A, 3-A, 4-B, 5-A, 6-A, 7-B, 8-A, 9-A, 10-A, 11-B, 12-D, 13-A, 14-A, 15-B.

🎁 Key Takeaways

• Computers need clear, exact instructions.
• Racket is a fun and powerful language.
• Variables store information.
• Functions help us reuse code.
• We made our first AI program!

🚀 Preparation for the Next Module

In Module Two, we will dive deeper into decision-making and start building more intelligent programs. We'll learn about logic, more math, and how to make our programs "remember" things. Get ready to create a tiny chatbot!

Before then, practice writing simple Racket expressions, create your own variables, and write at least three functions. The more you practice, the more it will stick.

🎉 You've completed Module One · Great job, future AI specialist! 🎉

🔄 Module Three · Repetition & Loops – Making Computers Work Hard

Certified Racket AI Specialist · Power of Doing Things Again and Again

📖 Module Introduction

Hello, clever coder! 👋 In Module Two, we taught our computer to make decisions. Now we will teach it something even more powerful: how to repeat tasks.

Think about a mother hen counting her chicks. She doesn't just count once — she counts each chick, one by one. If she had to count 100 chicks, she would do the same action 100 times. Computers are great at this! They never get bored or tired.

In this module, we will learn loops (ways to repeat code) and recursion (a function that calls itself). We'll build programs that can handle big lists, draw patterns, and solve problems that need many steps. By the end, you'll be able to make your computer do the hard work for you — just like a real AI!

🎯 Learning Objectives

After this module, you will be able to:

• ✔️ Understand why repetition is important in programming.
• ✔️ Use recursion to repeat a task.
• ✔️ Write a recursive function that counts down.
• ✔️ Use map to apply a function to every item in a list.
• ✔️ Use filter to select items from a list.
• ✔️ Use foldl (or reduce) to combine items.
• ✔️ Build programs that process large amounts of data.
• ✔️ Understand when to stop a loop (base case).

📚 Warm-up Story · The Endless Dance

Imagine you are at a party, and the DJ plays a song. Everyone starts dancing. When the song ends, the DJ plays the same song again — and again — and again. People keep dancing until the DJ stops.

That's like a loop in programming. The computer does the same action over and over until we tell it to stop.

But there is another way: imagine a line of people. You ask the first person, "What's your name?" They tell you. Then you ask the second person, and so on, until you reach the end of the line. In Racket, we use recursion to do this — a function that keeps calling itself until it reaches the end.

Let's learn both ways, starting with recursion — the Racket way!

   Loop (repeat)
   +--------+
   | Do work |
   +--------+
       |
       V
   +--------+
   | Repeat? |
   +--------+
       |
    Yes/No
  

🧩 Main Lessons

Lesson 1 · Why Repeat? The Power of Doing Things Many Times

Definition: Repetition means doing the same thing more than once.

Why important: Many tasks in AI involve doing the same thing to a lot of data — like checking all the numbers in a list, or training a model by repeating steps.

Simple explanation: If you want to eat 10 candies, you pick one, eat it, pick one, eat it... you repeat the "pick and eat" action 10 times.

Real-life example: A teacher checking homework for 30 students — checks each student's work one by one.

School example: Writing your name 5 times to practice.

Home example: Taking out all the dishes from a dishwasher — one plate at a time.

Nigerian example: Counting the number of mangoes in a basket — pick one, count, pick one, count.

Illustration:

   Task: Count apples
   Step 1: take one apple, count 1
   Step 2: take one apple, count 2
   Step 3: take one apple, count 3
   ... repeat until no apples left
  

Lesson 2 · Recursion – A Function That Calls Itself

Definition: Recursion is when a function calls itself to solve a smaller version of the same problem.

Why important: Recursion is the main way to repeat things in Racket. It's elegant and powerful.

Simple explanation: Imagine you are in a maze. You look around. If you see the exit, you go out. If not, you take one step and then solve the maze again. That's recursion — solving a smaller version of the same problem.

Real-life: Looking for a book in a stack: you check the top, if it's not there, you check the next, and so on.

School: Counting down to zero: "5, 4, 3, 2, 1, blast off!" Each step is a smaller count.

Home: Unwrapping a gift: you open one layer, if there's another layer, you open that too.

Nigerian: Sharing oranges: give one to a friend, then share the rest.

Illustration:

   (define (count-down n)
     (if (<= n 0)
         "blast off!"
         (begin
           (display n)
           (count-down (- n 1)))))
   (count-down 5)
   → 5 4 3 2 1 blast off!
  

Lesson 3 · The Base Case – When to Stop

Definition: The base case is the condition that stops the recursion. Without it, the function would run forever.

Why important: Every recursive function must have a base case to avoid infinite loops.

Simple explanation: It's like a "STOP" sign. When you reach the base case, you don't continue.

Real-life: In a race, the finish line is the base case — when you cross it, you stop.

School: When you finish a test, you stop writing.

Home: When the pot is empty, you stop serving food.

Nigerian: When the market closes, you stop buying.

Illustration:

   (define (sum-up-to n)
     (if (= n 0)          ; base case
         0                ; stop
         (+ n (sum-up-to (- n 1)))))
   (sum-up-to 5) → 15   (5+4+3+2+1+0)
  

Lesson 4 · Recursion on Lists – Processing Every Item

Definition: We can use recursion to go through each item in a list and do something with it.

Why important: AI often works with lists of data — like scores, names, or sensor readings.

Simple explanation: Imagine a line of students. You ask the first student a question, then move to the next, until you reach the end.

Real-life: Checking a shopping list: look at first item, buy it, then go to the next.

School: Taking attendance: call each name in the list.

Home: Reading a list of chores: do chore 1, then chore 2, etc.

Nigerian: Going through a list of market items: buy yam, then pepper, then onions.

Illustration:

   (define (sum-list lst)
     (if (empty? lst)      ; base case: empty list
         0
         (+ (first lst) (sum-list (rest lst)))))
   (sum-list '(1 2 3 4)) → 10
  

Lesson 5 · Map – Do Something to Every Item

Definition: map takes a function and a list, and applies that function to every item in the list, returning a new list.

Why important: It's a fast way to transform all items without writing a loop.

Simple explanation: It's like a teacher giving a sticker to every student in the class — one function applied to everyone.

Real-life: Adding tax to every item in a shopping cart.

School: Adding 5 points to everyone's test score.

Home: Cutting every fruit into pieces.

Nigerian: Adding 10% discount to every item in a price list.

Illustration:

   (define (double x) (* x 2))
   (map double '(1 2 3 4)) → '(2 4 6 8)
  

Lesson 6 · Filter – Keep Only What We Want

Definition: filter takes a test function and a list, and returns a new list with only the items that pass the test.

Why important: AI often needs to pick out certain data — like finding all numbers greater than 50.

Simple explanation: It's like a sieve — you shake it and only small particles pass through. Filter keeps only the items that are true.

Real-life: Sorting out ripe fruits from unripe ones.

School: Picking all students who scored above 70.

Home: Selecting only your favorite toys.

Nigerian: Choosing only the big fish from a basket.

Illustration:

   (define (even? n) (= 0 (remainder n 2)))
   (filter even? '(1 2 3 4 5)) → '(2 4)
  

Lesson 7 · Fold (Reduce) – Combine Everything

Definition: foldl (or fold) takes a function, an initial value, and a list, and combines all items into one value.

Why important: It's used for summing, multiplying, or combining data in many AI tasks.

Simple explanation: Think of a big pile of numbers. You start with 0, then add each number one by one to get the total.

Real-life: Adding up all the prices in a shopping cart.

School: Calculating the total marks for all subjects.

Home: Counting how many toys you have by adding 1 each time.

Nigerian: Summing the cost of all items in a market list.

Illustration:

   (foldl + 0 '(1 2 3 4)) → 10
   (foldl * 1 '(1 2 3 4)) → 24
  

Lesson 8 · Building a Recursive Function – Step by Step

Let's build a function that counts the number of items in a list (without using length).

   (define (my-length lst)
     (if (empty? lst)
         0
         (+ 1 (my-length (rest lst)))))
   (my-length '(a b c d)) → 4
  

Steps: 1) If list is empty, return 0. 2) Otherwise, count 1 for the first item, and add the length of the rest.

Lesson 9 · The Power of Recursion – Factorial

Factorial is a famous recursion example. 5! = 5 × 4 × 3 × 2 × 1.

   (define (factorial n)
     (if (= n 0)
         1
         (* n (factorial (- n 1)))))
   (factorial 5) → 120
  

AI uses factorial in probability and statistics.

Lesson 10 · Recursion vs. Loops in Other Languages

In Racket, we use recursion instead of traditional loops (like 'for' or 'while' in other languages). Recursion is more functional and elegant.

Lesson 11 · Processing Big Data – AI in Action

AI systems process huge lists of data. We can use map, filter, and fold to clean and analyze data. For example, we can filter out low scores, map each score to a grade, and fold to get the average.

Lesson 12 · Putting It All Together – A Data Analyzer

Let's build a program that takes a list of numbers, keeps only the even ones, doubles them, and sums them up.

   (define (process nums)
     (foldl + 0 (map double (filter even? nums))))
   (process '(1 2 3 4 5 6)) → 2*2 + 4*2 + 6*2 = 4+8+12 = 24
  

You just built a tiny data pipeline — the same idea used in big AI systems!

📖 Key Vocabulary

• Recursion: A function that calls itself.
• Base case: The condition that stops recursion.
• Map: Apply a function to every item in a list.
• Filter: Keep items that pass a test.
• Fold (reduce): Combine all items into one.
• List processing: Working with lists of data.
• Data pipeline: A series of transformations on data.

🧠 Important Concepts

• Recursion replaces loops: In Racket, we use recursion for repetition.
• Higher-order functions: map, filter, fold are functions that take other functions.
• Immutability: We don't change lists; we create new ones.
• Composition: We combine simple functions to build complex ones.

📘 Step-by-Step Explanations

How to write a recursive function:

1. Identify the base case (smallest problem).
2. Write what to do for the base case.
3. Identify the recursive case (how to break the problem down).
4. Write the recursive call with a smaller input.
5. Combine the result.

🌍 Real-life Examples

• Search engines: filter pages by keywords.
• Weather apps: process sensor data with map.
• Online shopping: calculate total price using fold.

🇳🇬 Nigerian Examples

• Market data: filter items under 500 Naira.
• School results: map scores to grades.
• Traffic data: sum vehicles per hour using fold.

🎈 Fun Examples

• Count how many cookies you have.
• Double all the numbers in a list.
• Keep only your favorite colors from a list.

🏠 Everyday Examples

• Making tea: repeat "pour water" until cup is full.
• Reading a book: read page 1, then page 2, etc.
• Cleaning: do one chore, then the next.

🧑‍🏫 Teacher Notes

Use physical demonstrations: pass a ball around a circle to show recursion. Use boxes to represent lists. Emphasize that recursion is just a function calling itself. Always write the base case first.

👪 Parent Tips

Encourage your child to think about patterns of repetition in daily life. Ask: "How would you tell a robot to count all your toys?" This builds the concept of iteration. Practice writing small recursive functions together.

🌟 Interesting Facts

• The factorial function was invented by Christian Kramp in 1808.
• Recursion is used in sorting algorithms that power search engines.
• AI systems use map/filter/fold to prepare data for training.

🤔 Did You Know?

Racket's map can work with multiple lists at the same time! For example: (map + '(1 2) '(3 4)) → '(4 6).

🧾 Remember This

• Recursion needs a base case to stop.
• Map transforms every item.
• Filter selects some items.
• Fold combines all items.
• These functions are the heart of list processing in AI.

⚠️ Common Mistakes

• Forgetting the base case — causes infinite recursion.
• Not using rest to shrink the list.
• Confusing map and filter — map returns same length, filter returns shorter.
• Using foldl with wrong initial value.

✅ Best Practices

• Always write the base case first.
• Use meaningful names for helper functions.
• Test with small inputs before big ones.
• Combine map, filter, fold for clean data processing.

📊 ASCII Illustrations

   Recursive process:
   function(5)
      |
      V
   function(4)
      |
      V
   function(3)
      |
      V
   function(2)
      |
      V
   function(1)
      |
      V
   function(0) → base case, returns
  

   Map process:
   [1,2,3] -- map double --> [2,4,6]
  

📋 Comparison Table

📌 End-of-Module Summary

You've mastered repetition in Racket! You learned recursion, map, filter, and fold. You can now process lists of any size. These skills are essential for AI — from cleaning data to training models. You are building a powerful toolkit.

❓ Frequently Asked Questions (10)

1. What is recursion? — A function that calls itself.
2. Why do we need a base case? — To stop the recursion.
3. What does map do? — Applies a function to every item.
4. What does filter do? — Keeps items that match a condition.
5. What does fold do? — Combines all items into one.
6. Can map change the length of a list? — No, it keeps the same length.
7. Can filter increase the length? — No, it only keeps some.
8. What is a data pipeline? — A series of transformations like filter, map, fold.
9. Is recursion faster than loops? — In Racket, recursion is efficient and encouraged.
10. Can we use recursion with strings? — Yes, by converting strings to lists.

📝 Review Questions (15)

1. What is recursion?
2. What is a base case?
3. Write a recursive function that prints numbers from N to 1.
4. What does map do?
5. What does filter do?
6. What does foldl do?
7. Write a function that doubles every number in a list using map.
8. Write a function that keeps only numbers greater than 5 using filter.
9. Write a function that sums a list using foldl.
10. What happens if you forget the base case?
11. Why is recursion useful for lists?
12. What is a higher-order function?
13. Can you use map with multiple lists?
14. Write a recursive function to find the length of a list.
15. What is the difference between map and filter?

✏️ Fill-in-the-Blank

1. ______ is a function that calls itself.
2. ______ stops recursion.
3. ______ applies a function to every item in a list.
4. ______ keeps only the items that satisfy a condition.
5. ______ combines all items into one value.

✅ True or False

1. Recursion can run forever if there is no base case. (True)
2. map returns a shorter list. (False)
3. filter returns a longer list. (False)
4. foldl returns a single value. (True)
5. We cannot use recursion with lists. (False)

🔘 Multiple Choice (15)

1. What does recursion do? A) calls itself B) stops C) adds numbers D) creates lists → A
2. What is a base case? A) stop condition B) function C) list D) number → A
3. What does map do? A) transforms each item B) keeps some C) combines D) sorts → A
4. What does filter do? A) keeps some B) transforms C) combines D) deletes → A
5. What does foldl do? A) combines B) transforms C) keeps D) sorts → A
6. Which function keeps the same length? A) map B) filter C) fold D) none → A
7. Which function can shorten a list? A) filter B) map C) fold D) all → A
8. What is (foldl + 0 '(1 2 3))? A) 6 B) 0 C) 1 D) 3 → A
9. What is (map double '(1 2)) if double is (* 2 x)? A) '(2 4) B) '(1 2) C) 3 D) error → A
10. What is (filter even? '(1 2 3))? A) '(2) B) '(1 3) C) '(1 2 3) D) '() → A
11. What happens if recursion has no base case? A) runs forever B) stops C) error D) returns 0 → A
12. What is a higher-order function? A) takes a function B) takes numbers C) takes lists D) takes strings → A
13. What does (rest '(1 2 3)) return? A) '(2 3) B) 1 C) 3 D) '() → A
14. What does (first '(a b)) return? A) a B) b C) (a b) D) error → A
15. What is the base case for a list recursion? A) empty list B) first item C) rest D) none → A

🔗 Matching

Answers: 1-B, 2-C, 3-A, 4-D

📝 Short Answer

1. Explain the difference between map and filter.
2. Why do we need a base case in recursion?
3. Write a recursive function that returns the sum of all numbers from 1 to n.

📖 Scenario-based Exercises

Scenario: You have a list of temperatures in Celsius. Write a program that converts them to Fahrenheit (C × 9/5 + 32) and then finds the average.

Answer: (define (avg lst) (/ (foldl + 0 lst) (length lst))) (avg (map (lambda (c) (+ (* c 1.8) 32)) temps))

👥 Group Activity

Each group writes a function that takes a list of words and returns a list of their lengths. Use map.

🧑‍💻 Individual Activity

Write a recursive function that returns the last element of a list.

💬 Classroom Discussion Questions

• How is recursion like solving a maze?
• Why is map useful for data science?
• What would happen if we didn't have map/filter/fold?

🛠️ Mini Project

Create a "smart filter" for a list of numbers: keep only the numbers that are perfect squares (like 1,4,9,16). Use filter and a helper function.

📋 Practical Assignment

Write a program that takes a list of exam scores, removes scores below 40, gives a 5-point bonus to the rest, and finds the total.

🏆 Challenge Exercise

Write a recursive function that reverses a list. (Hint: append the first item to the reverse of the rest.)

🔑 Quiz Answers

Multiple choice: 1-A, 2-A, 3-A, 4-A, 5-A, 6-A, 7-A, 8-A, 9-A, 10-A, 11-A, 12-A, 13-A, 14-A, 15-A.

🎁 Key Takeaways

• Recursion is a function that calls itself.
• Base case is essential to stop recursion.
• map, filter, fold are powerful list tools.
• Data pipelines combine these functions.
• You can now process large amounts of data!

🚀 Preparation for the Next Module

In Module Four, we will dive into data structures — more ways to organize information. We'll learn about structures, association lists, and trees. You'll be able to build more complex AI systems. Practice your recursion and list functions — they will be your best friends!

🎉 You've completed Module Three · You are now a Racket repetition expert! 🎉

🗂️ Module Four · Data Structures – Organising Information

Certified Racket AI Specialist · Building Smart Containers

📖 Module Introduction

Hello, young organiser! 👋 In Module Three, we learned to repeat tasks and process lists. But real-world data is often more complex than a simple list. We need better ways to organise information.

Think about a school. You don't just have a list of students — you also have their names, ages, classes, and scores. You need to keep all that related information together. That's where data structures come in.

In this module, we will learn about structures (custom containers for related data), association lists (key-value pairs), and trees (hierarchical data). These tools will help you build smarter, more realistic AI systems.

🎯 Learning Objectives

After this module, you will be able to:

• ✔️ Understand why we need different data structures.
• ✔️ Create your own structures using struct.
• ✔️ Use association lists to store key-value pairs.
• ✔️ Build simple trees to represent hierarchical data.
• ✔️ Access and update data inside structures and lists.
• ✔️ Choose the right data structure for the job.
• ✔️ Build a small AI system that uses multiple structures.

📚 Warm-up Story · The Great Library

Imagine you are in charge of a huge library. You have thousands of books. If you just pile them up, nobody can find anything. But if you organise them by category, author, and title, everything becomes easy to find.

In programming, data structures are like your library organisation system. They help you store, find, and use information quickly and correctly.

Today, we will build our own "organisers" — structures to hold related information, dictionaries to look things up, and trees to show relationships. Let's get organised!

   Without structure:
   [book1, book2, book3, ...]  (confusing)

   With structure:
   [ (title "Racket" author "Smith" year 2020),
     (title "AI" author "Jones" year 2021) ]
   (clear and organised)
  

🧩 Main Lessons

Lesson 1 · Why Data Structures Matter

Definition: A data structure is a way to store and organise data so that we can use it easily.

Why important: AI systems handle lots of data. Good structures make AI faster and easier to build.

Simple explanation: Think of a drawer. If you throw everything in, it's messy. If you use dividers, you can find things quickly. Data structures are like dividers.

Real-life: A phone book organises names and numbers.

School: A timetable organises subjects by day and time.

Home: A recipe book organises dishes by type (soup, rice, etc.).

Nigerian: A market seller organises goods by type: yams here, tomatoes there.

Illustration:

   Without structure:   [2, "Ade", #t, 5.6, "hello"]
   With structure:      (person name "Ade" age 12)
  

Lesson 2 · Structures – Custom Containers

Definition: A structure (struct) is a custom data type that groups related pieces of information together.

Why important: Structures let you create your own data types, like "Student" or "Book", with named fields.

Simple explanation: It's like a form you fill out: name, age, class. Each person gets their own form.

Real-life: A passport contains name, photo, nationality.

School: A report card contains subject, score, grade.

Home: A gift card contains sender, receiver, amount.

Nigerian: A voter's card contains name, age, polling unit.

Illustration:

   (struct student (name age class))
   (define s1 (student "Ade" 12 "JSS2"))
   (student-name s1) → "Ade"
   (student-age s1)  → 12
  

Lesson 3 · Creating and Using Structures

Let's create a structure for a book: title, author, pages.

   (struct book (title author pages))
   (define b1 (book "Racket for AI" "Dr. Ada" 120))
   (book-title b1)  → "Racket for AI"
   (book-author b1) → "Dr. Ada"
   (book-pages b1)  → 120
  

You can also make lists of structures.

Lesson 4 · Association Lists – Lookup Tables

Definition: An association list (alist) is a list of pairs: (key . value). It acts like a dictionary or lookup table.

Why important: AI often needs to look up values by key — like finding a word in a dictionary.

Simple explanation: It's like a label on a box: the label (key) tells you what's inside (value).

Real-life: A dictionary: word → meaning.

School: A class list: name → score.

Home: A chore chart: chore → who does it.

Nigerian: A menu: food → price.

Illustration:

   (define phone-list '((Ade . 080123) (Bola . 080456)))
   (assoc 'Ade phone-list) → '(Ade . 080123)
   (cdr (assoc 'Ade phone-list)) → 080123
  

Lesson 5 · Working with Association Lists

We can add, find, and update values in alists. Racket provides functions like assoc and alist-update.

Lesson 6 · Trees – Hierarchical Data

Definition: A tree is a data structure that has a root and branches. Each branch can have more branches. It's used for hierarchical data.

Why important: Many things are hierarchical: family trees, file systems, decision trees in AI.

Simple explanation: It's like a family tree: grandparents at the top, parents below, children below them.

Real-life: A company organisation chart: CEO → managers → employees.

School: A school system: Principal → Head teachers → Class teachers → Students.

Home: A wardrobe: clothes → tops → shirts.

Nigerian: Traditional title system: Oba → chiefs → villagers.

Illustration:

         Root
        /    \
     NodeA   NodeB
     /  \      |
   Leaf1 Leaf2 Leaf3
  

Lesson 7 · Building a Simple Tree in Racket

We can represent a tree using lists: (value children...). For example: (1 (2 (4) (5)) (3 (6)))

   (define tree '(1 (2 (4) (5)) (3 (6))))
   ; tree with root 1, children 2 and 3, etc.
  

We can write functions to traverse trees.

Lesson 8 · Using Structures for Tree Nodes

Better: use structures to make trees clearer.

   (struct node (value left right))
   (define tree (node 5 (node 3 #f #f) (node 7 #f #f)))
  

This is a binary tree: each node has a value, left child, and right child.

Lesson 9 · Traversing a Tree

We can visit every node in a tree (called traversal). There are different orders: pre-order, in-order, post-order.

   (define (in-order tree)
     (if (empty? tree)
         '()
         (append (in-order (node-left tree))
                 (list (node-value tree))
                 (in-order (node-right tree)))))
  

Lesson 10 · When to Use Each Structure

Lesson 11 · Building a Small AI System – Library Manager

Let's build a system that manages books using structures and association lists.

   (struct book (title author year))
   (define library '())
   (define (add-book library b) (cons b library))
   (define (find-by-author library author)
     (filter (lambda (b) (equal? (book-author b) author)) library))
  

This is a simple AI for managing a library!

Lesson 12 · Putting It All Together – A Student Database

Create a student structure with name, age, and scores. Store them in a list. Write functions to find students by name and to calculate average score.

📖 Key Vocabulary

• Data structure: A way to organise data.
• Struct: A custom container for related fields.
• Association list (alist): A list of (key . value) pairs.
• Tree: A hierarchical structure with root and branches.
• Node: An element in a tree.
• Traversal: Visiting every node in a tree.
• Key-value pair: A key that maps to a value.

🧠 Important Concepts

• Organisation: Good structures make programs easier to write and understand.
• Access: Each structure provides ways to get and set data.
• Hierarchy: Trees show parent-child relationships.
• Composition: Structures can contain other structures.

📘 Step-by-Step Explanations

How to create a structure and use it:

1. Define the structure: (struct person (name age))
2. Create an instance: (define p (person "Ada" 12))
3. Access fields: (person-name p) → "Ada"
4. Use in lists: (list (person "Bob" 10) (person "Eve" 11))

🌍 Real-life Examples

• Online store: structures for products (name, price, stock).
• Social media: structures for users (name, posts, friends).
• Bank: structures for accounts (owner, balance, transactions).

🇳🇬 Nigerian Examples

• Market inventory: alist for item → price.
• School system: structures for students and teachers.
• Village hierarchy: tree for traditional rulers.

🎈 Fun Examples

• Struct for a video game character (name, health, power).
• Alist for pet names → animal type.
• Tree for a story: beginning → middle → end.

🏠 Everyday Examples

• Contacts: alist with name → phone number.
• Recipe: struct for ingredients and steps.
• To-do list: list of tasks with priorities.

🧑‍🏫 Teacher Notes

Use physical objects: folders for structs, sticky notes for alists, family trees for trees. Encourage students to think about organising their own belongings. Relate every structure to something tangible.

👪 Parent Tips

Ask your child to describe how they organise their room. Relate that to data structures. Encourage them to think about how a library or shop organises items. Practice creating structures for things at home.

🌟 Interesting Facts

• The first data structures were developed in the 1950s.
• AI uses trees for decision-making (decision trees).
• Google uses huge trees to organise web pages.

🤔 Did You Know?

Racket's struct can automatically generate functions for you: a constructor, field accessors, and even a predicate (like student?).

🧾 Remember This

• Structures group related data.
• Association lists map keys to values.
• Trees show hierarchical relationships.
• Choose the right structure for your data.

⚠️ Common Mistakes

• Forgetting to use struct before creating an instance.
• Using assoc on an alist with improper formatting.
• Confusing tree nodes with lists.
• Not handling empty trees in recursive functions.

✅ Best Practices

• Name structures clearly: student, book, etc.
• Use empty? to check for empty lists and trees.
• Write helper functions to access nested data.
• Document what each field means.

📊 ASCII Illustrations

   Structure example:
   +------------------------+
   | Student                |
   +------------------------+
   | name: "Ade"            |
   | age: 12                |
   | class: "JSS2"          |
   +------------------------+
  

   Tree example:
         +-----+
         | 10  |  (root)
         +-----+
        /       \
     +---+     +---+
     | 5 |     | 15 |
     +---+     +---+
    /     \         \
  +---+   +---+     +---+
  | 2 |   | 7 |     | 20 |
  +---+   +---+     +---+
  

📋 Comparison Table

📌 End-of-Module Summary

You've learned how to organise data like a pro! You can now create structures, use association lists, and build trees. These tools are essential for any AI system — they help you store, find, and manage information efficiently. You're building the foundation for intelligent data handling.

❓ Frequently Asked Questions (10)

1. What is a data structure? — A way to organise data.
2. Why use struct? — To group related fields.
3. What is an alist? — A list of key-value pairs.
4. What is a tree? — A hierarchical structure.
5. How do I access a struct field? — Use the field accessor.
6. How do I find a key in an alist? — Use assoc.
7. How do I traverse a tree? — Recursively visit left and right.
8. Can I put a struct inside another struct? — Yes, you can nest them.
9. Are alists fast? — They are fast for small data.
10. Why are trees important for AI? — AI uses decision trees and hierarchical data.

📝 Review Questions (15)

1. What is a data structure?
2. How do you define a struct in Racket?
3. How do you create an instance of a struct?
4. What is an association list?
5. How do you look up a key in an alist?
6. What is a tree?
7. How do you represent a binary tree?
8. What is tree traversal?
9. Write a struct for a "car" with make, model, year.
10. Write an alist for a menu (food → price).
11. How do you check if an alist has a key?
12. What is a node in a tree?
13. Why is hierarchy useful?
14. Can a tree have more than two children?
15. Give an example of a tree in real life.

✏️ Fill-in-the-Blank

1. A ______ groups related fields together.
2. An association list stores ______ pairs.
3. A ______ has a root and branches.
4. We use ______ to find a key in an alist.
5. ______ traversal visits every node in a tree.

✅ True or False

1. Structures can have any number of fields. (True)
2. Association lists can only store numbers. (False)
3. A tree can have only two children. (False — it can have many.)
4. You can nest a struct inside another struct. (True)
5. Alists are used for hierarchical data. (False — trees are.)

🔘 Multiple Choice (15)

1. Which groups related fields? A) struct B) alist C) tree D) list → A
2. Which is a key-value pair list? A) alist B) struct C) tree D) list → A
3. Which has a root and branches? A) tree B) struct C) alist D) list → A
4. How do you access a struct field? A) field function B) assoc C) first D) rest → A
5. How do you find a key in an alist? A) assoc B) struct C) tree D) list → A
6. What is a node? A) element in a tree B) field in struct C) key in alist D) item in list → A
7. Which is best for a dictionary? A) alist B) struct C) tree D) list → A
8. Which is best for a student record? A) struct B) alist C) tree D) list → A
9. Which is best for a family tree? A) tree B) struct C) alist D) list → A
10. Can a tree have no children? A) yes (leaf) B) no C) only one D) always two → A
11. What does (assoc 'a '((a . 1) (b . 2))) return? A) '(a . 1) B) 1 C) #f D) error → A
12. What does (struct person (name age)) create? A) a struct type B) a list C) a tree D) an alist → A
13. How do you create a person? A) (person "Ade" 12) B) (make-person) C) (struct person) D) (list "Ade" 12) → A
14. What is a leaf in a tree? A) a node with no children B) a node with many children C) the root D) a branch → A
15. Why use data structures? A) to organise data B) to slow down programs C) to delete data D) to confuse programmers → A

🔗 Matching

Answers: 1-C, 2-A, 3-B

📝 Short Answer

1. Explain the difference between a struct and an alist.
2. Why are trees useful for AI?
3. Write a struct for a "movie" with title, director, year.

📖 Scenario-based Exercises

Scenario: You are building a school management system. You need to store student details (name, age, class) and also a list of their subjects and scores. How would you organise this using data structures?

Answer: Use a struct for student, and inside it, use an alist or another struct for subjects and scores.

👥 Group Activity

Each group designs a data structure for a "shop inventory" — products with name, price, and quantity. They also create an alist for discounts. Present the design.

🧑‍💻 Individual Activity

Write a struct for a "phone" with brand, model, and price. Create a list of three phones and write a function to find the most expensive phone.

💬 Classroom Discussion Questions

• What data structure would you use for a dictionary?
• How is a tree like a school system?
• Why is it important to choose the right structure?

🛠️ Mini Project

Build a "library manager" that stores books (title, author, year) and allows you to add, list, and find books by author.

📋 Practical Assignment

Create a student database using structs. Write functions to add a student, find a student by name, and calculate the average age of all students.

🏆 Challenge Exercise

Write a function that takes a binary tree and returns the sum of all values. (Assume each node has a value and left/right children.)

🔑 Quiz Answers

Multiple choice answers: 1-A, 2-A, 3-A, 4-A, 5-A, 6-A, 7-A, 8-A, 9-A, 10-A, 11-A, 12-A, 13-A, 14-A, 15-A.

🎁 Key Takeaways

• Data structures organise information.
• Structs group related fields.
• Alists provide key-value lookup.
• Trees show hierarchy.
• Choose the right structure for your problem.

🚀 Preparation for the Next Module

In Module Five, we will dive into recursion on trees and more advanced data processing. You'll learn to manipulate trees, build decision trees for AI, and combine structures with recursion. Keep practising with structures and lists — they will be your main tools!

🎉 You've completed Module Four · You are now a data structure master! 🎉

🌳 Module Five · Recursion on Trees & Advanced Data Processing

Certified Racket AI Specialist · Mastering Hierarchies

📖 Module Introduction

Hello, clever thinker! 👋 In Module Four, we learned about data structures like structs, association lists, and trees. Now we will become masters of trees — one of the most important structures in AI.

Think about how your family tree works: you start with your grandparents, then parents, then you, then your siblings. A computer can use this same idea to make decisions, organise data, and even play games!

In this module, we will learn how to walk through (traverse) trees, search for values in trees, and even build decision trees — the same kind used in real AI systems to decide things like whether to give you a loan or diagnose an illness. By the end, you'll be able to build your own simple AI that makes decisions based on a tree!

🎯 Learning Objectives

After this module, you will be able to:

• ✔️ Understand what a tree is and why it's important for AI.
• ✔️ Traverse a tree in different ways (pre-order, in-order, post-order).
• ✔️ Search for a value in a tree.
• ✔️ Build a decision tree for a simple AI.
• ✔️ Use recursion to process tree data.
• ✔️ Combine trees with structures for more complex data.
• ✔️ Understand how AI uses trees for decision-making.

📚 Warm-up Story · The Magical Maze

Imagine you are in a magical maze. At each junction, you can go left or right. Some paths lead to treasure, others lead to dead ends. You want to find all the treasure.

If you start at the entrance and explore every path, you are traversing the maze. You might decide to go left first, then right — that's an order of traversal.

In programming, a tree is like that maze. Each node (junction) has branches (paths). We can write recursive functions to explore every node and find what we need.

Let's learn how to navigate these magical trees!

   Magical Maze (Tree):
        Entrance
        /      \
      Left     Right
      /  \      /  \
    L1   L2   R1   R2
  

🧩 Main Lessons

Lesson 1 · Review: What is a Tree?

Definition: A tree is a structure with a root (top) and branches (children). Each branch can have more branches. A node with no children is called a leaf.

Why important: Trees are everywhere in AI: decision trees, file systems, website menus, and more.

Simple explanation: Think of a family tree: grandparents at the top, then parents, then children. That's a tree.

Real-life: A company organogram: CEO → managers → employees.

School: A school system: Principal → Head Teachers → Class Teachers → Students.

Home: A wardrobe: Clothes → Tops → Shirts.

Nigerian: Traditional title system: Oba → Chiefs → Village Heads → People.

Illustration:

         Root
        /    \
     NodeA   NodeB
     /  \      |
   Leaf1 Leaf2 Leaf3
  

Lesson 2 · Representing Trees in Racket

We can use structures to represent tree nodes. Each node has a value and a list of children.

   (struct node (value children))
   (define leaf1 (node 5 '()))
   (define leaf2 (node 7 '()))
   (define branch (node 3 (list leaf1 leaf2)))
   (define root (node 10 (list branch)))
  

This creates a tree: root 10 → child 3 → children 5 and 7.

Lesson 3 · Pre-order Traversal

Definition: Pre-order traversal visits the current node first, then each child.

Why important: Useful for copying a tree or saving its structure.

Simple explanation: Like a teacher calling out the class list: "Ade, then his children, then Bola..."

Real-life: Reading a book: start at chapter 1, then its sections.

School: Taking attendance: call the class captain, then their group members.

Home: Packing a suitcase: put big items first, then smaller ones.

Nigerian: Serving food: give the head of the family first, then others.

Illustration:

   Pre-order: Root → Left → Right
   Tree:      10
            /    \
           5      3
          / \    / \
         2   7  4   6
   Pre-order: 10, 5, 2, 7, 3, 4, 6
  

   (define (pre-order tree)
     (if (empty? (node-children tree))
         (list (node-value tree))
         (cons (node-value tree)
               (foldr append '() (map pre-order (node-children tree))))))
  

Lesson 4 · Post-order Traversal

Definition: Post-order visits all children first, then the node itself.

Why important: Used to calculate totals or evaluate expressions.

Simple explanation: Like cleaning a room: you clean the floor, then the table, then you leave.

Real-life: Eating a meal: you eat the vegetables, then the meat, then you finish.

School: Grading: you mark each student's work, then calculate the class average.

Home: Taking out trash: you empty all bins, then take the bag out.

Nigerian: Harvesting: you pick all the fruits, then take them to the market.

Illustration:

   Post-order: Left → Right → Root
   Tree:      10
            /    \
           5      3
          / \    / \
         2   7  4   6
   Post-order: 2, 7, 5, 4, 6, 3, 10
  

   (define (post-order tree)
     (if (empty? (node-children tree))
         (list (node-value tree))
         (append (foldr append '() (map post-order (node-children tree)))
                 (list (node-value tree)))))
  

Lesson 5 · In-order Traversal (for binary trees)

Definition: In-order visits left child, then node, then right child (for binary trees).

Why important: This is used for sorted data — like printing a sorted list.

Simple explanation: Like reading a dictionary: A, then B, then C...

Real-life: Organising files by date: oldest first, then newest.

School: Calling roll: start from A, go to Z.

Home: Sorting toys: put all red ones, then blue, then green.

Nigerian: Market prices: low to high.

Illustration:

   In-order: Left → Root → Right
   Tree:      10
            /    \
           5      3
          / \    / \
         2   7  4   6
   In-order: 2, 5, 7, 10, 4, 3, 6
  

Lesson 6 · Searching in a Tree

We can search for a value in a tree by traversing it and checking each node.

   (define (search tree target)
     (cond
       [(equal? (node-value tree) target) #t]
       [(empty? (node-children tree)) #f]
       [else (ormap (lambda (child) (search child target)) (node-children tree))]))
  

Lesson 7 · Counting Nodes

We can count how many nodes are in a tree by traversing it.

   (define (count-nodes tree)
     (if (empty? (node-children tree))
         1
         (+ 1 (foldl + 0 (map count-nodes (node-children tree))))))
  

Lesson 8 · Height of a Tree

The height of a tree is the longest path from root to a leaf.

   (define (height tree)
     (if (empty? (node-children tree))
         1
         (+ 1 (apply max (map height (node-children tree))))))
  

Lesson 9 · Building a Decision Tree

A decision tree is a tree where each node asks a question, and the branches are the answers. At the leaves, we get a decision.

Example: Should I play outside?

   Decision Tree:
   Is it sunny?
      /      \
    Yes      No
    /          \
   Is it warm?  Stay inside
    /    \
   Yes    No
   /        \
Play      Stay in
  

We can build this in Racket using structs.

Lesson 10 · Implementing a Decision Tree

Let's implement a simple decision tree that decides what to wear.

   (struct question (text yes no))
   (struct answer (text))
   (define decision-tree
     (question "Is it raining?"
       (question "Is it windy?"
         (answer "Wear a jacket and umbrella")
         (answer "Wear a jacket"))
       (answer "Wear light clothes")))
  

We can write a function to evaluate the tree with user input.

Lesson 11 · Evaluating a Decision Tree

Write a function that asks questions and returns the final answer.

   (define (decide tree)
     (cond
       [(answer? tree) (answer-text tree)]
       [(question? tree)
        (display (question-text tree))
        (newline)
        (if (equal? (read-line) "yes")
            (decide (question-yes tree))
            (decide (question-no tree)))]))
  

This creates an interactive AI!

Lesson 12 · Putting It All Together – A Smart Chatbot

Let's build a simple chatbot that helps decide what to eat for lunch.

   ; Build the tree
   (define food-tree
     (question "Do you want something hot?"
       (question "Do you want rice?"
         (answer "Jollof rice")
         (answer "Yam and egg"))
       (question "Do you want something cold?"
         (answer "Salad")
         (answer "Fruit juice"))))
   ; Run (decide food-tree)
  

You just built a tiny AI assistant!

📖 Key Vocabulary

• Tree: A structure with a root and branches.
• Node: An element in a tree.
• Leaf: A node with no children.
• Traversal: Visiting every node in a tree.
• Pre-order: Node, then children.
• Post-order: Children, then node.
• In-order: Left, node, right.
• Decision tree: A tree used for making decisions.

🧠 Important Concepts

• Recursion is key: Trees are processed recursively.
• Order matters: Different traversals give different results.
• Decision trees are AI: They are used in many AI systems.
• Composition: Trees can be combined with structs.

📘 Step-by-Step Explanations

How to traverse a tree:

1. Define the tree using structs or lists.
2. Write a recursive function that handles a node.
3. For pre-order: process node, then process each child.
4. For post-order: process each child, then process node.
5. For in-order (binary): process left, node, right.

🌍 Real-life Examples

• Decision trees in medicine: diagnose illness.
• Decision trees in banking: approve loans.
• File systems: folders and subfolders.

🇳🇬 Nigerian Examples

• Market decisions: which market to go to based on price and distance.
• School placement: which class a student should be in.
• Village governance: decision tree for conflict resolution.

🎈 Fun Examples

• What game to play: based on number of players.
• What to watch: based on mood.
• Which pet to get: based on house size.

🏠 Everyday Examples

• What to wear: based on weather.
• What to eat: based on hunger.
• Which route to take: based on traffic.

🧑‍🏫 Teacher Notes

Use physical trees (draw on board). Use real decision-making scenarios. Encourage students to build decision trees for everyday choices. Emphasise that recursion is natural for trees.

👪 Parent Tips

Ask your child to draw a decision tree for a simple decision (like what to wear). Discuss how computers use these trees. Practice together by building a tree for a family decision.

🌟 Interesting Facts

• Decision trees are used in Google's search algorithm.
• The first decision tree was developed in the 1960s.
• AI can learn decision trees automatically from data.

🤔 Did You Know?

Decision trees are so popular because they are easy to understand. You can draw them on a piece of paper and explain them to anyone!

🧾 Remember This

• Trees have a root and branches.
• Traversal visits every node.
• Pre-order: node first.
• Post-order: node last.
• Decision trees help AI make decisions.

⚠️ Common Mistakes

• Forgetting the base case in recursive traversal.
• Not handling empty children lists.
• Confusing pre-order and post-order.
• Not using empty? to check for no children.

✅ Best Practices

• Use structs to represent tree nodes.
• Always write the base case first.
• Use map and fold for child processing.
• Test with small trees first.

📊 ASCII Illustrations

   Tree traversal order:
   Pre-order:  Root → Left → Right
   In-order:   Left → Root → Right
   Post-order: Left → Right → Root
  

   Decision tree flow:
   Start
     |
     V
   Question 1
     /     \
   Yes      No
    |        |
    V        V
   Q2       Q3
    |         |
    V         V
   Decision  Decision
  

📋 Comparison Table

📌 End-of-Module Summary

You've become a tree master! You can now traverse trees in different orders, search for values, count nodes, and even build decision trees — the heart of many AI systems. You've built a simple chatbot that makes decisions. These skills are directly used in real AI applications. You're now ready to explore even more advanced AI topics!

❓ Frequently Asked Questions (10)

1. What is a tree? — A structure with a root and branches.
2. What is a leaf? — A node with no children.
3. What is pre-order traversal? — Visit node first, then children.
4. What is post-order traversal? — Visit children first, then node.
5. What is a decision tree? — A tree that helps make decisions.
6. How do you search a tree? — Traverse it and check each node.
7. What is the height of a tree? — The longest path from root to leaf.
8. Why are trees important for AI? — They are used for decision-making.
9. Can a tree have more than two children? — Yes, a general tree can.
10. What is a binary tree? — A tree where each node has at most two children.

📝 Review Questions (15)

1. What is a tree?
2. What is a leaf in a tree?
3. What is pre-order traversal?
4. What is post-order traversal?
5. What is in-order traversal?
6. How do you search for a value in a tree?
7. What is a decision tree?
8. Write a function to count the nodes in a tree.
9. Write a function to calculate the height of a tree.
10. How do you represent a tree in Racket?
11. What is the difference between pre-order and post-order?
12. Why is recursion useful for trees?
13. Give an example of a decision tree in real life.
14. Can a tree have zero nodes?
15. What is the root of a tree?

✏️ Fill-in-the-Blank

1. A ______ has a root and branches.
2. A node with no children is called a ______.
3. ______ traversal visits the node first, then children.
4. ______ traversal visits children first, then node.
5. A ______ tree helps make decisions.

✅ True or False

1. Pre-order visits children first. (False)
2. Post-order visits node last. (True)
3. A leaf has no children. (True)
4. In-order is only for binary trees. (True)
5. Decision trees are not used in AI. (False)

🔘 Multiple Choice (15)

1. What is a tree? A) root + branches B) list C) alist D) struct → A
2. What is a leaf? A) node with no children B) root C) child D) branch → A
3. Pre-order visits in what order? A) node, children B) children, node C) left, node, right D) right, node, left → A
4. Post-order visits in what order? A) children, node B) node, children C) left, node, right D) right, node, left → A
5. In-order visits in what order (for binary)? A) left, node, right B) node, left, right C) right, node, left D) children, node → A
6. What is a decision tree? A) helps make decisions B) stores numbers C) sorts lists D) counts nodes → A
7. How do you search a tree? A) traverse it B) use assoc C) use map D) use filter → A
8. What is the height of a tree? A) longest path B) number of nodes C) number of leaves D) root value → A
9. What is recursion? A) function calls itself B) loop C) if statement D) struct → A
10. Can a tree have more than two children? A) yes B) no C) only two D) only one → A
11. What is a binary tree? A) at most two children B) exactly two children C) only leaves D) no root → A
12. Which traversal is used for copying trees? A) pre-order B) post-order C) in-order D) random → A
13. Which traversal is used for evaluating expressions? A) post-order B) pre-order C) in-order D) none → A
14. What does (node-value tree) return? A) the value of the node B) the children C) the root D) the leaf → A
15. Why are trees important? A) organise data B) slow down programs C) delete data D) confuse programmers → A

🔗 Matching

Answers: 1-B, 2-A, 3-C

📝 Short Answer

1. Explain the difference between pre-order and post-order.
2. What is a decision tree and why is it useful?
3. Write a function that returns the sum of all values in a tree.

📖 Scenario-based Exercises

Scenario: You are building a system to recommend a movie based on age and interest. Design a decision tree for this.

Answer: Tree: Is age < 12? → Cartoon; else → Is it action? → Action; else → Comedy.

👥 Group Activity

Each group designs a decision tree for choosing a vacation destination. Questions: budget, beach or mountains, etc.

🧑‍💻 Individual Activity

Write a function that counts the number of leaves in a tree.

💬 Classroom Discussion Questions

• How is a decision tree like a flowchart?
• Why are trees better than lists for some data?
• What real-world problems can be solved with decision trees?

🛠️ Mini Project

Build a decision tree that helps choose a pet. Questions: Do you have a yard? Do you like walking? etc.

📋 Practical Assignment

Implement a decision tree for a restaurant recommendation based on cuisine preference and budget.

🏆 Challenge Exercise

Write a function that flattens a tree into a list using pre-order traversal.

🔑 Quiz Answers

Multiple choice answers: 1-A, 2-A, 3-A, 4-A, 5-A, 6-A, 7-A, 8-A, 9-A, 10-A, 11-A, 12-A, 13-A, 14-A, 15-A.

🎁 Key Takeaways

• Trees are hierarchical structures.
• Traversal visits every node in a specific order.
• Decision trees are a core AI tool.
• Recursion is natural for trees.
• You can build interactive AI with decision trees.

🚀 Preparation for the Next Module

In Module Six, we will explore Generative AI — how computers can create new things like stories, pictures, and music. We'll use what we've learned about trees and recursion to build creative programs. Get ready to become an AI artist!

🎉 You've completed Module Five · You are now a tree and decision-making expert! 🎉

✨ Module Six · Generative AI – Creating New Things

Certified Racket AI Specialist · The Creative Side of AI

📖 Module Introduction

Hello, young creator! 👋 So far, we've taught computers to do math, make decisions, and organise data. Now we will teach them something truly magical: how to create new things.

Think about a painter who mixes colours to make a new shade, or a musician who combines notes to make a new song. AI can do this too! We call this Generative AI — AI that creates new content like stories, poems, pictures, and even music.

In this module, we will learn the basics of how AI creates things. We'll use Racket to build our own simple generators — programs that produce new text, new lists, and even new structures. You'll become an AI artist!

🎯 Learning Objectives

After this module, you will be able to:

• ✔️ Understand what Generative AI is and why it's exciting.
• ✔️ Use randomness to create unpredictable outputs.
• ✔️ Build a text generator that creates new sentences.
• ✔️ Build a pattern generator that creates art.
• ✔️ Use combinations to create new things from existing parts.
• ✔️ Understand how AI can "imagine" new things.
• ✔️ Build your own simple story generator.

📚 Warm-up Story · The Magical Chef

Imagine you have a magical chef. Instead of following a recipe, this chef can invent new dishes. You give it some ingredients — rice, chicken, spices — and it creates a brand new meal that nobody has ever eaten before!

Generative AI works the same way. You give it examples (like words or pictures), and it learns the patterns. Then it uses those patterns to make something new.

Today, we'll build our own "magical chefs" using Racket. They won't be as smart as the ones in big companies, but they will create things that are new and fun!

   Ingredients (data)  →  AI learns patterns  →  Creates new things
      "cat", "dog", "bird"  →  "cog", "bat", "dird"  (new invented words!)
  

🧩 Main Lessons

Lesson 1 · What is Generative AI?

Definition: Generative AI is a type of AI that creates new content — like text, images, music, or code — instead of just analysing or classifying.

Why important: Generative AI is used to create art, write stories, help with design, and even discover new medicines!

Simple explanation: It's like a robot that can paint a new picture instead of just telling you about an existing one.

Real-life: ChatGPT writes new stories. DALL-E creates new images.

School: Imagine a computer that can write a new essay for you on any topic.

Home: A smart speaker that can make up a new bedtime story.

Nigerian: An AI that creates new African-inspired fashion designs.

Illustration:

   +-------------------+      +-------------------+
   |  Examples (data)  | ---> |  Generative AI    | --->  New creation
   +-------------------+      +-------------------+
         cats, dogs              "cog" (new animal)
         jazz, blues             new music style
  

Lesson 2 · Randomness – The Spark of Creativity

Definition: Randomness is when something happens by chance, without a fixed order.

Why important: AI uses randomness to create variety. Without randomness, everything would be the same.

Simple explanation: It's like rolling a dice. You never know what number you'll get.

Real-life: A lottery draw uses randomness.

School: A teacher randomly picking a student to answer a question.

Home: Picking a random movie to watch.

Nigerian: Using a lucky draw at a carnival.

Illustration:

   (define (roll-dice) (random 6))
   (roll-dice) → 3
   (roll-dice) → 5
   (roll-dice) → 2
  

Lesson 3 · Picking Random Items from a List

We can use random and list-ref to pick a random item from a list.

   (define fruits '("apple" "banana" "orange" "mango"))
   (define (pick-random lst) (list-ref lst (random (length lst))))
   (pick-random fruits) → "banana"
  

This is the simplest generative technique!

Lesson 4 · Building a Simple Word Generator

We can combine random pieces to make new words.

   (define starters '("b" "c" "d" "f" "g"))
   (define middles '("a" "e" "i" "o" "u"))
   (define endings '("t" "n" "p" "m"))
   (define (new-word)
     (string-append (pick-random starters) (pick-random middles) (pick-random endings)))
   (new-word) → "bim"
   (new-word) → "gan"
  

We just created a word generator!

Lesson 5 · Building a Story Generator

We can use the same idea to create simple stories.

   (define characters '("Ade" "Bola" "Chidi" "Dara"))
   (define actions '("ran" "jumped" "sang" "danced"))
   (define places '("market" "school" "beach" "village"))
   (define (story)
     (string-append (pick-random characters) " " (pick-random actions) " to the " (pick-random places)))
   (story) → "Bola sang to the beach"
  

Lesson 6 · Using Templates for Better Stories

We can use a template to make stories more interesting.

   (define templates
     '("The ~a loved to ~a in the ~a"
       "Every day, ~a would ~a at the ~a"
       "~a went to the ~a to ~a"))
   (define (better-story)
     (format (pick-random templates)
             (pick-random characters)
             (pick-random actions)
             (pick-random places)))
  

Lesson 7 · Creating Art with Text

We can generate simple ASCII art using random choices.

   (define shapes '("  *  " " *** " "*****"))
   (define (make-art)
     (string-join (list (pick-random shapes) (pick-random shapes) (pick-random shapes)) "\n"))
   (make-art)
   →   *
      ***
     *****
  

Lesson 8 · Generative Lists

We can generate lists of random numbers or items.

   (define (random-list n)
     (if (= n 0)
         '()
         (cons (random 10) (random-list (- n 1)))))
   (random-list 5) → '(3 7 1 8 4)
  

Lesson 9 · Generating Structured Data

We can generate structs with random fields.

   (struct person (name age))
   (define (random-person)
     (person (pick-random names) (+ 5 (random 15))))
   (random-person) → (person "Ade" 12)
  

Lesson 10 · Combining Patterns – The Power of Mixing

Generative AI works by learning patterns and mixing them. We can mix different categories.

   (define animals '("lion" "tiger" "bear"))
   (define colors '("red" "blue" "golden"))
   (define (new-animal) (string-append (pick-random colors) " " (pick-random animals)))
   (new-animal) → "red tiger"
  

Lesson 11 · Building a Recipe Generator

We can generate new recipes by combining ingredients.

   (define meats '("chicken" "beef" "fish"))
   (define spices '("pepper" "ginger" "garlic"))
   (define veggies '("onions" "tomatoes" "peppers"))
   (define (recipe)
     (string-append "Cook " (pick-random meats) " with " (pick-random spices) " and " (pick-random veggies)))
  

Lesson 12 · Putting It All Together – A Complete Generator

Let's build a program that generates a full story with a character, setting, and plot.

   (define (full-story)
     (string-append
       "Once upon a time, " (pick-random characters)
       " lived in " (pick-random places)
       ". One day, they " (pick-random actions)
       " and found a " (pick-random animals)
       ". They became friends!"))
   (full-story)
   → "Once upon a time, Chidi lived in school. One day, they danced and found a tiger. They became friends!"
  

You just built a Generative AI system!

📖 Key Vocabulary

• Generative AI: AI that creates new content.
• Randomness: Something that happens by chance.
• Template: A pattern with blanks to fill in.
• Combination: Mixing different elements together.
• Pattern: A repeated way of doing something.
• Generator: A program that creates new things.

🧠 Important Concepts

• Pattern recognition: AI learns patterns from examples.
• Randomness: Adds variety and creativity.
• Combination: New things come from mixing existing things.
• Template filling: A common generative technique.

📘 Step-by-Step Explanations

How to build a generator:

1. Decide what you want to generate (words, stories, art).
2. Gather examples and break them into pieces.
3. Create lists of each type of piece.
4. Write a function that randomly picks pieces and combines them.
5. Test it many times to see the variety.
6. Add templates to make the output better.

🌍 Real-life Examples

• ChatGPT: generates text responses.
• DALL-E: generates images from text.
• Music AI: generates new songs.

🇳🇬 Nigerian Examples

• AI that generates new Ankara patterns.
• AI that writes new Nigerian folktales.
• AI that creates new recipes for Nigerian dishes.

🎈 Fun Examples

• Generate new ice cream flavours.
• Generate new superhero names.
• Generate new holiday destinations.

🏠 Everyday Examples

• Making a new sandwich from available ingredients.
• Choosing a random outfit.
• Inventing a new game with existing rules.

🧑‍🏫 Teacher Notes

Encourage creativity. Let students build generators for anything they like. Emphasise that generative AI starts with simple techniques. Use the "mix and match" concept. Show how big AI uses these same ideas on a massive scale.

👪 Parent Tips

Ask your child to generate stories for you. Use the generators to create fun family activities — like a new recipe for dinner or a new bedtime story. Celebrate the creativity!

🌟 Interesting Facts

• Some AI-generated art has been sold for over $400,000.
• Generative AI can create new drug molecules for medicine.
• AI can generate new levels in video games.

🤔 Did You Know?

The first generative AI programs in the 1960s could generate simple poetry. Today, they can write entire novels!

🧾 Remember This

• Generative AI creates new things.
• Randomness is important for creativity.
• We combine pieces to make new things.
• Templates make outputs better.
• You can build your own generators!

⚠️ Common Mistakes

• Forgetting to use random for variety.
• Using lists that are too small — not enough variety.
• Not testing the generator enough times.
• Making templates too strict — no creativity.

✅ Best Practices

• Use large lists for more variety.
• Use templates for better structure.
• Test your generator many times.
• Combine different types of data.

📊 ASCII Illustrations

   Generator flow:
   Lists of pieces  →  Random pick  →  Combine  →  New creation

   Example:
   [Ade, Bola, Chidi] + [ran, sang] + [market, school]
   → "Chidi sang at school"
  

   Tree of combinations:
       Start
         |
         V
    Choose character
         |
         V
    Choose action
         |
         V
    Choose place
         |
         V
    Combine all → story!
  

📋 Comparison Table

📌 End-of-Module Summary

You've unlocked the creative side of AI! You learned about generative AI, used randomness, combined pieces to create new things, and built story generators and more. These are the same techniques used by big AI companies, just on a smaller scale. You are now an AI creator!

❓ Frequently Asked Questions (10)

1. What is Generative AI? — AI that creates new content.
2. Why use randomness? — To make outputs varied and creative.
3. What is a template? — A pattern with blanks to fill.
4. Can AI create art? — Yes, many AI systems create art.
5. How do we combine pieces? — Using functions like string-append.
6. What is a generator? — A program that creates new things.
7. Can AI write stories? — Yes, some AI writes stories.
8. Why is combination important? — New things come from mixing.
9. How can I make my generator better? — Use more data and better templates.
10. Is this really AI? — Yes, this is how many generative AI systems start!

📝 Review Questions (15)

1. What is Generative AI?
2. Why do we use randomness?
3. How do you pick a random item from a list?
4. Write a function that picks a random word from a list.
5. What is a template?
6. How can you make a story generator?
7. What is combination in generative AI?
8. Write a function that generates a random sentence.
9. How can you generate a random number?
10. Why are templates useful?
11. What is a generator?
12. Give an example of a real generative AI.
13. How can you generate a random list?
14. What is the difference between random and fixed?
15. How do you combine strings in Racket?

✏️ Fill-in-the-Blank

1. ______ AI creates new content.
2. ______ adds variety to generated content.
3. A ______ is a pattern with blanks to fill.
4. We use ______ to combine pieces.
5. A ______ is a program that creates new things.

✅ True or False

1. Generative AI only analyses data. (False)
2. Randomness is important for creativity. (True)
3. Templates make outputs less interesting. (False)
4. Combining pieces is a generative technique. (True)
5. AI cannot generate new images. (False)

🔘 Multiple Choice (15)

1. What is Generative AI? A) creates new content B) sorts data C) adds numbers D) deletes files → A
2. Why use randomness? A) for variety B) to slow down C) to delete data D) to sort → A
3. How do you pick a random item? A) list-ref + random B) first C) rest D) filter → A
4. What is a template? A) a pattern B) a list C) a number D) a string → A
5. What does (string-append "hi" " there") do? A) combines strings B) adds numbers C) sorts D) filters → A
6. What is a generator? A) creates new things B) deletes things C) sorts things D) counts things → A
7. Which is an example of generative AI? A) ChatGPT B) Calculator C) Database D) Spreadsheet → A
8. What does (pick-random lst) do? A) picks random item B) sorts list C) deletes list D) adds to list → A
9. How can we make a story generator? A) combine random parts B) only use one part C) no randomness D) use fixed text → A
10. What is combination? A) mixing things B) deleting things C) sorting things D) counting things → A
11. What does (random 10) return? A) number 0-9 B) 10 C) list D) string → A
12. Why are templates useful? A) make output structured B) add randomness C) delete data D) sort lists → A
13. Can AI generate music? A) yes B) no C) only if told D) never → A
14. What is the first step in building a generator? A) gather pieces B) delete data C) sort list D) add numbers → A
15. What does (length lst) do? A) returns length B) picks random C) sorts D) deletes → A

🔗 Matching

Answers: 1-A, 2-B, 3-C

📝 Short Answer

1. Explain how randomness helps AI create new things.
2. What is a template and why is it useful?
3. Write a function that generates a random sentence with a subject, verb, and object.

📖 Scenario-based Exercises

Scenario: You are building an AI that generates new superhero names. You have lists of adjectives (e.g., "mighty", "shadow") and nouns (e.g., "tiger", "dragon"). How would you build the generator?

Answer: Use random pick from adjectives and nouns, combine with string-append.

👥 Group Activity

Each group builds a generator for a topic of their choice (e.g., new ice cream flavours, new sports names, new holiday destinations). Share and compare outputs.

🧑‍💻 Individual Activity

Build a generator that creates new pet names by combining syllables.

💬 Classroom Discussion Questions

• How is generative AI different from other AI?
• Can a generator ever run out of new ideas?
• How could you make your generator even more creative?

🛠️ Mini Project

Build a "magic spell" generator. Create lists of words that sound magical and combine them to create new spells with "powers".

📋 Practical Assignment

Build a generator that creates new Nigerian dish descriptions. Use ingredients, cooking methods, and tasty words.

🏆 Challenge Exercise

Build a generator that creates simple poems. Use rhyme patterns and random word selection.

🔑 Quiz Answers

Multiple choice answers: 1-A, 2-A, 3-A, 4-A, 5-A, 6-A, 7-A, 8-A, 9-A, 10-A, 11-A, 12-A, 13-A, 14-A, 15-A.

🎁 Key Takeaways

• Generative AI creates new, original content.
• Randomness is essential for creativity.
• Combining pieces leads to new things.
• Templates improve the quality of generation.
• You can build your own generative systems!

🚀 Preparation for the Next Module

In Module Seven, we'll explore Machine Learning — how computers can learn from examples instead of being told exactly what to do. We'll build a simple learning system that improves over time. Get ready to teach your computer!

🎉 You've completed Module Six · You are now a Generative AI creator! 🎉

🤖 Module Seven · Machine Learning – Teaching Computers to Learn

Certified Racket AI Specialist · The Heart of AI

📖 Module Introduction

Hello, young teacher! 👋 So far, we've been telling the computer exactly what to do. We gave it rules, and it followed them. But what if we could teach the computer to figure out the rules by itself?

Think about how you learn to ride a bicycle. Nobody gives you a manual with all the rules. You try, you fall, you try again, and slowly you get better. That's how Machine Learning works — the computer learns from examples and improves over time.

In this module, we will build our own simple machine learning system. We'll teach a computer to recognise patterns and make predictions. You'll see how AI really learns!

🎯 Learning Objectives

After this module, you will be able to:

• ✔️ Understand what Machine Learning is and how it works.
• ✔️ Understand the difference between training and testing.
• ✔️ Build a simple classifier that learns from examples.
• ✔️ Use features to describe data.
• ✔️ Understand accuracy — how well a model performs.
• ✔️ Build a nearest neighbour classifier.
• ✔️ Train a model to make predictions on new data.

📚 Warm-up Story · The Fruit Sorter

Imagine you work at a fruit market. Your job is to sort apples and oranges. You don't have a rule book. Instead, a farmer shows you examples: "This is an apple. It's red and round. This is an orange. It's orange and round."

After seeing many examples, you learn the pattern. When you see a new fruit, you can guess if it's an apple or orange. That's exactly how Machine Learning works — you show the computer lots of examples, and it learns the pattern.

Today, we'll build a fruit sorter in Racket — a machine learning system that learns to recognise fruits!

   Training phase:
   [Apple, red, round] → apple
   [Orange, orange, round] → orange
   [Apple, red, round] → apple

   Testing phase:
   [New fruit, red, round] → guess: apple!
  

🧩 Main Lessons

Lesson 1 · What is Machine Learning?

Definition: Machine Learning is a way for computers to learn from examples without being explicitly programmed with rules.

Why important: This is how AI becomes smart — by learning from data instead of following fixed rules.

Simple explanation: It's like teaching a dog new tricks. You don't give it a book; you show it what to do and reward it when it gets it right.

Real-life: Spam filters learn which emails are spam by looking at examples.

School: You learn math by doing many practice problems.

Home: You learn to cook by trying recipes and learning from mistakes.

Nigerian: Learning to speak your mother tongue by listening to your family.

Illustration:

   +-------------------+      +-------------------+
   |   Examples (data) | ---> |  Machine Learning | --->  Rules (model)
   +-------------------+      +-------------------+
         apples, oranges         can classify new fruits
  

Lesson 2 · Training vs Testing

Definition: Training is when we show the computer examples to learn from. Testing is when we check how well it learned.

Why important: We need to know if our model works on new data, not just the examples it already saw.

Simple explanation: It's like studying for a test (training) and then taking the test (testing).

Real-life: A student practices math problems (training) and then takes an exam (testing).

School: Doing homework is training; the final exam is testing.

Home: Practicing a dance routine (training) and performing it (testing).

Nigerian: Learning to cook from your mother (training) and cooking for guests (testing).

Illustration:

   +------------+     +--------------+     +------------+
   |   Data     | --> |  Split data  | --> |  Training  | -->  Model
   +------------+     +--------------+     +------------+
                           |                       |
                           V                       V
                     +------------+        +------------+
                     |  Testing   |        |  Evaluate  |
                     +------------+        +------------+
  

Lesson 3 · Features – What Describes Our Data

Definition: Features are the characteristics of the data we use for learning. For a fruit, features could be colour, shape, and size.

Why important: The right features help the computer learn better.

Simple explanation: If you describe a person, you might use features like height, hair colour, and eye colour.

Real-life: To sort fruits, features are colour, shape, and size.

School: To describe a student, features are age, grade, and favourite subject.

Home: To describe a pet, features are size, colour, and breed.

Nigerian: To describe a car, features are brand, model, and colour.

Illustration:

   Fruit   →  [colour, shape, size]
   Apple   →  [red, round, medium]
   Orange  →  [orange, round, medium]
   Banana  →  [yellow, long, small]
  

Lesson 4 · Labels – What We Want to Predict

Definition: The label is the answer we want the computer to predict. For a fruit, the label is the type of fruit (apple, orange, etc.).

Why important: The computer learns to map features to labels.

Simple explanation: It's like the answer key for a test.

Real-life: In a photo of a cat, the label is "cat".

School: In a test, the label is the correct answer.

Home: When sorting laundry, the label is "dark" or "light".

Nigerian: In a market, the label is the price.

Illustration:

   Training example: [red, round, medium]  →  apple (label)
   Training example: [orange, round, medium] →  orange (label)
  

Lesson 5 · Representing Data in Racket

We can use lists to represent examples. Each example is a list of features, and we can store the label separately.

   (define apple-example '(red round medium))
   (define orange-example '(orange round medium))
   (define training-data
     '((red round medium apple)
       (orange round medium orange)
       (red round medium apple)
       (yellow long small banana)))
  

Or we can use structures for cleaner code.

Lesson 6 · The Nearest Neighbour Algorithm

Definition: Nearest Neighbour is a simple machine learning algorithm that classifies a new example by finding the most similar example in the training data.

Why important: It's simple, powerful, and easy to understand.

Simple explanation: If you want to know what a new fruit is, find the fruit that looks most like it and call it that.

Real-life: If you see a new bird, compare it to birds you know.

School: If you have a new word, find the one that looks most like it.

Home: If you find a toy you don't recognise, compare it to toys you know.

Nigerian: If you see a new type of cloth, compare it to known fabrics.

Illustration:

   New fruit: [red, round, medium]
   Compare to training:
   [red, round, medium] → apple (distance 0)
   [orange, round, medium] → orange (distance 1)
   [yellow, long, small] → banana (distance 3)
   Nearest is apple → predict apple!
  

Lesson 7 · Measuring Similarity – Distance

We need a way to measure how similar two examples are. A simple way is to count how many features are different.

   (define (distance a b)
     (length (filter (lambda (x) (not (equal? x (car b))))
                     (map list a b))))
   ; Or simpler: count differences
   (define (diff-count a b)
     (if (null? a)
         0
         (if (equal? (car a) (car b))
             (diff-count (cdr a) (cdr b))
             (+ 1 (diff-count (cdr a) (cdr b))))))
  

Lesson 8 · Implementing Nearest Neighbour

Now we can write the full classifier.

   (define (classify data features)
     (define (distance-to-example ex)
       (diff-count features (drop-right ex 1)))
     (define sorted-data
       (sort data (lambda (a b) (< (distance-to-example a) (distance-to-example b)))))
     (last (car sorted-data)))  ; the label is the last element
  

Lesson 9 · Training and Testing Our Classifier

Let's train our model and test it.

   (define training-data
     '((red round medium apple)
       (orange round medium orange)
       (red round medium apple)
       (yellow long small banana)
       (green round small grape)
       (purple round medium grape)))
   (classify training-data '(red round medium)) → apple
   (classify training-data '(orange round medium)) → orange
   (classify training-data '(yellow long small)) → banana
  

Lesson 10 · Accuracy – How Good Is Our Model?

Definition: Accuracy is the percentage of correct predictions our model makes on test data.

Why important: It tells us how well our model will work in the real world.

Simple explanation: If you get 8 out of 10 questions right on a test, your accuracy is 80%.

Real-life: A doctor's diagnostic accuracy is how often they are correct.

School: Your score on a test is your accuracy.

Home: How often you correctly guess the weather is your accuracy.

Nigerian: How often you correctly predict the price of goods is your accuracy.

Illustration:

   Test examples: 10
   Correct predictions: 8
   Accuracy = 8/10 = 80%
  

Lesson 11 · Improving Our Classifier – K-Nearest Neighbours

Instead of just looking at the nearest neighbour, we can look at the K nearest neighbours and take a vote. This is called K-Nearest Neighbours (KNN).

Why important: It makes our model more robust to noisy data.

Simple explanation: Instead of asking one friend for advice, ask five friends and go with the majority opinion.

   (define (k-classify data features k)
     (define (label-counts lst)
       ; count how many of each label in the list
       (define (count-label label lst)
         (length (filter (lambda (x) (equal? (last x) label)) lst)))
       ; ... implement majority vote
       )
  

Lesson 12 · Building a Real-World Classifier – Animal Recognizer

Let's build a classifier that recognises animals based on features: size, habitat, and diet.

   (define animal-data
     '((large land herbivore elephant)
       (small land herbivore rabbit)
       (large water carnivore shark)
       (medium land carnivore lion)
       (small air herbivore bird)
       (medium land omnivore bear)))
   (classify animal-data '(medium land carnivore)) → lion
  

Lesson 13 · Putting It All Together – A Complete ML System

Let's build a complete system that: 1) Loads data, 2) Splits it into training and testing, 3) Trains a model, 4) Tests it, 5) Reports accuracy.

   (define (ml-system data test-data)
     (define correct
       (length (filter (lambda (test)
                         (equal? (classify data (drop-right test 1))
                                 (last test)))
                       test-data)))
     (/ correct (length test-data)))
  

You built a complete machine learning system!

📖 Key Vocabulary

• Machine Learning: Learning from examples.
• Training: Learning phase.
• Testing: Evaluation phase.
• Features: Characteristics of data.
• Label: What we want to predict.
• Nearest Neighbour: Classifies by closest example.
• Accuracy: Percentage of correct predictions.
• K-Nearest Neighbours (KNN): Uses K nearest neighbours and votes.

🧠 Important Concepts

• Data is key: Better data = better learning.
• Features matter: Choose features that help distinguish.
• Overfitting: When a model is too specific to training data.
• Generalisaton: Model works well on new data.

📘 Step-by-Step Explanations

How to build a machine learning system:

1. Collect data (examples with features and labels).
2. Split into training and testing sets.
3. Choose an algorithm (like Nearest Neighbour).
4. Train the model on the training data.
5. Test the model on the testing data.
6. Calculate accuracy.
7. Use the model to make predictions on new data.

🌍 Real-life Examples

• Spam detection: features = words in email, label = spam/not.
• Face recognition: features = face measurements, label = person.
• Medical diagnosis: features = symptoms, label = disease.

🇳🇬 Nigerian Examples

• Predicting yam prices: features = season, region, quality, label = price.
• Traffic prediction: features = time, day, location, label = traffic level.
• Language identification: features = words, label = language (Yoruba, Igbo, Hausa).

🎈 Fun Examples

• Recognize Pokémon: features = colour, size, type, label = Pokémon name.
• Predict movie ratings: features = genre, length, actors, label = rating.
• Guess the animal: features = habitat, food, size, label = animal.

🏠 Everyday Examples

• Sorting laundry: features = colour, fabric, label = light/dark/delicate.
• Choosing a movie: features = genre, length, actors, label = watch/don't watch.
• Deciding what to eat: features = taste, health, price, label = choose/not choose.

🧑‍🏫 Teacher Notes

Use physical examples — show different fruits and ask students to identify them. Explain that the computer does this with numbers. Emphasize that data quality matters. Let students create their own small datasets and train classifiers.

👪 Parent Tips

Ask your child to teach you how the classifier works. Create a simple dataset at home (e.g., toy names with features: colour, size, type). Let them show you how the computer learns.

🌟 Interesting Facts

• The first machine learning program was written in 1951.
• Machine learning is used to detect diseases from X-rays.
• Self-driving cars use machine learning to understand the road.

🤔 Did You Know?

Machine learning models can learn to play games better than humans. The AlphaGo model beat the world champion at the game of Go!

🧾 Remember This

• Machine Learning learns from examples.
• Training is learning; testing is checking.
• Features describe the data.
• Labels are what we want to predict.
• Nearest Neighbour is a simple learning algorithm.

⚠️ Common Mistakes

• Testing on the same data used for training (cheating).
• Using too few examples (not enough to learn).
• Using irrelevant features (confuses the model).
• Overcomplicating when simple works.

✅ Best Practices

• Always split data into training and testing.
• Use enough examples (at least 10 per class).
• Choose features that matter.
• Start simple (Nearest Neighbour) before complex.

📊 ASCII Illustrations

   Machine Learning Flow:
   +------------------+
   |  Collect Data    |
   +--------+---------+
            |
            V
   +--------+---------+
   |  Split Data      |
   |  (Train/Test)    |
   +--------+---------+
            |
            V
   +--------+---------+
   |  Train Model     |
   +--------+---------+
            |
            V
   +--------+---------+
   |  Test Model      |
   +--------+---------+
            |
            V
   +--------+---------+
   |  Evaluate (Accuracy)|
   +--------+---------+
            |
            V
   +--------+---------+
   |  Predict New Data |
   +------------------+
  

   KNN Voting:
   New example → find K nearest
       |
       V
   +-----+-----+-----+
   |     |     |     |
   Apple Orange Apple
   (2)    (1)
   Vote: Apple!
  

📋 Comparison Table

📌 End-of-Module Summary

You've built your first machine learning system! You learned about training and testing, features and labels, and implemented the Nearest Neighbour algorithm. You even built a K-Nearest Neighbours classifier. These are the same ideas used in real AI systems — you're now a machine learning creator!

❓ Frequently Asked Questions (10)

1. What is Machine Learning? — Learning from examples.
2. What is training? — The learning phase.
3. What is testing? — Checking how well we learned.
4. What are features? — Characteristics of the data.
5. What is a label? — The answer we want to predict.
6. What is Nearest Neighbour? — Classifies by closest example.
7. What is accuracy? — Percentage of correct predictions.
8. What is KNN? — Uses K neighbours and votes.
9. Why do we split data? — To test on unseen data.
10. Can I use this for anything? — Yes, any problem with features and labels.

📝 Review Questions (15)

1. What is Machine Learning?
2. What is the difference between training and testing?
3. What are features?
4. What is a label?
5. How does Nearest Neighbour work?
6. What is accuracy?
7. What is K-Nearest Neighbours?
8. Why do we split data into training and testing?
9. Write a function to calculate distance between two examples.
10. How do you classify a new example with Nearest Neighbour?
11. What is a good accuracy score?
12. Give an example of a machine learning problem.
13. What is overfitting?
14. How can you improve a classifier?
15. What is the difference between rules-based AI and machine learning?

✏️ Fill-in-the-Blank

1. ______ learning learns from examples.
2. ______ is the learning phase.
3. ______ is the evaluation phase.
4. ______ describe the data.
5. ______ is what we want to predict.

✅ True or False

1. Machine Learning doesn't need examples. (False)
2. Training and testing should use the same data. (False)
3. Features describe the data. (True)
4. A label is what we predict. (True)
5. Nearest Neighbour is a complex algorithm. (False)

🔘 Multiple Choice (15)

1. What is Machine Learning? A) learning from examples B) following rules C) doing math D) storing data → A
2. What is training? A) learning phase B) evaluation phase C) storing data D) deleting data → A
3. What is testing? A) evaluation phase B) learning phase C) storing data D) deleting data → A
4. What are features? A) characteristics B) labels C) rules D) examples → A
5. What is a label? A) what we predict B) a characteristic C) a rule D) a feature → A
6. How does Nearest Neighbour work? A) finds closest example B) averages all examples C) picks random D) follows rules → A
7. What is accuracy? A) % correct predictions B) number of examples C) time taken D) memory used → A
8. What is KNN? A) K nearest neighbours B) K features C) K labels D) K rules → A
9. Why split data? A) to test on unseen data B) to make it slower C) to delete data D) to add features → A
10. What is a good use of ML? A) spam detection B) adding numbers C) sorting lists D) printing text → A
11. What is overfitting? A) too specific to training B) too general C) too fast D) too slow → A
12. Which is simpler? A) Nearest Neighbour B) Deep Learning C) KNN D) Random Forest → A
13. What does distance measure? A) similarity B) size C) time D) speed → A
14. What is a feature for a fruit? A) colour B) price C) name D) taste → A
15. What is a label for a fruit? A) type (apple) B) colour C) size D) shape → A

🔗 Matching

Answers: 1-B, 2-A, 3-C

📝 Short Answer

1. Explain the difference between training and testing.
2. What is the role of features in machine learning?
3. Write a function that calculates the accuracy of a classifier.

📖 Scenario-based Exercises

Scenario: You are building a system to predict if it will rain tomorrow. Features: temperature, humidity, wind speed. Label: rain/no rain. How would you set up the machine learning system?

Answer: Collect historical data with these features and the label, split into training/testing, use Nearest Neighbour or KNN, evaluate accuracy.

👥 Group Activity

Each group creates a dataset of 20 examples for a classification problem (e.g., animal recognition, food classification). Implement a Nearest Neighbour classifier and test it. Present results.

🧑‍💻 Individual Activity

Build a classifier that predicts whether a student will pass an exam based on study hours and attendance. Create your own data and test it.

💬 Classroom Discussion Questions

• What makes a good feature for a classifier?
• What happens if you have too few examples?
• How is machine learning different from traditional programming?

🛠️ Mini Project

Build a "Pokémon type classifier" that predicts the type of a Pokémon (fire, water, grass) based on features like colour, height, and weight.

📋 Practical Assignment

Implement a K-Nearest Neighbours classifier with K=3. Test it on a dataset of your choice and report the accuracy.

🏆 Challenge Exercise

Implement a weighted KNN where closer neighbours have more influence on the vote.

🔑 Quiz Answers

Multiple choice answers: 1-A, 2-A, 3-A, 4-A, 5-A, 6-A, 7-A, 8-A, 9-A, 10-A, 11-A, 12-A, 13-A, 14-A, 15-A.

🎁 Key Takeaways

• Machine Learning learns from examples.
• Training = learning, Testing = evaluation.
• Features describe data; labels are predictions.
• Nearest Neighbour is a simple, powerful algorithm.
• Accuracy measures model performance.

🚀 Preparation for the Next Module

In Module Eight, we'll explore AI in the Real World — how AI is used in robotics, healthcare, games, and more. We'll also talk about the ethics of AI and how to build responsible systems. Get ready to see your AI skills in action!

🎉 You've completed Module Seven · You are now a Machine Learning creator! 🎉