Merge pull request #13 from marimo-team/001-set

probability/00-sets.py

@@ -0,0 +1,297 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "marimo",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.11.0"
+app = marimo.App()
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # Sets
+
+        Probability is the study of "events", assigning numerical values to how likely
+        events are to occur. For example, probability lets us quantify how likely it is for it to rain or shine on a given day.
+
+
+        Typically we reason about _sets_ of events. In mathematics,
+        a set is a collection of elements, with no element included more than once.
+        Elements can be any kind of object.
+
+        For example:
+
+        - ☀️ Weather events: $\{\text{Rain}, \text{Overcast}, \text{Clear}\}$
+        - 🎲 Die rolls: $\{1, 2, 3, 4, 5, 6\}$
+        - 🪙 Pairs of coin flips = $\{ \text{(Heads, Heads)}, \text{(Heads, Tails)}, \text{(Tails, Tails)} \text{(Tails, Heads)}\}$
+
+        Sets are the building blocks of probability, and will arise frequently in our study.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""## Set operations""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""In Python, sets are made with the `set` function:""")
+    return
+
+
+@app.cell
+def _():
+    A = set([2, 3, 5, 7])
+    A
+    return (A,)
+
+
+@app.cell
+def _():
+    B = set([0, 1, 2, 3, 5, 8])
+    B
+    return (B,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Below we explain common operations on sets.
+
+        _**Try it!** Try modifying the definitions of `A` and `B` above, and see how the results change below._
+
+        The **union** $A \cup B$ of sets $A$ and $B$ is the set of elements in $A$, $B$, or both.
+        """
+    )
+    return
+
+
+@app.cell
+def _(A, B):
+    A | B
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""The **intersection** $A \cap B$ is the set of elements in both $A$ and $B$""")
+    return
+
+
+@app.cell
+def _(A, B):
+    A & B
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""The **difference** $A \setminus B$ is the set of elements in $A$ that are not in $B$.""")
+    return
+
+
+@app.cell
+def _(A, B):
+    A - B
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ### 🎬 An interactive example
+
+        Here's a simple example that classifies TV shows into sets by genre, and uses these sets to recommend shows to a user based on their preferences.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    viewer_type = mo.ui.radio(
+        options={
+            "I like action and drama!": "New Viewer",
+            "I only like action shows": "Action Fan",
+            "I only like dramas": "Drama Fan",
+        },
+        value="I like action and drama!",
+        label="Which genre do you prefer?",
+    )
+    return (viewer_type,)
+
+
+@app.cell(hide_code=True)
+def _(viewer_type):
+    viewer_type
+    return
+
+
+@app.cell
+def _():
+    action_shows = {"Stranger Things", "The Witcher", "Money Heist"}
+    drama_shows = {"The Crown", "Money Heist", "Bridgerton"}
+    return action_shows, drama_shows
+
+
+@app.cell
+def _(action_shows, drama_shows):
+    recommendations = {
+        "New Viewer": action_shows | drama_shows,  # Union for new viewers
+        "Action Fan": action_shows - drama_shows,  # Unique action shows
+        "Drama Fan": drama_shows - action_shows,  # Unique drama shows
+    }
+    return (recommendations,)
+
+
+@app.cell(hide_code=True)
+def _(mo, recommendations, viewer_type):
+    result = recommendations[viewer_type.value]
+
+    explanation = {
+        "New Viewer": "You get everything to explore!",
+        "Action Fan": "Pure action, no drama!",
+        "Drama Fan": "Drama-focused selections!",
+    }
+
+    mo.md(f"""
+    **🎬 Recommended shows.** Based on your preference for **{viewer_type.value}**,
+    we recommend:
+
+    {", ".join(result)}
+
+    **Why these shows?** 
+    {explanation[viewer_type.value]}
+    """)
+    return explanation, result
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""
+    ### Exercise
+
+    Given these sets:
+
+    - A = {🎮, 📱, 💻}
+
+    - B = {📱, 💻, 🖨️}
+
+    - C = {💻, 🖨️, ⌨️}
+
+    Can you:
+
+    1. Find all elements that are in A or B
+
+    2. Find elements common to all three sets
+
+    3. Find elements in A that aren't in C
+
+    <details>
+
+    <summary>Check your answers!</summary>
+
+    1. A ∪ B = {🎮, 📱, 💻, 🖨️}<br>
+    2. A ∩ B ∩ C = {💻}<br>
+    3. A - C = {🎮, 📱}
+
+    </details>
+    """)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 🧮 Set properties
+
+        Here are some important properties of the set operations:
+
+        1. **Commutative**: $A \cup B = B \cup A$
+        2. **Associative**: $(A \cup B) \cup C = A \cup (B \cup C)$
+        3. **Distributive**: $A \cup (B \cap C) = (A \cup B) \cap (A \cup C)$
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## Set builder notation
+
+        To compactly describe the elements in a set, we can use **set builder notation**, which specifies conditions that must be true for elements to be in the set.
+
+        For example, here is how to specify the set of positive numbers less than 10:
+
+        \[
+        \{x \mid 0 < x < 10 \}
+        \]
+
+        The predicate to the right of the vertical bar $\mid$ specifies conditions that must be true for an element to be in the set; the expression to the left of $\mid$ specifies the value being included.
+
+        In Python, set builder notation is called a "set comprehension."
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    def predicate(x):
+        return x > 0 and x < 10
+    return (predicate,)
+
+
+@app.cell
+def _(predicate):
+    set(x for x in range(100) if predicate(x))
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""**Try it!** Try modifying the `predicate` function above and see how the set changes.""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""
+    ## Summary
+
+    You've learned:
+
+    - Basic set operations
+    - Set properties
+    - Real-world applications
+
+    In the next lesson, we'll define probability from the ground up, using sets.
+
+    Remember: In probability, every event is a set, and every set can be an event!
+    """)
+    return
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+if __name__ == "__main__":
+    app.run()