Lemma Academy

9th in a nine courses designed to teach essential principles of ethical, productive group collaboration and decision-making, suitable for any advisory or project team setting.

8th in a nine courses designed to teach essential principles of ethical, productive group collaboration and decision-making, suitable for any advisory or project team setting.

7th in a nine courses designed to teach essential principles of ethical, productive group collaboration and decision-making, suitable for any advisory or project team setting.

Equitable Participation

Achieving Cohesion

The Global Perspective

Fostering a Cooperative Spirit

Lesson: Respect for Each Other

The foundation of fruitful collaboration is genuine mutual esteem. Every person in the group must recognize the inherent value and potential contribution of every other member, regardless of experience, background, or current role. Dialogue should be conducted with the utmost courtesy, using mild language and a respectful tone, even when disagreeing strongly with an idea. Personal attacks, sarcasm, or dismissive attitudes are destructive and shut down the creative flow necessary for finding the best solutions. The focus should always be on critiquing the idea, never the person who offered it.

First in a nine courses designed to teach essential principles of ethical, productive group collaboration and decision-making, suitable for any advisory or project team setting.

Target Audience: School Club Moderators/Teachers

Course Goal: To guide team dynamics, resolve conflicts, and utilize the student micro-courses to build a foundation of respectful and high-performing collaboration.

Target Audience: School Club Moderators/Teachers

Course Goal: To master the primary digital tools (NotebookLMS and Custom GPTs) that organize club work and provide students with instant, powerful support.

Target Audience: School Club Moderators/Teachers

Course Goal: To launch your club effectively by recruiting motivated students and clearly articulating the academic and career value of club participation.

Welcome to Course 3: Mastering Python's Core Concepts! 🚀

You've successfully built a solid foundation in our first two courses, and now it's time to elevate your programming skills! This third course in our free Python programming series is designed to push you beyond the basics, focusing on applying core concepts to solve practical, real-world problems.

What's In Store?

This course takes a project-based approach, challenging you to use everything you've learned about variables, operators, loops, and decision structures to tackle engaging assignments. We'll be focusing on two main, practical problem domains:

• Improper Fractions Assignment: This assignment will test your mathematical and logical skills by requiring you to manipulate and work with numerical concepts like improper fractions. It's an excellent exercise in data manipulation and precise conditional logic within your Python code. You'll solidify your understanding of arithmetic operations and input validation.

• Everyone's Favourite - Taxes: Assignment: Get ready for a hands-on application of decision structures (if/else) and mathematical expressions! This challenging assignment requires you to model a simplified tax calculation system. It's a perfect example of how programming is used to manage complex rules and varying conditions—a skill that is fundamental to developing effective AI and business applications.

Your Next Step to AI

The ability to translate real-world scenarios (like financial rules or mathematical concepts) into functional code is the hallmark of a confident programmer and the necessary skill set for anyone moving into AI. In this course, you will transition from learning syntax to solving problems.

Let's sharpen those problem-solving skills and take your Python fluency to the next level!

Welcome to Course 2: Building Your Python Foundation! 🐍✨

Congratulations on completing your first steps in Python! Now that you've got a taste of the programming world, it's time to solidify your understanding and dive deeper into the core mechanics of Python. This second course in our free programming series, "Building Your Python Foundation," is designed to expand on the basics and equip you with the essential tools for writing more sophisticated and interactive programs.

What You Will Learn

In this course, we'll move beyond the absolute fundamentals and focus on practical application and essential programming constructs. Each module is crafted to build upon the last, ensuring a smooth and comprehensive learning experience:

• Python Comments: Learn how to make your code readable and understandable, not just for others, but for your future self!

• Python Variables: Deepen your understanding of how to store and manage data within your programs.

• Python Input and Output: Discover how to make your programs interactive by taking input from the user and displaying results.

• Python Mathematical Expressions & Operators: Refine your skills in performing calculations and logical operations, crucial for any programming task.

• Python Decision Structures: Master the art of making your programs "think" by implementing conditional logic (if/else statements).

• Python Loops: Further explore how to automate repetitive tasks efficiently, a cornerstone of effective programming.

• Python Functions: Elevate your coding by learning to write reusable blocks of code, making your programs modular and organized.

Summarizing Your Learning with ChatGPT (Assignment!)

To cap off this course, you'll have an exciting opportunity to use a cutting-edge AI tool! Our "Summarizing your Learning With ChatGPT" assignment will challenge you to articulate what you've learned, fostering both your programming comprehension and your ability to interact with AI-powered language models.

This course is all about reinforcing your knowledge and giving you the confidence to tackle more complex challenges. Get ready to enhance your Python skills and continue your journey towards AI mastery!

Let's continue building!

Welcome to the World of Python Programming! 🐍

Ready to embark on a journey that will open doors to the exciting field of Artificial Intelligence? This course, "Introduction to Computer Programming in Python," is your essential first step. Designed as the prerequisite for all subsequent AI courses in this series, it will build the fundamental programming bedrock you need to succeed.

Why Python?

Python isn't just a programming language; it's the lingua franca of modern AI, data science, and machine learning. Its simple, readable syntax makes it the perfect language for beginners, allowing you to focus on logic and problem-solving rather than wrestling with complex code structures. By mastering Python, you're gaining a powerful, versatile tool used by companies and researchers globally.

What You Will Learn

This course is structured to take you from a complete beginner to a confident Python programmer. We'll cover all the core concepts necessary to write functional, efficient code:

• Fundamentals: Understanding Variables, Operators, and creating basic Mathematical Expressions.

• Control Flow: Mastering Conditional Statements (making decisions in code) and Loops (automating repetitive tasks).

• Organization: Learning to write reusable code blocks with Functions and organize complex data efficiently using various Data Structures.

• Object-Oriented Programming (OOP): An introduction to Classes, which will allow you to structure your programs in a robust, intuitive way.

• Practical Application: We'll conclude by introducing Graphing techniques and basic concepts in Mathematical Modelling—the very foundations of data visualization and the quantitative analysis central to AI.

Your Path to AI

Every line of code you write in this course will be a step toward understanding how algorithms work and, ultimately, how to build intelligent systems. Think of this course not just as learning Python, but as gaining computational fluency—the ability to think like a programmer.

Let's dive in and start coding!

Let's explore how you can use AI to make your Python coding even better! You've learned how to talk to the AI; now we'll look at how your code can talk directly to the AI to get work done.

💻 Supercharge Your Coding with LLMs

In this lesson, you'll see real-world Python examples where a Large Language Model (LLM) is used as a tool right inside your program. This lets the AI handle complex tasks—like summarizing text or generating code—while your Python script manages the process. You'll also learn extra tips and tricks to become an LLM professional!

🔑 The Power of Delimiters

When you give the AI a long block of text or multiple sets of instructions, it can get confused about what's what. Delimiters are special characters you use to clearly mark where one part of the input ends and another begins.

You can use anything as a delimiter, like: triple backticks (```), triple quotes ("""), or angle brackets (< >).

Example Code: Summarizing with Delimiters

This code shows a Python script that uses the OpenAI API to ask an AI model to summarize a piece of text. Notice how the triple backticks (```) are used as delimiters to clearly separate the instructions from the actual text.

import openai
import os
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv())
openai.api_key  = os.getenv('OPENAI_API_KEY')
client = openai.OpenAI()

def get_completion(prompt, model="gpt-3.5-turbo"):
    messages = [{"role": "user", "content": prompt}]
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0
    )
    return response.choices[0].message.content

text = f"""
You should express what you want a model to do by \ 
providing instructions that are as clear and \ 
specific as you can possibly make them. \ 
This will guide the model towards the desired output, \ 
and reduce the chances of receiving irrelevant \ 
or incorrect responses. Don't confuse writing a \ 
clear prompt with writing a short prompt. \ 
In many cases, longer prompts provide more clarity \ 
and context for the model, which can lead to \ 
more detailed and relevant outputs.
"""

prompt = f"""
Summarize the text delimited by triple backticks \ 
into a single sentence.
```{text}```
"""
response = get_completion(prompt)
print(response)

🛠️ Code Breakdown: What's Happening

This Python code uses an external service (the OpenAI API) to generate text, specifically aimed at summarizing information.

1. Setting Up the Connection

• Imports: The code brings in necessary tools: openai to talk to the AI, os and dotenv to safely load your secret API key.

• API Key: Your API key is your personal password that lets you use the AI service. The code safely loads this key from a hidden file (.env) so it's not exposed in your main program.

2. The get_completion Function

This is the main function that does the work of talking to the AI.

• It takes your prompt (what you want the AI to do) and the model (which AI brain you want to use, like "gpt-3.5-turbo").

• It sets the messages structure: it tells the AI that the text you send has the "user" role, meaning it's the instruction.

• client.chat.completions.create sends your instruction to the OpenAI service.

• temperature=0 is important: it controls the randomness. Setting it to 0 means the AI will try to give you the most deterministic (least creative, most predictable) answer based on your prompt, which is usually best for coding tasks.

• It returns the final text the AI came up with.

3. Generating the Summary

• The code defines the text you want summarized in the text variable.

• It creates a new string called prompt that contains two things: the instruction ("Summarize the text...") and the text to be summarized (which is safely wrapped in triple backticks to act as a delimiter).

• It runs the get_completion function with this prompt and prints the result.

In summary: This program safely connects to the AI, tells the AI exactly what to do using clear delimiters, and then prints the high-quality, non-random summary it received.

No problem. Here is the revised text for the Polynomials and the ReAct Pattern lesson, explaining the concepts in a straightforward, continuous description, perfect for students.

🧩 Polynomials and the ReAct Pattern: AI as Your Research Assistant

This lesson connects the math topic of Polynomials with a powerful AI technique called ReAct Prompting.

What is a Polynomial?

A Polynomial is simply a math expression made up of variables (like x) and numbers (coefficients), combined by adding, subtracting, and multiplying. They are the essential building blocks used everywhere—from modeling a ball's trajectory to calculating interest. For instance, a linear polynomial like 2x+3 models a straight line, while a quadratic one like x2−4x+7 models a curve, like a parabola.

🤖 What is the ReAct Pattern?

The ReAct (Reasoning + Acting) Prompting pattern turns the AI into a smart research assistant that can use external tools. This is key because not every problem can be solved just by the AI thinking; sometimes, it needs to go look stuff up or use a tool like a graphing calculator.

The ReAct process has two parts:

1. Reasoning: The AI first explains its thought process (e.g., "I know I need to check an outside source to be sure.").

2. Acting: The AI then takes a specific action (e.g., "I will search on Google," or "I will use a graphing calculator.").

🔭 Applying ReAct to Polynomials

Students can use ReAct every time their work with polynomials requires information that the AI might not have or when they need to visualize the problem.

• Fact-Checking: If you need to verify a complex polynomial identity (like checking if (x+y)2 is truly equal to x2+2xy+y2), you can use ReAct. The AI's logic will be: "I must check a reliable math website," and its action will be to search for the identity on a site like Wolfram Alpha.

• Visualization: If you need to see what the graph of a polynomial (like y=x2−4x+7) looks like, the ReAct pattern is ideal. The AI's logic will be: "To understand this curve, I need a visual tool," and its action will be to plot the polynomial using a graphing tool like Desmos.

✅ The Big Benefits

Using ReAct when studying polynomials gives you huge advantages:

• Super Accuracy: By using external tools like calculators and search engines, the AI grounds its answers in facts, drastically reducing mistakes.

• Transparency: You see exactly which source the AI checked, making you trust the answer more.

• Expanded Power: The AI can now solve problems that go beyond simple math textbook questions, bridging the gap between theory and the real world.

In summary: If your polynomial problem needs the AI to think in steps, use Chain of Thought. If your polynomial problem needs the AI to use a tool or look up facts, use ReAct.

🧠 Chain of Thought: Solving Math Problems with Logic

You're moving into Level 3, which is all about finding patterns, calculating sums, and using sequences and series in your Python programs. These problems are great, but they all require careful, multi-step logic.

This is where the Chain of Thought (CoT) Pattern comes in.

What is the Chain of Thought Pattern?

The CoT Pattern is a technique that makes the AI show its work, just like your math teacher asks you to! Instead of just giving the final answer, you force the AI to write out every logical step it took to get there.

This pattern is designed to guide the AI through complex problems that need step-by-step reasoning. By giving the AI an example of the right reasoning, you teach it the best method to solve a new problem, drastically improving its accuracy.

🔢 How CoT Works with Sequences and Series

Many problems involving sequences and series (like finding the 100th term, or figuring out a pattern) need a clear, logical progression. The CoT Pattern guides the AI through these exact steps:

Example: Finding the 10th Term

Here is how students would use the CoT pattern to solve a sequence problem:

The Goal: Find the 10th term in the arithmetic sequence: 7,11,15,19...

Your Prompt (The CoT Instruction):

"Here's the exact thought process to follow:

1. Identify: The first term (a) is 7, and the common difference (d) is 4.

2. Formula: We use the formula: nth term =a+(n−1)×d.

3. Substitute: 10th term =7+(10−1)×4.

4. Calculate: 7+9×4=7+36=43.

Now, using this exact reasoning, find the 10th term in the sequence: 7,11,15,19..."

Expected Outcome: The AI will not only give you the answer (43) but also the four clear steps, showing you it understood the logic.

🌟 Why This Technique is Powerful

• You Teach the AI: By showing the AI an explicit, clear reasoning path, you make sure it uses the correct formula and logic, rather than just guessing or taking shortcuts.

• Built-in Verification: You can instantly check the AI's work, which is especially useful when integrating these calculations into your Python programs.

• Works for Complex Tasks: You can use this method for much harder problems, like figuring out the sum of a long series or identifying complex growth patterns.

🧠 Question Refinement: Asking Smarter Questions

You already know that the quality of the AI's answer depends on the quality of your question. The Question Refinement Pattern is the technique that makes the AI a better partner by asking it to critique and improve your questions for you!

Think of it this way: When you're stuck on a tricky math problem, a good teacher doesn't just give you the answer. They suggest a new way to look at the problem, pointing out something you might have missed. The Question Refinement Pattern does the exact same thing with the AI.

How it Works: The Smart Tutor Process

1. Ask Your Question: You start with your initial question (e.g., "Tell me about climate change.").

2. AI Analysis: The AI acts like a smart tutor and analyzes your question, deciding how it could be better, more specific, or more focused.

3. Refined Suggestion: The AI suggests a smarter version of your question (e.g., "Do you mean, 'What are the top three effects of climate change on coastal ecosystems in the next 20 years?'").

4. Your Choice: You choose the refined question or stick with your original.

💻 Using Python for Next-Level Refinement

We make this process even more powerful by using the Python coding concepts you just learned. Students can integrate programming logic directly into their refinement prompts:

• Decision Structures (if statements): You can program your prompt to read the user's initial question and then automatically suggest different refined questions based on the topic.

  • Example: IF the user mentions "history," the prompt suggests adding a date range. ELSE IF they mention "science," it suggests adding a specific experiment.

• Loops (Repeating Actions): You can use a loop to force the process of refinement until you are happy.

  • Example: Your code can make the AI suggest three different ways to refine your question, allowing you to quickly compare and choose the best one before moving on.

🚀 Why Refine Your Questions?

By actively participating in the question refinement process, you get these huge advantages:

• More Accurate Answers: A clear, well-framed question always leads to a precise and actionable response.

• New Insights: A different perspective on your question can unlock knowledge and details you didn't even know to ask for.

• Save Time: You avoid frustrating back-and-forth communication with the AI, getting the detailed answer you need right away.

Remember: The AI is a tool to enhance your learning, not replace it. By actively refining your questions, you deepen your understanding and sharpen your critical thinking skills!