a big --fix indeed

_server/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # marimo learn server
 
 This folder contains server code for hosting marimo apps.
@@ -21,4 +26,4 @@ docker build -t marimo-learn .
 
 ```bash
 docker run -p 7860:7860 marimo-learn
-```
+```

daft/01_what_makes_daft_special.py

@@ -8,28 +8,25 @@
 
 import marimo
 
-__generated_with = "0.13.6"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # What Makes Daft Special?
 
     > _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
 
     Welcome to the course on [Daft](https://www.getdaft.io/), the distributed dataframe library! In this first chapter, we'll explore what Daft is and what makes it a noteworthy tool in the landscape of data processing. We'll look at its core design choices and how they aim to help you work with data more effectively, whether you're a data engineer, data scientist, or analyst.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🎯 Introducing Daft: A Unified Data Engine
 
     Daft is a distributed query engine designed to handle a wide array of data tasks, from data engineering and analytics to powering ML/AI workflows. It provides both a Python DataFrame API, familiar to users of libraries like Pandas, and a SQL interface, allowing you to choose the interaction style that best suits your needs or the task at hand.
@@ -37,8 +34,7 @@ def _(mo):
     The main goal of Daft is to provide a robust and versatile platform for processing data, whether it's gigabytes on your laptop or petabytes on a cluster.
 
     Let's go ahead and `pip install daft` to see it in action!
-    """
-    )
+    """)
     return
 
 
@@ -86,8 +82,7 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🦀 Built with Rust: Performance and Simplicity
 
     One of Daft's key characteristics is that its core engine is written in Rust. This choice has several implications for users:
@@ -97,8 +92,7 @@ def _(mo):
     *   **Simplified Developer Experience**: Rust-based systems typically require less configuration tuning compared to JVM-based systems. You don't need to worry about JVM heap sizes, garbage collection parameters, or managing Java dependencies.
 
     Daft also leverages [Apache Arrow](https://arrow.apache.org/) for its in-memory data format. This allows for efficient data exchange between Daft's Rust core and Python, often with zero-copy data sharing, further enhancing performance.
-    """
-    )
+    """)
     return
 
 
@@ -118,7 +112,9 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""A cornerstone of Daft's design is **lazy execution**. Imagine defining a DataFrame with a trillion rows on your laptop – usually not a great prospect for your device's memory!""")
+    mo.md(r"""
+    A cornerstone of Daft's design is **lazy execution**. Imagine defining a DataFrame with a trillion rows on your laptop – usually not a great prospect for your device's memory!
+    """)
     return
 
 
@@ -135,7 +131,9 @@ def _(daft):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""With Daft, this is perfectly fine. Operations like `with_column` or `filter` don't compute results immediately. Instead, Daft builds a *logical plan* – a blueprint of the transformations you've defined. You can inspect this plan:""")
+    mo.md(r"""
+    With Daft, this is perfectly fine. Operations like `with_column` or `filter` don't compute results immediately. Instead, Daft builds a *logical plan* – a blueprint of the transformations you've defined. You can inspect this plan:
+    """)
     return
 
 
@@ -147,14 +145,15 @@ def _(mo, trillion_rows_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""This plan is only executed (and data materialized) when you explicitly request it (e.g., with `.show()`, `.collect()`, or by writing to a file). Before execution, Daft's optimizer works to make your query run as efficiently as possible. This approach allows you to define complex operations on massive datasets without immediate computational cost or memory overflow.""")
+    mo.md(r"""
+    This plan is only executed (and data materialized) when you explicitly request it (e.g., with `.show()`, `.collect()`, or by writing to a file). Before execution, Daft's optimizer works to make your query run as efficiently as possible. This approach allows you to define complex operations on massive datasets without immediate computational cost or memory overflow.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🌐 Scale Your Work: From Laptop to Cluster
 
     Daft is designed with scalability in mind. As the trillion-row dataframe example above illustrates, you can write your data processing logic using Daft's Python API, and this same code can run:
@@ -163,15 +162,13 @@ def _(mo):
     *   **On a Cluster**: By integrating with [Ray](https://www.ray.io/), a framework for distributed computing. This allows Daft to scale out to process very large datasets across many machines.
 
     This "write once, scale anywhere" approach means you don't need to significantly refactor your code when moving from local development to large-scale distributed execution. We'll delve into distributed computing with Ray in a later chapter.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🖼️ Handling More Than Just Tables: Multimodal Data Support
 
     Modern datasets often contain more than just numbers and text. They might include images, audio clips, URLs pointing to external files, tensor data from machine learning models, or complex nested structures like JSON.
@@ -179,8 +176,7 @@ def _(mo):
     Daft is built to accommodate these **multimodal data types** as integral parts of a DataFrame. This means you can have columns containing image data, embeddings, or other complex Python objects, and Daft provides mechanisms to process them. This is particularly useful for ML/AI pipelines and advanced analytics where diverse data sources are common.
 
     As an example of how Daft simplifies working with such complex data, let's see how we can process image URLs. With just a few lines of Daft code, we can pull open data from the [National Gallery of Art](https://github.com/NationalGalleryOfArt/opendata), then directly fetch, decode, and even resize the images within our DataFrame:
-    """
-    )
+    """)
     return
 
 
@@ -217,20 +213,23 @@ def _(daft):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""> Example inspired by the great post [Exploring Art with TypeScript, Jupyter, Polars, and Observable Plot](https://deno.com/blog/exploring-art-with-typescript-and-jupyter) published on Deno's blog.""")
+    mo.md(r"""
+    > Example inspired by the great post [Exploring Art with TypeScript, Jupyter, Polars, and Observable Plot](https://deno.com/blog/exploring-art-with-typescript-and-jupyter) published on Deno's blog.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""In later chapters, we'll explore in more detail how to work with these image objects and other complex types, including applying User-Defined Functions (UDFs) for custom processing. Until then, you can [take a look at a more complex example](https://blog.getdaft.io/p/we-cloned-over-15000-repos-to-find), in which Daft is used to clone over 15,000 GitHub repos to find the best developers.""")
+    mo.md(r"""
+    In later chapters, we'll explore in more detail how to work with these image objects and other complex types, including applying User-Defined Functions (UDFs) for custom processing. Until then, you can [take a look at a more complex example](https://blog.getdaft.io/p/we-cloned-over-15000-repos-to-find), in which Daft is used to clone over 15,000 GitHub repos to find the best developers.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🧑‍💻 Designed for Developers: Python and SQL Interfaces
 
     Daft aims to be developer-friendly by offering flexible ways to interact with your data:
@@ -239,8 +238,7 @@ def _(mo):
     *   **SQL Interface**: For those who prefer SQL or have existing SQL-based logic, Daft allows you to write queries using SQL syntax. Daft can execute SQL queries directly or even translate SQL expressions into its native expression system.
 
     This dual-interface approach allows developers to choose the most appropriate tool for their specific task or leverage existing skills.
-    """
-    )
+    """)
     return
 
 
@@ -285,8 +283,7 @@ def _(daft):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## 🟣 Daft's Value Proposition
 
     So, what makes Daft special? It's the combination of these design choices:
@@ -299,8 +296,7 @@ def _(mo):
     These elements combine to make Daft a versatile tool for tackling modern data challenges.
 
     And this is just scratching the surface. Daft is a growing data engine with an ambitious vision: to unify data engineering, analytics, and ML/AI workflows 🚀.
-    """
-    )
+    """)
     return
 
 
@@ -308,7 +304,6 @@ def _(mo):
 def _():
     import daft
     import marimo as mo
-
     return daft, mo
 
 

daft/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # Learn Daft
 
 _🚧 This collection is a work in progress. Please help us add notebooks!_
@@ -23,4 +28,4 @@ You can also open notebooks in our online playground by appending marimo.app/ to
 
 **Thanks to all our notebook authors!**
 
-* [Péter Gyarmati](https://github.com/peter-gy)
+* [Péter Gyarmati](https://github.com/peter-gy)

duckdb/008_loading_parquet.py

@@ -11,39 +11,35 @@
 
 import marimo
 
-__generated_with = "0.14.10"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Loading Parquet files with DuckDB
     *By [Thomas Liang](https://github.com/thliang01)*
     #
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        [Apache Parquet](https://parquet.apache.org/) is a popular columnar storage format, optimized for analytics. Its columnar nature allows query engines like DuckDB to read only the necessary columns, leading to significant performance gains, especially for wide tables.
-
-        DuckDB has excellent, built-in support for reading Parquet files, making it incredibly easy to query and analyze Parquet data directly without a separate loading step.
-
-        In this notebook, we'll explore how to load and analyze Airbnb's stock price data from a remote Parquet file:
-        <ul>
-            <li>Querying a remote Parquet file directly.</li>
-            <li>Using the `read_parquet` function for more control.</li>
-            <li>Creating a persistent table from a Parquet file.</li>
-            <li>Performing basic data analysis and visualization.</li>
-        </ul>
-        """
-    )
+    mo.md(r"""
+    [Apache Parquet](https://parquet.apache.org/) is a popular columnar storage format, optimized for analytics. Its columnar nature allows query engines like DuckDB to read only the necessary columns, leading to significant performance gains, especially for wide tables.
+
+    DuckDB has excellent, built-in support for reading Parquet files, making it incredibly easy to query and analyze Parquet data directly without a separate loading step.
+
+    In this notebook, we'll explore how to load and analyze Airbnb's stock price data from a remote Parquet file:
+    <ul>
+        <li>Querying a remote Parquet file directly.</li>
+        <li>Using the `read_parquet` function for more control.</li>
+        <li>Creating a persistent table from a Parquet file.</li>
+        <li>Performing basic data analysis and visualization.</li>
+    </ul>
+    """)
     return
 
 
@@ -55,24 +51,24 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Using `FROM` to query Parquet files""")
+    mo.md(r"""
+    ## Using `FROM` to query Parquet files
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        The simplest way to query a Parquet file is to use it directly in a `FROM` clause, just like you would with a table. DuckDB will automatically detect that it's a Parquet file and read it accordingly.
+    mo.md(r"""
+    The simplest way to query a Parquet file is to use it directly in a `FROM` clause, just like you would with a table. DuckDB will automatically detect that it's a Parquet file and read it accordingly.
 
-        Let's query a dataset of Airbnb's stock price from Hugging Face.
-        """
-    )
+    Let's query a dataset of Airbnb's stock price from Hugging Face.
+    """)
     return
 
 
 @app.cell
-def _(AIRBNB_URL, mo, null):
+def _(AIRBNB_URL, mo):
     mo.sql(
         f"""
         SELECT *
@@ -85,24 +81,24 @@ def _(AIRBNB_URL, mo, null):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Using `read_parquet`""")
+    mo.md(r"""
+    ## Using `read_parquet`
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        For more control, you can use the `read_parquet` table function. This is useful when you need to specify options, for example, when dealing with multiple files or specific data types.
-        Some useful options for `read_parquet` include:
+    mo.md(r"""
+    For more control, you can use the `read_parquet` table function. This is useful when you need to specify options, for example, when dealing with multiple files or specific data types.
+    Some useful options for `read_parquet` include:
 
-        - `binary_as_string=True`: Reads `BINARY` columns as `VARCHAR`.
-        - `filename=True`: Adds a `filename` column with the path of the file for each row.
-        - `hive_partitioning=True`: Enables reading of Hive-partitioned datasets.
+    - `binary_as_string=True`: Reads `BINARY` columns as `VARCHAR`.
+    - `filename=True`: Adds a `filename` column with the path of the file for each row.
+    - `hive_partitioning=True`: Enables reading of Hive-partitioned datasets.
 
-        Here, we'll use `read_parquet` to select only a few relevant columns. This is much more efficient than `SELECT *` because DuckDB only needs to read the data for the columns we specify.
-        """
-    )
+    Here, we'll use `read_parquet` to select only a few relevant columns. This is much more efficient than `SELECT *` because DuckDB only needs to read the data for the columns we specify.
+    """)
     return
 
 
@@ -120,31 +116,29 @@ def _(AIRBNB_URL, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        You can also read multiple Parquet files at once using a glob pattern. For example, to read all Parquet files in a directory `data/`:
+    mo.md(r"""
+    You can also read multiple Parquet files at once using a glob pattern. For example, to read all Parquet files in a directory `data/`:
 
-        ```sql
-        SELECT * FROM read_parquet('data/*.parquet');
-        ```
-        """
-    )
+    ```sql
+    SELECT * FROM read_parquet('data/*.parquet');
+    ```
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Creating a table from a Parquet file""")
+    mo.md(r"""
+    ## Creating a table from a Parquet file
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        While querying Parquet files directly is powerful, sometimes it's useful to load the data into a persistent table within your DuckDB database. This can simplify subsequent queries and is a good practice if you'll be accessing the data frequently.
-        """
-    )
+    mo.md(r"""
+    While querying Parquet files directly is powerful, sometimes it's useful to load the data into a persistent table within your DuckDB database. This can simplify subsequent queries and is a good practice if you'll be accessing the data frequently.
+    """)
     return
 
 
@@ -156,7 +150,7 @@ def _(AIRBNB_URL, mo):
         SELECT * FROM read_parquet('{AIRBNB_URL}');
         """
     )
-    return airbnb_stock, stock_table
+    return (stock_table,)
 
 
 @app.cell(hide_code=True)
@@ -172,7 +166,7 @@ def _(mo, stock_table):
 
 
 @app.cell
-def _(airbnb_stock, mo):
+def _(mo):
     mo.sql(
         f"""
         SELECT * FROM airbnb_stock LIMIT 5;
@@ -183,18 +177,22 @@ def _(airbnb_stock, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Analysis and Visualization""")
+    mo.md(r"""
+    ## Analysis and Visualization
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's perform a simple analysis: plotting the closing stock price over time.""")
+    mo.md(r"""
+    Let's perform a simple analysis: plotting the closing stock price over time.
+    """)
     return
 
 
 @app.cell
-def _(airbnb_stock, mo):
+def _(mo):
     stock_data = mo.sql(
         f"""
         SELECT
@@ -209,7 +207,9 @@ def _(airbnb_stock, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now we can easily visualize this result using marimo's integration with plotting libraries like Plotly.""")
+    mo.md(r"""
+    Now we can easily visualize this result using marimo's integration with plotting libraries like Plotly.
+    """)
     return
 
 
@@ -227,14 +227,15 @@ def _(px, stock_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Conclusion""")
+    mo.md(r"""
+    ## Conclusion
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     In this notebook, we've seen how easy it is to work with Parquet files in DuckDB. We learned how to:
     <ul>
         <li>Query Parquet files directly from a URL using a simple `FROM` clause.</li>
@@ -244,8 +245,7 @@ def _(mo):
     </ul>
 
     DuckDB's native Parquet support makes it a powerful tool for interactive data analysis on large datasets without complex ETL pipelines.
-    """
-    )
+    """)
     return
 
 

duckdb/009_loading_json.py

@@ -10,38 +10,34 @@
 
 import marimo
 
-__generated_with = "0.12.8"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Loading JSON
+    mo.md(r"""
+    # Loading JSON
 
-        DuckDB supports reading and writing JSON through the `json` extension that should be present in most distributions and is autoloaded on first-use. If it's not, you can [install and load](https://duckdb.org/docs/stable/data/json/installing_and_loading.html) it manually like any other extension.
+    DuckDB supports reading and writing JSON through the `json` extension that should be present in most distributions and is autoloaded on first-use. If it's not, you can [install and load](https://duckdb.org/docs/stable/data/json/installing_and_loading.html) it manually like any other extension.
 
-        In this tutorial we'll cover 4 different ways we can transfer JSON data in and out of DuckDB:
+    In this tutorial we'll cover 4 different ways we can transfer JSON data in and out of DuckDB:
 
-        - [`FROM`](https://duckdb.org/docs/stable/sql/query_syntax/from.html) statement.
-        - [`read_json`](https://duckdb.org/docs/stable/data/json/loading_json#the-read_json-function) function.
-        - [`COPY`](https://duckdb.org/docs/stable/sql/statements/copy#copy--from) statement.
-        - [`IMPORT DATABASE`](https://duckdb.org/docs/stable/sql/statements/export.html) statement.
-        """
-    )
+    - [`FROM`](https://duckdb.org/docs/stable/sql/query_syntax/from.html) statement.
+    - [`read_json`](https://duckdb.org/docs/stable/data/json/loading_json#the-read_json-function) function.
+    - [`COPY`](https://duckdb.org/docs/stable/sql/statements/copy#copy--from) statement.
+    - [`IMPORT DATABASE`](https://duckdb.org/docs/stable/sql/statements/export.html) statement.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Using `FROM`
+    mo.md(r"""
+    ## Using `FROM`
 
-        Loading data using `FROM` is simple and straightforward. We use a path or URL to the file we want to load where we'd normally put a table name. When we do this, DuckDB attempts to infer the right way to read the file including the correct format and column types. In most cases this is all we need to load data into DuckDB.
-        """
-    )
+    Loading data using `FROM` is simple and straightforward. We use a path or URL to the file we want to load where we'd normally put a table name. When we do this, DuckDB attempts to infer the right way to read the file including the correct format and column types. In most cases this is all we need to load data into DuckDB.
+    """)
     return
 
 
@@ -57,20 +53,18 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Using `read_json`
+    mo.md(r"""
+    ## Using `read_json`
 
-        For greater control over how the JSON is read, we can directly call the [`read_json`](https://duckdb.org/docs/stable/data/json/loading_json#the-read_json-function) function. It supports a few different arguments — some common ones are:
+    For greater control over how the JSON is read, we can directly call the [`read_json`](https://duckdb.org/docs/stable/data/json/loading_json#the-read_json-function) function. It supports a few different arguments — some common ones are:
 
-        - `format='array'` or `format='newline_delimited'` - the former tells DuckDB that the rows should be read from a top-level JSON array while the latter means the rows should be read from JSON objects separated by a newline (JSONL/NDJSON).
-        - `ignore_errors=true` - skips lines with parse errors when reading newline delimited JSON.
-        - `columns={columnName: type, ...}` - lets you set types for individual columns manually.
-        - `dateformat` and `timestampformat` - controls how DuckDB attempts to parse [Date](https://duckdb.org/docs/stable/sql/data_types/date) and [Timestamp](https://duckdb.org/docs/stable/sql/data_types/timestamp) types. Use the format specifiers specified in the [docs](https://duckdb.org/docs/stable/sql/functions/dateformat.html#format-specifiers).
+    - `format='array'` or `format='newline_delimited'` - the former tells DuckDB that the rows should be read from a top-level JSON array while the latter means the rows should be read from JSON objects separated by a newline (JSONL/NDJSON).
+    - `ignore_errors=true` - skips lines with parse errors when reading newline delimited JSON.
+    - `columns={columnName: type, ...}` - lets you set types for individual columns manually.
+    - `dateformat` and `timestampformat` - controls how DuckDB attempts to parse [Date](https://duckdb.org/docs/stable/sql/data_types/date) and [Timestamp](https://duckdb.org/docs/stable/sql/data_types/timestamp) types. Use the format specifiers specified in the [docs](https://duckdb.org/docs/stable/sql/functions/dateformat.html#format-specifiers).
 
-        We could rewrite the previous query more explicitly as:
-        """
-    )
+    We could rewrite the previous query more explicitly as:
+    """)
     return
 
 
@@ -99,24 +93,24 @@ def _(mo):
         ;
         """
     )
-    return (cars_df,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Other than singular files we can read [multiple files](https://duckdb.org/docs/stable/data/multiple_files/overview.html) at a time by either passing a list of files or a UNIX glob pattern.""")
+    mo.md(r"""
+    Other than singular files we can read [multiple files](https://duckdb.org/docs/stable/data/multiple_files/overview.html) at a time by either passing a list of files or a UNIX glob pattern.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Using `COPY`
+    mo.md(r"""
+    ## Using `COPY`
 
-        `COPY` is for useful both for importing and exporting data in a variety of formats including JSON. For example, we can import data into an existing table from a JSON file.
-        """
-    )
+    `COPY` is for useful both for importing and exporting data in a variety of formats including JSON. For example, we can import data into an existing table from a JSON file.
+    """)
     return
 
 
@@ -137,11 +131,11 @@ def _(mo):
         );
         """
     )
-    return (cars2,)
+    return
 
 
 @app.cell
-def _(cars2, mo):
+def _(mo):
     _df = mo.sql(
         f"""
         COPY cars2 FROM 'https://raw.githubusercontent.com/vega/vega-datasets/refs/heads/main/data/cars.json' (FORMAT json, ARRAY true, DATEFORMAT '%Y-%m-%d');
@@ -153,7 +147,9 @@ def _(cars2, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Similarly, we can write data from a table or select statement to a JSON file. For example, we create a new JSONL file with just the car names and miles per gallon. We first create a temporary directory to avoid cluttering our project directory.""")
+    mo.md(r"""
+    Similarly, we can write data from a table or select statement to a JSON file. For example, we create a new JSONL file with just the car names and miles per gallon. We first create a temporary directory to avoid cluttering our project directory.
+    """)
     return
 
 
@@ -164,11 +160,11 @@ def _(Path):
     TMP_DIR = TemporaryDirectory()
     COPY_PATH = Path(TMP_DIR.name) / "cars_mpg.jsonl"
     print(COPY_PATH)
-    return COPY_PATH, TMP_DIR, TemporaryDirectory
+    return COPY_PATH, TMP_DIR
 
 
 @app.cell
-def _(COPY_PATH, cars2, mo):
+def _(COPY_PATH, mo):
     _df = mo.sql(
         f"""
         COPY (
@@ -191,13 +187,11 @@ def _(COPY_PATH, Path):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Using `IMPORT DATABASE`
+    mo.md(r"""
+    ## Using `IMPORT DATABASE`
 
-        The last method we can use to load JSON data is using the `IMPORT DATABASE` statement. It works in conjunction with `EXPORT DATABASE` to save and load an entire database to and from a directory. For example let's try and export our default in-memory database.
-        """
-    )
+    The last method we can use to load JSON data is using the `IMPORT DATABASE` statement. It works in conjunction with `EXPORT DATABASE` to save and load an entire database to and from a directory. For example let's try and export our default in-memory database.
+    """)
     return
 
 
@@ -226,7 +220,9 @@ def _(EXPORT_PATH, Path):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can then load the database back into DuckDB.""")
+    mo.md(r"""
+    We can then load the database back into DuckDB.
+    """)
     return
 
 
@@ -250,14 +246,12 @@ def _(TMP_DIR):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Further Reading
+    mo.md(r"""
+    ## Further Reading
 
-        - Complete information on the JSON support in DuckDB can be found in their [documentation](https://duckdb.org/docs/stable/data/json/overview.html).
-        - You can also learn more about using SQL in marimo from the [examples](https://github.com/marimo-team/marimo/tree/main/examples/sql).
-        """
-    )
+    - Complete information on the JSON support in DuckDB can be found in their [documentation](https://duckdb.org/docs/stable/data/json/overview.html).
+    - You can also learn more about using SQL in marimo from the [examples](https://github.com/marimo-team/marimo/tree/main/examples/sql).
+    """)
     return
 
 

duckdb/011_working_with_apache_arrow.py

@@ -14,41 +14,37 @@
 
 import marimo
 
-__generated_with = "0.14.12"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Working with Apache Arrow
     *By [Thomas Liang](https://github.com/thliang01)*
     #
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        [Apache Arrow](https://arrow.apache.org/) is a multi-language toolbox for building high performance applications that process and transport large data sets. It is designed to both improve the performance of analytical algorithms and the efficiency of moving data from one system or programming language to another.
+    mo.md(r"""
+    [Apache Arrow](https://arrow.apache.org/) is a multi-language toolbox for building high performance applications that process and transport large data sets. It is designed to both improve the performance of analytical algorithms and the efficiency of moving data from one system or programming language to another.
 
-        A critical component of Apache Arrow is its in-memory columnar format, a standardized, language-agnostic specification for representing structured, table-like datasets in-memory. This data format has a rich data type system (included nested and user-defined data types) designed to support the needs of analytic database systems, data frame libraries, and more.
+    A critical component of Apache Arrow is its in-memory columnar format, a standardized, language-agnostic specification for representing structured, table-like datasets in-memory. This data format has a rich data type system (included nested and user-defined data types) designed to support the needs of analytic database systems, data frame libraries, and more.
 
-        DuckDB has native support for Apache Arrow, which is an in-memory columnar data format. This allows for efficient data transfer between DuckDB and other Arrow-compatible systems, such as Polars and Pandas (via PyArrow).
+    DuckDB has native support for Apache Arrow, which is an in-memory columnar data format. This allows for efficient data transfer between DuckDB and other Arrow-compatible systems, such as Polars and Pandas (via PyArrow).
 
-        In this notebook, we'll explore how to:
+    In this notebook, we'll explore how to:
 
-        - Create an Arrow table from a DuckDB query.
-        - Load an Arrow table into DuckDB.
-        - Convert between DuckDB, Arrow, and Polars/Pandas DataFrames.
-        - Combining data from multiple sources
-        - Performance benefits
-        """
-    )
+    - Create an Arrow table from a DuckDB query.
+    - Load an Arrow table into DuckDB.
+    - Convert between DuckDB, Arrow, and Polars/Pandas DataFrames.
+    - Combining data from multiple sources
+    - Performance benefits
+    """)
     return
 
 
@@ -71,23 +67,21 @@ def _(mo):
             (5, 'Eve', 40, 'London');
         """
     )
-    return (users,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 1. Creating an Arrow Table from a DuckDB Query
+    mo.md(r"""
+    ## 1. Creating an Arrow Table from a DuckDB Query
 
-        You can directly fetch the results of a DuckDB query as an Apache Arrow table using the `.arrow()` method on the query result.
-        """
-    )
+    You can directly fetch the results of a DuckDB query as an Apache Arrow table using the `.arrow()` method on the query result.
+    """)
     return
 
 
 @app.cell
-def _(mo, users):
+def _(mo):
     users_arrow_table = mo.sql(  # type: ignore
         """
         SELECT * FROM users WHERE age > 30;
@@ -98,7 +92,9 @@ def _(mo, users):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The `.arrow()` method returns a `pyarrow.Table` object. We can inspect its schema:""")
+    mo.md(r"""
+    The `.arrow()` method returns a `pyarrow.Table` object. We can inspect its schema:
+    """)
     return
 
 
@@ -110,13 +106,11 @@ def _(users_arrow_table):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 2. Loading an Arrow Table into DuckDB
+    mo.md(r"""
+    ## 2. Loading an Arrow Table into DuckDB
 
-        You can also register an existing Arrow table (or a Polars/Pandas DataFrame, which uses Arrow under the hood) directly with DuckDB. This allows you to query the in-memory data without any copying, which is highly efficient.
-        """
-    )
+    You can also register an existing Arrow table (or a Polars/Pandas DataFrame, which uses Arrow under the hood) directly with DuckDB. This allows you to query the in-memory data without any copying, which is highly efficient.
+    """)
     return
 
 
@@ -129,17 +123,19 @@ def _(pa):
         'age': [22, 45],
         'city': ['Berlin', 'Tokyo']
     })
-    return (new_data,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now, we can query this Arrow table `new_data` directly from SQL by embedding it in the query.""")
+    mo.md(r"""
+    Now, we can query this Arrow table `new_data` directly from SQL by embedding it in the query.
+    """)
     return
 
 
 @app.cell
-def _(mo, new_data):
+def _(mo):
     mo.sql(
         f"""
         SELECT name, age, city
@@ -152,19 +148,19 @@ def _(mo, new_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 3. Convert between DuckDB, Arrow, and Polars/Pandas DataFrames.
+    mo.md(r"""
+    ## 3. Convert between DuckDB, Arrow, and Polars/Pandas DataFrames.
 
-        The real power of DuckDB's Arrow integration comes from its seamless interoperability with data frame libraries like Polars and Pandas. Because they all share the Arrow in-memory format, conversions are often zero-copy and extremely fast.
-        """
-    )
+    The real power of DuckDB's Arrow integration comes from its seamless interoperability with data frame libraries like Polars and Pandas. Because they all share the Arrow in-memory format, conversions are often zero-copy and extremely fast.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### From DuckDB to Polars/Pandas""")
+    mo.md(r"""
+    ### From DuckDB to Polars/Pandas
+    """)
     return
 
 
@@ -186,7 +182,9 @@ def _(users_arrow_table):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### From Polars/Pandas to DuckDB""")
+    mo.md(r"""
+    ### From Polars/Pandas to DuckDB
+    """)
     return
 
 
@@ -199,17 +197,19 @@ def _(pl):
         "price": [1200.00, 25.50, 75.00]
     })
     polars_df
-    return (polars_df,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now we can query this Polars DataFrame directly in DuckDB:""")
+    mo.md(r"""
+    Now we can query this Polars DataFrame directly in DuckDB:
+    """)
     return
 
 
 @app.cell
-def _(mo, polars_df):
+def _(mo):
     # Query the Polars DataFrame directly in DuckDB
     mo.sql(
         f"""
@@ -224,7 +224,9 @@ def _(mo, polars_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Similarly, we can query a Pandas DataFrame:""")
+    mo.md(r"""
+    Similarly, we can query a Pandas DataFrame:
+    """)
     return
 
 
@@ -238,11 +240,11 @@ def _(pd):
         "order_date": pd.to_datetime(['2024-01-15', '2024-01-16', '2024-01-16', '2024-01-17'])
     })
     pandas_df
-    return (pandas_df,)
+    return
 
 
 @app.cell
-def _(mo, pandas_df):
+def _(mo):
     # Query the Pandas DataFrame in DuckDB
     mo.sql(
         f"""
@@ -257,18 +259,16 @@ def _(mo, pandas_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 4. Advanced Example: Combining Multiple Data Sources
+    mo.md(r"""
+    ## 4. Advanced Example: Combining Multiple Data Sources
 
-        One of the most powerful features is the ability to join data from different sources (DuckDB tables, Arrow tables, Polars/Pandas DataFrames) in a single query:
-        """
-    )
+    One of the most powerful features is the ability to join data from different sources (DuckDB tables, Arrow tables, Polars/Pandas DataFrames) in a single query:
+    """)
     return
 
 
 @app.cell
-def _(mo, pandas_df, polars_df, users):
+def _(mo):
     # Join the DuckDB users table with the Polars products DataFrame and Pandas orders DataFrame
     result = mo.sql(
         f"""
@@ -291,27 +291,28 @@ def _(mo, pandas_df, polars_df, users):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 5. Performance Benefits of Arrow Integration
+    mo.md(r"""
+    ## 5. Performance Benefits of Arrow Integration
 
-        The zero-copy integration between DuckDB and Apache Arrow delivers significant performance and memory benefits. This seamless integration enables:
+    The zero-copy integration between DuckDB and Apache Arrow delivers significant performance and memory benefits. This seamless integration enables:
 
-        ### Key Benefits:
+    ### Key Benefits:
 
-        - **Memory Efficiency**: Arrow's columnar format uses 20-40% less memory than traditional DataFrames through compact columnar representation and better compression ratios
-        - **Zero-Copy Operations**: Data can be shared between DuckDB and Arrow-compatible systems (Polars, Pandas) without any data copying, eliminating redundant memory usage
-        - **Query Performance**: 2-10x faster queries compared to traditional approaches that require data copying
-        - **Larger-than-Memory Analysis**: Both DuckDB and Arrow-compatible libraries support streaming query results, allowing you to execute queries on data larger than available memory by processing data in batches.
-        - **Advanced Query Optimization**: DuckDB's optimizer can push down filters and projections directly into Arrow scans, reading only relevant columns and partitions 
-        Let's demonstrate these benefits with concrete examples:
-        """
-    )
+    - **Memory Efficiency**: Arrow's columnar format uses 20-40% less memory than traditional DataFrames through compact columnar representation and better compression ratios
+    - **Zero-Copy Operations**: Data can be shared between DuckDB and Arrow-compatible systems (Polars, Pandas) without any data copying, eliminating redundant memory usage
+    - **Query Performance**: 2-10x faster queries compared to traditional approaches that require data copying
+    - **Larger-than-Memory Analysis**: Both DuckDB and Arrow-compatible libraries support streaming query results, allowing you to execute queries on data larger than available memory by processing data in batches.
+    - **Advanced Query Optimization**: DuckDB's optimizer can push down filters and projections directly into Arrow scans, reading only relevant columns and partitions
+    Let's demonstrate these benefits with concrete examples:
+    """)
     return
 
+
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Memory Efficiency Demonstration""")
+    mo.md(r"""
+    ### Memory Efficiency Demonstration
+    """)
     return
 
 
@@ -352,18 +353,22 @@ def _(pd, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Performance Comparison: Arrow vs Non-Arrow Approaches""")
+    mo.md(r"""
+    ### Performance Comparison: Arrow vs Non-Arrow Approaches
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's compare three approaches for the same analytical query:""")
+    mo.md(r"""
+    Let's compare three approaches for the same analytical query:
+    """)
     return
 
 
 @app.cell
-def _(duckdb, mo, pandas_data, polars_data, time):
+def _(duckdb, mo, pandas_data, time):
     # Test query: group by category and calculate aggregations
     query = """
     SELECT 
@@ -425,14 +430,16 @@ def _(duckdb, mo, pandas_data, polars_data, time):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Visualizing the Performance Difference""")
+    mo.md(r"""
+    ### Visualizing the Performance Difference
+    """)
     return
 
 
 @app.cell
 def _(approach1_time, approach2_time, approach3_time, mo, pl):
     import altair as alt
-    
+
     # Create a bar chart showing the performance comparison
     performance_data = pl.DataFrame({
         "Approach": ["Traditional\n(Copy to DuckDB)", "Pandas\nGroupBy", "Arrow-based\n(Zero-copy)"],
@@ -450,27 +457,30 @@ def _(approach1_time, approach2_time, approach3_time, mo, pl):
         width=400,
         height=300
     )
-    
+
     # Display using marimo's altair_chart UI element
     mo.ui.altair_chart(chart)
-    return alt, chart, performance_data
-
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Complex Query Performance""")
+    mo.md(r"""
+    ### Complex Query Performance
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's test a more complex query with joins and window functions:""")
+    mo.md(r"""
+    Let's test a more complex query with joins and window functions:
+    """)
     return
 
 
 @app.cell
-def _(mo, pl, polars_data, time):
+def _(mo, pl, time):
     # Create additional datasets for join operations
     categories_df = pl.DataFrame({
         "category": [f"cat_{i}" for i in range(100)],
@@ -510,23 +520,21 @@ def _(mo, pl, polars_data, time):
     print(f"Complex query with joins and window functions completed in {complex_query_time:.3f} seconds")
 
     complex_result
-    return (categories_df,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Memory Efficiency During Operations
 
     Let's demonstrate how Arrow's zero-copy operations save memory during data transformations:
-    """
-    )
+    """)
     return
 
 
 @app.cell
-def _(polars_data, time):
+def _(polars_data, psutil, time):
     import os
     import pyarrow.compute as pc  # Add this import
 
@@ -558,7 +566,7 @@ def _(polars_data, time):
 
     copy_ops_time = time.time() - latest_start_time
     memory_after_copy = process.memory_info().rss / 1024 / 1024  # MB
- 
+
     print("Memory Usage Comparison:")
     print(f"Initial memory: {memory_before:.2f} MB")
     print(f"After Arrow operations: {memory_after_arrow:.2f} MB (diff: +{memory_after_arrow - memory_before:.2f} MB)")
@@ -567,14 +575,12 @@ def _(polars_data, time):
     print(f"Arrow operations: {arrow_ops_time:.3f} seconds")
     print(f"Copy operations: {copy_ops_time:.3f} seconds")
     print(f"Speedup: {copy_ops_time/arrow_ops_time:.1f}x")
-    return pc
-
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Summary
 
     In this notebook, we've explored:
@@ -590,8 +596,7 @@ def _(mo):
         - **Better scalability**: Can handle larger datasets within the same memory constraints
 
     The seamless integration between DuckDB and Arrow-compatible systems makes it easy to work with data across different tools while maintaining high performance and memory efficiency.
-    """
-    )
+    """)
     return
 
 
@@ -604,7 +609,7 @@ def _():
     import duckdb
     import sqlglot
     import psutil
-    return duckdb, mo, pa, pd, pl
+    return duckdb, mo, pa, pd, pl, psutil
 
 
 if __name__ == "__main__":

duckdb/01_getting_started.py

@@ -15,26 +15,23 @@
 
 import marimo
 
-__generated_with = "0.13.4"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        rf"""
+    mo.md(rf"""
     <p align="center">
       <img src="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSxHAqB0W_61zuIGVMiU6sEeQyTaw-9xwiprw&s" alt="DuckDB Image"/>
     </p>
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        rf"""
+    mo.md(rf"""
     # 🦆 **DuckDB**: An Embeddable Analytical Database System
 
     ## What is DuckDB?
@@ -83,15 +80,13 @@ def _(mo):
     /// attention | Note
     DuckDB requires Python 3.7 or newer. You also need to have Python and `pip` or `conda` installed on your system.
     ///
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # [1. DuckDB Connections: In-Memory vs. File-based](https://duckdb.org/docs/stable/connect/overview.html)
 
     DuckDB is a lightweight, _relational database management system (RDBMS)_ designed for analytical workloads. Unlike traditional client-server databases, it operates _in-process_ (embedded within your application) and supports both _in-memory_ (temporary) and _file-based_ (persistent) storage.
@@ -105,8 +100,7 @@ def _(mo):
     | Performance | Faster for most operations | Slightly slower but provides persistence |
     | Creation | duckdb.connect(':memory:') | duckdb.connect('filename.db') |
     | Multiple Connection Access | Limited to single connection | Multiple connections can access the same database |
-    """
-    )
+    """)
     return
 
 
@@ -134,8 +128,7 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ## Creating DuckDB Connections
 
     Let's create both types of DuckDB connections and explore their characteristics.
@@ -144,8 +137,7 @@ def _(mo):
     2. **File-based connection**: Data persists between sessions
 
     We'll then demonstrate the key differences between these connection types.
-    """
-    )
+    """)
     return
 
 
@@ -176,28 +168,28 @@ def _(file_db, memory_db):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Testing Connection Persistence
 
-    Let's demonstrate how in-memory databases are ephemeral, while file-based databases persist. 
+    Let's demonstrate how in-memory databases are ephemeral, while file-based databases persist.
 
     1. First, we'll query our tables to confirm the data was properly inserted
     2. Then, we'll simulate an application restart by creating new connections
     3. Finally, we'll check which data persists after the "restart"
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Current Database Contents""")
+    mo.md(r"""
+    ## Current Database Contents
+    """)
     return
 
 
 @app.cell(hide_code=True)
-def _(mem_test, memory_db, mo):
+def _(memory_db, mo):
     _df = mo.sql(
         f"""
         SELECT * FROM mem_test
@@ -208,7 +200,7 @@ def _(mem_test, memory_db, mo):
 
 
 @app.cell(hide_code=True)
-def _(file_db, file_test, mo):
+def _(file_db, mo):
     _df = mo.sql(
         f"""
         SELECT * FROM file_test
@@ -227,7 +219,9 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(rf"""## 🔄 Simulating Application Restart...""")
+    mo.md(rf"""
+    ## 🔄 Simulating Application Restart...
+    """)
     return
 
 
@@ -311,8 +305,7 @@ def _(file_data, file_data_available, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # [2. Creating Tables in DuckDB](https://duckdb.org/docs/stable/sql/statements/create_table.html)
 
     DuckDB supports standard SQL syntax for creating tables. Let's create more complex tables to demonstrate different data types and constraints.
@@ -326,8 +319,7 @@ def _(mo):
     - **CREATE OR REPLACE** to recreate tables
     - **Primary keys** and other constraints
     - **Various data types** including INTEGER, VARCHAR, TIMESTAMP, DECIMAL, etc.
-    """
-    )
+    """)
     return
 
 
@@ -406,8 +398,7 @@ def _(memory_schema, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # [3. Inserting Data Into Tables](https://duckdb.org/docs/stable/sql/statements/insert)
 
     DuckDB supports multiple ways to insert data:
@@ -418,8 +409,7 @@ def _(mo):
     4. **Bulk inserts**: For efficient loading of multiple rows
 
     Let's demonstrate these different insertion methods:
-    """
-    )
+    """)
     return
 
 
@@ -741,8 +731,7 @@ def _(file_results, memory_results, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # [4. Using SQL Directly in marimo](https://duckdb.org/docs/stable/sql/query_syntax/select)
 
     There are multiple ways to leverage DuckDB's SQL capabilities in marimo:
@@ -752,8 +741,7 @@ def _(mo):
     3. **Interactive queries**: Combining UI elements with SQL execution
 
     Let's explore these approaches:
-    """
-    )
+    """)
     return
 
 
@@ -808,7 +796,9 @@ def _(age_threshold, filtered_users, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# [5. Working with Polars and DuckDB](https://duckdb.org/docs/stable/guides/python/polars.html)""")
+    mo.md(r"""
+    # [5. Working with Polars and DuckDB](https://duckdb.org/docs/stable/guides/python/polars.html)
+    """)
     return
 
 
@@ -904,7 +894,9 @@ def _(complex_query_result, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# [6. Advanced Queries: Joins Between Tables](https://duckdb.org/docs/stable/guides/performance/join_operations.html)""")
+    mo.md(r"""
+    # [6. Advanced Queries: Joins Between Tables](https://duckdb.org/docs/stable/guides/performance/join_operations.html)
+    """)
     return
 
 
@@ -950,12 +942,10 @@ def _(new_memory_db):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        rf"""
+    mo.md(rf"""
     <!-- Display the join result -->
     ## Join Result (Users and Departments):
-    """
-    )
+    """)
     return
 
 
@@ -967,12 +957,10 @@ def _(join_result, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        rf"""
+    mo.md(rf"""
     <!-- Demonstrate different types of joins -->
     ## Different Types of Joins
-    """
-    )
+    """)
     return
 
 
@@ -1122,7 +1110,9 @@ def _(join_description, join_tabs, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# [7. Aggregate Functions in DuckDB](https://duckdb.org/docs/stable/sql/functions/aggregates.html)""")
+    mo.md(r"""
+    # [7. Aggregate Functions in DuckDB](https://duckdb.org/docs/stable/sql/functions/aggregates.html)
+    """)
     return
 
 
@@ -1224,7 +1214,9 @@ def _(mo, window_result):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# [8. Converting DuckDB Results to Polars/Pandas](https://duckdb.org/docs/stable/guides/python/polars.html)""")
+    mo.md(r"""
+    # [8. Converting DuckDB Results to Polars/Pandas](https://duckdb.org/docs/stable/guides/python/polars.html)
+    """)
     return
 
 
@@ -1342,7 +1334,9 @@ def _(mo, pandas_result):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""# 9. Data Visualization with DuckDB and Plotly""")
+    mo.md("""
+    # 9. Data Visualization with DuckDB and Plotly
+    """)
     return
 
 
@@ -1498,8 +1492,7 @@ def _(age_groups, mo, new_memory_db, plotly_express):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     /// admonition |
     ## Database Management Best Practices
     ///
@@ -1538,14 +1531,15 @@ def _(mo):
     - Create indexes for frequently queried columns
     - For large datasets, consider partitioning
     - Use prepared statements for repeated queries
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(rf"""## 10. Interactive DuckDB Dashboard with marimo and Plotly""")
+    mo.md(rf"""
+    ## 10. Interactive DuckDB Dashboard with marimo and Plotly
+    """)
     return
 
 
@@ -1736,8 +1730,7 @@ def _(
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        rf"""
+    mo.md(rf"""
     # Summary and Key Takeaways
 
     In this notebook, we've explored DuckDB, a powerful embedded analytical database system. Here's what we covered:
@@ -1770,8 +1763,7 @@ def _(mo):
     - Experiment with more complex queries and window functions
     - Use DuckDB's COPY functionality to import/export data from/to files
     - Create more advanced interactive dashboards with marimo and Plotly
-    """
-    )
+    """)
     return
 
 

duckdb/DuckDB_Loading_CSVs.py

@@ -13,39 +13,41 @@
 
 import marimo
 
-__generated_with = "0.12.10"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""#Loading CSVs with DuckDB""")
+    mo.md(r"""
+    #Loading CSVs with DuckDB
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        <p> I remember when I first learnt about DuckDB, it was a gamechanger — I used to load the data I wanted to work on to a database software like MS SQL Server, and then build a bridge to an IDE with the language I wanted to use like Python, or R; it was quite the hassle. DuckDB changed my whole world — now I could just import the data file into the IDE, or notebook, make a duckdb connection, and there we go! But then, I realized I didn't even need the step of first importing the file using python. I could just query the csv file directly using SQL through a DuckDB connection.</p> 
-
-        ##Introduction
-        <p> I found this dataset on the evolution of AI research by discipline from <a href= "https://oecd.ai/en/data?selectedArea=ai-research&selectedVisualization=16731"> OECD</a>, and it piqued my interest. I feel like publications in natural language processing drastically jumped in the mid 2010s, and I'm excited to find out if that's the case. </p> 
-
-        <p> In this notebook, we'll: </p>
-        <ul>
-            <li> Import the CSV file into the notebook</li>
-            <li> Create another table within the database based on the CSV</li>
-            <li> Dig into publications on natural language processing have evolved over the years</li>
-        </ul>
-        """
-    )
+    mo.md(r"""
+    <p> I remember when I first learnt about DuckDB, it was a gamechanger — I used to load the data I wanted to work on to a database software like MS SQL Server, and then build a bridge to an IDE with the language I wanted to use like Python, or R; it was quite the hassle. DuckDB changed my whole world — now I could just import the data file into the IDE, or notebook, make a duckdb connection, and there we go! But then, I realized I didn't even need the step of first importing the file using python. I could just query the csv file directly using SQL through a DuckDB connection.</p>
+
+    ##Introduction
+    <p> I found this dataset on the evolution of AI research by discipline from <a href= "https://oecd.ai/en/data?selectedArea=ai-research&selectedVisualization=16731"> OECD</a>, and it piqued my interest. I feel like publications in natural language processing drastically jumped in the mid 2010s, and I'm excited to find out if that's the case. </p>
+
+    <p> In this notebook, we'll: </p>
+    <ul>
+        <li> Import the CSV file into the notebook</li>
+        <li> Create another table within the database based on the CSV</li>
+        <li> Dig into publications on natural language processing have evolved over the years</li>
+    </ul>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""##Load the CSV""")
+    mo.md(r"""
+    ##Load the CSV
+    """)
     return
 
 
@@ -67,7 +69,9 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""##Create Another Table""")
+    mo.md(r"""
+    ##Create Another Table
+    """)
     return
 
 
@@ -80,11 +84,11 @@ def _(mo):
             SELECT Year, Concept, publications FROM "https://raw.githubusercontent.com/Mustjaab/Loading_CSVs_in_DuckDB/refs/heads/main/AI_Research_Data.csv"
         """
     )
-    return Discipline_Analysis, Domain_Analysis
+    return
 
 
 @app.cell
-def _(Domain_Analysis, mo):
+def _(mo):
     Analysis = mo.sql(
         f"""
         SELECT * 
@@ -93,11 +97,11 @@ def _(Domain_Analysis, mo):
         ORDER BY Year
         """
     )
-    return (Analysis,)
+    return
 
 
 @app.cell
-def _(Domain_Analysis, mo):
+def _(mo):
     _df = mo.sql(
         f"""
         SELECT 
@@ -111,7 +115,7 @@ def _(Domain_Analysis, mo):
 
 
 @app.cell
-def _(Domain_Analysis, mo):
+def _(mo):
     NLP_Analysis = mo.sql(
         f"""
         SELECT 
@@ -137,21 +141,23 @@ def _(NLP_Analysis, px):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""<p> We can see there's a significant increase in NLP publications 2020 and onwards which definitely makes sense provided the rapid emergence of commercial large language models, and AI assistants. </p>""")
+    mo.md(r"""
+    <p> We can see there's a significant increase in NLP publications 2020 and onwards which definitely makes sense provided the rapid emergence of commercial large language models, and AI assistants. </p>
+    """)
+    return
+
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ##Conclusion
-        <p> In this notebook, we learned how to:</p> 
-        <ul>
-            <li> Load a CSV into DuckDB </li>
-            <li> Create other tables using the imported CSV </li>
-            <li> Seamlessly analyze and visualize data between SQL, and Python cells</li>
-        </ul>
-        """
-    )
+    mo.md(r"""
+    ##Conclusion
+    <p> In this notebook, we learned how to:</p>
+    <ul>
+        <li> Load a CSV into DuckDB </li>
+        <li> Create other tables using the imported CSV </li>
+        <li> Seamlessly analyze and visualize data between SQL, and Python cells</li>
+    </ul>
+    """)
     return
 
 
@@ -159,7 +165,7 @@ def _(mo):
 def _():
     import pyarrow
     import polars
-    return polars, pyarrow
+    return
 
 
 @app.cell

duckdb/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # Learn DuckDB
 
 _🚧 This collection is a work in progress. Please help us add notebooks!_

functional_programming/05_functors.py

@@ -7,102 +7,98 @@
 
 import marimo
 
-__generated_with = "0.12.8"
+__generated_with = "0.18.4"
 app = marimo.App(app_title="Category Theory and Functors")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Category Theory and Functors
+    mo.md("""
+    # Category Theory and Functors
 
-        In this notebook, you will learn:
+    In this notebook, you will learn:
 
-        * Why `length` is a *functor* from the category of `list concatenation` to the category of `integer addition`
-        * How to *lift* an ordinary function into a specific *computational context*
-        * How to write an *adapter* between two categories
+    * Why `length` is a *functor* from the category of `list concatenation` to the category of `integer addition`
+    * How to *lift* an ordinary function into a specific *computational context*
+    * How to write an *adapter* between two categories
 
-        In short, a mathematical functor is a **mapping** between two categories in category theory. In practice, a functor represents a type that can be mapped over.
+    In short, a mathematical functor is a **mapping** between two categories in category theory. In practice, a functor represents a type that can be mapped over.
 
-        /// admonition | Intuitions 
+    /// admonition | Intuitions
 
-        - A simple intuition is that a `Functor` represents a **container** of values, along with the ability to apply a function uniformly to every element in the container.
-        - Another intuition is that a `Functor` represents some sort of **computational context**.
-        - Mathematically, `Functors` generalize the idea of a container or a computational context.
-        ///
+    - A simple intuition is that a `Functor` represents a **container** of values, along with the ability to apply a function uniformly to every element in the container.
+    - Another intuition is that a `Functor` represents some sort of **computational context**.
+    - Mathematically, `Functors` generalize the idea of a container or a computational context.
+    ///
 
-        We will start with intuition, introduce the basics of category theory, and then examine functors from a categorical perspective.
+    We will start with intuition, introduce the basics of category theory, and then examine functors from a categorical perspective.
 
-        /// details | Notebook metadata
-            type: info
+    /// details | Notebook metadata
+        type: info
 
-        version: 0.1.5 | last modified: 2025-04-11 | author: [métaboulie](https://github.com/metaboulie)<br/>
-        reviewer: [Haleshot](https://github.com/Haleshot)
+    version: 0.1.5 | last modified: 2025-04-11 | author: [métaboulie](https://github.com/metaboulie)<br/>
+    reviewer: [Haleshot](https://github.com/Haleshot)
 
-        ///
-        """
-    )
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Functor as a Computational Context
+    mo.md("""
+    # Functor as a Computational Context
 
-        A [**Functor**](https://wiki.haskell.org/Functor) is an abstraction that represents a computational context with the ability to apply a function to every value inside it without altering the structure of the context itself. This enables transformations while preserving the shape of the data.
+    A [**Functor**](https://wiki.haskell.org/Functor) is an abstraction that represents a computational context with the ability to apply a function to every value inside it without altering the structure of the context itself. This enables transformations while preserving the shape of the data.
 
-        To understand this, let's look at a simple example.
+    To understand this, let's look at a simple example.
 
-        ## [The One-Way Wrapper Design Pattern](http://blog.sigfpe.com/2007/04/trivial-monad.html)
+    ## [The One-Way Wrapper Design Pattern](http://blog.sigfpe.com/2007/04/trivial-monad.html)
 
-        Often, we need to wrap data in some kind of context. However, when performing operations on wrapped data, we typically have to:
+    Often, we need to wrap data in some kind of context. However, when performing operations on wrapped data, we typically have to:
 
-        1. Unwrap the data.
-        2. Modify the unwrapped data.
-        3. Rewrap the modified data.
+    1. Unwrap the data.
+    2. Modify the unwrapped data.
+    3. Rewrap the modified data.
 
-        This process is tedious and inefficient. Instead, we want to wrap data **once** and apply functions directly to the wrapped data without unwrapping it.
+    This process is tedious and inefficient. Instead, we want to wrap data **once** and apply functions directly to the wrapped data without unwrapping it.
 
-        /// admonition | Rules for a One-Way Wrapper
+    /// admonition | Rules for a One-Way Wrapper
 
-        1. We can wrap values, but we cannot unwrap them.
-        2. We should still be able to apply transformations to the wrapped data.
-        3. Any operation that depends on wrapped data should itself return a wrapped result.
-        ///
+    1. We can wrap values, but we cannot unwrap them.
+    2. We should still be able to apply transformations to the wrapped data.
+    3. Any operation that depends on wrapped data should itself return a wrapped result.
+    ///
 
-        Let's define such a `Wrapper` class:
+    Let's define such a `Wrapper` class:
 
-        ```python
-        from dataclasses import dataclass
-        from typing import TypeVar
+    ```python
+    from dataclasses import dataclass
+    from typing import TypeVar
 
-        A = TypeVar("A")
-        B = TypeVar("B")
+    A = TypeVar("A")
+    B = TypeVar("B")
 
-        @dataclass
-        class Wrapper[A]:
-            value: A
-        ```
+    @dataclass
+    class Wrapper[A]:
+        value: A
+    ```
 
-        Now, we can create an instance of wrapped data:
+    Now, we can create an instance of wrapped data:
 
-        ```python
-        wrapped = Wrapper(1)
-        ```
+    ```python
+    wrapped = Wrapper(1)
+    ```
 
-        ### Mapping Functions Over Wrapped Data
+    ### Mapping Functions Over Wrapped Data
 
-        To modify wrapped data while keeping it wrapped, we define an `fmap` method:
-        """
-    )
+    To modify wrapped data while keeping it wrapped, we define an `fmap` method:
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(A, B, Callable, Functor, dataclass):
     @dataclass
     class Wrapper[A](Functor):
         value: A
@@ -115,26 +111,24 @@ def _(B, Callable, Functor, dataclass):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// attention
+    mo.md(r"""
+    /// attention
 
-        To distinguish between regular types and functors, we use the prefix `f` to indicate `Functor`.
+    To distinguish between regular types and functors, we use the prefix `f` to indicate `Functor`.
 
-        For instance,
+    For instance,
 
-        - `a: A` is a regular variable of type `A`
-        - `g: Callable[[A], B]` is a regular function from type `A` to `B`
-        - `fa: Functor[A]` is a *Functor* wrapping a value of type `A`  
-        - `fg: Functor[Callable[[A], B]]` is a *Functor* wrapping a function from type `A` to `B`  
+    - `a: A` is a regular variable of type `A`
+    - `g: Callable[[A], B]` is a regular function from type `A` to `B`
+    - `fa: Functor[A]` is a *Functor* wrapping a value of type `A`
+    - `fg: Functor[Callable[[A], B]]` is a *Functor* wrapping a function from type `A` to `B`
 
-        and we will avoid using `f` to represent a function
+    and we will avoid using `f` to represent a function
 
-        ///
+    ///
 
-        > Try with Wrapper below
-        """
-    )
+    > Try with Wrapper below
+    """)
     return
 
 
@@ -149,46 +143,42 @@ def _(Wrapper, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        We can analyze the type signature of `fmap` for `Wrapper`:
+    mo.md("""
+    We can analyze the type signature of `fmap` for `Wrapper`:
 
-        * `g` is of type `Callable[[A], B]`
-        * `fa` is of type `Wrapper[A]`
-        * The return value is of type `Wrapper[B]`
+    * `g` is of type `Callable[[A], B]`
+    * `fa` is of type `Wrapper[A]`
+    * The return value is of type `Wrapper[B]`
 
-        Thus, in Python's type system, we can express the type signature of `fmap` as:
+    Thus, in Python's type system, we can express the type signature of `fmap` as:
 
-        ```python
-        fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]:
-        ```
+    ```python
+    fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]:
+    ```
 
-        Essentially, `fmap`:
+    Essentially, `fmap`:
 
-        1. Takes a function `Callable[[A], B]` and a `Wrapper[A]` instance as input.
-        2. Applies the function to the value inside the wrapper.
-        3. Returns a new `Wrapper[B]` instance with the transformed value, leaving the original wrapper and its internal data unmodified.
+    1. Takes a function `Callable[[A], B]` and a `Wrapper[A]` instance as input.
+    2. Applies the function to the value inside the wrapper.
+    3. Returns a new `Wrapper[B]` instance with the transformed value, leaving the original wrapper and its internal data unmodified.
 
-        Now, let's examine `list` as a similar kind of wrapper.
-        """
-    )
+    Now, let's examine `list` as a similar kind of wrapper.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## The List Functor
+    mo.md("""
+    ## The List Functor
 
-        We can define a `List` class to represent a wrapped list that supports `fmap`:
-        """
-    )
+    We can define a `List` class to represent a wrapped list that supports `fmap`:
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(A, B, Callable, Functor, dataclass):
     @dataclass
     class List[A](Functor):
         value: list[A]
@@ -201,7 +191,9 @@ def _(B, Callable, Functor, dataclass):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""> Try with List below""")
+    mo.md(r"""
+    > Try with List below
+    """)
     return
 
 
@@ -215,114 +207,106 @@ def _(List, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Extracting the Type of `fmap`
+    mo.md("""
+    ### Extracting the Type of `fmap`
 
-        The type signature of `fmap` for `List` is:
+    The type signature of `fmap` for `List` is:
 
-        ```python
-        fmap(g: Callable[[A], B], fa: List[A]) -> List[B]
-        ```
+    ```python
+    fmap(g: Callable[[A], B], fa: List[A]) -> List[B]
+    ```
 
-        Similarly, for `Wrapper`:
+    Similarly, for `Wrapper`:
 
-        ```python
-        fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]
-        ```
+    ```python
+    fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]
+    ```
 
-        Both follow the same pattern, which we can generalize as:
+    Both follow the same pattern, which we can generalize as:
 
-        ```python
-        fmap(g: Callable[[A], B], fa: Functor[A]) -> Functor[B]
-        ```
+    ```python
+    fmap(g: Callable[[A], B], fa: Functor[A]) -> Functor[B]
+    ```
 
-        where `Functor` can be `Wrapper`, `List`, or any other wrapper type that follows the same structure.
+    where `Functor` can be `Wrapper`, `List`, or any other wrapper type that follows the same structure.
 
-        ### Functors in Haskell (optional)
+    ### Functors in Haskell (optional)
 
-        In Haskell, the type of `fmap` is:
+    In Haskell, the type of `fmap` is:
 
-        ```haskell
-        fmap :: Functor f => (a -> b) -> f a -> f b
-        ```
+    ```haskell
+    fmap :: Functor f => (a -> b) -> f a -> f b
+    ```
 
-        or equivalently:
+    or equivalently:
 
-        ```haskell
-        fmap :: Functor f => (a -> b) -> (f a -> f b)
-        ```
+    ```haskell
+    fmap :: Functor f => (a -> b) -> (f a -> f b)
+    ```
 
-        This means that `fmap` **lifts** an ordinary function into the **functor world**, allowing it to operate within a computational context.
+    This means that `fmap` **lifts** an ordinary function into the **functor world**, allowing it to operate within a computational context.
 
-        Now, let's define an abstract class for `Functor`.
-        """
-    )
+    Now, let's define an abstract class for `Functor`.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Defining Functor
+    mo.md("""
+    ## Defining Functor
 
-        Recall that, a **Functor** is an abstraction that allows us to apply a function to values inside a computational context while preserving its structure. 
+    Recall that, a **Functor** is an abstraction that allows us to apply a function to values inside a computational context while preserving its structure.
 
-        To define `Functor` in Python, we use an abstract base class:
+    To define `Functor` in Python, we use an abstract base class:
 
-        ```python
-        @dataclass
-        class Functor[A](ABC):
-            @classmethod
-            @abstractmethod
-            def fmap(g: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
-                raise NotImplementedError
-        ```
+    ```python
+    @dataclass
+    class Functor[A](ABC):
+        @classmethod
+        @abstractmethod
+        def fmap(g: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
+            raise NotImplementedError
+    ```
 
-        We can now extend custom wrappers, containers, or computation contexts with this `Functor` base class, implement the `fmap` method, and apply any function.
-        """
-    )
+    We can now extend custom wrappers, containers, or computation contexts with this `Functor` base class, implement the `fmap` method, and apply any function.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # More Functor instances (optional)
+    mo.md(r"""
+    # More Functor instances (optional)
 
-        In this section, we will explore more *Functor* instances to help you build up a better comprehension.
+    In this section, we will explore more *Functor* instances to help you build up a better comprehension.
 
-        The main reference is [Data.Functor](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Functor.html)
-        """
-    )
+    The main reference is [Data.Functor](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Functor.html)
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The [Maybe](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Maybe.html#t:Maybe) Functor
+    mo.md(r"""
+    ## The [Maybe](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Maybe.html#t:Maybe) Functor
 
-        **`Maybe`** is a functor that can either hold a value (`Just(value)`) or be `Nothing` (equivalent to `None` in Python). 
+    **`Maybe`** is a functor that can either hold a value (`Just(value)`) or be `Nothing` (equivalent to `None` in Python).
 
-        - It the value exists, `fmap` applies the function to this value inside the functor.
-        - If the value is `None`, `fmap` simply returns `None`.
+    - It the value exists, `fmap` applies the function to this value inside the functor.
+    - If the value is `None`, `fmap` simply returns `None`.
 
-        /// admonition
-        By using `Maybe` as a functor, we gain the ability to apply transformations (`fmap`) to potentially absent values, without having to explicitly handle the `None` case every time.
-        ///
+    /// admonition
+    By using `Maybe` as a functor, we gain the ability to apply transformations (`fmap`) to potentially absent values, without having to explicitly handle the `None` case every time.
+    ///
 
-        We can implement the `Maybe` functor as:
-        """
-    )
+    We can implement the `Maybe` functor as:
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(A, B, Callable, Functor, dataclass):
     @dataclass
     class Maybe[A](Functor):
         value: None | A
@@ -345,24 +329,22 @@ def _(Maybe, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The [Either](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Either.html#t:Either) Functor
+    mo.md(r"""
+    ## The [Either](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Either.html#t:Either) Functor
 
-        The `Either` type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.
+    The `Either` type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.
 
-        The `Either` type is sometimes used to represent a value which is **either correct or an error**; by convention, the `left` attribute is used to hold an error value and the `right` attribute is used to hold a correct value.
+    The `Either` type is sometimes used to represent a value which is **either correct or an error**; by convention, the `left` attribute is used to hold an error value and the `right` attribute is used to hold a correct value.
 
-        `fmap` for `Either` will ignore Left values, but will apply the supplied function to values contained in the Right.
+    `fmap` for `Either` will ignore Left values, but will apply the supplied function to values contained in the Right.
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, Union, dataclass):
+def _(A, B, Callable, Functor, Union, dataclass):
     @dataclass
     class Either[A](Functor):
         left: A = None
@@ -400,29 +382,27 @@ def _(Either):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## The [RoseTree](https://en.wikipedia.org/wiki/Rose_tree) Functor
+    mo.md("""
+    ## The [RoseTree](https://en.wikipedia.org/wiki/Rose_tree) Functor
 
-        A **RoseTree** is a tree where:
+    A **RoseTree** is a tree where:
 
-        - Each node holds a **value**.
-        - Each node has a **list of child nodes** (which are also RoseTrees).
+    - Each node holds a **value**.
+    - Each node has a **list of child nodes** (which are also RoseTrees).
 
-        This structure is useful for representing hierarchical data, such as:
+    This structure is useful for representing hierarchical data, such as:
 
-        - Abstract Syntax Trees (ASTs)
-        - File system directories
-        - Recursive computations
+    - Abstract Syntax Trees (ASTs)
+    - File system directories
+    - Recursive computations
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(A, B, Callable, Functor, dataclass):
     @dataclass
     class RoseTree[A](Functor):
         value: A  # The value stored in the node.
@@ -459,34 +439,32 @@ def _(RoseTree, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Generic Functions that can be Used with Any Functor
+    mo.md("""
+    ## Generic Functions that can be Used with Any Functor
 
-        One of the powerful features of functors is that we can write **generic functions** that can work with any functor.
+    One of the powerful features of functors is that we can write **generic functions** that can work with any functor.
 
-        Remember that in Haskell, the type of `fmap` can be written as:
+    Remember that in Haskell, the type of `fmap` can be written as:
 
-        ```haskell
-        fmap :: Functor f => (a -> b) -> (f a -> f b)
-        ```
+    ```haskell
+    fmap :: Functor f => (a -> b) -> (f a -> f b)
+    ```
 
-        Translating to Python, we get:
+    Translating to Python, we get:
 
-        ```python
-        def fmap(g: Callable[[A], B]) -> Callable[[Functor[A]], Functor[B]]
-        ```
+    ```python
+    def fmap(g: Callable[[A], B]) -> Callable[[Functor[A]], Functor[B]]
+    ```
 
-        This means that `fmap`:
+    This means that `fmap`:
 
-        - Takes an **ordinary function** `Callable[[A], B]` as input.
-        - Outputs a function that:
-            - Takes a **functor** of type `Functor[A]` as input.
-            - Outputs a **functor** of type `Functor[B]`.
+    - Takes an **ordinary function** `Callable[[A], B]` as input.
+    - Outputs a function that:
+        - Takes a **functor** of type `Functor[A]` as input.
+        - Outputs a **functor** of type `Functor[B]`.
 
-        Inspired by this, we can implement an `inc` function which takes a functor, applies the function `lambda x: x + 1` to every value inside it, and returns a new functor with the updated values.
-        """
-    )
+    Inspired by this, we can implement an `inc` function which takes a functor, applies the function `lambda x: x + 1` to every value inside it, and returns a new functor with the updated values.
+    """)
     return
 
 
@@ -506,55 +484,51 @@ def _(flist, inc, pp, rosetree, wrapper):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// admonition | exercise
-        Implement other generic functions and apply them to different *Functor* instances.
-        ///
-        """
-    )
+    mo.md(r"""
+    /// admonition | exercise
+    Implement other generic functions and apply them to different *Functor* instances.
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# Functor laws and utility functions""")
+    mo.md(r"""
+    # Functor laws and utility functions
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Functor laws
+    mo.md("""
+    ## Functor laws
 
-        In addition to providing a function `fmap` of the specified type, functors are also required to satisfy two equational laws:
+    In addition to providing a function `fmap` of the specified type, functors are also required to satisfy two equational laws:
 
-        ```haskell
-        fmap id = id                    -- fmap preserves identity
-        fmap (g . h) = fmap g . fmap h  -- fmap distributes over composition
-        ```
+    ```haskell
+    fmap id = id                    -- fmap preserves identity
+    fmap (g . h) = fmap g . fmap h  -- fmap distributes over composition
+    ```
 
-        1. `fmap` should preserve the **identity function**, in the sense that applying `fmap` to this function returns the same function as the result.
-        2. `fmap` should also preserve **function composition**. Applying two composed functions `g` and `h` to a functor via `fmap` should give the same result as first applying `fmap` to `g` and then applying `fmap` to `h`.
+    1. `fmap` should preserve the **identity function**, in the sense that applying `fmap` to this function returns the same function as the result.
+    2. `fmap` should also preserve **function composition**. Applying two composed functions `g` and `h` to a functor via `fmap` should give the same result as first applying `fmap` to `g` and then applying `fmap` to `h`.
 
-        /// admonition | 
-        - Any `Functor` instance satisfying the first law `(fmap id = id)` will [automatically satisfy the second law](https://github.com/quchen/articles/blob/master/second_functor_law.md) as well.
-        ///
-        """
-    )
+    /// admonition |
+    - Any `Functor` instance satisfying the first law `(fmap id = id)` will [automatically satisfy the second law](https://github.com/quchen/articles/blob/master/second_functor_law.md) as well.
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Functor laws verification
+    mo.md(r"""
+    ### Functor laws verification
 
-        We can define `id` and `compose` in `Python` as:
-        """
-    )
+    We can define `id` and `compose` in `Python` as:
+    """)
     return
 
 
@@ -562,12 +536,14 @@ def _(mo):
 def _():
     id = lambda x: x
     compose = lambda f, g: lambda x: f(g(x))
-    return compose, id
+    return (id,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can add a helper function `check_functor_law` to verify that an instance satisfies the functor laws:""")
+    mo.md(r"""
+    We can add a helper function `check_functor_law` to verify that an instance satisfies the functor laws:
+    """)
     return
 
 
@@ -581,7 +557,9 @@ def _(id):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can verify the functor we've defined:""")
+    mo.md(r"""
+    We can verify the functor we've defined:
+    """)
     return
 
 
@@ -589,17 +567,19 @@ def _(mo):
 def _(check_functor_law, flist, pp, rosetree, wrapper):
     for functor in (wrapper, flist, rosetree):
         pp(check_functor_law(functor))
-    return (functor,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.""")
+    mo.md("""
+    And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.
+    """)
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(A, B, Callable, Functor, dataclass):
     @dataclass
     class EvilFunctor[A](Functor):
         value: list[A]
@@ -624,31 +604,29 @@ def _(EvilFunctor, check_functor_law, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Utility functions
-
-        ```python
-        @classmethod
-        def const(cls, fa: "Functor[A]", b: B) -> "Functor[B]":
-            return cls.fmap(lambda _: b, fa)
-
-        @classmethod
-        def void(cls, fa: "Functor[A]") -> "Functor[None]":
-            return cls.const(fa, None)
-
-        @classmethod
-        def unzip(
-            cls, fab: "Functor[tuple[A, B]]"
-        ) -> tuple["Functor[A]", "Functor[B]"]:
-            return cls.fmap(lambda p: p[0], fab), cls.fmap(lambda p: p[1], fab)
-        ```
-
-        - `const` replaces all values inside a functor with a constant `b`
-        - `void` is equivalent to `const(fa, None)`, transforming all values in a functor into `None`
-        - `unzip` is a generalization of the regular *unzip* on a list of pairs
-        """
-    )
+    mo.md(r"""
+    ## Utility functions
+
+    ```python
+    @classmethod
+    def const(cls, fa: "Functor[A]", b: B) -> "Functor[B]":
+        return cls.fmap(lambda _: b, fa)
+
+    @classmethod
+    def void(cls, fa: "Functor[A]") -> "Functor[None]":
+        return cls.const(fa, None)
+
+    @classmethod
+    def unzip(
+        cls, fab: "Functor[tuple[A, B]]"
+    ) -> tuple["Functor[A]", "Functor[B]"]:
+        return cls.fmap(lambda p: p[0], fab), cls.fmap(lambda p: p[1], fab)
+    ```
+
+    - `const` replaces all values inside a functor with a constant `b`
+    - `void` is equivalent to `const(fa, None)`, transforming all values in a functor into `None`
+    - `unzip` is a generalization of the regular *unzip* on a list of pairs
+    """)
     return
 
 
@@ -676,13 +654,11 @@ def _(List, Maybe):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// admonition
-        You can always override these utility functions with a more efficient implementation for specific instances.
-        ///
-        """
-    )
+    mo.md(r"""
+    /// admonition
+    You can always override these utility functions with a more efficient implementation for specific instances.
+    ///
+    """)
     return
 
 
@@ -697,7 +673,9 @@ def _(List, RoseTree, flist, pp, rosetree):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""# Formal implementation of Functor""")
+    mo.md("""
+    # Formal implementation of Functor
+    """)
     return
 
 
@@ -728,291 +706,275 @@ def _(ABC, B, Callable, abstractmethod, dataclass):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Limitations of Functor
+    mo.md("""
+    ## Limitations of Functor
 
-        Functors abstract the idea of mapping a function over each element of a structure. Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
+    Functors abstract the idea of mapping a function over each element of a structure. Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
 
-        ```haskell
-        fmap0 :: a -> f a
+    ```haskell
+    fmap0 :: a -> f a
 
-        fmap1 :: (a -> b) -> f a -> f b
+    fmap1 :: (a -> b) -> f a -> f b
 
-        fmap2 :: (a -> b -> c) -> f a -> f b -> f c
+    fmap2 :: (a -> b -> c) -> f a -> f b -> f c
 
-        fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
-        ```
+    fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+    ```
 
-        And we have to declare a special version of the functor class for each case.
+    And we have to declare a special version of the functor class for each case.
 
-        We will learn how to resolve this problem in the next notebook on `Applicatives`.
-        """
-    )
+    We will learn how to resolve this problem in the next notebook on `Applicatives`.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Introduction to Categories
+    mo.md("""
+    # Introduction to Categories
 
-        A [category](https://en.wikibooks.org/wiki/Haskell/Category_theory#Introduction_to_categories) is, in essence, a simple collection. It has three components: 
+    A [category](https://en.wikibooks.org/wiki/Haskell/Category_theory#Introduction_to_categories) is, in essence, a simple collection. It has three components:
 
-        - A collection of **objects**.
-        - A collection of **morphisms**, each of which ties two objects (a _source object_ and a _target object_) together. If $f$ is a morphism with source object $C$ and target object $B$, we write $f : C → B$.
-        - A notion of **composition** of these morphisms. If $g : A → B$ and $f : B → C$ are two morphisms, they can be composed, resulting in a morphism $f ∘ g : A → C$.
+    - A collection of **objects**.
+    - A collection of **morphisms**, each of which ties two objects (a _source object_ and a _target object_) together. If $f$ is a morphism with source object $C$ and target object $B$, we write $f : C → B$.
+    - A notion of **composition** of these morphisms. If $g : A → B$ and $f : B → C$ are two morphisms, they can be composed, resulting in a morphism $f ∘ g : A → C$.
 
-        ## Category laws
+    ## Category laws
 
-        There are three laws that categories need to follow. 
+    There are three laws that categories need to follow.
 
-        1. The composition of morphisms needs to be **associative**. Symbolically, $f ∘ (g ∘ h) = (f ∘ g) ∘ h$
+    1. The composition of morphisms needs to be **associative**. Symbolically, $f ∘ (g ∘ h) = (f ∘ g) ∘ h$
 
-            - Morphisms are applied right to left, so with $f ∘ g$ first $g$ is applied, then $f$. 
+        - Morphisms are applied right to left, so with $f ∘ g$ first $g$ is applied, then $f$.
 
-        2. The category needs to be **closed** under the composition operation. So if $f : B → C$ and $g : A → B$, then there must be some morphism $h : A → C$ in the category such that $h = f ∘ g$. 
+    2. The category needs to be **closed** under the composition operation. So if $f : B → C$ and $g : A → B$, then there must be some morphism $h : A → C$ in the category such that $h = f ∘ g$.
 
-        3. Given a category $C$ there needs to be for every object $A$ an **identity** morphism, $id_A : A → A$ that is an identity of composition with other morphisms. Put precisely, for every morphism $g : A → B$: $g ∘ id_A = id_B ∘ g = g$
+    3. Given a category $C$ there needs to be for every object $A$ an **identity** morphism, $id_A : A → A$ that is an identity of composition with other morphisms. Put precisely, for every morphism $g : A → B$: $g ∘ id_A = id_B ∘ g = g$
 
-        /// attention | The definition of a category does not define: 
+    /// attention | The definition of a category does not define:
 
-        - what `∘` is,
-        - what `id` is, or
-        - what `f`, `g`, and `h` might be. 
+    - what `∘` is,
+    - what `id` is, or
+    - what `f`, `g`, and `h` might be.
 
-        Instead, category theory leaves it up to us to discover what they might be.
-        ///
-        """
-    )
+    Instead, category theory leaves it up to us to discover what they might be.
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## The Python category
-
-        The main category we'll be concerning ourselves with in this part is the Python category, or we can give it a shorter name: `Py`. `Py` treats Python types as objects and Python functions as morphisms. A function `def f(a: A) -> B` for types A and B is a morphism in Python.
-
-        Remember that we defined the `id` and `compose` function above as:
-
-        ```Python
-        def id(x: A) -> A:
-            return x
-
-        def compose(f: Callable[[B], C], g: Callable[[A], B]) -> Callable[[A], C]:
-            return lambda x: f(g(x))  
-        ```
-
-        We can check second law easily. 
-
-        For the first law, we have:
-
-        ```python
-        # compose(f, g) = lambda x: f(g(x))
-        f ∘ (g ∘ h) 
-        = compose(f, compose(g, h)) 
-        = lambda x: f(compose(g, h)(x))
-        = lambda x: f(lambda y: g(h(y))(x))
-        = lambda x: f(g(h(x)))
-
-        (f ∘ g) ∘ h 
-        = compose(compose(f, g), h)
-        = lambda x: compose(f, g)(h(x))
-        = lambda x: lambda y: f(g(y))(h(x))
-        = lambda x: f(g(h(x)))
-        ```
-
-        For the third law, we have: 
-
-        ```python
-        g ∘ id_A 
-        = compose(g: Callable[[a], b], id: Callable[[a], a]) -> Callable[[a], b]
-        = lambda x: g(id(x))
-        = lambda x: g(x) # id(x) = x
-        = g
-        ```
-        the similar proof can be applied to $id_B ∘ g =g$.
-
-        Thus `Py` is a valid category.
-        """
-    )
+    mo.md("""
+    ## The Python category
+
+    The main category we'll be concerning ourselves with in this part is the Python category, or we can give it a shorter name: `Py`. `Py` treats Python types as objects and Python functions as morphisms. A function `def f(a: A) -> B` for types A and B is a morphism in Python.
+
+    Remember that we defined the `id` and `compose` function above as:
+
+    ```Python
+    def id(x: A) -> A:
+        return x
+
+    def compose(f: Callable[[B], C], g: Callable[[A], B]) -> Callable[[A], C]:
+        return lambda x: f(g(x))
+    ```
+
+    We can check second law easily.
+
+    For the first law, we have:
+
+    ```python
+    # compose(f, g) = lambda x: f(g(x))
+    f ∘ (g ∘ h)
+    = compose(f, compose(g, h))
+    = lambda x: f(compose(g, h)(x))
+    = lambda x: f(lambda y: g(h(y))(x))
+    = lambda x: f(g(h(x)))
+
+    (f ∘ g) ∘ h
+    = compose(compose(f, g), h)
+    = lambda x: compose(f, g)(h(x))
+    = lambda x: lambda y: f(g(y))(h(x))
+    = lambda x: f(g(h(x)))
+    ```
+
+    For the third law, we have:
+
+    ```python
+    g ∘ id_A
+    = compose(g: Callable[[a], b], id: Callable[[a], a]) -> Callable[[a], b]
+    = lambda x: g(id(x))
+    = lambda x: g(x) # id(x) = x
+    = g
+    ```
+    the similar proof can be applied to $id_B ∘ g =g$.
+
+    Thus `Py` is a valid category.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Functors, again
+    mo.md("""
+    # Functors, again
 
-        A functor is essentially a transformation between categories, so given categories $C$ and $D$, a functor $F : C → D$:
+    A functor is essentially a transformation between categories, so given categories $C$ and $D$, a functor $F : C → D$:
 
-        - Maps any object $A$ in $C$ to $F ( A )$, in $D$.
-        - Maps morphisms $f : A → B$ in $C$ to $F ( f ) : F ( A ) → F ( B )$ in $D$.
+    - Maps any object $A$ in $C$ to $F ( A )$, in $D$.
+    - Maps morphisms $f : A → B$ in $C$ to $F ( f ) : F ( A ) → F ( B )$ in $D$.
 
-        /// admonition | 
+    /// admonition |
 
-        Endofunctors are functors from a category to itself.
+    Endofunctors are functors from a category to itself.
 
-        ///
-        """
-    )
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Functors on the category of Python
+    mo.md("""
+    ## Functors on the category of Python
 
-        Remember that a functor has two parts: it maps objects in one category to objects in another and morphisms in the first category to morphisms in the second. 
+    Remember that a functor has two parts: it maps objects in one category to objects in another and morphisms in the first category to morphisms in the second.
 
-        Functors in Python are from `Py` to `Func`, where `Func` is the subcategory of `Py` defined on just that functor's types. E.g. the RoseTree functor goes from `Py` to `RoseTree`, where `RoseTree` is the category containing only RoseTree types, that is, `RoseTree[T]` for any type `T`. The morphisms in `RoseTree` are functions defined on RoseTree types, that is, functions `Callable[[RoseTree[T]], RoseTree[U]]` for types `T`, `U`.
+    Functors in Python are from `Py` to `Func`, where `Func` is the subcategory of `Py` defined on just that functor's types. E.g. the RoseTree functor goes from `Py` to `RoseTree`, where `RoseTree` is the category containing only RoseTree types, that is, `RoseTree[T]` for any type `T`. The morphisms in `RoseTree` are functions defined on RoseTree types, that is, functions `Callable[[RoseTree[T]], RoseTree[U]]` for types `T`, `U`.
 
-        Recall the definition of `Functor`:
+    Recall the definition of `Functor`:
 
-        ```Python
-        @dataclass
-        class Functor[A](ABC)
-        ```
+    ```Python
+    @dataclass
+    class Functor[A](ABC)
+    ```
 
-        And RoseTree: 
+    And RoseTree:
 
-        ```Python
-        @dataclass
-        class RoseTree[A](Functor)
-        ```
+    ```Python
+    @dataclass
+    class RoseTree[A](Functor)
+    ```
 
-        **Here's the key part:** the _type constructor_ `RoseTree` takes any type `T` to a new type, `RoseTree[T]`. Also, `fmap` restricted to `RoseTree` types takes a function `Callable[[A], B]` to a function `Callable[[RoseTree[A]], RoseTree[B]]`.
+    **Here's the key part:** the _type constructor_ `RoseTree` takes any type `T` to a new type, `RoseTree[T]`. Also, `fmap` restricted to `RoseTree` types takes a function `Callable[[A], B]` to a function `Callable[[RoseTree[A]], RoseTree[B]]`.
 
-        But that's it. We've defined two parts, something that takes objects in `Py` to objects in another category (that of `RoseTree` types and functions defined on `RoseTree` types), and something that takes morphisms in `Py` to morphisms in this category. So `RoseTree` is a functor. 
+    But that's it. We've defined two parts, something that takes objects in `Py` to objects in another category (that of `RoseTree` types and functions defined on `RoseTree` types), and something that takes morphisms in `Py` to morphisms in this category. So `RoseTree` is a functor.
 
-        To sum up:
+    To sum up:
 
-        - We work in the category **Py** and its subcategories.  
-        - **Objects** are types (e.g., `int`, `str`, `list`).  
-        - **Morphisms** are functions (`Callable[[A], B]`).  
-        - **Things that take a type and return another type** are type constructors (`RoseTree[T]`).  
-        - **Things that take a function and return another function** are higher-order functions (`Callable[[Callable[[A], B]], Callable[[C], D]]`).  
-        - **Abstract base classes (ABC)** and duck typing provide a way to express polymorphism, capturing the idea that in category theory, structures are often defined over multiple objects at once.
-        """
-    )
+    - We work in the category **Py** and its subcategories.
+    - **Objects** are types (e.g., `int`, `str`, `list`).
+    - **Morphisms** are functions (`Callable[[A], B]`).
+    - **Things that take a type and return another type** are type constructors (`RoseTree[T]`).
+    - **Things that take a function and return another function** are higher-order functions (`Callable[[Callable[[A], B]], Callable[[C], D]]`).
+    - **Abstract base classes (ABC)** and duck typing provide a way to express polymorphism, capturing the idea that in category theory, structures are often defined over multiple objects at once.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Functor laws, again
+    mo.md("""
+    ## Functor laws, again
 
-        Once again there are a few axioms that functors have to obey. 
+    Once again there are a few axioms that functors have to obey.
 
-        1. Given an identity morphism $id_A$ on an object $A$, $F ( id_A )$ must be the identity morphism on $F ( A )$.:
+    1. Given an identity morphism $id_A$ on an object $A$, $F ( id_A )$ must be the identity morphism on $F ( A )$.:
 
-        $$F({id} _{A})={id} _{F(A)}$$
+    $$F({id} _{A})={id} _{F(A)}$$
 
-        3. Functors must distribute over morphism composition.
+    3. Functors must distribute over morphism composition.
 
-        $$F(f\circ g)=F(f)\circ F(g)$$
-        """
-    )
+    $$F(f\circ g)=F(f)\circ F(g)$$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        Remember that we defined the `id` and `compose` as 
-        ```python
-        id = lambda x: x
-        compose = lambda f, g: lambda x: f(g(x))
-        ```
-
-        We can define `fmap` as: 
-
-        ```python
-        fmap = lambda g, functor: functor.fmap(g, functor)  
-        ```
-
-        Let's prove that `fmap` is a functor.
-
-        First, let's define a `Category` for a specific `Functor`. We choose to define the `Category` for the `Wrapper` as `WrapperCategory` here for simplicity, but remember that `Wrapper` can be any `Functor`(i.e. `List`, `RoseTree`, `Maybe` and more):
-
-        We define `WrapperCategory` as:
-
-        ```python
-        @dataclass
-        class WrapperCategory:
-            @staticmethod
-            def id(wrapper: Wrapper[A]) -> Wrapper[A]:
-                return Wrapper(wrapper.value)
-
-            @staticmethod
-            def compose(
-                f: Callable[[Wrapper[B]], Wrapper[C]],
-                g: Callable[[Wrapper[A]], Wrapper[B]],
-                wrapper: Wrapper[A]
-            ) -> Callable[[Wrapper[A]], Wrapper[C]]:
-                return f(g(Wrapper(wrapper.value)))
-        ```
-
-        And `Wrapper` is:
-
-        ```Python
-        @dataclass
-        class Wrapper[A](Functor):
-            value: A
-
-            @classmethod
-            def fmap(cls, g: Callable[[A], B], fa: "Wrapper[A]") -> "Wrapper[B]":
-                return Wrapper(g(fa.value))
-        ```
-        """
-    )
+    mo.md("""
+    Remember that we defined the `id` and `compose` as
+    ```python
+    id = lambda x: x
+    compose = lambda f, g: lambda x: f(g(x))
+    ```
+
+    We can define `fmap` as:
+
+    ```python
+    fmap = lambda g, functor: functor.fmap(g, functor)
+    ```
+
+    Let's prove that `fmap` is a functor.
+
+    First, let's define a `Category` for a specific `Functor`. We choose to define the `Category` for the `Wrapper` as `WrapperCategory` here for simplicity, but remember that `Wrapper` can be any `Functor`(i.e. `List`, `RoseTree`, `Maybe` and more):
+
+    We define `WrapperCategory` as:
+
+    ```python
+    @dataclass
+    class WrapperCategory:
+        @staticmethod
+        def id(wrapper: Wrapper[A]) -> Wrapper[A]:
+            return Wrapper(wrapper.value)
+
+        @staticmethod
+        def compose(
+            f: Callable[[Wrapper[B]], Wrapper[C]],
+            g: Callable[[Wrapper[A]], Wrapper[B]],
+            wrapper: Wrapper[A]
+        ) -> Callable[[Wrapper[A]], Wrapper[C]]:
+            return f(g(Wrapper(wrapper.value)))
+    ```
+
+    And `Wrapper` is:
+
+    ```Python
+    @dataclass
+    class Wrapper[A](Functor):
+        value: A
+
+        @classmethod
+        def fmap(cls, g: Callable[[A], B], fa: "Wrapper[A]") -> "Wrapper[B]":
+            return Wrapper(g(fa.value))
+    ```
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        We can prove that:
-
-        ```python
-        fmap(id, wrapper)
-        = Wrapper.fmap(id, wrapper)
-        = Wrapper(id(wrapper.value))
-        = Wrapper(wrapper.value)
-        = WrapperCategory.id(wrapper)
-        ```
-        and:
-        ```python
-        fmap(compose(f, g), wrapper)
-        = Wrapper.fmap(compose(f, g), wrapper)
-        = Wrapper(compose(f, g)(wrapper.value))
-        = Wrapper(f(g(wrapper.value)))
-
-        WrapperCategory.compose(fmap(f, wrapper), fmap(g, wrapper), wrapper)
-        = fmap(f, wrapper)(fmap(g, wrapper)(wrapper))
-        = fmap(f, wrapper)(Wrapper.fmap(g, wrapper))
-        = fmap(f, wrapper)(Wrapper(g(wrapper.value)))
-        = Wrapper.fmap(f, Wrapper(g(wrapper.value)))
-        = Wrapper(f(Wrapper(g(wrapper.value)).value))
-        = Wrapper(f(g(wrapper.value)))  # Wrapper(g(wrapper.value)).value = g(wrapper.value)
-        ```
-
-        So our `Wrapper` is a valid `Functor`.
-
-        > Try validating functor laws for `Wrapper` below.
-        """
-    )
+    mo.md("""
+    We can prove that:
+
+    ```python
+    fmap(id, wrapper)
+    = Wrapper.fmap(id, wrapper)
+    = Wrapper(id(wrapper.value))
+    = Wrapper(wrapper.value)
+    = WrapperCategory.id(wrapper)
+    ```
+    and:
+    ```python
+    fmap(compose(f, g), wrapper)
+    = Wrapper.fmap(compose(f, g), wrapper)
+    = Wrapper(compose(f, g)(wrapper.value))
+    = Wrapper(f(g(wrapper.value)))
+
+    WrapperCategory.compose(fmap(f, wrapper), fmap(g, wrapper), wrapper)
+    = fmap(f, wrapper)(fmap(g, wrapper)(wrapper))
+    = fmap(f, wrapper)(Wrapper.fmap(g, wrapper))
+    = fmap(f, wrapper)(Wrapper(g(wrapper.value)))
+    = Wrapper.fmap(f, Wrapper(g(wrapper.value)))
+    = Wrapper(f(Wrapper(g(wrapper.value)).value))
+    = Wrapper(f(g(wrapper.value)))  # Wrapper(g(wrapper.value)).value = g(wrapper.value)
+    ```
+
+    So our `Wrapper` is a valid `Functor`.
+
+    > Try validating functor laws for `Wrapper` below.
+    """)
     return
 
 
@@ -1042,19 +1004,17 @@ def _(WrapperCategory, id, pp, wrapper):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Length as a Functor
+    mo.md("""
+    ## Length as a Functor
 
-        Remember that a functor is a transformation between two categories. It is not only limited to a functor from `Py` to `Func`, but also includes transformations between other mathematical structures.
+    Remember that a functor is a transformation between two categories. It is not only limited to a functor from `Py` to `Func`, but also includes transformations between other mathematical structures.
 
-        Let’s prove that **`length`** can be viewed as a functor. Specifically, we will demonstrate that `length` is a functor from the **category of list concatenation** to the **category of integer addition**.
+    Let’s prove that **`length`** can be viewed as a functor. Specifically, we will demonstrate that `length` is a functor from the **category of list concatenation** to the **category of integer addition**.
 
-        ### Category of List Concatenation
+    ### Category of List Concatenation
 
-        First, let’s define the category of list concatenation:
-        """
-    )
+    First, let’s define the category of list concatenation:
+    """)
     return
 
 
@@ -1078,24 +1038,20 @@ def _(A, dataclass):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        - **Identity**: The identity element is an empty list (`ListConcatenation([])`).
-        - **Composition**: The composition of two lists is their concatenation (`this.value + other.value`).
-        """
-    )
+    mo.md("""
+    - **Identity**: The identity element is an empty list (`ListConcatenation([])`).
+    - **Composition**: The composition of two lists is their concatenation (`this.value + other.value`).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Category of Integer Addition
+    mo.md("""
+    ### Category of Integer Addition
 
-        Now, let's define the category of integer addition:
-        """
-    )
+    Now, let's define the category of integer addition:
+    """)
     return
 
 
@@ -1117,28 +1073,24 @@ def _(dataclass):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        - **Identity**: The identity element is `IntAddition(0)` (the additive identity).
-        - **Composition**: The composition of two integers is their sum (`this.value + other.value`).
-        """
-    )
+    mo.md("""
+    - **Identity**: The identity element is `IntAddition(0)` (the additive identity).
+    - **Composition**: The composition of two integers is their sum (`this.value + other.value`).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Defining the Length Functor
+    mo.md("""
+    ### Defining the Length Functor
 
-        We now define the `length` function as a functor, mapping from the category of list concatenation to the category of integer addition:
+    We now define the `length` function as a functor, mapping from the category of list concatenation to the category of integer addition:
 
-        ```python
-        length = lambda l: IntAddition(len(l.value))
-        ```
-        """
-    )
+    ```python
+    length = lambda l: IntAddition(len(l.value))
+    ```
+    """)
     return
 
 
@@ -1150,23 +1102,23 @@ def _(IntAddition):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""This function takes an instance of `ListConcatenation`, computes its length, and returns an `IntAddition` instance with the computed length.""")
+    mo.md("""
+    This function takes an instance of `ListConcatenation`, computes its length, and returns an `IntAddition` instance with the computed length.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Verifying Functor Laws
+    mo.md("""
+    ### Verifying Functor Laws
 
-        Now, let’s verify that `length` satisfies the two functor laws.
+    Now, let’s verify that `length` satisfies the two functor laws.
 
-        **Identity Law**
+    **Identity Law**
 
-        The identity law states that applying the functor to the identity element of one category should give the identity element of the other category.
-        """
-    )
+    The identity law states that applying the functor to the identity element of one category should give the identity element of the other category.
+    """)
     return
 
 
@@ -1178,19 +1130,19 @@ def _(IntAddition, ListConcatenation, length, pp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""This ensures that the length of an empty list (identity in the `ListConcatenation` category) is `0` (identity in the `IntAddition` category).""")
+    mo.md("""
+    This ensures that the length of an empty list (identity in the `ListConcatenation` category) is `0` (identity in the `IntAddition` category).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        **Composition Law**
+    mo.md("""
+    **Composition Law**
 
-        The composition law states that the functor should preserve composition. Applying the functor to a composed element should be the same as composing the functor applied to the individual elements.
-        """
-    )
+    The composition law states that the functor should preserve composition. Applying the functor to a composed element should be the same as composing the functor applied to the individual elements.
+    """)
     return
 
 
@@ -1202,36 +1154,36 @@ def _(IntAddition, ListConcatenation, length, pp):
         length(ListConcatenation.compose(lista, listb))
         == IntAddition.compose(length(lista), length(listb))
     )
-    return lista, listb
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""This ensures that the length of the concatenation of two lists is the same as the sum of the lengths of the individual lists.""")
+    mo.md("""
+    This ensures that the length of the concatenation of two lists is the same as the sum of the lengths of the individual lists.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Bifunctor
+    mo.md(r"""
+    # Bifunctor
 
-        A `Bifunctor` is a type constructor that takes two type arguments and **is a functor in both arguments.** 
+    A `Bifunctor` is a type constructor that takes two type arguments and **is a functor in both arguments.**
 
-        For example, think about `Either`'s usual `Functor` instance. It only allows you to fmap over the second type parameter: `right` values get mapped, `left` values stay as they are.
+    For example, think about `Either`'s usual `Functor` instance. It only allows you to fmap over the second type parameter: `right` values get mapped, `left` values stay as they are.
 
-        However, its `Bifunctor` instance allows you to map both halves of the sum.
+    However, its `Bifunctor` instance allows you to map both halves of the sum.
 
-        There are three core methods for `Bifunctor`: 
+    There are three core methods for `Bifunctor`:
 
-        - `bimap` allows mapping over both type arguments at once.
-        - `first` and `second` are also provided for mapping over only one type argument at a time.
+    - `bimap` allows mapping over both type arguments at once.
+    - `first` and `second` are also provided for mapping over only one type argument at a time.
 
 
-        The abstraction of `Bifunctor` is: 
-        """
-    )
+    The abstraction of `Bifunctor` is:
+    """)
     return
 
 
@@ -1261,38 +1213,36 @@ def _(ABC, B, Callable, D, dataclass, f, id):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// admonition | minimal implementation requirement
-        - `bimap` or both `first` and `second`
-        ///
-        """
-    )
+    mo.md(r"""
+    /// admonition | minimal implementation requirement
+    - `bimap` or both `first` and `second`
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Instances of Bifunctor""")
+    mo.md(r"""
+    ## Instances of Bifunctor
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### The Either Bifunctor
+    mo.md(r"""
+    ### The Either Bifunctor
 
-        For the `Either Bifunctor`, we allow it to map a function over the `left` value as well.
+    For the `Either Bifunctor`, we allow it to map a function over the `left` value as well.
 
-        Notice that, the `Either Bifunctor`  still only contains the `left` value or the `right` value.
-        """
-    )
+    Notice that, the `Either Bifunctor`  still only contains the `left` value or the `right` value.
+    """)
     return
 
 
 @app.cell
-def _(B, Bifunctor, Callable, D, dataclass):
+def _(A, B, Bifunctor, C, Callable, D, dataclass):
     @dataclass
     class BiEither[A, C](Bifunctor):
         left: A = None
@@ -1334,18 +1284,16 @@ def _(BiEither):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### The 2d Tuple Bifunctor
+    mo.md(r"""
+    ### The 2d Tuple Bifunctor
 
-        For 2d tuples, we simply expect `bimap` to map 2 functions to the 2 elements in the tuple respectively.
-        """
-    )
+    For 2d tuples, we simply expect `bimap` to map 2 functions to the 2 elements in the tuple respectively.
+    """)
     return
 
 
 @app.cell
-def _(B, Bifunctor, Callable, D, dataclass):
+def _(A, B, Bifunctor, C, Callable, D, dataclass):
     @dataclass
     class BiTuple[A, C](Bifunctor):
         value: tuple[A, C]
@@ -1368,19 +1316,17 @@ def _(BiTuple):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Bifunctor laws
+    mo.md(r"""
+    ## Bifunctor laws
 
-        The only law we need to follow is
+    The only law we need to follow is
 
-        ```python
-        bimap(id, id, fa) == id(fa)
-        ```
+    ```python
+    bimap(id, id, fa) == id(fa)
+    ```
 
-        and then other laws are followed automatically.
-        """
-    )
+    and then other laws are followed automatically.
+    """)
     return
 
 
@@ -1394,24 +1340,22 @@ def _(BiEither, BiTuple, id):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Further reading
-
-        - [The Trivial Monad](http://blog.sigfpe.com/2007/04/trivial-monad.html)
-        - [Haskellforall: The Category Design Pattern](https://www.haskellforall.com/2012/08/the-category-design-pattern.html)
-        - [Haskellforall: The Functor Design Pattern](https://www.haskellforall.com/2012/09/the-functor-design-pattern.html)
-
-            /// attention | ATTENTION 
-            The functor design pattern doesn't work at all if you aren't using categories in the first place. This is why you should structure your tools using the compositional category design pattern so that you can take advantage of functors to easily mix your tools together. 
-            ///
-
-        - [Haskellwiki: Functor](https://wiki.haskell.org/index.php?title=Functor)
-        - [Haskellwiki: Typeclassopedia#Functor](https://wiki.haskell.org/index.php?title=Typeclassopedia#Functor)
-        - [Haskellwiki: Typeclassopedia#Category](https://wiki.haskell.org/index.php?title=Typeclassopedia#Category)
-        - [Haskellwiki: Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory)
-        """
-    )
+    mo.md("""
+    # Further reading
+
+    - [The Trivial Monad](http://blog.sigfpe.com/2007/04/trivial-monad.html)
+    - [Haskellforall: The Category Design Pattern](https://www.haskellforall.com/2012/08/the-category-design-pattern.html)
+    - [Haskellforall: The Functor Design Pattern](https://www.haskellforall.com/2012/09/the-functor-design-pattern.html)
+
+        /// attention | ATTENTION
+        The functor design pattern doesn't work at all if you aren't using categories in the first place. This is why you should structure your tools using the compositional category design pattern so that you can take advantage of functors to easily mix your tools together.
+        ///
+
+    - [Haskellwiki: Functor](https://wiki.haskell.org/index.php?title=Functor)
+    - [Haskellwiki: Typeclassopedia#Functor](https://wiki.haskell.org/index.php?title=Typeclassopedia#Functor)
+    - [Haskellwiki: Typeclassopedia#Category](https://wiki.haskell.org/index.php?title=Typeclassopedia#Category)
+    - [Haskellwiki: Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory)
+    """)
     return
 
 

functional_programming/06_applicatives.py

@@ -7,266 +7,261 @@
 
 import marimo
 
-__generated_with = "0.12.9"
+__generated_with = "0.18.4"
 app = marimo.App(app_title="Applicative programming with effects")
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # Applicative programming with effects
+def _(mo):
+    mo.md(r"""
+    # Applicative programming with effects
 
-        `Applicative Functor` encapsulates certain sorts of *effectful* computations in a functionally pure way, and encourages an *applicative* programming style.
+    `Applicative Functor` encapsulates certain sorts of *effectful* computations in a functionally pure way, and encourages an *applicative* programming style.
 
-        Applicative is a functor with application, providing operations to
+    Applicative is a functor with application, providing operations to
 
-        + embed pure expressions (`pure`), and
-        + sequence computations and combine their results (`apply`).
+    + embed pure expressions (`pure`), and
+    + sequence computations and combine their results (`apply`).
 
-        In this notebook, you will learn:
+    In this notebook, you will learn:
 
-        1. How to view `Applicative` as multi-functor intuitively.
-        2. How to use `lift` to simplify chaining application.
-        3. How to bring *effects* to the functional pure world.
-        4. How to view `Applicative` as a lax monoidal functor.
-        5. How to use `Alternative` to amalgamate multiple computations into a single computation.
+    1. How to view `Applicative` as multi-functor intuitively.
+    2. How to use `lift` to simplify chaining application.
+    3. How to bring *effects* to the functional pure world.
+    4. How to view `Applicative` as a lax monoidal functor.
+    5. How to use `Alternative` to amalgamate multiple computations into a single computation.
 
-        /// details | Notebook metadata
-            type: info
+    /// details | Notebook metadata
+        type: info
 
-        version: 0.1.3 | last modified: 2025-04-16 | author: [métaboulie](https://github.com/metaboulie)<br/>
-        reviewer: [Haleshot](https://github.com/Haleshot)
+    version: 0.1.3 | last modified: 2025-04-16 | author: [métaboulie](https://github.com/metaboulie)<br/>
+    reviewer: [Haleshot](https://github.com/Haleshot)
 
-        ///
-        """
-    )
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # The intuition: [Multifunctor](https://arxiv.org/pdf/2401.14286)
+def _(mo):
+    mo.md(r"""
+    # The intuition: [Multifunctor](https://arxiv.org/pdf/2401.14286)
 
-        ## Limitations of functor
+    ## Limitations of functor
 
-        Recall that functors abstract the idea of mapping a function over each element of a structure.
+    Recall that functors abstract the idea of mapping a function over each element of a structure.
 
-        Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
+    Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
 
-        ```haskell
-        fmap0 :: a -> f a
+    ```haskell
+    fmap0 :: a -> f a
 
-        fmap1 :: (a -> b) -> f a -> f b
+    fmap1 :: (a -> b) -> f a -> f b
 
-        fmap2 :: (a -> b -> c) -> f a -> f b -> f c
+    fmap2 :: (a -> b -> c) -> f a -> f b -> f c
 
-        fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
-        ```
+    fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+    ```
 
-        And we have to declare a special version of the functor class for each case.
-        """
-    )
+    And we have to declare a special version of the functor class for each case.
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Defining Multifunctor
-
-        /// admonition
-        we use prefix `f` rather than `ap` to indicate *Applicative Functor*
-        ///
-
-        As a result, we may want to define a single `Multifunctor` such that:
+def _(mo):
+    mo.md(r"""
+    ## Defining Multifunctor
 
-        1. Lift a regular n-argument function into the context of functors
+    /// admonition
+    we use prefix `f` rather than `ap` to indicate *Applicative Functor*
+    ///
 
-            ```python
-            # lift a regular 3-argument function `g`
-            g: Callable[[A, B, C], D]
-            # into the context of functors
-            fg: Callable[[Functor[A], Functor[B], Functor[C]], Functor[D]]
-            ```
+    As a result, we may want to define a single `Multifunctor` such that:
 
-        3. Apply it to n functor-wrapped values
+    1. Lift a regular n-argument function into the context of functors
 
-            ```python
-            # fa: Functor[A], fb: Functor[B], fc: Functor[C]
-            fg(fa, fb, fc)
-            ```
+        ```python
+        # lift a regular 3-argument function `g`
+        g: Callable[[A, B, C], D]
+        # into the context of functors
+        fg: Callable[[Functor[A], Functor[B], Functor[C]], Functor[D]]
+        ```
 
-        5. Get a single functor-wrapped result
+    3. Apply it to n functor-wrapped values
 
-            ```python
-            fd: Functor[D]
-            ```
+        ```python
+        # fa: Functor[A], fb: Functor[B], fc: Functor[C]
+        fg(fa, fb, fc)
+        ```
 
-        We will define a function `lift` such that
+    5. Get a single functor-wrapped result
 
         ```python
-        fd = lift(g, fa, fb, fc)
+        fd: Functor[D]
         ```
-        """
-    )
-
 
-@app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Pure, apply and lift
+    We will define a function `lift` such that
 
-        Traditionally, applicative functors are presented through two core operations:
+    ```python
+    fd = lift(g, fa, fb, fc)
+    ```
+    """)
+    return
 
-        1. `pure`: embeds an object (value or function) into the applicative functor
 
-            ```python
-            # a -> F a
-            pure: Callable[[A], Applicative[A]]
-            # for example, if `a` is
-            a: A
-            # then we can have `fa` as
-            fa: Applicative[A] = pure(a)
-            # or if we have a regular function `g`
-            g: Callable[[A], B]
-            # then we can have `fg` as
-            fg: Applicative[Callable[[A], B]] = pure(g)
-            ```
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    ## Pure, apply and lift
 
-        2. `apply`: applies a function inside an applicative functor to a value inside an applicative functor
+    Traditionally, applicative functors are presented through two core operations:
 
-            ```python
-            # F (a -> b) -> F a -> F b
-            apply: Callable[[Applicative[Callable[[A], B]], Applicative[A]], Applicative[B]]
-            # and we can have
-            fd = apply(apply(apply(fg, fa), fb), fc)
-            ```
+    1. `pure`: embeds an object (value or function) into the applicative functor
 
+        ```python
+        # a -> F a
+        pure: Callable[[A], Applicative[A]]
+        # for example, if `a` is
+        a: A
+        # then we can have `fa` as
+        fa: Applicative[A] = pure(a)
+        # or if we have a regular function `g`
+        g: Callable[[A], B]
+        # then we can have `fg` as
+        fg: Applicative[Callable[[A], B]] = pure(g)
+        ```
 
-        As a result,
+    2. `apply`: applies a function inside an applicative functor to a value inside an applicative functor
 
         ```python
-        lift(g, fa, fb, fc) = apply(apply(apply(pure(g), fa), fb), fc)
+        # F (a -> b) -> F a -> F b
+        apply: Callable[[Applicative[Callable[[A], B]], Applicative[A]], Applicative[B]]
+        # and we can have
+        fd = apply(apply(apply(fg, fa), fb), fc)
         ```
-        """
-    )
+
+
+    As a result,
+
+    ```python
+    lift(g, fa, fb, fc) = apply(apply(apply(pure(g), fa), fb), fc)
+    ```
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        /// admonition | How to use *Applicative* in the manner of *Multifunctor*
+def _(mo):
+    mo.md(r"""
+    /// admonition | How to use *Applicative* in the manner of *Multifunctor*
 
-        1. Define `pure` and `apply` for an `Applicative` subclass
+    1. Define `pure` and `apply` for an `Applicative` subclass
 
-            - We can define them much easier compared with `lift`.
+        - We can define them much easier compared with `lift`.
 
-        2. Use the `lift` method
+    2. Use the `lift` method
 
-            - We can use it much more convenient compared with the combination of `pure` and `apply`.
+        - We can use it much more convenient compared with the combination of `pure` and `apply`.
 
 
-        ///
+    ///
 
-        /// attention | You can suppress the chaining application of `apply` and `pure` as:
+    /// attention | You can suppress the chaining application of `apply` and `pure` as:
 
-        ```python
-        apply(pure(g), fa) -> lift(g, fa)
-        apply(apply(pure(g), fa), fb) -> lift(g, fa, fb)
-        apply(apply(apply(pure(g), fa), fb), fc) -> lift(g, fa, fb, fc)
-        ```
+    ```python
+    apply(pure(g), fa) -> lift(g, fa)
+    apply(apply(pure(g), fa), fb) -> lift(g, fa, fb)
+    apply(apply(apply(pure(g), fa), fb), fc) -> lift(g, fa, fb, fc)
+    ```
 
-        ///
-        """
-    )
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Abstracting applicatives
+def _(mo):
+    mo.md(r"""
+    ## Abstracting applicatives
 
-        We can now provide an initial abstraction definition of applicatives:
+    We can now provide an initial abstraction definition of applicatives:
 
-        ```python
-        @dataclass
-        class Applicative[A](Functor, ABC):
-            @classmethod
-            @abstractmethod
-            def pure(cls, a: A) -> "Applicative[A]":
-                raise NotImplementedError("Subclasses must implement pure")
-
-            @classmethod
-            @abstractmethod
-            def apply(
-                cls, fg: "Applicative[Callable[[A], B]]", fa: "Applicative[A]"
-            ) -> "Applicative[B]":
-                raise NotImplementedError("Subclasses must implement apply")
-
-            @classmethod
-            def lift(cls, f: Callable, *args: "Applicative") -> "Applicative":
-                curr = cls.pure(f)
-                if not args:
-                    return curr
-                for arg in args:
-                    curr = cls.apply(curr, arg)
+    ```python
+    @dataclass
+    class Applicative[A](Functor, ABC):
+        @classmethod
+        @abstractmethod
+        def pure(cls, a: A) -> "Applicative[A]":
+            raise NotImplementedError("Subclasses must implement pure")
+
+        @classmethod
+        @abstractmethod
+        def apply(
+            cls, fg: "Applicative[Callable[[A], B]]", fa: "Applicative[A]"
+        ) -> "Applicative[B]":
+            raise NotImplementedError("Subclasses must implement apply")
+
+        @classmethod
+        def lift(cls, f: Callable, *args: "Applicative") -> "Applicative":
+            curr = cls.pure(f)
+            if not args:
                 return curr
-        ```
+            for arg in args:
+                curr = cls.apply(curr, arg)
+            return curr
+    ```
 
-        /// attention | minimal implementation requirement
+    /// attention | minimal implementation requirement
 
-        - `pure`
-        - `apply`
-        ///
-        """
-    )
+    - `pure`
+    - `apply`
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""# Instances, laws and utility functions""")
+def _(mo):
+    mo.md(r"""
+    # Instances, laws and utility functions
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Applicative instances
+def _(mo):
+    mo.md(r"""
+    ## Applicative instances
 
-        When we are actually implementing an *Applicative* instance, we can keep in mind that `pure` and `apply` fundamentally:
+    When we are actually implementing an *Applicative* instance, we can keep in mind that `pure` and `apply` fundamentally:
 
-        - embed an object (value or function) to the computational context
-        - apply a function inside the computation context to a value inside the computational context
-        """
-    )
+    - embed an object (value or function) to the computational context
+    - apply a function inside the computation context to a value inside the computational context
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ### The Wrapper Applicative
+def _(mo):
+    mo.md(r"""
+    ### The Wrapper Applicative
 
-        - `pure` should simply *wrap* an object, in the sense that:
+    - `pure` should simply *wrap* an object, in the sense that:
 
-            ```haskell
-            Wrapper.pure(1) => Wrapper(value=1)
-            ```
+        ```haskell
+        Wrapper.pure(1) => Wrapper(value=1)
+        ```
 
-        - `apply` should apply a *wrapped* function to a *wrapped* value
+    - `apply` should apply a *wrapped* function to a *wrapped* value
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
-def _(Applicative, dataclass):
+def _(A, Applicative, dataclass):
     @dataclass
     class Wrapper[A](Applicative):
         value: A
@@ -284,42 +279,45 @@ def _(Applicative, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""> try with Wrapper below""")
+def _(mo):
+    mo.md(r"""
+    > try with Wrapper below
+    """)
+    return
 
 
 @app.cell
-def _(Wrapper) -> None:
+def _(Wrapper):
     Wrapper.lift(
         lambda a: lambda b: lambda c: a + b * c,
         Wrapper(1),
         Wrapper(2),
         Wrapper(3),
     )
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ### The List Applicative
+def _(mo):
+    mo.md(r"""
+    ### The List Applicative
 
-        - `pure` should wrap the object in a list, in the sense that:
+    - `pure` should wrap the object in a list, in the sense that:
 
-            ```haskell
-            List.pure(1) => List(value=[1])
-            ```
+        ```haskell
+        List.pure(1) => List(value=[1])
+        ```
 
-        - `apply` should apply a list of functions to a list of values
-            - you can think of this as cartesian product, concatenating the result of applying every function to every value
+    - `apply` should apply a list of functions to a list of values
+        - you can think of this as cartesian product, concatenating the result of applying every function to every value
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
-def _(Applicative, dataclass, product):
+def _(A, Applicative, dataclass, product):
     @dataclass
     class List[A](Applicative):
         value: list[A]
@@ -335,47 +333,51 @@ def _(Applicative, dataclass, product):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""> try with List below""")
+def _(mo):
+    mo.md(r"""
+    > try with List below
+    """)
+    return
 
 
 @app.cell
-def _(List) -> None:
+def _(List):
     List.apply(
         List([lambda a: a + 1, lambda a: a * 2]),
         List([1, 2]),
     )
+    return
 
 
 @app.cell
-def _(List) -> None:
+def _(List):
     List.lift(lambda a: lambda b: a + b, List([1, 2]), List([3, 4, 5]))
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ### The Maybe Applicative
+def _(mo):
+    mo.md(r"""
+    ### The Maybe Applicative
 
-        - `pure` should wrap the object in a Maybe, in the sense that:
+    - `pure` should wrap the object in a Maybe, in the sense that:
 
-            ```haskell
-            Maybe.pure(1)    => "Just 1"
-            Maybe.pure(None) => "Nothing"
-            ```
+        ```haskell
+        Maybe.pure(1)    => "Just 1"
+        Maybe.pure(None) => "Nothing"
+        ```
 
-        - `apply` should apply a function maybe exist to a value maybe exist
-            - if the function is `None` or the value is `None`, simply returns `None`
-            - else apply the function to the value and wrap the result in `Just`
+    - `apply` should apply a function maybe exist to a value maybe exist
+        - if the function is `None` or the value is `None`, simply returns `None`
+        - else apply the function to the value and wrap the result in `Just`
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
-def _(Applicative, dataclass):
+def _(A, Applicative, dataclass):
     @dataclass
     class Maybe[A](Applicative):
         value: None | A
@@ -399,51 +401,55 @@ def _(Applicative, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""> try with Maybe below""")
+def _(mo):
+    mo.md(r"""
+    > try with Maybe below
+    """)
+    return
 
 
 @app.cell
-def _(Maybe) -> None:
+def _(Maybe):
     Maybe.lift(
         lambda a: lambda b: a + b,
         Maybe(1),
         Maybe(2),
     )
+    return
 
 
 @app.cell
-def _(Maybe) -> None:
+def _(Maybe):
     Maybe.lift(
         lambda a: lambda b: None,
         Maybe(1),
         Maybe(2),
     )
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ### The Either Applicative
+def _(mo):
+    mo.md(r"""
+    ### The Either Applicative
 
-        - `pure` should wrap the object in `Right`, in the sense that:
+    - `pure` should wrap the object in `Right`, in the sense that:
 
-            ```haskell
-            Either.pure(1) => Right(1)
-            ```
+        ```haskell
+        Either.pure(1) => Right(1)
+        ```
 
-        - `apply` should apply a function that is either on Left or Right to a value that is either on Left or Right
-            - if the function is `Left`, simply returns the `Left` of the function
-            - else `fmap` the `Right` of the function to the value
+    - `apply` should apply a function that is either on Left or Right to a value that is either on Left or Right
+        - if the function is `Left`, simply returns the `Left` of the function
+        - else `fmap` the `Right` of the function to the value
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
-def _(Applicative, B, Callable, Union, dataclass):
+def _(A, Applicative, B, Callable, Union, dataclass):
     @dataclass
     class Either[A](Applicative):
         left: A = None
@@ -486,171 +492,180 @@ def _(Applicative, B, Callable, Union, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""> try with `Either` below""")
+def _(mo):
+    mo.md(r"""
+    > try with `Either` below
+    """)
+    return
 
 
 @app.cell
-def _(Either) -> None:
+def _(Either):
     Either.apply(Either(left=TypeError("Parse Error")), Either(right=2))
+    return
 
 
 @app.cell
-def _(Either) -> None:
+def _(Either):
     Either.apply(
         Either(right=lambda x: x + 1), Either(left=TypeError("Parse Error"))
     )
+    return
 
 
 @app.cell
-def _(Either) -> None:
+def _(Either):
     Either.apply(Either(right=lambda x: x + 1), Either(right=1))
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Collect the list of response with sequenceL
+def _(mo):
+    mo.md(r"""
+    ## Collect the list of response with sequenceL
 
-        One often wants to execute a list of commands and collect the list of their response, and we can define a function `sequenceL` for this
+    One often wants to execute a list of commands and collect the list of their response, and we can define a function `sequenceL` for this
 
-        /// admonition
-        In a further notebook about `Traversable`, we will have a more generic `sequence` that execute a **sequence** of commands and collect the **sequence** of their response, which is not limited to `list`.
-        ///
+    /// admonition
+    In a further notebook about `Traversable`, we will have a more generic `sequence` that execute a **sequence** of commands and collect the **sequence** of their response, which is not limited to `list`.
+    ///
 
-        ```python
-        @classmethod
-        def sequenceL(cls, fas: list["Applicative[A]"]) -> "Applicative[list[A]]":
-            if not fas:
-                return cls.pure([])
+    ```python
+    @classmethod
+    def sequenceL(cls, fas: list["Applicative[A]"]) -> "Applicative[list[A]]":
+        if not fas:
+            return cls.pure([])
 
-            return cls.apply(
-                cls.fmap(lambda v: lambda vs: [v] + vs, fas[0]),
-                cls.sequenceL(fas[1:]),
-            )
-        ```
+        return cls.apply(
+            cls.fmap(lambda v: lambda vs: [v] + vs, fas[0]),
+            cls.sequenceL(fas[1:]),
+        )
+    ```
 
-        Let's try `sequenceL` with the instances.
-        """
-    )
+    Let's try `sequenceL` with the instances.
+    """)
+    return
 
 
 @app.cell
-def _(Wrapper) -> None:
+def _(Wrapper):
     Wrapper.sequenceL([Wrapper(1), Wrapper(2), Wrapper(3)])
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        /// attention
-        For the `Maybe` Applicative, the presence of any `Nothing` causes the entire computation to return Nothing.
-        ///
-        """
-    )
+def _(mo):
+    mo.md(r"""
+    /// attention
+    For the `Maybe` Applicative, the presence of any `Nothing` causes the entire computation to return Nothing.
+    ///
+    """)
+    return
 
 
 @app.cell
-def _(Maybe) -> None:
+def _(Maybe):
     Maybe.sequenceL([Maybe(1), Maybe(2), Maybe(None), Maybe(3)])
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""The result of `sequenceL` for `List Applicative`  is the Cartesian product of the input lists, yielding all possible ordered combinations of elements from each list.""")
+def _(mo):
+    mo.md(r"""
+    The result of `sequenceL` for `List Applicative`  is the Cartesian product of the input lists, yielding all possible ordered combinations of elements from each list.
+    """)
+    return
 
 
 @app.cell
-def _(List) -> None:
+def _(List):
     List.sequenceL([List([1, 2]), List([3]), List([5, 6, 7])])
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Applicative laws
-
-        /// admonition | id and compose
-
-        Remember that
-
-        - `id = lambda x: x`
-        - `compose = lambda f: lambda g: lambda x: f(g(x))`
-
-        ///
-
-        Traditionally, there are four laws that `Applicative` instances should satisfy. In some sense, they are all concerned with making sure that `pure` deserves its name:
-
-        - The identity law:
-          ```python
-          # fa: Applicative[A]
-          apply(pure(id), fa) = fa
-          ```
-        - Homomorphism:
-          ```python
-          # a: A
-          # g: Callable[[A], B]
-          apply(pure(g), pure(a)) = pure(g(a))
-          ```
-          Intuitively, applying a non-effectful function to a non-effectful argument in an effectful context is the same as just applying the function to the argument and then injecting the result into the context with pure.
-        - Interchange:
-          ```python
-          # a: A
-          # fg: Applicative[Callable[[A], B]]
-          apply(fg, pure(a)) = apply(pure(lambda g: g(a)), fg)
-          ```
-          Intuitively, this says that when evaluating the application of an effectful function to a pure argument, the order in which we evaluate the function and its argument doesn't matter.
-        - Composition:
-          ```python
-          # fg: Applicative[Callable[[B], C]]
-          # fh: Applicative[Callable[[A], B]]
-          # fa: Applicative[A]
-          apply(fg, apply(fh, fa)) = lift(compose, fg, fh, fa)
-          ```
-          This one is the trickiest law to gain intuition for. In some sense it is expressing a sort of associativity property of `apply`.
-
-        We can add 4 helper functions to `Applicative` to check whether an instance respects the laws or not:
+def _(mo):
+    mo.md(r"""
+    ## Applicative laws
+
+    /// admonition | id and compose
+
+    Remember that
+
+    - `id = lambda x: x`
+    - `compose = lambda f: lambda g: lambda x: f(g(x))`
+
+    ///
+
+    Traditionally, there are four laws that `Applicative` instances should satisfy. In some sense, they are all concerned with making sure that `pure` deserves its name:
+
+    - The identity law:
+      ```python
+      # fa: Applicative[A]
+      apply(pure(id), fa) = fa
+      ```
+    - Homomorphism:
+      ```python
+      # a: A
+      # g: Callable[[A], B]
+      apply(pure(g), pure(a)) = pure(g(a))
+      ```
+      Intuitively, applying a non-effectful function to a non-effectful argument in an effectful context is the same as just applying the function to the argument and then injecting the result into the context with pure.
+    - Interchange:
+      ```python
+      # a: A
+      # fg: Applicative[Callable[[A], B]]
+      apply(fg, pure(a)) = apply(pure(lambda g: g(a)), fg)
+      ```
+      Intuitively, this says that when evaluating the application of an effectful function to a pure argument, the order in which we evaluate the function and its argument doesn't matter.
+    - Composition:
+      ```python
+      # fg: Applicative[Callable[[B], C]]
+      # fh: Applicative[Callable[[A], B]]
+      # fa: Applicative[A]
+      apply(fg, apply(fh, fa)) = lift(compose, fg, fh, fa)
+      ```
+      This one is the trickiest law to gain intuition for. In some sense it is expressing a sort of associativity property of `apply`.
+
+    We can add 4 helper functions to `Applicative` to check whether an instance respects the laws or not:
+
+    ```python
+    @dataclass
+    class Applicative[A](Functor, ABC):
 
-        ```python
-        @dataclass
-        class Applicative[A](Functor, ABC):
-
-            @classmethod
-            def check_identity(cls, fa: "Applicative[A]"):
-                if cls.lift(id, fa) != fa:
-                    raise ValueError("Instance violates identity law")
-                return True
-
-            @classmethod
-            def check_homomorphism(cls, a: A, f: Callable[[A], B]):
-                if cls.lift(f, cls.pure(a)) != cls.pure(f(a)):
-                    raise ValueError("Instance violates homomorphism law")
-                return True
-
-            @classmethod
-            def check_interchange(cls, a: A, fg: "Applicative[Callable[[A], B]]"):
-                if cls.apply(fg, cls.pure(a)) != cls.lift(lambda g: g(a), fg):
-                    raise ValueError("Instance violates interchange law")
-                return True
-
-            @classmethod
-            def check_composition(
-                cls,
-                fg: "Applicative[Callable[[B], C]]",
-                fh: "Applicative[Callable[[A], B]]",
-                fa: "Applicative[A]",
-            ):
-                if cls.apply(fg, cls.apply(fh, fa)) != cls.lift(compose, fg, fh, fa):
-                    raise ValueError("Instance violates composition law")
-                return True
-        ```
+        @classmethod
+        def check_identity(cls, fa: "Applicative[A]"):
+            if cls.lift(id, fa) != fa:
+                raise ValueError("Instance violates identity law")
+            return True
 
-        > Try to validate applicative laws below
-        """
-    )
+        @classmethod
+        def check_homomorphism(cls, a: A, f: Callable[[A], B]):
+            if cls.lift(f, cls.pure(a)) != cls.pure(f(a)):
+                raise ValueError("Instance violates homomorphism law")
+            return True
+
+        @classmethod
+        def check_interchange(cls, a: A, fg: "Applicative[Callable[[A], B]]"):
+            if cls.apply(fg, cls.pure(a)) != cls.lift(lambda g: g(a), fg):
+                raise ValueError("Instance violates interchange law")
+            return True
+
+        @classmethod
+        def check_composition(
+            cls,
+            fg: "Applicative[Callable[[B], C]]",
+            fh: "Applicative[Callable[[A], B]]",
+            fa: "Applicative[A]",
+        ):
+            if cls.apply(fg, cls.apply(fh, fa)) != cls.lift(compose, fg, fh, fa):
+                raise ValueError("Instance violates composition law")
+            return True
+    ```
+
+    > Try to validate applicative laws below
+    """)
+    return
 
 
 @app.cell
@@ -662,7 +677,7 @@ def _():
 
 
 @app.cell
-def _(List, Wrapper) -> None:
+def _(List, Wrapper):
     print("Checking Wrapper")
     print(Wrapper.check_identity(Wrapper.pure(1)))
     print(Wrapper.check_homomorphism(1, lambda x: x + 1))
@@ -684,79 +699,77 @@ def _(List, Wrapper) -> None:
             List.pure(lambda x: x * 2), List.pure(lambda x: x + 0.1), List.pure(1)
         )
     )
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Utility functions
+def _(mo):
+    mo.md(r"""
+    ## Utility functions
 
-        /// attention | using `fmap`
-        `fmap` is defined automatically using `pure` and `apply`, so you can use `fmap` with any `Applicative`
-        ///
+    /// attention | using `fmap`
+    `fmap` is defined automatically using `pure` and `apply`, so you can use `fmap` with any `Applicative`
+    ///
 
-        ```python
-        @dataclass
-        class Applicative[A](Functor, ABC):
-            @classmethod
-            def skip(
-                cls, fa: "Applicative[A]", fb: "Applicative[B]"
-            ) -> "Applicative[B]":
-                '''
-                Sequences the effects of two Applicative computations,
-                but discards the result of the first.
-                '''
-                return cls.apply(cls.const(fa, id), fb)
-
-            @classmethod
-            def keep(
-                cls, fa: "Applicative[A]", fb: "Applicative[B]"
-            ) -> "Applicative[B]":
-                '''
-                Sequences the effects of two Applicative computations,
-                but discard the result of the second.
-                '''
-                return cls.lift(const, fa, fb)
-
-            @classmethod
-            def revapp(
-                cls, fa: "Applicative[A]", fg: "Applicative[Callable[[A], [B]]]"
-            ) -> "Applicative[B]":
-                '''
-                The first computation produces values which are provided
-                as input to the function(s) produced by the second computation.
-                '''
-                return cls.lift(lambda a: lambda f: f(a), fa, fg)
-        ```
+    ```python
+    @dataclass
+    class Applicative[A](Functor, ABC):
+        @classmethod
+        def skip(
+            cls, fa: "Applicative[A]", fb: "Applicative[B]"
+        ) -> "Applicative[B]":
+            '''
+            Sequences the effects of two Applicative computations,
+            but discards the result of the first.
+            '''
+            return cls.apply(cls.const(fa, id), fb)
 
-        - `skip` sequences the effects of two Applicative computations, but **discards the result of the first**. For example, if `m1` and `m2` are instances of type `Maybe[Int]`, then `Maybe.skip(m1, m2)` is `Nothing` whenever either `m1` or `m2` is `Nothing`; but if not, it will have the same value as `m2`.
-        - Likewise, `keep` sequences the effects of two computations, but **keeps only the result of the first**.
-        - `revapp` is similar to `apply`, but where the first computation produces value(s) which are provided as input to the function(s) produced by the second computation.
-        """
-    )
+        @classmethod
+        def keep(
+            cls, fa: "Applicative[A]", fb: "Applicative[B]"
+        ) -> "Applicative[B]":
+            '''
+            Sequences the effects of two Applicative computations,
+            but discard the result of the second.
+            '''
+            return cls.lift(const, fa, fb)
+
+        @classmethod
+        def revapp(
+            cls, fa: "Applicative[A]", fg: "Applicative[Callable[[A], [B]]]"
+        ) -> "Applicative[B]":
+            '''
+            The first computation produces values which are provided
+            as input to the function(s) produced by the second computation.
+            '''
+            return cls.lift(lambda a: lambda f: f(a), fa, fg)
+    ```
+
+    - `skip` sequences the effects of two Applicative computations, but **discards the result of the first**. For example, if `m1` and `m2` are instances of type `Maybe[Int]`, then `Maybe.skip(m1, m2)` is `Nothing` whenever either `m1` or `m2` is `Nothing`; but if not, it will have the same value as `m2`.
+    - Likewise, `keep` sequences the effects of two computations, but **keeps only the result of the first**.
+    - `revapp` is similar to `apply`, but where the first computation produces value(s) which are provided as input to the function(s) produced by the second computation.
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        /// admonition | Exercise
-        Try to use utility functions with different instances
-        ///
-        """
-    )
+def _(mo):
+    mo.md(r"""
+    /// admonition | Exercise
+    Try to use utility functions with different instances
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # Formal implementation of Applicative
+def _(mo):
+    mo.md(r"""
+    # Formal implementation of Applicative
 
-        Now, we can give the formal implementation of `Applicative`
-        """
-    )
+    Now, we can give the formal implementation of `Applicative`
+    """)
+    return
 
 
 @app.cell
@@ -887,40 +900,38 @@ def _(
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # Effectful programming
+def _(mo):
+    mo.md(r"""
+    # Effectful programming
 
-        Our original motivation for applicatives was the desire to generalise the idea of mapping to functions with multiple arguments. This is a valid interpretation of the concept of applicatives, but from the three instances we have seen it becomes clear that there is also another, more abstract view.
+    Our original motivation for applicatives was the desire to generalise the idea of mapping to functions with multiple arguments. This is a valid interpretation of the concept of applicatives, but from the three instances we have seen it becomes clear that there is also another, more abstract view.
 
-         The arguments are no longer just plain values but may also have effects, such as the possibility of failure, having many ways to succeed, or performing input/output actions. In this manner, applicative functors can also be viewed as abstracting the idea of **applying pure functions to effectful arguments**, with the precise form of effects that are permitted depending on the nature of the underlying functor.
-        """
-    )
+     The arguments are no longer just plain values but may also have effects, such as the possibility of failure, having many ways to succeed, or performing input/output actions. In this manner, applicative functors can also be viewed as abstracting the idea of **applying pure functions to effectful arguments**, with the precise form of effects that are permitted depending on the nature of the underlying functor.
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## The IO Applicative
+def _(mo):
+    mo.md(r"""
+    ## The IO Applicative
 
-        We will try to define an `IO` applicative here.
+    We will try to define an `IO` applicative here.
 
-        As before, we first abstract how `pure` and `apply` should function.
+    As before, we first abstract how `pure` and `apply` should function.
 
-        - `pure` should wrap the object in an IO action, and make the object *callable* if it's not because we want to perform the action later:
+    - `pure` should wrap the object in an IO action, and make the object *callable* if it's not because we want to perform the action later:
 
-            ```haskell
-            IO.pure(1) => IO(effect=lambda: 1)
-            IO.pure(f) => IO(effect=f)
-            ```
+        ```haskell
+        IO.pure(1) => IO(effect=lambda: 1)
+        IO.pure(f) => IO(effect=f)
+        ```
 
-        - `apply` should perform an action that produces a value, then apply the function with the value
+    - `apply` should perform an action that produces a value, then apply the function with the value
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
@@ -943,8 +954,11 @@ def _(Applicative, Callable, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""For example, a function that reads a given number of lines from the keyboard can be defined in applicative style as follows:""")
+def _(mo):
+    mo.md(r"""
+    For example, a function that reads a given number of lines from the keyboard can be defined in applicative style as follows:
+    """)
+    return
 
 
 @app.cell
@@ -953,29 +967,31 @@ def _(IO):
         return IO.sequenceL([
             IO.pure(input(f"input the {i}th str")) for i in range(1, n + 1)
         ])
-    return (get_chars,)
+    return
 
 
 @app.cell
-def _() -> None:
+def _():
     # get_chars()()
     return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""# From the perspective of category theory""")
+def _(mo):
+    mo.md(r"""
+    # From the perspective of category theory
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Lax Monoidal Functor
+def _(mo):
+    mo.md(r"""
+    ## Lax Monoidal Functor
 
-        An alternative, equivalent formulation of `Applicative` is given by
-        """
-    )
+    An alternative, equivalent formulation of `Applicative` is given by
+    """)
+    return
 
 
 @app.cell
@@ -997,97 +1013,92 @@ def _(ABC, Functor, abstractmethod, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        Intuitively, this states that a *monoidal functor* is one which has some sort of "default shape" and which supports some sort of "combining" operation.
+def _(mo):
+    mo.md(r"""
+    Intuitively, this states that a *monoidal functor* is one which has some sort of "default shape" and which supports some sort of "combining" operation.
 
-        - `unit` provides the identity element
-        - `tensor` combines two contexts into a product context
+    - `unit` provides the identity element
+    - `tensor` combines two contexts into a product context
 
-        More technically, the idea is that `monoidal functor` preserves the "monoidal structure" given by the pairing constructor `(,)` and unit type `()`.
-        """
-    )
+    More technically, the idea is that `monoidal functor` preserves the "monoidal structure" given by the pairing constructor `(,)` and unit type `()`.
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        Furthermore, to deserve the name "monoidal", instances of Monoidal ought to satisfy the following laws, which seem much more straightforward than the traditional Applicative laws:
+def _(mo):
+    mo.md(r"""
+    Furthermore, to deserve the name "monoidal", instances of Monoidal ought to satisfy the following laws, which seem much more straightforward than the traditional Applicative laws:
 
-        - Left identity
+    - Left identity
 
-            `tensor(unit, v) ≅ v`
+        `tensor(unit, v) ≅ v`
 
-        - Right identity
+    - Right identity
 
-            `tensor(u, unit) ≅ u`
+        `tensor(u, unit) ≅ u`
 
-        - Associativity
+    - Associativity
 
-            `tensor(u, tensor(v, w)) ≅ tensor(tensor(u, v), w)`
-        """
-    )
+        `tensor(u, tensor(v, w)) ≅ tensor(tensor(u, v), w)`
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        /// admonition | ≅ indicates isomorphism
+def _(mo):
+    mo.md(r"""
+    /// admonition | ≅ indicates isomorphism
 
-        `≅` refers to *isomorphism* rather than equality.
+    `≅` refers to *isomorphism* rather than equality.
 
-        In particular we consider `(x, ()) ≅ x ≅ ((), x)` and `((x, y), z) ≅ (x, (y, z))`
+    In particular we consider `(x, ()) ≅ x ≅ ((), x)` and `((x, y), z) ≅ (x, (y, z))`
 
-        ///
-        """
-    )
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Mutual definability of Monoidal and Applicative
-
-        We can implement `pure` and `apply` in terms of `unit` and `tensor`, and vice versa.
-
-        ```python
-        pure(a) = fmap((lambda _: a), unit)
-        apply(fg, fa) = fmap((lambda pair: pair[0](pair[1])), tensor(fg, fa))
-        ```
-
-        ```python
-        unit() = pure(())
-        tensor(fa, fb) = lift(lambda fa: lambda fb: (fa, fb), fa, fb)
-        ```
-        """
-    )
+def _(mo):
+    mo.md(r"""
+    ## Mutual definability of Monoidal and Applicative
+
+    We can implement `pure` and `apply` in terms of `unit` and `tensor`, and vice versa.
+
+    ```python
+    pure(a) = fmap((lambda _: a), unit)
+    apply(fg, fa) = fmap((lambda pair: pair[0](pair[1])), tensor(fg, fa))
+    ```
+
+    ```python
+    unit() = pure(())
+    tensor(fa, fb) = lift(lambda fa: lambda fb: (fa, fb), fa, fb)
+    ```
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Instance: ListMonoidal
+def _(mo):
+    mo.md(r"""
+    ## Instance: ListMonoidal
 
-        - `unit` should simply return a empty tuple wrapper in a list
+    - `unit` should simply return a empty tuple wrapper in a list
 
-            ```haskell
-            ListMonoidal.unit() => [()]
-            ```
+        ```haskell
+        ListMonoidal.unit() => [()]
+        ```
 
-        - `tensor` should return the *cartesian product* of the items of 2 ListMonoidal instances
+    - `tensor` should return the *cartesian product* of the items of 2 ListMonoidal instances
 
-        The implementation is:
-        """
-    )
+    The implementation is:
+    """)
+    return
 
 
 @app.cell
-def _(B, Callable, Monoidal, dataclass, product):
+def _(A, B, Callable, Monoidal, dataclass, product):
     @dataclass
     class ListMonoidal[A](Monoidal):
         items: list[A]
@@ -1111,8 +1122,11 @@ def _(B, Callable, Monoidal, dataclass, product):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""> try with `ListMonoidal` below""")
+def _(mo):
+    mo.md(r"""
+    > try with `ListMonoidal` below
+    """)
+    return
 
 
 @app.cell
@@ -1124,13 +1138,17 @@ def _(ListMonoidal):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""and we can prove that `tensor(fa, fb) = lift(lambda fa: lambda fb: (fa, fb), fa, fb)`:""")
+def _(mo):
+    mo.md(r"""
+    and we can prove that `tensor(fa, fb) = lift(lambda fa: lambda fb: (fa, fb), fa, fb)`:
+    """)
+    return
 
 
 @app.cell
-def _(List, xs, ys) -> None:
+def _(List, xs, ys):
     List.lift(lambda fa: lambda fb: (fa, fb), List(xs.items), List(ys.items))
+    return
 
 
 @app.cell(hide_code=True)
@@ -1179,83 +1197,81 @@ def _(TypeVar):
     A = TypeVar("A")
     B = TypeVar("B")
     C = TypeVar("C")
-    return A, B, C
+    return A, B
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # From Applicative to Alternative
-
-        ## Abstracting Alternative
-
-        In our studies so far, we saw that both `Maybe` and `List` can represent computations with a varying number of results.
-
-        We use `Maybe` to indicate a computation can fail somehow and `List` for computations that can have many possible results. In both of these cases, one useful operation is amalgamating all possible results from multiple computations into a single computation.
+def _(mo):
+    mo.md(r"""
+    # From Applicative to Alternative
 
-        `Alternative` formalizes computations that support:
+    ## Abstracting Alternative
 
-        - **Failure** (empty result)
-        - **Choice** (combination of results)
-        - **Repetition** (multiple results)
+    In our studies so far, we saw that both `Maybe` and `List` can represent computations with a varying number of results.
 
-        It extends `Applicative` with monoidal structure, where:
+    We use `Maybe` to indicate a computation can fail somehow and `List` for computations that can have many possible results. In both of these cases, one useful operation is amalgamating all possible results from multiple computations into a single computation.
 
-        ```python
-        @dataclass
-        class Alternative[A](Applicative, ABC):
-            @classmethod
-            @abstractmethod
-            def empty(cls) -> "Alternative[A]":
-                '''Identity element for alternative computations'''
-
-            @classmethod
-            @abstractmethod
-            def alt(
-                cls, fa: "Alternative[A]", fb: "Alternative[A]"
-            ) -> "Alternative[A]":
-                '''Binary operation combining computations'''
-        ```
+    `Alternative` formalizes computations that support:
 
-        - `empty` is the identity element (e.g., `Maybe(None)`, `List([])`)
-        - `alt` is a combination operator (e.g., `Maybe` fallback, list concatenation)
+    - **Failure** (empty result)
+    - **Choice** (combination of results)
+    - **Repetition** (multiple results)
 
-        `empty` and `alt` should satisfy the following **laws**:
-
-        ```python
-        # Left identity
-        alt(empty, fa) == fa
-        # Right identity
-        alt(fa, empty) == fa
-        # Associativity
-        alt(fa, alt(fb, fc)) == alt(alt(fa, fb), fc)
-        ```
+    It extends `Applicative` with monoidal structure, where:
 
-        /// admonition
-        Actually, `Alternative` is a *monoid* on `Applicative Functors`. We will talk about *monoid* and review these laws in the next notebook about `Monads`.
-        ///
+    ```python
+    @dataclass
+    class Alternative[A](Applicative, ABC):
+        @classmethod
+        @abstractmethod
+        def empty(cls) -> "Alternative[A]":
+            '''Identity element for alternative computations'''
 
-        /// attention | minimal implementation requirement
-        - `empty`
-        - `alt`
-        ///
-        """
-    )
+        @classmethod
+        @abstractmethod
+        def alt(
+            cls, fa: "Alternative[A]", fb: "Alternative[A]"
+        ) -> "Alternative[A]":
+            '''Binary operation combining computations'''
+    ```
+
+    - `empty` is the identity element (e.g., `Maybe(None)`, `List([])`)
+    - `alt` is a combination operator (e.g., `Maybe` fallback, list concatenation)
+
+    `empty` and `alt` should satisfy the following **laws**:
+
+    ```python
+    # Left identity
+    alt(empty, fa) == fa
+    # Right identity
+    alt(fa, empty) == fa
+    # Associativity
+    alt(fa, alt(fb, fc)) == alt(alt(fa, fb), fc)
+    ```
+
+    /// admonition
+    Actually, `Alternative` is a *monoid* on `Applicative Functors`. We will talk about *monoid* and review these laws in the next notebook about `Monads`.
+    ///
+
+    /// attention | minimal implementation requirement
+    - `empty`
+    - `alt`
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## Instances of Alternative
+def _(mo):
+    mo.md(r"""
+    ## Instances of Alternative
 
-        ### The Maybe Alternative
+    ### The Maybe Alternative
 
-        - `empty`: the identity element of `Maybe` is `Maybe(None)`
-        - `alt`: return the first element if it's not `None`, else return the second element
-        """
-    )
+    - `empty`: the identity element of `Maybe` is `Maybe(None)`
+    - `alt`: return the first element if it's not `None`, else return the second element
+    """)
+    return
 
 
 @app.cell
@@ -1278,31 +1294,32 @@ def _(Alternative, Maybe, dataclass):
 
 
 @app.cell
-def _(AltMaybe) -> None:
+def _(AltMaybe):
     print(AltMaybe.empty())
     print(AltMaybe.alt(AltMaybe(None), AltMaybe(1)))
     print(AltMaybe.alt(AltMaybe(None), AltMaybe(None)))
     print(AltMaybe.alt(AltMaybe(1), AltMaybe(None)))
     print(AltMaybe.alt(AltMaybe(1), AltMaybe(2)))
+    return
 
 
 @app.cell
-def _(AltMaybe) -> None:
+def _(AltMaybe):
     print(AltMaybe.check_left_identity(AltMaybe(1)))
     print(AltMaybe.check_right_identity(AltMaybe(1)))
     print(AltMaybe.check_associativity(AltMaybe(1), AltMaybe(2), AltMaybe(None)))
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ### The List Alternative
-
-        - `empty`: the identity element of `List` is `List([])`
-        - `alt`: return the concatenation of 2 input lists
-        """
-    )
+def _(mo):
+    mo.md(r"""
+    ### The List Alternative
+
+    - `empty`: the identity element of `List` is `List([])`
+    - `alt`: return the concatenation of 2 input lists
+    """)
+    return
 
 
 @app.cell
@@ -1320,23 +1337,26 @@ def _(Alternative, List, dataclass):
 
 
 @app.cell
-def _(AltList) -> None:
+def _(AltList):
     print(AltList.empty())
     print(AltList.alt(AltList([1, 2, 3]), AltList([4, 5])))
+    return
 
 
 @app.cell
-def _(AltList) -> None:
+def _(AltList):
     AltList([1])
+    return
 
 
 @app.cell
-def _(AltList) -> None:
+def _(AltList):
     AltList([1])
+    return
 
 
 @app.cell
-def _(AltList) -> None:
+def _(AltList):
     print(AltList.check_left_identity(AltList([1, 2, 3])))
     print(AltList.check_right_identity(AltList([1, 2, 3])))
     print(
@@ -1344,77 +1364,88 @@ def _(AltList) -> None:
             AltList([1, 2]), AltList([3, 4, 5]), AltList([6])
         )
     )
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        ## some and many
+def _(mo):
+    mo.md(r"""
+    ## some and many
 
 
-        /// admonition | This section mainly refers to
+    /// admonition | This section mainly refers to
 
-        - https://stackoverflow.com/questions/7671009/some-and-many-functions-from-the-alternative-type-class/7681283#7681283
+    - https://stackoverflow.com/questions/7671009/some-and-many-functions-from-the-alternative-type-class/7681283#7681283
 
-        ///
+    ///
 
-        First let's have a look at the implementation of `some` and `many`:
+    First let's have a look at the implementation of `some` and `many`:
 
-        ```python
-        @classmethod
-        def some(cls, fa: "Alternative[A]") -> "Alternative[list[A]]":
-            # Short-circuit if input is empty
-            if fa == cls.empty():
-                return cls.empty()
+    ```python
+    @classmethod
+    def some(cls, fa: "Alternative[A]") -> "Alternative[list[A]]":
+        # Short-circuit if input is empty
+        if fa == cls.empty():
+            return cls.empty()
 
-            return cls.apply(
-                cls.fmap(lambda a: lambda b: [a] + b, fa), cls.many(fa)
-            )
+        return cls.apply(
+            cls.fmap(lambda a: lambda b: [a] + b, fa), cls.many(fa)
+        )
 
-        @classmethod
-        def many(cls, fa: "Alternative[A]") -> "Alternative[list[A]]":
-            # Directly return empty list if input is empty
-            if fa == cls.empty():
-                return cls.pure([])
+    @classmethod
+    def many(cls, fa: "Alternative[A]") -> "Alternative[list[A]]":
+        # Directly return empty list if input is empty
+        if fa == cls.empty():
+            return cls.pure([])
 
-            return cls.alt(cls.some(fa), cls.pure([]))
-        ```
+        return cls.alt(cls.some(fa), cls.pure([]))
+    ```
 
-        So `some f` runs `f` once, then *many* times, and conses the results. `many f` runs f *some* times, or *alternatively* just returns the empty list.
+    So `some f` runs `f` once, then *many* times, and conses the results. `many f` runs f *some* times, or *alternatively* just returns the empty list.
 
-        The idea is that they both run `f` as often as possible until it **fails**, collecting the results in a list. The difference is that `some f` immediately fails if `f` fails, while `many f` will still succeed and *return* the empty list in such a case. But what all this exactly means depends on how `alt` is defined.
+    The idea is that they both run `f` as often as possible until it **fails**, collecting the results in a list. The difference is that `some f` immediately fails if `f` fails, while `many f` will still succeed and *return* the empty list in such a case. But what all this exactly means depends on how `alt` is defined.
 
-        Let's see what it does for the instances `AltMaybe` and `AltList`.
-        """
-    )
+    Let's see what it does for the instances `AltMaybe` and `AltList`.
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""For `AltMaybe`. `None` means failure, so some `None` fails as well and evaluates to `None` while many `None` succeeds and evaluates to `Just []`. Both `some (Just ())` and `many (Just ())` never return, because `Just ()` never fails.""")
+def _(mo):
+    mo.md(r"""
+    For `AltMaybe`. `None` means failure, so some `None` fails as well and evaluates to `None` while many `None` succeeds and evaluates to `Just []`. Both `some (Just ())` and `many (Just ())` never return, because `Just ()` never fails.
+    """)
+    return
 
 
 @app.cell
-def _(AltMaybe) -> None:
+def _(AltMaybe):
     print(AltMaybe.some(AltMaybe.empty()))
     print(AltMaybe.many(AltMaybe.empty()))
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""For `AltList`, `[]` means failure, so `some []` evaluates to `[]` (no answers) while `many []` evaluates to `[[]]` (there's one answer and it is the empty list). Again `some [()]` and `many [()]` don't return.""")
+def _(mo):
+    mo.md(r"""
+    For `AltList`, `[]` means failure, so `some []` evaluates to `[]` (no answers) while `many []` evaluates to `[[]]` (there's one answer and it is the empty list). Again `some [()]` and `many [()]` don't return.
+    """)
+    return
 
 
 @app.cell
-def _(AltList) -> None:
+def _(AltList):
     print(AltList.some(AltList.empty()))
     print(AltList.many(AltList.empty()))
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(r"""## Formal implementation of Alternative""")
+def _(mo):
+    mo.md(r"""
+    ## Formal implementation of Alternative
+    """)
+    return
 
 
 @app.cell
@@ -1472,42 +1503,40 @@ def _(ABC, Applicative, abstractmethod, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        /// admonition
+def _(mo):
+    mo.md(r"""
+    /// admonition
 
-        We will explore more about `Alternative` in a future notebooks about [Monadic Parsing](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/monadic-parsing-in-haskell/E557DFCCE00E0D4B6ED02F3FB0466093)
+    We will explore more about `Alternative` in a future notebooks about [Monadic Parsing](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/monadic-parsing-in-haskell/E557DFCCE00E0D4B6ED02F3FB0466093)
 
-        ///
-        """
-    )
+    ///
+    """)
+    return
 
 
 @app.cell(hide_code=True)
-def _(mo) -> None:
-    mo.md(
-        r"""
-        # Further reading
-
-        Notice that these reading sources are optional and non-trivial
-
-        - [Applicaive Programming with Effects](https://www.staff.city.ac.uk/~ross/papers/Applicative.html)
-        - [Equivalence of Applicative Functors and
-        Multifunctors](https://arxiv.org/pdf/2401.14286)
-        - [Applicative functor](https://wiki.haskell.org/index.php?title=Applicative_functor)
-        - [Control.Applicative](https://hackage.haskell.org/package/base-4.21.0.0/docs/Control-Applicative.html#t:Applicative)
-        - [Typeclassopedia#Applicative](https://wiki.haskell.org/index.php?title=Typeclassopedia#Applicative)
-        - [Notions of computation as monoids](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/notions-of-computation-as-monoids/70019FC0F2384270E9F41B9719042528)
-        - [Free Applicative Functors](https://arxiv.org/abs/1403.0749)
-        - [The basics of applicative functors, put to practical work](http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/)
-        - [Abstracting with Applicatives](http://comonad.com/reader/2012/abstracting-with-applicatives/)
-        - [Static analysis with Applicatives](https://gergo.erdi.hu/blog/2012-12-01-static_analysis_with_applicatives/)
-        - [Explaining Applicative functor in categorical terms - monoidal functors](https://cstheory.stackexchange.com/questions/12412/explaining-applicative-functor-in-categorical-terms-monoidal-functors)
-        - [Applicative, A Strong Lax Monoidal Functor](https://beuke.org/applicative/)
-        - [Applicative Functors](https://bartoszmilewski.com/2017/02/06/applicative-functors/)
-        """
-    )
+def _(mo):
+    mo.md(r"""
+    # Further reading
+
+    Notice that these reading sources are optional and non-trivial
+
+    - [Applicaive Programming with Effects](https://www.staff.city.ac.uk/~ross/papers/Applicative.html)
+    - [Equivalence of Applicative Functors and
+    Multifunctors](https://arxiv.org/pdf/2401.14286)
+    - [Applicative functor](https://wiki.haskell.org/index.php?title=Applicative_functor)
+    - [Control.Applicative](https://hackage.haskell.org/package/base-4.21.0.0/docs/Control-Applicative.html#t:Applicative)
+    - [Typeclassopedia#Applicative](https://wiki.haskell.org/index.php?title=Typeclassopedia#Applicative)
+    - [Notions of computation as monoids](https://www.cambridge.org/core/journals/journal-of-functional-programming/article/notions-of-computation-as-monoids/70019FC0F2384270E9F41B9719042528)
+    - [Free Applicative Functors](https://arxiv.org/abs/1403.0749)
+    - [The basics of applicative functors, put to practical work](http://www.serpentine.com/blog/2008/02/06/the-basics-of-applicative-functors-put-to-practical-work/)
+    - [Abstracting with Applicatives](http://comonad.com/reader/2012/abstracting-with-applicatives/)
+    - [Static analysis with Applicatives](https://gergo.erdi.hu/blog/2012-12-01-static_analysis_with_applicatives/)
+    - [Explaining Applicative functor in categorical terms - monoidal functors](https://cstheory.stackexchange.com/questions/12412/explaining-applicative-functor-in-categorical-terms-monoidal-functors)
+    - [Applicative, A Strong Lax Monoidal Functor](https://beuke.org/applicative/)
+    - [Applicative Functors](https://bartoszmilewski.com/2017/02/06/applicative-functors/)
+    """)
+    return
 
 
 if __name__ == "__main__":

functional_programming/CHANGELOG.md

@@ -1,3 +1,8 @@
+---
+title: Changelog
+marimo-version: 0.18.4
+---
+
 # Changelog of the functional-programming course
 
 ## 2025-04-16
@@ -121,4 +126,4 @@ for reviewing
 
 **functors.py**
 
-- Demo version of notebook `05_functors.py`
+- Demo version of notebook `05_functors.py`

functional_programming/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # Learn Functional Programming
 
 _🚧 This collection is a [work in progress](https://github.com/marimo-team/learn/issues/51)._
@@ -24,13 +29,13 @@ Topics include:
 
 To run a notebook locally, use
 
-```bash 
-uvx marimo edit <URL> 
+```bash
+uvx marimo edit <URL>
 ```
 
 For example, run the `Functor` tutorial with
 
-```bash 
+```bash
 uvx marimo edit https://github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py
 ```
 
@@ -52,11 +57,11 @@ on Discord (@eugene.hs).
 ## Description of notebooks
 
 Check [here](https://github.com/marimo-team/learn/issues/51) for current series
-structure. 
+structure.
 
 | Notebook | Title | Key Concepts | Prerequisites |
-|----------|-------|--------------|---------------| 
-| [05. Functors](https://github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py) | Category Theory and Functors | Category Theory, Functor, fmap, Bifunctor | Basic Python, Functions | 
+|----------|-------|--------------|---------------|
+| [05. Functors](https://github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py) | Category Theory and Functors | Category Theory, Functor, fmap, Bifunctor | Basic Python, Functions |
 | [06. Applicatives](https://github.com/marimo-team/learn/blob/main/functional_programming/06_applicatives.py) | Applicative programming with effects | Applicative Functor, pure, apply, Effectful programming, Alternative | Functors |
 
 **Authors.**
@@ -69,4 +74,4 @@ Thanks to all our notebook authors!
 
 Thanks to all our notebook reviews!
 
-- [Haleshot](https://github.com/Haleshot)
+- [Haleshot](https://github.com/Haleshot)

optimization/01_least_squares.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -21,45 +21,41 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Least squares
+    mo.md(r"""
+    # Least squares
 
-        In a least-squares problem, we have measurements $A \in \mathcal{R}^{m \times
-        n}$ (i.e., $m$ rows and $n$ columns) and $b \in \mathcal{R}^m$. We seek a vector
-        $x \in \mathcal{R}^{n}$ such that $Ax$ is close to $b$. The matrices $A$ and $b$ are problem data or constants, and $x$ is the variable we are solving for.
+    In a least-squares problem, we have measurements $A \in \mathcal{R}^{m \times
+    n}$ (i.e., $m$ rows and $n$ columns) and $b \in \mathcal{R}^m$. We seek a vector
+    $x \in \mathcal{R}^{n}$ such that $Ax$ is close to $b$. The matrices $A$ and $b$ are problem data or constants, and $x$ is the variable we are solving for.
 
-        Closeness is defined as the sum of the squared differences:
+    Closeness is defined as the sum of the squared differences:
 
-        \[ \sum_{i=1}^m (a_i^Tx - b_i)^2, \]
+    \[ \sum_{i=1}^m (a_i^Tx - b_i)^2, \]
 
-        also known as the $\ell_2$-norm squared, $\|Ax - b\|_2^2$.
+    also known as the $\ell_2$-norm squared, $\|Ax - b\|_2^2$.
 
-        For example, we might have a dataset of $m$ users, each represented by $n$ features. Each row $a_i^T$ of $A$ is the feature vector for user $i$, while the corresponding entry $b_i$ of $b$ is the measurement we want to predict from $a_i^T$, such as ad spending. The prediction for user $i$ is given by $a_i^Tx$.
+    For example, we might have a dataset of $m$ users, each represented by $n$ features. Each row $a_i^T$ of $A$ is the feature vector for user $i$, while the corresponding entry $b_i$ of $b$ is the measurement we want to predict from $a_i^T$, such as ad spending. The prediction for user $i$ is given by $a_i^Tx$.
 
-        We find the optimal value of $x$ by solving the optimization problem
+    We find the optimal value of $x$ by solving the optimization problem
 
-        \[
-            \begin{array}{ll}
-            \text{minimize}   & \|Ax - b\|_2^2.
-            \end{array}
-        \]
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & \|Ax - b\|_2^2.
+        \end{array}
+    \]
 
-        Let $x^\star$ denote the optimal $x$. The quantity $r = Ax^\star - b$ is known as the residual. If $\|r\|_2 = 0$, we have a perfect fit.
-        """
-    )
+    Let $x^\star$ denote the optimal $x$. The quantity $r = Ax^\star - b$ is known as the residual. If $\|r\|_2 = 0$, we have a perfect fit.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example
+    mo.md(r"""
+    ## Example
 
-        In this example, we use the Python library [CVXPY](https://github.com/cvxpy/cvxpy) to construct and solve a least-squares problems.
-        """
-    )
+    In this example, we use the Python library [CVXPY](https://github.com/cvxpy/cvxpy) to construct and solve a least-squares problems.
+    """)
     return
 
 
@@ -91,7 +87,7 @@ def _(A, b, cp, n):
     objective = cp.sum_squares(A @ x - b)
     problem = cp.Problem(cp.Minimize(objective))
     optimal_value = problem.solve()
-    return objective, optimal_value, problem, x
+    return optimal_value, x
 
 
 @app.cell
@@ -108,14 +104,12 @@ def _(A, b, cp, mo, optimal_value, x):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Further reading
+    mo.md(r"""
+    ## Further reading
 
-        For a primer on least squares, with many real-world examples, check out the free book
-        [Vectors, Matrices, and Least Squares](https://web.stanford.edu/~boyd/vmls/), which is used for undergraduate linear algebra education at Stanford.
-        """
-    )
+    For a primer on least squares, with many real-world examples, check out the free book
+    [Vectors, Matrices, and Least Squares](https://web.stanford.edu/~boyd/vmls/), which is used for undergraduate linear algebra education at Stanford.
+    """)
     return
 
 

optimization/02_linear_program.py

@@ -11,7 +11,7 @@
 
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -23,33 +23,31 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Linear program
+    mo.md(r"""
+    # Linear program
 
-        A linear program is an optimization problem with a linear objective and affine
-        inequality constraints. A common standard form is the following:
+    A linear program is an optimization problem with a linear objective and affine
+    inequality constraints. A common standard form is the following:
 
-        \[  
-            \begin{array}{ll}
-            \text{minimize}   & c^Tx \\
-            \text{subject to} & Ax \leq b.
-            \end{array}
-        \]
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & c^Tx \\
+        \text{subject to} & Ax \leq b.
+        \end{array}
+    \]
 
-        Here $A \in \mathcal{R}^{m \times n}$, $b \in \mathcal{R}^m$, and $c \in \mathcal{R}^n$ are problem data and $x \in \mathcal{R}^{n}$ is the optimization variable. The inequality constraint $Ax \leq b$ is elementwise.
+    Here $A \in \mathcal{R}^{m \times n}$, $b \in \mathcal{R}^m$, and $c \in \mathcal{R}^n$ are problem data and $x \in \mathcal{R}^{n}$ is the optimization variable. The inequality constraint $Ax \leq b$ is elementwise.
 
-        For example, we might have $n$ different products, each constructed out of $m$ components. Each entry $A_{ij}$ is the amount of component $i$ required to build one unit of product $j$. Each entry $b_i$ is the total amount of component $i$ available. We lose $c_j$ for each unit of product $j$ ($c_j < 0$ indicates profit). Our goal then is to choose how many units of each product $j$ to make, $x_j$, in order to minimize loss without exceeding our budget for any component.
+    For example, we might have $n$ different products, each constructed out of $m$ components. Each entry $A_{ij}$ is the amount of component $i$ required to build one unit of product $j$. Each entry $b_i$ is the total amount of component $i$ available. We lose $c_j$ for each unit of product $j$ ($c_j < 0$ indicates profit). Our goal then is to choose how many units of each product $j$ to make, $x_j$, in order to minimize loss without exceeding our budget for any component.
 
-        In addition to a solution $x^\star$, we obtain a dual solution $\lambda^\star$. A positive entry $\lambda^\star_i$ indicates that the constraint $a_i^Tx \leq b_i$ holds with equality for $x^\star$ and suggests that changing $b_i$ would change the optimal value.
+    In addition to a solution $x^\star$, we obtain a dual solution $\lambda^\star$. A positive entry $\lambda^\star_i$ indicates that the constraint $a_i^Tx \leq b_i$ holds with equality for $x^\star$ and suggests that changing $b_i$ would change the optimal value.
 
-        **Why linear programming?** Linear programming is a way to achieve an optimal outcome, such as maximum utility or lowest cost, subject to a linear objective function and affine constraints. Developed in the 20th century, linear programming is widely used today to solve problems in resource allocation, scheduling, transportation, and more. The discovery of polynomial-time algorithms to solve linear programs was of tremendous worldwide importance and entered the public discourse, even making the front page of the New York Times.
+    **Why linear programming?** Linear programming is a way to achieve an optimal outcome, such as maximum utility or lowest cost, subject to a linear objective function and affine constraints. Developed in the 20th century, linear programming is widely used today to solve problems in resource allocation, scheduling, transportation, and more. The discovery of polynomial-time algorithms to solve linear programs was of tremendous worldwide importance and entered the public discourse, even making the front page of the New York Times.
 
-        In the late 20th and early 21st century, researchers generalized linear programming to a much wider class of problems called convex optimization problems. Nearly all convex optimization problems can be solved efficiently and reliably, and even more difficult problems are readily solved by a sequence of convex optimization problems. Today, convex optimization is used to fit machine learning models, land rockets in real-time at SpaceX, plan trajectories for self-driving cars at Waymo, execute many billions of dollars of financial trades a day, and much more.
+    In the late 20th and early 21st century, researchers generalized linear programming to a much wider class of problems called convex optimization problems. Nearly all convex optimization problems can be solved efficiently and reliably, and even more difficult problems are readily solved by a sequence of convex optimization problems. Today, convex optimization is used to fit machine learning models, land rockets in real-time at SpaceX, plan trajectories for self-driving cars at Waymo, execute many billions of dollars of financial trades a day, and much more.
 
-        This marimo learn course uses CVXPY, a modeling language for convex optimization problems developed originally at Stanford, to construct and solve convex programs.
-        """
-    )
+    This marimo learn course uses CVXPY, a modeling language for convex optimization problems developed originally at Stanford, to construct and solve convex programs.
+    """)
     return
 
 
@@ -66,13 +64,11 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example
+    mo.md(r"""
+    ## Example
 
-        Here we use CVXPY to construct and solve a linear program.
-        """
-    )
+    Here we use CVXPY to construct and solve a linear program.
+    """)
     return
 
 
@@ -119,7 +115,9 @@ def _(np):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We've randomly generated problem data $A$ and $B$. The vector for $c$ is shown below. Try playing with the value of $c$ by dragging the components, and see how the level curves change in the visualization below.""")
+    mo.md(r"""
+    We've randomly generated problem data $A$ and $B$. The vector for $c$ is shown below. Try playing with the value of $c$ by dragging the components, and see how the level curves change in the visualization below.
+    """)
     return
 
 
@@ -129,7 +127,7 @@ def _(mo, np):
 
     c_widget = mo.ui.anywidget(Matrix(matrix=np.array([[0.1, -0.2]]), step=0.01))
     c_widget
-    return Matrix, c_widget
+    return (c_widget,)
 
 
 @app.cell
@@ -149,7 +147,9 @@ def _(A, b, c, cp):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Below, we plot the feasible region of the problem — the intersection of the inequalities — and the level curves of the objective function. The optimal value $x^\star$ is the point farthest in the feasible region in the direction $-c$.""")
+    mo.md(r"""
+    Below, we plot the feasible region of the problem — the intersection of the inequalities — and the level curves of the objective function. The optimal value $x^\star$ is the point farthest in the feasible region in the direction $-c$.
+    """)
     return
 
 
@@ -249,7 +249,7 @@ def _(np):
         ax.set_xlim(np.min(x_vals), np.max(x_vals))
         ax.set_ylim(np.min(y_vals), np.max(y_vals))
         return ax
-    return make_plot, plt
+    return (make_plot,)
 
 
 @app.cell(hide_code=True)
@@ -257,7 +257,7 @@ def _(mo, prob, x):
     mo.md(
         f"""
         The optimal value is {prob.value:.04f}.
-        
+
         A solution $x$ is {mo.as_html(list(x.value))}
         A dual solution is is {mo.as_html(list(prob.constraints[0].dual_value))}
         """

optimization/03_minimum_fuel_optimal_control.py

@@ -1,6 +1,6 @@
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -12,46 +12,44 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Minimal fuel optimal control
+    mo.md(r"""
+    # Minimal fuel optimal control
 
-        This notebook includes an application of linear programming to controlling a
-        physical system, adapted from [Convex
-        Optimization](https://web.stanford.edu/~boyd/cvxbook/) by Boyd and Vandenberghe.
+    This notebook includes an application of linear programming to controlling a
+    physical system, adapted from [Convex
+    Optimization](https://web.stanford.edu/~boyd/cvxbook/) by Boyd and Vandenberghe.
 
-        We consider a linear dynamical system with state $x(t) \in \mathbf{R}^n$, for $t = 0, \ldots, T$. At each time step $t = 0, \ldots, T - 1$, an actuator or input signal $u(t)$ is applied, affecting the state. The dynamics
-        of the system is given by the linear recurrence
+    We consider a linear dynamical system with state $x(t) \in \mathbf{R}^n$, for $t = 0, \ldots, T$. At each time step $t = 0, \ldots, T - 1$, an actuator or input signal $u(t)$ is applied, affecting the state. The dynamics
+    of the system is given by the linear recurrence
 
-        \[
-            x(t + 1) = Ax(t) + bu(t), \quad t = 0, \ldots, T - 1,
-        \]
+    \[
+        x(t + 1) = Ax(t) + bu(t), \quad t = 0, \ldots, T - 1,
+    \]
 
-        where $A \in \mathbf{R}^{n \times n}$ and $b \in \mathbf{R}^n$ are given and encode how the system evolves. The initial state $x(0)$ is also given.
+    where $A \in \mathbf{R}^{n \times n}$ and $b \in \mathbf{R}^n$ are given and encode how the system evolves. The initial state $x(0)$ is also given.
 
-        The _minimum fuel optimal control problem_ is to choose the inputs $u(0), \ldots, u(T - 1)$ so as to achieve
-        a given desired state $x_\text{des} = x(T)$ while minimizing the total fuel consumed
+    The _minimum fuel optimal control problem_ is to choose the inputs $u(0), \ldots, u(T - 1)$ so as to achieve
+    a given desired state $x_\text{des} = x(T)$ while minimizing the total fuel consumed
 
-        \[
-        F = \sum_{t=0}^{T - 1} f(u(t)).
-        \]
+    \[
+    F = \sum_{t=0}^{T - 1} f(u(t)).
+    \]
 
-        The function $f : \mathbf{R} \to \mathbf{R}$ tells us how much fuel is consumed as a function of the input, and is given by
+    The function $f : \mathbf{R} \to \mathbf{R}$ tells us how much fuel is consumed as a function of the input, and is given by
 
-        \[
-            f(a) = \begin{cases}
-            |a| & |a| \leq 1 \\
-            2|a| - 1 & |a| > 1.
-            \end{cases}
-        \]
+    \[
+        f(a) = \begin{cases}
+        |a| & |a| \leq 1 \\
+        2|a| - 1 & |a| > 1.
+        \end{cases}
+    \]
 
-        This means the fuel use is proportional to the magnitude of the signal between $-1$ and $1$, but for larger signals the marginal fuel efficiency is half.
+    This means the fuel use is proportional to the magnitude of the signal between $-1$ and $1$, but for larger signals the marginal fuel efficiency is half.
 
-        **This notebook.** In this notebook we use CVXPY to formulate the minimum fuel optimal control problem as a linear program. The notebook lets you play with the initial and target states, letting you see how they affect the planned trajectory of inputs $u$.
+    **This notebook.** In this notebook we use CVXPY to formulate the minimum fuel optimal control problem as a linear program. The notebook lets you play with the initial and target states, letting you see how they affect the planned trajectory of inputs $u$.
 
-        First, we create the **problem data**.
-        """
-    )
+    First, we create the **problem data**.
+    """)
     return
 
 
@@ -85,7 +83,7 @@ def _(mo, n, np):
         rf"""
 
         Choose a value for $x_0$ ...
-        
+
         {x0_widget}
         """
     )
@@ -99,7 +97,7 @@ def _(mo, n, np):
     )
 
     mo.hstack([_a, _b], justify="space-around")
-    return wigglystuff, x0_widget, xdes_widget
+    return x0_widget, xdes_widget
 
 
 @app.cell
@@ -111,7 +109,9 @@ def _(x0_widget, xdes_widget):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""**Next, we specify the problem as a linear program using CVXPY.** This problem is linear because the objective and constraints are affine. (In fact, the objective is piecewise affine, but CVXPY rewrites it to be affine for you.)""")
+    mo.md(r"""
+    **Next, we specify the problem as a linear program using CVXPY.** This problem is linear because the objective and constraints are affine. (In fact, the objective is piecewise affine, but CVXPY rewrites it to be affine for you.)
+    """)
     return
 
 
@@ -134,18 +134,16 @@ def _(A, T, b, cp, mo, n, x0, xdes):
 
     fuel_used = cp.Problem(cp.Minimize(objective), constraints).solve()
     mo.md(f"Achieved a fuel usage of {fuel_used:.02f}. 🚀")
-    return X, constraints, fuel_used, objective, u
+    return (u,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        Finally, we plot the chosen inputs over time.
+    mo.md("""
+    Finally, we plot the chosen inputs over time.
 
-        **🌊 Try it!** Change the initial and desired states; how do fuel usage and controls change? Can you explain what you see? You can also try experimenting with the value of $T$.
-        """
-    )
+    **🌊 Try it!** Change the initial and desired states; how do fuel usage and controls change? Can you explain what you see? You can also try experimenting with the value of $T$.
+    """)
     return
 
 

optimization/04_quadratic_program.py

@@ -11,7 +11,7 @@
 
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -23,53 +23,49 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Quadratic program
+    mo.md(r"""
+    # Quadratic program
 
-        A quadratic program is an optimization problem with a quadratic objective and
-        affine equality and inequality constraints. A common standard form is the
-        following:
+    A quadratic program is an optimization problem with a quadratic objective and
+    affine equality and inequality constraints. A common standard form is the
+    following:
 
-        \[
-            \begin{array}{ll}
-            \text{minimize}   & (1/2)x^TPx + q^Tx\\
-            \text{subject to} & Gx \leq h \\
-                              & Ax = b.
-            \end{array}
-        \]
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & (1/2)x^TPx + q^Tx\\
+        \text{subject to} & Gx \leq h \\
+                          & Ax = b.
+        \end{array}
+    \]
 
-        Here $P \in \mathcal{S}^{n}_+$, $q \in \mathcal{R}^n$, $G \in \mathcal{R}^{m \times n}$, $h \in \mathcal{R}^m$, $A \in \mathcal{R}^{p \times n}$, and $b \in \mathcal{R}^p$ are problem data and $x \in \mathcal{R}^{n}$ is the optimization variable. The inequality constraint $Gx \leq h$ is elementwise.
+    Here $P \in \mathcal{S}^{n}_+$, $q \in \mathcal{R}^n$, $G \in \mathcal{R}^{m \times n}$, $h \in \mathcal{R}^m$, $A \in \mathcal{R}^{p \times n}$, and $b \in \mathcal{R}^p$ are problem data and $x \in \mathcal{R}^{n}$ is the optimization variable. The inequality constraint $Gx \leq h$ is elementwise.
 
-        **Why quadratic programming?** Quadratic programs are convex optimization problems that generalize both least-squares and linear programming.They can be solved efficiently and reliably, even in real-time.
+    **Why quadratic programming?** Quadratic programs are convex optimization problems that generalize both least-squares and linear programming.They can be solved efficiently and reliably, even in real-time.
 
-        **An example from finance.** A simple example of a quadratic program arises in finance. Suppose we have $n$ different stocks, an estimate $r \in \mathcal{R}^n$ of the expected return on each stock, and an estimate $\Sigma \in \mathcal{S}^{n}_+$ of the covariance of the returns. Then we solve the optimization problem
+    **An example from finance.** A simple example of a quadratic program arises in finance. Suppose we have $n$ different stocks, an estimate $r \in \mathcal{R}^n$ of the expected return on each stock, and an estimate $\Sigma \in \mathcal{S}^{n}_+$ of the covariance of the returns. Then we solve the optimization problem
 
-        \[
-            \begin{array}{ll}
-            \text{minimize}   & (1/2)x^T\Sigma x - r^Tx\\
-            \text{subject to} & x \geq 0 \\
-                              & \mathbf{1}^Tx = 1,
-            \end{array}
-        \]
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & (1/2)x^T\Sigma x - r^Tx\\
+        \text{subject to} & x \geq 0 \\
+                          & \mathbf{1}^Tx = 1,
+        \end{array}
+    \]
 
-        to find a nonnegative portfolio allocation $x \in \mathcal{R}^n_+$ that optimally balances expected return and variance of return.
+    to find a nonnegative portfolio allocation $x \in \mathcal{R}^n_+$ that optimally balances expected return and variance of return.
 
-        When we solve a quadratic program, in addition to a solution $x^\star$, we obtain a dual solution $\lambda^\star$ corresponding to the inequality constraints. A positive entry $\lambda^\star_i$ indicates that the constraint $g_i^Tx \leq h_i$ holds with equality for $x^\star$ and suggests that changing $h_i$ would change the optimal value.
-        """
-    )
+    When we solve a quadratic program, in addition to a solution $x^\star$, we obtain a dual solution $\lambda^\star$ corresponding to the inequality constraints. A positive entry $\lambda^\star_i$ indicates that the constraint $g_i^Tx \leq h_i$ holds with equality for $x^\star$ and suggests that changing $h_i$ would change the optimal value.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example
+    mo.md(r"""
+    ## Example
 
-        In this example, we use CVXPY to construct and solve a quadratic program.
-        """
-    )
+    In this example, we use CVXPY to construct and solve a quadratic program.
+    """)
     return
 
 
@@ -82,7 +78,9 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""First we generate synthetic data. In this problem, we don't include equality constraints, only inequality.""")
+    mo.md("""
+    First we generate synthetic data. In this problem, we don't include equality constraints, only inequality.
+    """)
     return
 
 
@@ -95,7 +93,7 @@ def _(np):
     q = np.random.randn(n)
     G = np.random.randn(m, n)
     h = G @ np.random.randn(n)
-    return G, h, m, n, q
+    return G, h, n, q
 
 
 @app.cell(hide_code=True)
@@ -114,7 +112,7 @@ def _(mo, np):
         {P_widget.center()}
         """
     )
-    return P_widget, wigglystuff
+    return (P_widget,)
 
 
 @app.cell
@@ -125,7 +123,9 @@ def _(P_widget, np):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Next, we specify the problem. Notice that we use the `quad_form` function from CVXPY to create the quadratic form $x^TPx$.""")
+    mo.md(r"""
+    Next, we specify the problem. Notice that we use the `quad_form` function from CVXPY to create the quadratic form $x^TPx$.
+    """)
     return
 
 
@@ -162,14 +162,12 @@ def _(G, P, h, plot_contours, q, x):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        In this plot, the gray shaded region is the feasible region (points satisfying the inequality), and the ellipses are level curves of the quadratic form.
+    mo.md(r"""
+    In this plot, the gray shaded region is the feasible region (points satisfying the inequality), and the ellipses are level curves of the quadratic form.
 
-        **🌊 Try it!** Try changing the entries of $P$ above with your mouse. How do the
-        level curves and the optimal value of $x$ change? Can you explain what you see?
-        """
-    )
+    **🌊 Try it!** Try changing the entries of $P$ above with your mouse. How do the
+    level curves and the optimal value of $x$ change? Can you explain what you see?
+    """)
     return
 
 
@@ -178,7 +176,7 @@ def _(P, mo):
     mo.md(
         rf"""
         The above contour lines were generated with
-        
+
         \[
         P= \begin{{bmatrix}}
         {P[0, 0]:.01f} & {P[0, 1]:.01f} \\

optimization/05_portfolio_optimization.py

@@ -12,7 +12,7 @@
 
 import marimo
 
-__generated_with = "0.11.2"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -24,88 +24,78 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# Portfolio optimization""")
+    mo.md(r"""
+    # Portfolio optimization
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        In this example we show how to use CVXPY to design a financial portfolio; this is called _portfolio optimization_.
+    mo.md(r"""
+    In this example we show how to use CVXPY to design a financial portfolio; this is called _portfolio optimization_.
 
-        In portfolio optimization we have some amount of money to invest in any of $n$ different assets.
-        We choose what fraction $w_i$ of our money to invest in each asset $i$, $i=1, \ldots, n$. The goal is to maximize return of the portfolio while minimizing risk.
-        """
-    )
+    In portfolio optimization we have some amount of money to invest in any of $n$ different assets.
+    We choose what fraction $w_i$ of our money to invest in each asset $i$, $i=1, \ldots, n$. The goal is to maximize return of the portfolio while minimizing risk.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Asset returns and risk
+    mo.md(r"""
+    ## Asset returns and risk
 
-        We will only model investments held for one period. The initial prices are $p_i > 0$. The end of period prices are $p_i^+ >0$. The asset (fractional) returns are $r_i = (p_i^+-p_i)/p_i$. The portfolio (fractional) return is $R = r^Tw$.
+    We will only model investments held for one period. The initial prices are $p_i > 0$. The end of period prices are $p_i^+ >0$. The asset (fractional) returns are $r_i = (p_i^+-p_i)/p_i$. The portfolio (fractional) return is $R = r^Tw$.
 
-        A common model is that $r$ is a random variable with mean ${\bf E}r = \mu$ and covariance ${\bf E{(r-\mu)(r-\mu)^T}} = \Sigma$.
-        It follows that $R$ is a random variable with ${\bf E}R = \mu^T w$ and ${\bf var}(R) = w^T\Sigma w$. In real-world applications, $\mu$ and $\Sigma$ are estimated from data and models, and $w$ is chosen using a library like CVXPY.
+    A common model is that $r$ is a random variable with mean ${\bf E}r = \mu$ and covariance ${\bf E{(r-\mu)(r-\mu)^T}} = \Sigma$.
+    It follows that $R$ is a random variable with ${\bf E}R = \mu^T w$ and ${\bf var}(R) = w^T\Sigma w$. In real-world applications, $\mu$ and $\Sigma$ are estimated from data and models, and $w$ is chosen using a library like CVXPY.
 
-        ${\bf E}R$ is the (mean) *return* of the portfolio. ${\bf var}(R)$ is the *risk* of the portfolio. Portfolio optimization has two competing objectives: high return and low risk.
-        """
-    )
+    ${\bf E}R$ is the (mean) *return* of the portfolio. ${\bf var}(R)$ is the *risk* of the portfolio. Portfolio optimization has two competing objectives: high return and low risk.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Classical (Markowitz) portfolio optimization
+    mo.md(r"""
+    ## Classical (Markowitz) portfolio optimization
 
-        Classical (Markowitz) portfolio optimization solves the optimization problem
-        """
-    )
+    Classical (Markowitz) portfolio optimization solves the optimization problem
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        $$
-        \begin{array}{ll} \text{maximize} & \mu^T w - \gamma w^T\Sigma w\\
-        \text{subject to} & {\bf 1}^T w = 1, w \geq 0,
-        \end{array}
-        $$
-        """
-    )
+    mo.md(r"""
+    $$
+    \begin{array}{ll} \text{maximize} & \mu^T w - \gamma w^T\Sigma w\\
+    \text{subject to} & {\bf 1}^T w = 1, w \geq 0,
+    \end{array}
+    $$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        where $w \in {\bf R}^n$ is the optimization variable and $\gamma >0$ is a constant called the *risk aversion parameter*. The constraint $\mathbf{1}^Tw = 1$ says the portfolio weight vector must sum to 1, and $w \geq 0$ says that we can't invest a negative amount into any asset.
+    mo.md(r"""
+    where $w \in {\bf R}^n$ is the optimization variable and $\gamma >0$ is a constant called the *risk aversion parameter*. The constraint $\mathbf{1}^Tw = 1$ says the portfolio weight vector must sum to 1, and $w \geq 0$ says that we can't invest a negative amount into any asset.
 
-        The objective $\mu^Tw - \gamma w^T\Sigma w$ is the *risk-adjusted return*. Varying $\gamma$ gives the optimal *risk-return trade-off*.
-        We can get the same risk-return trade-off by fixing return and minimizing risk.
-        """
-    )
+    The objective $\mu^Tw - \gamma w^T\Sigma w$ is the *risk-adjusted return*. Varying $\gamma$ gives the optimal *risk-return trade-off*.
+    We can get the same risk-return trade-off by fixing return and minimizing risk.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example
+    mo.md(r"""
+    ## Example
 
-        In the following code we compute and plot the optimal risk-return trade-off for $10$ assets. First we generate random problem data $\mu$ and $\Sigma$.
-        """
-    )
+    In the following code we compute and plot the optimal risk-return trade-off for $10$ assets. First we generate random problem data $\mu$ and $\Sigma$.
+    """)
     return
 
 
@@ -148,7 +138,7 @@ def _(mo, np):
         _Try changing the entries of $\mu$ and see how the plots below change._
         """
     )
-    return mu_widget, wigglystuff
+    return (mu_widget,)
 
 
 @app.cell
@@ -163,7 +153,9 @@ def _(mu_widget, np):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""Next, we solve the problem for 100 different values of $\gamma$""")
+    mo.md("""
+    Next, we solve the problem for 100 different values of $\gamma$
+    """)
     return
 
 
@@ -176,7 +168,7 @@ def _(Sigma, mu, n):
     ret = mu.T @ w
     risk = cp.quad_form(w, Sigma)
     prob = cp.Problem(cp.Maximize(ret - gamma * risk), [cp.sum(w) == 1, w >= 0])
-    return cp, gamma, prob, ret, risk, w
+    return cp, gamma, prob, ret, risk
 
 
 @app.cell
@@ -195,7 +187,9 @@ def _(cp, gamma, np, prob, ret, risk):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""Plotted below are the risk return tradeoffs for two values of $\gamma$ (blue squares), and the risk return tradeoffs for investing fully in each asset (red circles)""")
+    mo.md("""
+    Plotted below are the risk return tradeoffs for two values of $\gamma$ (blue squares), and the risk return tradeoffs for investing fully in each asset (red circles)
+    """)
     return
 
 
@@ -218,17 +212,15 @@ def _(Sigma, cp, gamma_vals, mu, n, ret_data, risk_data):
     plt.xlabel("Standard deviation")
     plt.ylabel("Return")
     plt.show()
-    return ax, fig, marker, markers_on, plt
+    return markers_on, plt
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        We plot below the return distributions for the two risk aversion values marked on the trade-off curve.
-        Notice that the probability of a loss is near 0 for the low risk value and far above 0 for the high risk value.
-        """
-    )
+    mo.md(r"""
+    We plot below the return distributions for the two risk aversion values marked on the trade-off curve.
+    Notice that the probability of a loss is near 0 for the low risk value and far above 0 for the high risk value.
+    """)
     return
 
 
@@ -250,7 +242,7 @@ def _(gamma, gamma_vals, markers_on, np, plt, prob, ret, risk):
     plt.ylabel("Density")
     plt.legend(loc="upper right")
     plt.show()
-    return midx, spstats, x
+    return
 
 
 if __name__ == "__main__":

optimization/06_convex_optimization.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.2"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -21,41 +21,39 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Convex optimization
-
-        In the previous tutorials, we learned about least squares, linear programming,
-        and quadratic programming, and saw applications of each. We also learned that these problem
-        classes can be solved efficiently and reliably using CVXPY. That's because these problem classes are a special
-        case of a more general class of tractable problems, called **convex optimization problems.**
-
-        A convex optimization problem is an optimization problem that minimizes a convex
-        function, subject to affine equality constraints and convex inequality
-        constraints ($f_i(x)\leq 0$, where $f_i$ is a convex function).
-
-        **CVXPY.** CVXPY lets you specify and solve any convex optimization problem,
-        abstracting away the more specific problem classes. You start with CVXPY's **atomic functions**, like `cp.exp`, `cp.log`, and `cp.square`, and compose them to build more complex convex functions. As long as the functions are composed in the right way — as long as they are "DCP-compliant" —  your resulting problem will be convex and solvable by CVXPY.
-        """
-    )
+    mo.md(r"""
+    # Convex optimization
+
+    In the previous tutorials, we learned about least squares, linear programming,
+    and quadratic programming, and saw applications of each. We also learned that these problem
+    classes can be solved efficiently and reliably using CVXPY. That's because these problem classes are a special
+    case of a more general class of tractable problems, called **convex optimization problems.**
+
+    A convex optimization problem is an optimization problem that minimizes a convex
+    function, subject to affine equality constraints and convex inequality
+    constraints ($f_i(x)\leq 0$, where $f_i$ is a convex function).
+
+    **CVXPY.** CVXPY lets you specify and solve any convex optimization problem,
+    abstracting away the more specific problem classes. You start with CVXPY's **atomic functions**, like `cp.exp`, `cp.log`, and `cp.square`, and compose them to build more complex convex functions. As long as the functions are composed in the right way — as long as they are "DCP-compliant" —  your resulting problem will be convex and solvable by CVXPY.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        **🛑 Stop!** Before proceeding, read the CVXPY docs to learn about atomic functions and the DCP ruleset:
+    mo.md(r"""
+    **🛑 Stop!** Before proceeding, read the CVXPY docs to learn about atomic functions and the DCP ruleset:
 
-        https://www.cvxpy.org/tutorial/index.html
-        """
-    )
+    https://www.cvxpy.org/tutorial/index.html
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""**Is my problem DCP-compliant?** Below is a sample CVXPY problem. It is DCP-compliant. Try typing in other problems and seeing if they are DCP-compliant. If you know your problem is convex, there exists a way to express it in a DCP-compliant way.""")
+    mo.md(r"""
+    **Is my problem DCP-compliant?** Below is a sample CVXPY problem. It is DCP-compliant. Try typing in other problems and seeing if they are DCP-compliant. If you know your problem is convex, there exists a way to express it in a DCP-compliant way.
+    """)
     return
 
 
@@ -71,7 +69,7 @@ def _(mo):
     constraints = [x >= 0, cp.sum(x) == 1]
     problem = cp.Problem(cp.Maximize(objective), constraints)
     mo.md(f"Is my problem DCP? `{problem.is_dcp()}`")
-    return P_sqrt, constraints, cp, np, objective, problem, x
+    return problem, x
 
 
 @app.cell

optimization/07_sdp.py

@@ -10,7 +10,7 @@
 
 import marimo
 
-__generated_with = "0.11.2"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -22,49 +22,47 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# Semidefinite program""")
+    mo.md(r"""
+    # Semidefinite program
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        _This notebook introduces an advanced topic._ A semidefinite program (SDP) is an optimization problem of the form
-
-        \[
-            \begin{array}{ll}
-            \text{minimize}   & \mathbf{tr}(CX) \\
-            \text{subject to} & \mathbf{tr}(A_iX) = b_i, \quad i=1,\ldots,p \\
-                              & X \succeq 0,
-            \end{array}
-        \]
-
-        where $\mathbf{tr}$ is the trace function, $X \in \mathcal{S}^{n}$ is the optimization variable and $C, A_1, \ldots, A_p \in \mathcal{S}^{n}$, and $b_1, \ldots, b_p \in \mathcal{R}$ are problem data, and $X \succeq 0$ is a matrix inequality. Here $\mathcal{S}^{n}$ denotes the set of $n$-by-$n$ symmetric matrices.
-
-        **Example.** An example of an SDP is to complete a covariance matrix $\tilde \Sigma \in \mathcal{S}^{n}_+$ with missing entries $M \subset \{1,\ldots,n\} \times \{1,\ldots,n\}$:
-
-        \[
-            \begin{array}{ll}
-            \text{minimize}   & 0 \\
-            \text{subject to} & \Sigma_{ij} = \tilde \Sigma_{ij}, \quad (i,j) \notin M \\
-                              & \Sigma \succeq 0,
-            \end{array}
-        \]
-        """
-    )
+    mo.md(r"""
+    _This notebook introduces an advanced topic._ A semidefinite program (SDP) is an optimization problem of the form
+
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & \mathbf{tr}(CX) \\
+        \text{subject to} & \mathbf{tr}(A_iX) = b_i, \quad i=1,\ldots,p \\
+                          & X \succeq 0,
+        \end{array}
+    \]
+
+    where $\mathbf{tr}$ is the trace function, $X \in \mathcal{S}^{n}$ is the optimization variable and $C, A_1, \ldots, A_p \in \mathcal{S}^{n}$, and $b_1, \ldots, b_p \in \mathcal{R}$ are problem data, and $X \succeq 0$ is a matrix inequality. Here $\mathcal{S}^{n}$ denotes the set of $n$-by-$n$ symmetric matrices.
+
+    **Example.** An example of an SDP is to complete a covariance matrix $\tilde \Sigma \in \mathcal{S}^{n}_+$ with missing entries $M \subset \{1,\ldots,n\} \times \{1,\ldots,n\}$:
+
+    \[
+        \begin{array}{ll}
+        \text{minimize}   & 0 \\
+        \text{subject to} & \Sigma_{ij} = \tilde \Sigma_{ij}, \quad (i,j) \notin M \\
+                          & \Sigma \succeq 0,
+        \end{array}
+    \]
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example
+    mo.md(r"""
+    ## Example
 
-        In the following code, we show how to specify and solve an SDP with CVXPY.
-        """
-    )
+    In the following code, we show how to specify and solve an SDP with CVXPY.
+    """)
     return
 
 
@@ -87,7 +85,7 @@ def _(np):
     for i in range(p):
         A.append(np.random.randn(n, n))
         b.append(np.random.randn())
-    return A, C, b, i, n, p
+    return A, C, b, n, p
 
 
 @app.cell
@@ -101,7 +99,7 @@ def _(A, C, b, cp, n, p):
     constraints += [cp.trace(A[i] @ X) == b[i] for i in range(p)]
     prob = cp.Problem(cp.Minimize(cp.trace(C @ X)), constraints)
     _ = prob.solve()
-    return X, constraints, prob
+    return X, prob
 
 
 @app.cell
@@ -111,7 +109,7 @@ def _(X, mo, prob, wigglystuff):
         The optimal value is {prob.value:0.4f}.
 
         A solution for $X$ is (rounded to the nearest decimal) is: 
-        
+
         {mo.ui.anywidget(wigglystuff.Matrix(X.value)).center()}
         """
     )

optimization/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # Learn optimization
 
 This collection of marimo notebooks teaches you the basics of convex
@@ -30,4 +35,4 @@ to a notebook's URL: [marimo.app/github.com/marimo-team/learn/blob/main/optimiza
 
 **Thanks to all our notebook authors!**
 
-* [Akshay Agrawal](https://github.com/akshayka)
+* [Akshay Agrawal](https://github.com/akshayka)

polars/01_why_polars.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.8"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -21,17 +21,15 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # An introduction to Polars
+    mo.md("""
+    # An introduction to Polars
 
-        _By [Koushik Khan](https://github.com/koushikkhan)._
+    _By [Koushik Khan](https://github.com/koushikkhan)._
 
-        This notebook provides a birds-eye overview of [Polars](https://pola.rs/), a fast and user-friendly data manipulation library for Python, and compares it to alternatives like Pandas and PySpark.
+    This notebook provides a birds-eye overview of [Polars](https://pola.rs/), a fast and user-friendly data manipulation library for Python, and compares it to alternatives like Pandas and PySpark.
 
-        Like Pandas and PySpark, the central data structure in Polars is **the DataFrame**, a tabular data structure consisting of named columns. For example, the next cell constructs a DataFrame that records the gender, age, and height in centimeters for a number of individuals.
-        """
-    )
+    Like Pandas and PySpark, the central data structure in Polars is **the DataFrame**, a tabular data structure consisting of named columns. For example, the next cell constructs a DataFrame that records the gender, age, and height in centimeters for a number of individuals.
+    """)
     return
 
 
@@ -48,46 +46,40 @@ def _():
         }
     )
     df_pl
-    return df_pl, pl
+    return (pl,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        Unlike Python's earliest DataFrame library Pandas, Polars was designed with performance and usability in mind — Polars can scale to large datasets with ease while maintaining a simple and intuitive API. 
+    mo.md("""
+    Unlike Python's earliest DataFrame library Pandas, Polars was designed with performance and usability in mind — Polars can scale to large datasets with ease while maintaining a simple and intuitive API.
 
-        Polars' performance is due to a number of factors, including its implementation in rust and its ability to perform operations in a parallelized and vectorized manner. It supports a wide range of data types, advanced query optimizations, and seamless integration with other Python libraries, making it a versatile tool for data scientists, engineers, and analysts. Additionally, Polars provides a lazy API for deferred execution, allowing users to optimize their workflows by chaining operations and executing them in a single pass.
+    Polars' performance is due to a number of factors, including its implementation in rust and its ability to perform operations in a parallelized and vectorized manner. It supports a wide range of data types, advanced query optimizations, and seamless integration with other Python libraries, making it a versatile tool for data scientists, engineers, and analysts. Additionally, Polars provides a lazy API for deferred execution, allowing users to optimize their workflows by chaining operations and executing them in a single pass.
 
-        With its focus on speed, scalability, and ease of use, Polars is quickly becoming a go-to choice for data professionals looking to streamline their data processing pipelines and tackle large-scale data challenges.
-        """
-    )
+    With its focus on speed, scalability, and ease of use, Polars is quickly becoming a go-to choice for data professionals looking to streamline their data processing pipelines and tackle large-scale data challenges.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Choosing Polars over Pandas
+    mo.md("""
+    ## Choosing Polars over Pandas
 
-        In this section we'll give a few reasons why Polars is a better choice than Pandas, along with examples.
-        """
-    )
+    In this section we'll give a few reasons why Polars is a better choice than Pandas, along with examples.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Intuitive syntax
+    mo.md("""
+    ### Intuitive syntax
 
-        Polars' syntax is similar to PySpark and intuitive like SQL, making heavy use of **method chaining**. This makes it easy for data professionals to transition to Polars, and leads to an API that is more concise and readable than Pandas.
+    Polars' syntax is similar to PySpark and intuitive like SQL, making heavy use of **method chaining**. This makes it easy for data professionals to transition to Polars, and leads to an API that is more concise and readable than Pandas.
 
-        **Example.** In the next few cells, we contrast the code to perform a basic filter and aggregation of data with Pandas to the code required to accomplish the same task with `Polars`.
-        """
-    )
+    **Example.** In the next few cells, we contrast the code to perform a basic filter and aggregation of data with Pandas to the code required to accomplish the same task with `Polars`.
+    """)
     return
 
 
@@ -112,12 +104,14 @@ def _():
     # step-2: groupby and aggregation
     result_pd = filtered_df_pd.groupby("Gender")["Height_CM"].mean()
     result_pd
-    return df_pd, filtered_df_pd, pd, result_pd
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The same example can be worked out in Polars more concisely, using method chaining. Notice how the Polars code is essentially as readable as English.""")
+    mo.md(r"""
+    The same example can be worked out in Polars more concisely, using method chaining. Notice how the Polars code is essentially as readable as English.
+    """)
     return
 
 
@@ -137,17 +131,15 @@ def _(pl):
     # filter, groupby and aggregation using method chaining
     result_pl = data_pl.filter(pl.col("Age") > 15).group_by("Gender").agg(pl.mean("Height_CM"))
     result_pl
-    return data_pl, result_pl
+    return (data_pl,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        Notice how Polars uses a *method-chaining* approach, similar to PySpark, which makes the code more readable and expressive while using a *single line* to design the query.
-        Additionally, Polars supports SQL-like operations *natively*, that allows you to write SQL queries directly on polars dataframe:
-        """
-    )
+    mo.md("""
+    Notice how Polars uses a *method-chaining* approach, similar to PySpark, which makes the code more readable and expressive while using a *single line* to design the query.
+    Additionally, Polars supports SQL-like operations *natively*, that allows you to write SQL queries directly on polars dataframe:
+    """)
     return
 
 
@@ -155,159 +147,145 @@ def _(mo):
 def _(data_pl):
     result = data_pl.sql("SELECT Gender, AVG(Height_CM) FROM self WHERE Age > 15 GROUP BY Gender")
     result
-    return (result,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### A large collection of built-in APIs
+    mo.md("""
+    ### A large collection of built-in APIs
 
-        Polars has a comprehensive API that enables to perform virtually any operation using built-in methods. In contrast, Pandas often requires more complex operations to be handled using the `apply` method with a lambda function. The issue with `apply` is that it processes rows sequentially, looping through the DataFrame one row at a time, which can be inefficient. By leveraging Polars' built-in methods, you can operate on entire columns at once, unlocking the power of **SIMD (Single Instruction, Multiple Data)** parallelism. This approach not only simplifies your code but also significantly improves performance.
-        """
-    )
+    Polars has a comprehensive API that enables to perform virtually any operation using built-in methods. In contrast, Pandas often requires more complex operations to be handled using the `apply` method with a lambda function. The issue with `apply` is that it processes rows sequentially, looping through the DataFrame one row at a time, which can be inefficient. By leveraging Polars' built-in methods, you can operate on entire columns at once, unlocking the power of **SIMD (Single Instruction, Multiple Data)** parallelism. This approach not only simplifies your code but also significantly improves performance.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Query optimization 📈
+    mo.md("""
+    ### Query optimization 📈
 
-        A key factor behind Polars' performance lies in its **evaluation strategy**. While Pandas defaults to **eager execution**, executing operations in the exact order they are written, Polars offers both **eager and lazy execution**. With lazy execution, Polars employs a **query optimizer** that analyzes all required operations and determines the most efficient way to execute them. This optimization can involve reordering operations, eliminating redundant calculations, and more. 
+    A key factor behind Polars' performance lies in its **evaluation strategy**. While Pandas defaults to **eager execution**, executing operations in the exact order they are written, Polars offers both **eager and lazy execution**. With lazy execution, Polars employs a **query optimizer** that analyzes all required operations and determines the most efficient way to execute them. This optimization can involve reordering operations, eliminating redundant calculations, and more.
 
-        For example, consider the following expression to calculate the mean of the `Number1` column for categories "A" and "B" in the `Category` column:
+    For example, consider the following expression to calculate the mean of the `Number1` column for categories "A" and "B" in the `Category` column:
 
-        ```python
-        (
-            df
-            .groupby(by="Category").agg(pl.col("Number1").mean())
-            .filter(pl.col("Category").is_in(["A", "B"]))
-        )
-        ```
-
-        If executed eagerly, the `groupby` operation would first be applied to the entire DataFrame, followed by filtering the results by `Category`. However, with **lazy execution**, Polars can optimize this process by first filtering the DataFrame to include only the relevant categories ("A" and "B") and then performing the `groupby` operation on the reduced dataset. This approach minimizes unnecessary computations and significantly improves efficiency.
-        """
+    ```python
+    (
+        df
+        .groupby(by="Category").agg(pl.col("Number1").mean())
+        .filter(pl.col("Category").is_in(["A", "B"]))
     )
+    ```
+
+    If executed eagerly, the `groupby` operation would first be applied to the entire DataFrame, followed by filtering the results by `Category`. However, with **lazy execution**, Polars can optimize this process by first filtering the DataFrame to include only the relevant categories ("A" and "B") and then performing the `groupby` operation on the reduced dataset. This approach minimizes unnecessary computations and significantly improves efficiency.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Scalability — handling large datasets in memory ⬆️
+    mo.md("""
+    ### Scalability — handling large datasets in memory ⬆️
 
-        Pandas is limited by its single-threaded design and reliance on Python, which makes it inefficient for processing large datasets. Polars, on the other hand, is built in Rust and optimized for parallel processing, enabling it to handle datasets that are orders of magnitude larger.
+    Pandas is limited by its single-threaded design and reliance on Python, which makes it inefficient for processing large datasets. Polars, on the other hand, is built in Rust and optimized for parallel processing, enabling it to handle datasets that are orders of magnitude larger.
 
-        **Example: Processing a Large Dataset**
-        In Pandas, loading a large dataset (e.g., 10GB) often results in memory errors:
+    **Example: Processing a Large Dataset**
+    In Pandas, loading a large dataset (e.g., 10GB) often results in memory errors:
 
-        ```python
-        # This may fail with large datasets
-        df = pd.read_csv("large_dataset.csv")
-        ```
+    ```python
+    # This may fail with large datasets
+    df = pd.read_csv("large_dataset.csv")
+    ```
 
-        In Polars, the same operation runs quickly, without memory pressure:
+    In Polars, the same operation runs quickly, without memory pressure:
 
-        ```python
-        df = pl.read_csv("large_dataset.csv")
-        ```
+    ```python
+    df = pl.read_csv("large_dataset.csv")
+    ```
 
-        Polars also supports lazy evaluation, which allows you to optimize your workflows by deferring computations until necessary. This is particularly useful for large datasets:
+    Polars also supports lazy evaluation, which allows you to optimize your workflows by deferring computations until necessary. This is particularly useful for large datasets:
 
-        ```python
-        df = pl.scan_csv("large_dataset.csv")  # Lazy DataFrame
-        result = df.filter(pl.col("A") > 1).groupby("A").agg(pl.sum("B")).collect()  # Execute
-        ```
-        """
-    )
+    ```python
+    df = pl.scan_csv("large_dataset.csv")  # Lazy DataFrame
+    result = df.filter(pl.col("A") > 1).groupby("A").agg(pl.sum("B")).collect()  # Execute
+    ```
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Compatibility with other machine learning libraries 🤝
+    mo.md("""
+    ### Compatibility with other machine learning libraries 🤝
 
-        Polars integrates seamlessly with popular machine learning libraries like Scikit-learn, PyTorch, and TensorFlow. Its ability to handle large datasets efficiently makes it an excellent choice for preprocessing data before feeding it into ML models.
+    Polars integrates seamlessly with popular machine learning libraries like Scikit-learn, PyTorch, and TensorFlow. Its ability to handle large datasets efficiently makes it an excellent choice for preprocessing data before feeding it into ML models.
 
-        **Example: Preprocessing Data for Scikit-learn**
+    **Example: Preprocessing Data for Scikit-learn**
 
-        ```python
-        import polars as pl
-        from sklearn.linear_model import LinearRegression
+    ```python
+    import polars as pl
+    from sklearn.linear_model import LinearRegression
 
-        # Load and preprocess data
-        df = pl.read_csv("data.csv")
-        X = df.select(["feature1", "feature2"]).to_numpy()
-        y = df.select("target").to_numpy()
+    # Load and preprocess data
+    df = pl.read_csv("data.csv")
+    X = df.select(["feature1", "feature2"]).to_numpy()
+    y = df.select("target").to_numpy()
 
-        # Train a model
-        model = LinearRegression()
-        model.fit(X, y)
-        ```
+    # Train a model
+    model = LinearRegression()
+    model.fit(X, y)
+    ```
 
-        Polars also supports conversion to other formats like NumPy arrays and Pandas DataFrames, ensuring compatibility with virtually any ML library:
+    Polars also supports conversion to other formats like NumPy arrays and Pandas DataFrames, ensuring compatibility with virtually any ML library:
 
-        ```python
-        # Convert to Pandas DataFrame
-        pandas_df = df.to_pandas()
+    ```python
+    # Convert to Pandas DataFrame
+    pandas_df = df.to_pandas()
 
-        # Convert to NumPy array
-        numpy_array = df.to_numpy()
-        ```
-        """
-    )
+    # Convert to NumPy array
+    numpy_array = df.to_numpy()
+    ```
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### Easy to use, with room for power users
+    mo.md("""
+    ### Easy to use, with room for power users
 
-        Polars supports advanced operations like
+    Polars supports advanced operations like
 
-        - **date handling**
-        - **window functions**
-        - **joins**
-        - **nested data types**
+    - **date handling**
+    - **window functions**
+    - **joins**
+    - **nested data types**
 
-        which is making it a versatile tool for data manipulation.
-        """
-    )
+    which is making it a versatile tool for data manipulation.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Why not PySpark?
+    mo.md("""
+    ## Why not PySpark?
 
-        While **PySpark** is versatile tool that has transformed the way big data is handled and processed in Python, its **complex setup process** can be intimidating, especially for beginners. In contrast, **Polars** requires minimal setup and is ready to use right out of the box, making it more accessible for users of all skill levels.
+    While **PySpark** is versatile tool that has transformed the way big data is handled and processed in Python, its **complex setup process** can be intimidating, especially for beginners. In contrast, **Polars** requires minimal setup and is ready to use right out of the box, making it more accessible for users of all skill levels.
 
-        When deciding between the two, **PySpark** is the preferred choice for processing large datasets distributed across a **multi-node cluster**. However, for computations on a **single-node machine**, **Polars** is an excellent alternative. Remarkably, Polars is capable of handling datasets that exceed the size of the available RAM, making it a powerful tool for efficient data processing even on limited hardware.
-        """
-    )
+    When deciding between the two, **PySpark** is the preferred choice for processing large datasets distributed across a **multi-node cluster**. However, for computations on a **single-node machine**, **Polars** is an excellent alternative. Remarkably, Polars is capable of handling datasets that exceed the size of the available RAM, making it a powerful tool for efficient data processing even on limited hardware.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## 🔖 References
+    mo.md("""
+    ## 🔖 References
 
-        - [Polars official website](https://pola.rs/)
-        - [Polars vs. Pandas](https://blog.jetbrains.com/pycharm/2024/07/polars-vs-pandas/)
-        """
-    )
+    - [Polars official website](https://pola.rs/)
+    - [Polars vs. Pandas](https://blog.jetbrains.com/pycharm/2024/07/polars-vs-pandas/)
+    """)
     return
 
 

polars/02_dataframes.py

@@ -10,14 +10,13 @@
 
 import marimo
 
-__generated_with = "0.13.10"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # DataFrames
     Author: [*Raine Hoang*](https://github.com/Jystine)
 
@@ -25,33 +24,31 @@ def _(mo):
 
     /// Note
     The following tutorial has been adapted from the Polars [documentation](https://docs.pola.rs/api/python/stable/reference/dataframe/index.html).
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ## Defining a DataFrame
 
     At the most basic level, all that you need to do in order to create a DataFrame in Polars is to use the .DataFrame() method and pass in some data into the data parameter. However, there are restrictions as to what exactly you can pass into this method.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### What Can Be a DataFrame?""")
+    mo.md(r"""
+    ### What Can Be a DataFrame?
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     There are [5 data types](https://github.com/pola-rs/polars/blob/py-1.29.0/py-polars/polars/dataframe/frame.py#L197) that can be converted into a DataFrame.
 
     1. Dictionary
@@ -59,20 +56,17 @@ def _(mo):
     3. NumPy Array
     4. Series
     5. Pandas DataFrame
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### Dictionary
 
     Dictionaries are structures that store data as `key:value` pairs. Let's say we have the following dictionary:
-    """
-    )
+    """)
     return
 
 
@@ -85,7 +79,9 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""In order to convert this dictionary into a DataFrame, we simply need to pass it into the data parameter in the `.DataFrame()` method like so.""")
+    mo.md(r"""
+    In order to convert this dictionary into a DataFrame, we simply need to pass it into the data parameter in the `.DataFrame()` method like so.
+    """)
     return
 
 
@@ -98,25 +94,21 @@ def _(dct_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-    In this case, Polars turned each of the lists in the dictionary into a column in the DataFrame. 
+    mo.md(r"""
+    In this case, Polars turned each of the lists in the dictionary into a column in the DataFrame.
 
     The other data structures will follow a similar pattern when converting them to DataFrames.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ##### Sequence
 
     Sequences are data structures that contain collections of items, which can be accessed using its index. Examples of sequences are lists, tuples, and strings. We will be using a list of lists in order to demonstrate how to convert a sequence in a DataFrame.
-    """
-    )
+    """)
     return
 
 
@@ -136,19 +128,19 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Notice that since we didn't specify the column names, Polars automatically named them `column_0`, `column_1`, and `column_2`. Later, we will show you how to specify the names of the columns.""")
+    mo.md(r"""
+    Notice that since we didn't specify the column names, Polars automatically named them `column_0`, `column_1`, and `column_2`. Later, we will show you how to specify the names of the columns.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ##### NumPy Array
 
     NumPy arrays are considered a sequence of items that can also be accessed using its index. An important thing to note is that all of the items in an array must have the same data type.
-    """
-    )
+    """)
     return
 
 
@@ -168,19 +160,19 @@ def _(arr_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Notice that each inner array is a row in the DataFrame, not a column like the previous methods discussed. Later, we will go over how to tell Polars if we the information in the data structure to be presented as rows or columns.""")
+    mo.md(r"""
+    Notice that each inner array is a row in the DataFrame, not a column like the previous methods discussed. Later, we will go over how to tell Polars if we the information in the data structure to be presented as rows or columns.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ##### Series
 
     Series are a way to store a single column in a DataFrame and all entries in a series must have the same data type. You can combine these series together to form one DataFrame.
-    """
-    )
+    """)
     return
 
 
@@ -200,13 +192,11 @@ def _(pl, pl_series):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ##### Pandas DataFrame
 
     Another popular package that utilizes DataFrames is pandas. By passing in a pandas DataFrame into .DataFrame(), you can easily convert it into a Polars DataFrame.
-    """
-    )
+    """)
     return
 
 
@@ -230,19 +220,19 @@ def _(pd_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now that we've looked over what can be converted into a DataFrame and the basics of it, let's look at the structure of the DataFrame.""")
+    mo.md(r"""
+    Now that we've looked over what can be converted into a DataFrame and the basics of it, let's look at the structure of the DataFrame.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## DataFrame Structure
 
     Let's recall one of the DataFrames we defined earlier.
-    """
-    )
+    """)
     return
 
 
@@ -254,14 +244,15 @@ def _(dct_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can see that this DataFrame has 4 rows and 3 columns as indicated by the text beneath the DataFrame. Each column has a name that can be used to access the data within that column. In this case, the names are: "col1", "col2", and "col3". Below the column name, there is text that indicates the data type stored within that column. "col1" has the text "i64" underneath its name, meaning that that column stores integers. "col2" stores strings as seen by the "str" under the column name. Finally, "col3" stores floats as it has "f64" under the column name. Polars will automatically assume the data types stored in each column, but we will go over a way to specify it later in this tutorial. Each column can only hold one data type at a time, so you can't have a string and an integer in the same column.""")
+    mo.md(r"""
+    We can see that this DataFrame has 4 rows and 3 columns as indicated by the text beneath the DataFrame. Each column has a name that can be used to access the data within that column. In this case, the names are: "col1", "col2", and "col3". Below the column name, there is text that indicates the data type stored within that column. "col1" has the text "i64" underneath its name, meaning that that column stores integers. "col2" stores strings as seen by the "str" under the column name. Finally, "col3" stores floats as it has "f64" under the column name. Polars will automatically assume the data types stored in each column, but we will go over a way to specify it later in this tutorial. Each column can only hold one data type at a time, so you can't have a string and an integer in the same column.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Parameters
 
     On top of the "data" parameter, there are 6 additional parameters you can specify:
@@ -272,20 +263,17 @@ def _(mo):
     4. orient
     5. infer_schema_length
     6. nan_to_null
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### Schema
 
     Let's recall the DataFrame we created using a sequence.
-    """
-    )
+    """)
     return
 
 
@@ -297,7 +285,9 @@ def _(seq_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can see that the column names and data type were inferred by Polars. The schema parameter allows us to specify the column names and data type we want for each column. There are 3 ways you can use this parameter. The first way involves using a dictionary to define the following key value pair: column name:data type.""")
+    mo.md(r"""
+    We can see that the column names and data type were inferred by Polars. The schema parameter allows us to specify the column names and data type we want for each column. There are 3 ways you can use this parameter. The first way involves using a dictionary to define the following key value pair: column name:data type.
+    """)
     return
 
 
@@ -309,7 +299,9 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""You can also do this using a list of (column name, data type) pairs instead of a dictionary.""")
+    mo.md(r"""
+    You can also do this using a list of (column name, data type) pairs instead of a dictionary.
+    """)
     return
 
 
@@ -321,7 +313,9 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Notice how both the column names and the data type (text underneath the column name) is different from the original `seq_df`. If you only wanted to specify the column names and let Polars assume the data type, you can do so using a list of column names.""")
+    mo.md(r"""
+    Notice how both the column names and the data type (text underneath the column name) is different from the original `seq_df`. If you only wanted to specify the column names and let Polars assume the data type, you can do so using a list of column names.
+    """)
     return
 
 
@@ -333,19 +327,19 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The text under the column names is different from the previous two DataFrames we created since we didn't explicitly tell Polars what data type we wanted in each column.""")
+    mo.md(r"""
+    The text under the column names is different from the previous two DataFrames we created since we didn't explicitly tell Polars what data type we wanted in each column.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### Schema_Overrides
 
     If you only wanted to specify the data type of specific columns and let Polars infer the rest, you can use the schema_overrides parameter for that. This parameter requires that you pass in a dictionary where the key value pair is column name:data type. Unlike the schema parameter, the column name must match the name already present in the DataFrame as that is how Polars will identify which column you want to specify the data type. If you use a column name that doesn't already exist, Polars won't be able to change the data type.
-    """
-    )
+    """)
     return
 
 
@@ -357,13 +351,11 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Notice here that only the data type in the first column changed while Polars inferred the rest.
 
     It is important to note that if you only use the schema_overrides parameter, you are limited to how much you can change the data type. In the example above, we were able to change the data type from int32 to int16 without any further parameters since the data type is still an integer. However, if we wanted to change the first column to be a string, we would get an error as Polars has already strictly set the schema to only take in integer values.
-    """
-    )
+    """)
     return
 
 
@@ -378,25 +370,27 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""If we wanted to use schema_override to completely change the data type of the column, we need an additional parameter: strict.""")
+    mo.md(r"""
+    If we wanted to use schema_override to completely change the data type of the column, we need an additional parameter: strict.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### Strict
 
     The strict parameter allows you to specify if you want a column's data type to be enforced with flexibility or not. When set to `True`, Polars will raise an error if there is a data type that doesn't match the data type the column is expecting. It will not attempt to type cast it to the correct data type as Polars prioritizes that all the data can be converted without any loss or error. When set to `False`, Polars will attempt to type cast the data into the data type the column wants. If it is unable to successfully convert the data type, the value will be replaced with a null value.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's see an example of what happens when strict is set to `True`. The cell below should show an error.""")
+    mo.md(r"""
+    Let's see an example of what happens when strict is set to `True`. The cell below should show an error.
+    """)
     return
 
 
@@ -413,7 +407,9 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now let's try setting strict to `False`.""")
+    mo.md(r"""
+    Now let's try setting strict to `False`.
+    """)
     return
 
 
@@ -425,19 +421,19 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Since we allowed for Polars to change the schema by setting strict to `False`, we were able to cast the first column to be strings.""")
+    mo.md(r"""
+    Since we allowed for Polars to change the schema by setting strict to `False`, we were able to cast the first column to be strings.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     #### Orient
 
     Let's recall the DataFrame we made by using an array and the data used to make it.
-    """
-    )
+    """)
     return
 
 
@@ -455,7 +451,9 @@ def _(arr_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Notice how Polars decided to make each inner array a row in the DataFrame. If we wanted to make it so that each inner array was a column instead of a row, all we would need to do is pass `"col"` into the orient parameter.""")
+    mo.md(r"""
+    Notice how Polars decided to make each inner array a row in the DataFrame. If we wanted to make it so that each inner array was a column instead of a row, all we would need to do is pass `"col"` into the orient parameter.
+    """)
     return
 
 
@@ -467,7 +465,9 @@ def _(arr_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""If we wanted to do the opposite, then we pass `"row"` into the orient parameter.""")
+    mo.md(r"""
+    If we wanted to do the opposite, then we pass `"row"` into the orient parameter.
+    """)
     return
 
 
@@ -485,39 +485,33 @@ def _(pl, seq_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### Infer_Schema_Length
 
     Without setting the schema ourselves, Polars uses the data provided to infer the data types of the columns. It does this by looking at each of the rows in the data provided. You can specify to Polars how many rows to look at by using the infer_schema_length parameter. For example, if you were to set this parameter to 5, then Polars would use the first 5 rows to infer the schema.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     #### NaN_To_Null
 
     If there are np.nan values in the data, you can convert them to null values by setting the nan_to_null parameter to `True`.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Summary
 
-    DataFrames are a useful data structure that can be used to organize and perform additional analysis on your data. In this notebook, we have learned how to define DataFrames, what can be a DataFrame, the structure of it, and additional parameters you can set while creating it. 
+    DataFrames are a useful data structure that can be used to organize and perform additional analysis on your data. In this notebook, we have learned how to define DataFrames, what can be a DataFrame, the structure of it, and additional parameters you can set while creating it.
 
     In order to create a DataFrame, you pass your data into the .DataFrame() method through the data parameter. The data you pass through must be either a dictionary, sequence, array, series, or pandas DataFrame. Once defined, the DataFrame will separate the data into different columns and the data within the column must have the same data type. There exists additional parameters besides data that allows you to further customize the ending DataFrame. Some examples of these are orient, strict, and infer_schema_length.
-    """
-    )
+    """)
     return
 
 

polars/03_loading_data.py

@@ -14,14 +14,13 @@
 
 import marimo
 
-__generated_with = "0.15.2"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Loading Data
 
     _By [etrotta](https://github.com/etrotta)._
@@ -29,8 +28,7 @@ def _(mo):
     This tutorial covers how to load data of varying formats and from different sources using [polars](https://docs.pola.rs/).
 
     It includes examples of how to load and write to a variety of formats, shows how to convert data from other libraries to support formats not supported directly by polars, includes relevant links for users that need to connect with external sources, and explains how to deal with custom formats via plugins.
-    """
-    )
+    """)
     return
 
 
@@ -80,12 +78,10 @@ def _(mo, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Parquet
     Parquet is a popular format for storing tabular data based on the Arrow memory spec, it is a great default and you'll find a lot of datasets already using it in sites like HuggingFace
-    """
-    )
+    """)
     return
 
 
@@ -100,14 +96,12 @@ def _(df, folder, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## CSV
     A classic and common format that has been widely used for decades.
 
     The API is almost identical to Parquet - You can just replace `parquet` by `csv` and it will work with the default settings, but polars also allows for you to customize some settings such as the delimiter and quoting rules.
-    """
-    )
+    """)
     return
 
 
@@ -123,8 +117,7 @@ def _(df, folder, lz, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## JSON
 
     JavaScript Object Notation is somewhat commonly used for storing unstructed data, and extremely commonly used for API responses.
@@ -138,8 +131,7 @@ def _(mo):
         Polars supports Lists with variable length, Arrays with fixed length, and Structs with well defined fields, but not mappings with arbitrary keys.
 
         You might want to transform data by unnesting structs and exploding lists after loading from complex JSON files.
-    """
-    )
+    """)
     return
 
 
@@ -163,8 +155,7 @@ def _(df, folder, lz, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Databases
 
     Polars doesn't supports any databases _directly_, but rather uses other libraries as Engines. Reading and writing to databases using polars methods does not supports Lazy execution, but you may pass an SQL Query for the database to pre-filter the data before reaches polars. See the [User Guide](https://docs.pola.rs/user-guide/io/database)  for more details.
@@ -172,8 +163,7 @@ def _(mo):
     You can also use other libraries with [arrow support](#arrow-support) or [polars plugins](#plugin-support) to read from databases before loading into polars, some of which support lazy reading.
 
     Using the Arrow Database Connectivity SQLite support as an example:
-    """
-    )
+    """)
     return
 
 
@@ -190,43 +180,37 @@ def _(df, folder, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Excel
 
     From a performance perspective, we recommend using other formats if possible, such as Parquet or CSV files.
 
     Similarly to Databases, polars doesn't supports it natively but rather uses other libraries as Engines. See the [User Guide](https://docs.pola.rs/user-guide/io/excel) if you need to use it.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Others natively supported
 
     If you understood the above examples, then all other formats should feel familiar - the core API is the same for all formats, `read` and `write` for the Eager API or `scan` and `sink` for the lazy API.
 
     See https://docs.pola.rs/api/python/stable/reference/io.html for the full list of formats natively supported by Polars
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Arrow Support
 
     You can convert Arrow compatible data from other libraries such as `pandas`, `duckdb` or `pyarrow` to polars DataFrames and vice-versa, much of the time without even having to copy data.
 
     This allows for you to use other libraries to load data in formats not support by polars, then convert the dataframe in-memory to polars.
-    """
-    )
+    """)
     return
 
 
@@ -241,13 +225,11 @@ def _(df, folder, pd, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Plugin Support
 
     You can also write [IO Plugins](https://docs.pola.rs/user-guide/plugins/io_plugins/) for Polars in order to support any format you need, or use other libraries that support polars via their own plugins such as DuckDB.
-    """
-    )
+    """)
     return
 
 
@@ -261,8 +243,7 @@ def _(duckdb, folder):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Creating your own Plugin
 
     The simplest form of plugins are essentially generators that yield DataFrames.
@@ -273,12 +254,11 @@ def _(mo):
 
     - You must use `register_io_source` for polars to create the LazyFrame which will consume the Generator
     - You are expected to provide a Schema before the Generator starts
-    - - For many use cases the Plugin may be able to infer it, but you could also pass it explicitly to the plugin function 
+    - - For many use cases the Plugin may be able to infer it, but you could also pass it explicitly to the plugin function
     - Ideally you should parse some of the filters and column selectors to avoid unnecessary work, but it is possible to delegate that to polars after loading the data in order to keep it simpler (at the cost of efficiency)
 
     Efficiently parsing the filter expressions is out of the scope for this notebook.
-    """
-    )
+    """)
     return
 
 
@@ -351,8 +331,7 @@ def _(Iterator, get_positional_names, itertools, pl, register_io_source):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### DuckDB
 
     As demonstrated above, in addition to Arrow interoperability support, [DuckDB](https://duckdb.org/) also has added support for loading query results into a polars DataFrame or LazyFrame via a polars plugin.
@@ -363,8 +342,7 @@ def _(mo):
     - https://duckdb.org/docs/stable/guides/python/polars.html
 
     You can learn more about DuckDB in the marimo course about it as well, including Marimo SQL related features
-    """
-    )
+    """)
     return
 
 
@@ -398,16 +376,14 @@ def _(duckdb_conn, duckdb_query):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Hive Partitions
 
     There is also support for [Hive](https://docs.pola.rs/user-guide/io/hive/) partitioned data, but parts of the API are still unstable (may change in future polars versions
     ).
 
     Even without using partitions, many methods also support glob patterns to read multiple files in the same folder such as `scan_csv(folder / "*.csv")`
-    """
-    )
+    """)
     return
 
 
@@ -422,28 +398,24 @@ def _(df, folder, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Reading from the Cloud
 
-    Polars also has support for reading public and private datasets from multiple websites 
+    Polars also has support for reading public and private datasets from multiple websites
     and cloud storage solutions.
 
     If you must (re)use the same file many times in the same machine you may want to manually download it then load from your local file system instead to avoid re-downloading though, or download and write to disk only if the file does not exists.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Arbitrary web sites
 
     You can load files from nearly any website just by using a HTTPS URL, as long as it is not locked behind authorization.
-    """
-    )
+    """)
     return
 
 
@@ -455,15 +427,13 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Hugging Face & Kaggle Datasets
 
     Look for polars inside of dropdowns such as "Use this dataset" in Hugging Face or "Code" in Kaggle, and oftentimes you'll get a snippet to load data directly into a dataframe you can use
 
     Read more: [Hugging Face](https://docs.pola.rs/user-guide/io/hugging-face/), [Kaggle](https://github.com/Kaggle/kagglehub/blob/main/README.md#kaggledatasetadapterpolars)
-    """
-    )
+    """)
     return
 
 
@@ -475,15 +445,13 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Cloud Storage - AWS S3, Azure Blob Storage, Google Cloud Storage
 
     The API is the same for all three storage providers, check the [User Guide](https://docs.pola.rs/user-guide/io/cloud-storage/) if you need of any of them.
 
     Runnable examples are not included in this Notebook as it would require setting up authentication, but the disabled cell below shows an example using Azure.
-    """
-    )
+    """)
     return
 
 
@@ -510,13 +478,11 @@ def _(adlfs, df, os, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Multiplexing
 
     You can also split a query into multiple sinks via [multiplexing](https://docs.pola.rs/user-guide/lazy/multiplexing/), to avoid reading multiple times, repeating the same operations for each sink or collecting intermediary results into memory.
-    """
-    )
+    """)
     return
 
 
@@ -540,13 +506,11 @@ def _(folder, lz, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Async Execution
 
     Polars also has experimental support for running lazy queries in `async` mode, letting you `await` operations inside of async functions.
-    """
-    )
+    """)
     return
 
 
@@ -566,27 +530,23 @@ async def _(folder, lz, pl, sinks):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Conclusion
     As you have seen, polars makes it easy to work with a variety of formats and different data sources.
 
     From natively supported formats such as Parquet and CSV files, to using other libraries as an intermediary for XML or geospatial data, and plugins for newly emerging or proprietary formats, as long as your data can fit in a table then odds are you can turn it into a polars DataFrame.
 
     Combined with loading directly from remote sources, including public data platforms such as Hugging Face and Kaggle as well as private data in your cloud, you can import datasets for almost anything you can imagine.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Utilities
     Imports, utility functions and alike used through the Notebook
-    """
-    )
+    """)
     return
 
 

polars/04_basic_operations.py

@@ -8,7 +8,7 @@
 
 import marimo
 
-__generated_with = "0.11.13"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -20,14 +20,12 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Basic operations on data
-        _By [Joram Mutenge](https://www.udemy.com/user/joram-mutenge/)._
+    mo.md(r"""
+    # Basic operations on data
+    _By [Joram Mutenge](https://www.udemy.com/user/joram-mutenge/)._
 
-        In this notebook, you'll learn how to perform arithmetic operations, comparisons, and conditionals on a Polars dataframe. We'll work with a DataFrame that tracks software usage by year, categorized as either Vintage (old) or Modern (new).
-        """
-    )
+    In this notebook, you'll learn how to perform arithmetic operations, comparisons, and conditionals on a Polars dataframe. We'll work with a DataFrame that tracks software usage by year, categorized as either Vintage (old) or Modern (new).
+    """)
     return
 
 
@@ -107,13 +105,11 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Arithmetic
-        ### Addition
-        Let's add 42 users to each piece of software. This means adding 42 to each value under **users**.
-        """
-    )
+    mo.md(r"""
+    ## Arithmetic
+    ### Addition
+    Let's add 42 users to each piece of software. This means adding 42 to each value under **users**.
+    """)
     return
 
 
@@ -125,7 +121,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Another way to perform the above operation is using the built-in function.""")
+    mo.md(r"""
+    Another way to perform the above operation is using the built-in function.
+    """)
     return
 
 
@@ -137,12 +135,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Subtraction
-        Let's subtract 42 users to each piece of software.
-        """
-    )
+    mo.md(r"""
+    ### Subtraction
+    Let's subtract 42 users to each piece of software.
+    """)
     return
 
 
@@ -154,7 +150,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Alternatively, you could subtract like this:""")
+    mo.md(r"""
+    Alternatively, you could subtract like this:
+    """)
     return
 
 
@@ -166,12 +164,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Division
-        Suppose the **users** values are inflated, we can reduce them by dividing by 1000. Here's how to do it.
-        """
-    )
+    mo.md(r"""
+    ### Division
+    Suppose the **users** values are inflated, we can reduce them by dividing by 1000. Here's how to do it.
+    """)
     return
 
 
@@ -183,7 +179,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Or we could do it with a built-in expression.""")
+    mo.md(r"""
+    Or we could do it with a built-in expression.
+    """)
     return
 
 
@@ -195,7 +193,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""If we didn't care about the remainder after division (i.e remove numbers after decimal point) we could do it like this.""")
+    mo.md(r"""
+    If we didn't care about the remainder after division (i.e remove numbers after decimal point) we could do it like this.
+    """)
     return
 
 
@@ -207,12 +207,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Multiplication
-        Let's pretend the *user* values are deflated and increase them by multiplying by 100.
-        """
-    )
+    mo.md(r"""
+    ### Multiplication
+    Let's pretend the *user* values are deflated and increase them by multiplying by 100.
+    """)
     return
 
 
@@ -224,7 +222,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Polars also has a built-in function for multiplication.""")
+    mo.md(r"""
+    Polars also has a built-in function for multiplication.
+    """)
     return
 
 
@@ -236,7 +236,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""So far, we've only modified the values in an existing column. Let's create a column **decade** that will represent the years as decades. Thus 1985 will be 1980 and 2008 will be 2000.""")
+    mo.md(r"""
+    So far, we've only modified the values in an existing column. Let's create a column **decade** that will represent the years as decades. Thus 1985 will be 1980 and 2008 will be 2000.
+    """)
     return
 
 
@@ -248,7 +250,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We could create a new column another way as follows:""")
+    mo.md(r"""
+    We could create a new column another way as follows:
+    """)
     return
 
 
@@ -260,16 +264,14 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        **Tip**  
-        Polars encounrages you to perform your operations as a chain. This enables you to take advantage of the query optimizer. We'll build upon the above code as a chain.
+    mo.md(r"""
+    **Tip**
+    Polars encounrages you to perform your operations as a chain. This enables you to take advantage of the query optimizer. We'll build upon the above code as a chain.
 
-        ## Comparison
-        ### Equal
-        Let's get all the software categorized as Vintage.
-        """
-    )
+    ## Comparison
+    ### Equal
+    Let's get all the software categorized as Vintage.
+    """)
     return
 
 
@@ -284,7 +286,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We could also do a double comparison. VisiCal is the only software that's vintage and in the decade 1970s. Let's perform this comparison operation.""")
+    mo.md(r"""
+    We could also do a double comparison. VisiCal is the only software that's vintage and in the decade 1970s. Let's perform this comparison operation.
+    """)
     return
 
 
@@ -300,13 +304,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        We could also do this comparison in one line, if readability is not a concern
+    mo.md(r"""
+    We could also do this comparison in one line, if readability is not a concern
 
-        **Notice** that we must enclose the two expressions between the `&` with parenthesis.
-        """
-    )
+    **Notice** that we must enclose the two expressions between the `&` with parenthesis.
+    """)
     return
 
 
@@ -321,7 +323,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can also use the built-in function for equal to comparisons.""")
+    mo.md(r"""
+    We can also use the built-in function for equal to comparisons.
+    """)
     return
 
 
@@ -336,12 +340,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Not equal
-        We can also compare if something is `not` equal to something. In this case, category is not vintage.
-        """
-    )
+    mo.md(r"""
+    ### Not equal
+    We can also compare if something is `not` equal to something. In this case, category is not vintage.
+    """)
     return
 
 
@@ -356,7 +358,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Or with the built-in function.""")
+    mo.md(r"""
+    Or with the built-in function.
+    """)
     return
 
 
@@ -371,7 +375,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Or if you want to be extra clever, you can use the negation symbol `~` used in logic.""")
+    mo.md(r"""
+    Or if you want to be extra clever, you can use the negation symbol `~` used in logic.
+    """)
     return
 
 
@@ -386,12 +392,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Greater than
-        Let's get the software where the year is greater than 2008 from the above dataframe.
-        """
-    )
+    mo.md(r"""
+    ### Greater than
+    Let's get the software where the year is greater than 2008 from the above dataframe.
+    """)
     return
 
 
@@ -407,7 +411,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Or if we wanted the year 2008 to be included, we could use great or equal to.""")
+    mo.md(r"""
+    Or if we wanted the year 2008 to be included, we could use great or equal to.
+    """)
     return
 
 
@@ -423,7 +429,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We could do the previous two operations with built-in functions. Here's with greater than.""")
+    mo.md(r"""
+    We could do the previous two operations with built-in functions. Here's with greater than.
+    """)
     return
 
 
@@ -439,7 +447,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""And here's with greater or equal to""")
+    mo.md(r"""
+    And here's with greater or equal to
+    """)
     return
 
 
@@ -455,14 +465,12 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        **Note**: For "less than", and "less or equal to" you can use the operators `<` or `<=`. Alternatively, you can use built-in functions `lt` or `le` respectively.
+    mo.md(r"""
+    **Note**: For "less than", and "less or equal to" you can use the operators `<` or `<=`. Alternatively, you can use built-in functions `lt` or `le` respectively.
 
-        ### Is between
-        Polars also allows us to filter between a range of values. Let's get the modern software were the year is between 2013 and 2016. This is inclusive on both ends (i.e. both years are part of the result).
-        """
-    )
+    ### Is between
+    Polars also allows us to filter between a range of values. Let's get the modern software were the year is between 2013 and 2016. This is inclusive on both ends (i.e. both years are part of the result).
+    """)
     return
 
 
@@ -478,14 +486,12 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Or operator
-        If we only want either one of the conditions in the comparison to be met, we could use `|`, which is the `or` operator.
+    mo.md(r"""
+    ### Or operator
+    If we only want either one of the conditions in the comparison to be met, we could use `|`, which is the `or` operator.
 
-        Let's get software that is either modern or used in the decade 1980s.
-        """
-    )
+    Let's get software that is either modern or used in the decade 1980s.
+    """)
     return
 
 
@@ -500,14 +506,12 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Conditionals
-        Polars also allows you create new columns based on a condition. Let's create a column *status* that will indicate if the software is "discontinued" or "in use".
+    mo.md(r"""
+    ## Conditionals
+    Polars also allows you create new columns based on a condition. Let's create a column *status* that will indicate if the software is "discontinued" or "in use".
 
-        Here's a list of products that are no longer in use.
-        """
-    )
+    Here's a list of products that are no longer in use.
+    """)
     return
 
 
@@ -519,7 +523,9 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Here's how we can get a dataframe of the products that are discontinued.""")
+    mo.md(r"""
+    Here's how we can get a dataframe of the products that are discontinued.
+    """)
     return
 
 
@@ -534,7 +540,9 @@ def _(df, discontinued_list, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now, let's create the **status** column.""")
+    mo.md(r"""
+    Now, let's create the **status** column.
+    """)
     return
 
 
@@ -553,12 +561,10 @@ def _(df, discontinued_list, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Unique counts
-        Sometimes you may want to see only the unique values in a column. Let's check the unique decades we have in our DataFrame.
-        """
-    )
+    mo.md(r"""
+    ## Unique counts
+    Sometimes you may want to see only the unique values in a column. Let's check the unique decades we have in our DataFrame.
+    """)
     return
 
 
@@ -578,7 +584,9 @@ def _(df, discontinued_list, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Finally, let's find out the number of software used in each decade.""")
+    mo.md(r"""
+    Finally, let's find out the number of software used in each decade.
+    """)
     return
 
 
@@ -598,7 +606,9 @@ def _(df, discontinued_list, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We could also rewrite the above code as follows:""")
+    mo.md(r"""
+    We could also rewrite the above code as follows:
+    """)
     return
 
 
@@ -618,7 +628,9 @@ def _(df, discontinued_list, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Hopefully, we've picked your interest to try out Polars the next time you analyze your data.""")
+    mo.md(r"""
+    Hopefully, we've picked your interest to try out Polars the next time you analyze your data.
+    """)
     return
 
 

polars/05_reactive_plots.py

@@ -11,26 +11,24 @@
 
 import marimo
 
-__generated_with = "0.12.10"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Reactive Plots
+    mo.md("""
+    # Reactive Plots
 
-        _By [etrotta](https://github.com/etrotta)._
+    _By [etrotta](https://github.com/etrotta)._
 
-        This tutorial covers Data Visualisation basics using marimo, [polars](https://docs.pola.rs/) and [plotly](https://plotly.com/python/plotly-express/).
-        It shows how to load data, explore and visualise it, then use User Interface elements (including the plots themselves) to filter and select data for more refined analysis.
+    This tutorial covers Data Visualisation basics using marimo, [polars](https://docs.pola.rs/) and [plotly](https://plotly.com/python/plotly-express/).
+    It shows how to load data, explore and visualise it, then use User Interface elements (including the plots themselves) to filter and select data for more refined analysis.
 
-        We will be using a [Spotify Tracks dataset](https://huggingface.co/datasets/maharshipandya/spotify-tracks-dataset). Before you write any code yourself, I recommend taking some time to understand the data you're working with, from which columns are available to what are their possible values, as well as more abstract details such as the scope, coverage and intended uses of the dataset.
+    We will be using a [Spotify Tracks dataset](https://huggingface.co/datasets/maharshipandya/spotify-tracks-dataset). Before you write any code yourself, I recommend taking some time to understand the data you're working with, from which columns are available to what are their possible values, as well as more abstract details such as the scope, coverage and intended uses of the dataset.
 
-        Note that this dataset does not contains data about ***all***  tracks, you can try using a larger dataset such as [bigdata-pw/Spotify](https://huggingface.co/datasets/bigdata-pw/Spotify), but I'm sticking with the smaller one to keep the notebook size manageable for most users.
-        """
-    )
+    Note that this dataset does not contains data about ***all***  tracks, you can try using a larger dataset such as [bigdata-pw/Spotify](https://huggingface.co/datasets/bigdata-pw/Spotify), but I'm sticking with the smaller one to keep the notebook size manageable for most users.
+    """)
     return
 
 
@@ -47,20 +45,18 @@ def _(pl):
     # Or save to a local file first if you want to avoid downloading it each time you run:
     # file_path = "spotify-tracks.parquet"
     # lz = pl.scan_parquet(file_path)
-    return URL, branch, file_path, lz, repo_id
+    return (lz,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        You should always take a look at the data you are working on before actually doing any operations on it - for data coming from sources such as HuggingFace or Kaggle you can preview it via their websites, and optionally filter or do some transformations before downloading.
+    mo.md("""
+    You should always take a look at the data you are working on before actually doing any operations on it - for data coming from sources such as HuggingFace or Kaggle you can preview it via their websites, and optionally filter or do some transformations before downloading.
 
-        The [Polars Lazy API](https://docs.pola.rs/user-guide/lazy/) allows for you define operations before loading the data, and polars will optimize the plan in order to avoid doing unnecessary operations or loading data we do not care about.
+    The [Polars Lazy API](https://docs.pola.rs/user-guide/lazy/) allows for you define operations before loading the data, and polars will optimize the plan in order to avoid doing unnecessary operations or loading data we do not care about.
 
-        Let's say that looking at the dataset's preview in the Data Viewer, we decided we do not want the Unnamed column (which appears to be the row index), nor do we care about the original ID, and we only want non-explicit tracks.
-        """
-    )
+    Let's say that looking at the dataset's preview in the Data Viewer, we decided we do not want the Unnamed column (which appears to be the row index), nor do we care about the original ID, and we only want non-explicit tracks.
+    """)
     return
 
 
@@ -87,18 +83,16 @@ def _(lz, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        When you start exploring a dataset, some of the first things to do may include:
+    mo.md(r"""
+    When you start exploring a dataset, some of the first things to do may include:
 
-        - investigating any values that seem weird
-        - verifying if there could be issues in the data
-        - checking for potential bugs in our pipelines
-        - ensuring you understand the data correctly, including its relationships and edge cases
+    - investigating any values that seem weird
+    - verifying if there could be issues in the data
+    - checking for potential bugs in our pipelines
+    - ensuring you understand the data correctly, including its relationships and edge cases
 
-        For example, the "min" value for the duration column is zero, and the max is over an hour. Why is that?
-        """
-    )
+    For example, the "min" value for the duration column is zero, and the max is over an hour. Why is that?
+    """)
     return
 
 
@@ -112,13 +106,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        For this Notebook we will be using [plotly](https://plotly.com/python), but Marimo also [supports other plotting libraries](https://docs.marimo.io/guides/working_with_data/plotting/).
+    mo.md(r"""
+    For this Notebook we will be using [plotly](https://plotly.com/python), but Marimo also [supports other plotting libraries](https://docs.marimo.io/guides/working_with_data/plotting/).
 
-        Let's visualize it using a [bar chart](https://plotly.com/python/bar-charts/) and get a feel for which region makes sense to focus on for our analysis
-        """
-    )
+    Let's visualize it using a [bar chart](https://plotly.com/python/bar-charts/) and get a feel for which region makes sense to focus on for our analysis
+    """)
     return
 
 
@@ -129,20 +121,18 @@ def _(df, mo, px):
     fig.update_layout(selectdirection="h")
     plot = mo.ui.plotly(fig)
     plot
-    return duration_counts, fig, plot
+    return (plot,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        Note how there are a few outliers with extremely little duration (less than 2 minutes) and a few with extremely long duration (more than 6 minutes)
+    mo.md("""
+    Note how there are a few outliers with extremely little duration (less than 2 minutes) and a few with extremely long duration (more than 6 minutes)
 
-        You can select a region in the graph by clicking and dragging, which can later be used to filter or transform data. In this Notebook we set a default if there is no selection, but you should try selecting a region yourself.
+    You can select a region in the graph by clicking and dragging, which can later be used to filter or transform data. In this Notebook we set a default if there is no selection, but you should try selecting a region yourself.
 
-        We will focus on those within that middle ground from around 120 seconds to 360 seconds, but you can play around with it a bit and see how the results change if you move the Selection region. Perhaps you can even find some Classical songs?
-        """
-    )
+    We will focus on those within that middle ground from around 120 seconds to 360 seconds, but you can play around with it a bit and see how the results change if you move the Selection region. Perhaps you can even find some Classical songs?
+    """)
     return
 
 
@@ -154,7 +144,7 @@ def _(pl, plot):
 
 
 @app.cell
-def _(df, get_extremes, pl, plot):
+def _(df, pl, plot):
     # Now, we want to filter to only include tracks whose duration falls inside of our selection - we will need to first identify the extremes, then filter based on them
     min_dur, max_dur = get_extremes(
         plot.value, col="duration_seconds", defaults_if_missing=(120, 360)
@@ -168,27 +158,25 @@ def _(df, get_extremes, pl, plot):
     # Actually apply the filter
     filtered_duration = df.filter(duration_in_range)
     filtered_duration
-    return duration_in_range, filtered_duration, max_dur, min_dur
+    return (filtered_duration,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Now that our data is 'clean', let's start coming up with and answering some questions about it. Some examples:
-
-        - Which tracks or artists are the most popular? (Both globally as well as for each genre)
-        - Which genres are the most popular? The loudest?
-        - What are some common combinations of different artists? 
-        - What can we infer anything based on the track's title or artist name?
-        - How popular is some specific song you like?
-        - How much does the mode and key affect other attributes?
-        - Can you classify a song's genre based on its attributes?
-
-        For brevity, we will not explore all of them - feel free to try some of the others yourself, or go more in deep in the explored ones.
-        Make sure to come up with some questions of your own and explore them as well!
-        """
-    )
+    mo.md(r"""
+    Now that our data is 'clean', let's start coming up with and answering some questions about it. Some examples:
+
+    - Which tracks or artists are the most popular? (Both globally as well as for each genre)
+    - Which genres are the most popular? The loudest?
+    - What are some common combinations of different artists?
+    - What can we infer anything based on the track's title or artist name?
+    - How popular is some specific song you like?
+    - How much does the mode and key affect other attributes?
+    - Can you classify a song's genre based on its attributes?
+
+    For brevity, we will not explore all of them - feel free to try some of the others yourself, or go more in deep in the explored ones.
+    Make sure to come up with some questions of your own and explore them as well!
+    """)
     return
 
 
@@ -235,18 +223,16 @@ def _(filter_genre, filtered_duration, mo, pl):
             ),
         ],
     )
-    return (most_popular_artists,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        So far so good - but there's been a distinct lack of visualations, so let's fix that.
+    mo.md(r"""
+    So far so good - but there's been a distinct lack of visualations, so let's fix that.
 
-        Let's start simple, just some metrics for each genre:
-        """
-    )
+    Let's start simple, just some metrics for each genre:
+    """)
     return
 
 
@@ -263,22 +249,20 @@ def _(filtered_duration, pl, px):
         x="popularity",
     )
     fig_dur_per_genre
-    return (fig_dur_per_genre,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Now, why don't we play a bit with marimo's UI elements?
+    mo.md(r"""
+    Now, why don't we play a bit with marimo's UI elements?
 
-        We will use Dropdowns to allow for the user to select any column to use for the visualisation, and throw in some extras
+    We will use Dropdowns to allow for the user to select any column to use for the visualisation, and throw in some extras
 
-        - A slider for the transparency to help understand dense clusters
-        - Add a Trendline to the scatterplot (requires statsmodels)
-        - Filter by some specific Genre
-        """
-    )
+    - A slider for the transparency to help understand dense clusters
+    - Add a Trendline to the scatterplot (requires statsmodels)
+    - Filter by some specific Genre
+    """)
     return
 
 
@@ -312,18 +296,16 @@ def _(
     chart2 = mo.ui.plotly(fig2)
 
     mo.vstack([mo.hstack([x_axis, y_axis, color, alpha, include_trendline, filter_genre2]), chart2])
-    return chart2, fig2
+    return (chart2,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        As we have seen before, we can also use the plot as an input to select a region and look at it in more detail.
+    mo.md(r"""
+    As we have seen before, we can also use the plot as an input to select a region and look at it in more detail.
 
-        Try selecting a region then performing some explorations of your own with the data inside of it.
-        """
-    )
+    Try selecting a region then performing some explorations of your own with the data inside of it.
+    """)
     return
 
 
@@ -340,47 +322,45 @@ def _(chart2, filtered_duration, mo, pl):
             pl.col(column_order), pl.exclude(*column_order)
         )
     out
-    return active_columns, column_order, out
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        In this notebook, we've focused on a few key aspects. First, it's essential to *understand* the data you're working with — this forms the foundation of any analysis. 
+    mo.md(r"""
+    In this notebook, we've focused on a few key aspects. First, it's essential to *understand* the data you're working with — this forms the foundation of any analysis.
 
-        Creating plots is a powerful way to identify patterns, outliers, and trends. These visualizations are not just for _presentation_; they are tools for deeper insight.
+    Creating plots is a powerful way to identify patterns, outliers, and trends. These visualizations are not just for _presentation_; they are tools for deeper insight.
 
-        /// NOTE
-        With marimo's `interactive` UI elements, exploring different _facets_ of the data becomes seamless, allowing for dynamic analysis without altering the code.
+    /// NOTE
+    With marimo's `interactive` UI elements, exploring different _facets_ of the data becomes seamless, allowing for dynamic analysis without altering the code.
 
-        Keep these points in mind as you continue to work with data.
-        """
-    )
+    Keep these points in mind as you continue to work with data.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""# Utility Functions and UI Elements""")
+    mo.md(r"""
+    # Utility Functions and UI Elements
+    """)
     return
 
 
-@app.cell
-def get_extremes():
-    def get_extremes(selection, col, defaults_if_missing):
-        "Get the minimum and maximum values for a given column within the selection"
-        if selection is None or len(selection) == 0:
-            print(
-                f"Could not find a selected region. Using default values {defaults_if_missing} instead, try clicking and dragging in the plot to change them."
-            )
-            return defaults_if_missing
-        else:
-            return (
-                min(row[col] for row in selection),
-                max(row[col] for row in selection),
-            )
-    return (get_extremes,)
+@app.function
+def get_extremes(selection, col, defaults_if_missing):
+    "Get the minimum and maximum values for a given column within the selection"
+    if selection is None or len(selection) == 0:
+        print(
+            f"Could not find a selected region. Using default values {defaults_if_missing} instead, try clicking and dragging in the plot to change them."
+        )
+        return defaults_if_missing
+    else:
+        return (
+            min(row[col] for row in selection),
+            max(row[col] for row in selection),
+        )
 
 
 @app.cell
@@ -426,20 +406,14 @@ def _(filtered_duration, mo):
         searchable=True,
         label="Filter by Track Genre:",
     )
-    return (
-        alpha,
-        color,
-        filter_genre2,
-        include_trendline,
-        options,
-        x_axis,
-        y_axis,
-    )
+    return alpha, color, filter_genre2, include_trendline, x_axis, y_axis
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""# Appendix : Some other examples""")
+    mo.md("""
+    # Appendix : Some other examples
+    """)
     return
 
 
@@ -461,12 +435,7 @@ def _(filtered_duration, mo, pl):
     # So we just provide freeform text boxes and filter ourselfves later
     # (the "alternative_" in the name is just to avoid conflicts with the above cell,
     #  despite this being disabled marimo still requires global variables to be unique)
-    return (
-        all_artists,
-        all_tracks,
-        alternative_filter_artist,
-        alternative_filter_track,
-    )
+    return
 
 
 @app.cell
@@ -503,7 +472,7 @@ def _(filter_artist, filter_track, filtered_duration, mo, pl):
     )
 
     mo.vstack([mo.md("Filter a track based on its name or artist"), filter_artist, filter_track, filtered_artist_track])
-    return filtered_artist_track, score_match_text
+    return
 
 
 @app.cell
@@ -532,7 +501,7 @@ def _(filter_genre2, filtered_duration, mo, pl):
         ],
         align="center",
     )
-    return (artist_combinations,)
+    return
 
 
 @app.cell

polars/06_Dataframe_Transformer.py

@@ -12,21 +12,19 @@
 
 import marimo
 
-__generated_with = "0.14.10"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Polars with Marimo's Dataframe Transformer
 
     *By [jesshart](https://github.com/jesshart)*
 
     The goal of this notebook is to explore Marimo's data explore capabilities alonside the power of polars. Feel free to reference the latest about these Marimo features here: https://docs.marimo.io/guides/working_with_data/dataframes/?h=dataframe#transforming-dataframes
-    """
-    )
+    """)
     return
 
 
@@ -40,14 +38,12 @@ def _(requests):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Loading Data
     Let's start by loading our data and getting into the `.lazy()` format so our transformations and queries are speedy.
 
     Read more about `.lazy()` here: https://docs.pola.rs/user-guide/lazy/
-    """
-    )
+    """)
     return
 
 
@@ -60,21 +56,18 @@ def _(json_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-    Above, you will notice that when you reference the object as a standalone, you get out-of-the-box convenience from `marimo`. You have the `Table` and `Query Plan` options to choose from. 
+    mo.md(r"""
+    Above, you will notice that when you reference the object as a standalone, you get out-of-the-box convenience from `marimo`. You have the `Table` and `Query Plan` options to choose from.
 
     - 💡 Try out the `Table` view! You can click the `Preview data` button to get a quick view of your data.
     - 💡 Take a look at the `Query plan`. Learn more about Polar's query plan here: https://docs.pola.rs/user-guide/lazy/query-plan/
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## marimo's Native Dataframe UI
 
     There are a few ways to leverage marimo's native dataframe UI. One is by doing what we saw above—by referencing a `pl.LazyFrame` directly. You can also try,
@@ -83,19 +76,16 @@ def _(mo):
     - Referencing a `pl.DataFrame` and see how it different from its corresponding lazy version
     - Use `mo.ui.table`
     - Use `mo.ui.dataframe`
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Reference a `pl.DataFrame`
     Let's reference the same frame as before, but this time as a `pl.DataFrame` by calling `.collect()` on it.
-    """
-    )
+    """)
     return
 
 
@@ -107,26 +97,22 @@ def _(demand: "pl.LazyFrame"):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Note how much functionality we have right out-of-the-box. Click on column names to see rich features like sorting, freezing, filtering, searching, and more!
 
     Notice how `order_quantity` has a green bar chart under it indicating the distribution of values for the field!
 
     Don't miss the `Download` feature as well which supports downloading in CSV, json, or parquet format!
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Use `mo.ui.table`
     The `mo.ui.table` allows you to select rows for use downstream. You can select the rows you want, and then use these as filtered rows downstream.
-    """
-    )
+    """)
     return
 
 
@@ -144,7 +130,9 @@ def _(demand_table):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""I like to use this feature to select groupings based on summary statistics so I can quickly explore subsets of categories. Let me show you what I mean.""")
+    mo.md(r"""
+    I like to use this feature to select groupings based on summary statistics so I can quickly explore subsets of categories. Let me show you what I mean.
+    """)
     return
 
 
@@ -175,13 +163,11 @@ def _(summary_table):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Now, instead of manually creating a filter for what I want to take a closer look at, I simply select from the ui and do a simple join to get that aggregated level with more detail.
 
     The following cell uses the output of the `mo.ui.table` selection, selects its unique keys, and uses that to join for the selected subset of the original table.
-    """
-    )
+    """)
     return
 
 
@@ -199,13 +185,17 @@ def _(demand: "pl.LazyFrame", pl, summary_table):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""You can learn more about joins in Polars by checking out my other interactive notebook here: https://marimo.io/p/@jesshart/basic-polars-joins""")
+    mo.md("""
+    You can learn more about joins in Polars by checking out my other interactive notebook here: https://marimo.io/p/@jesshart/basic-polars-joins
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Use `mo.ui.dataframe`""")
+    mo.md(r"""
+    ## Use `mo.ui.dataframe`
+    """)
     return
 
 
@@ -218,7 +208,9 @@ def _(demand: "pl.LazyFrame", mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Below I simply call the object into view. We will play with it in the following cells.""")
+    mo.md(r"""
+    Below I simply call the object into view. We will play with it in the following cells.
+    """)
     return
 
 
@@ -230,7 +222,9 @@ def _(mo_dataframe):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""One way to group this data in polars code directly would be to group by product family to get the mean. This is how it is done in polars:""")
+    mo.md(r"""
+    One way to group this data in polars code directly would be to group by product family to get the mean. This is how it is done in polars:
+    """)
     return
 
 
@@ -245,16 +239,14 @@ def _(demand_cached, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        f"""
+    mo.md(f"""
     ## Try Before You Buy
 
     1. Now try to do the same summary using Marimo's `mo.ui.dataframe` object above. Also, note how your aggregated column is already renamed! Nice touch!
     2. Try (1) again but use select statements first (This is actually better polars practice anyway since it reduces the frame as you move to aggregation.)
 
     *When you are ready, check the `Python Code` tab at the top of the table to compare your output to the answer below.*
-    """
-    )
+    """)
     return
 
 
@@ -331,29 +323,27 @@ def _(demand_agg: "pl.DataFrame", mo, px):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # About this Notebook
     Polars and Marimo are both relatively new to the data wrangling space, but their power (and the thrill of their use) cannot be overstated—well, I suppose it could, but you get the meaning. In this notebook, you learn how to leverage basic Polars skills to load-in and explore your data in concert with Marimo's powerful UI elements.
 
     ## 📚 Documentation References
 
-    - **Marimo: Dataframe Transformation Guide**  
+    - **Marimo: Dataframe Transformation Guide**
       https://docs.marimo.io/guides/working_with_data/dataframes/?h=dataframe#transforming-dataframes
 
-    - **Polars: Lazy API Overview**  
+    - **Polars: Lazy API Overview**
       https://docs.pola.rs/user-guide/lazy/
 
-    - **Polars: Query Plan Explained**  
+    - **Polars: Query Plan Explained**
       https://docs.pola.rs/user-guide/lazy/query-plan/
 
-    - **Marimo Notebook: Basic Polars Joins (by jesshart)**  
+    - **Marimo Notebook: Basic Polars Joins (by jesshart)**
       https://marimo.io/p/@jesshart/basic-polars-joins
 
-    - **Marimo Learn: Interactive Graphs with Polars**  
+    - **Marimo Learn: Interactive Graphs with Polars**
       https://github.com/marimo-team/learn/blob/main/polars/05_reactive_plots.py
-    """
-    )
+    """)
     return
 
 

polars/07-querying-with-sql.py

@@ -35,7 +35,7 @@ def _(mo):
 
 
 @app.cell
-def _(mo, reviews, sqlite_engine):
+def _(mo, sqlite_engine):
     _df = mo.sql(
         f"""
         SELECT * FROM reviews LIMIT 100
@@ -91,7 +91,7 @@ def _(mo):
 
 
 @app.cell
-def _(hotels, mo, sqlite_engine):
+def _(mo, sqlite_engine):
     _df = mo.sql(
         f"""
         SELECT * FROM hotels LIMIT 10
@@ -112,7 +112,7 @@ def _(mo):
 
 
 @app.cell
-def _(mo, reviews, sqlite_engine, users):
+def _(mo, sqlite_engine):
     polars_age_groups = mo.sql(
         f"""
         SELECT reviews.*, age_group FROM reviews JOIN users ON reviews.user_id = users.user_id LIMIT 1000
@@ -139,7 +139,7 @@ def _(mo):
 
 
 @app.cell
-def _(mo, reviews, sqlite_engine, users):
+def _(mo, sqlite_engine):
     _df = mo.sql(
         f"""
         SELECT age_group, AVG(reviews.score_overall) FROM reviews JOIN users ON reviews.user_id = users.user_id GROUP BY age_group
@@ -158,7 +158,7 @@ def _(mo):
 
 
 @app.cell
-def _(mo, polars_age_groups):
+def _(mo):
     _df = mo.sql(
         f"""
         SELECT * FROM polars_age_groups LIMIT 10
@@ -261,7 +261,7 @@ def _(mo):
 
 
 @app.cell
-def _(duckdb, hotels):
+def _(duckdb):
     duckdb.sql("SELECT * FROM hotels").pl(lazy=True).sort("cleanliness_base", descending=True).limit(5).collect()
     return
 

polars/08_working_with_columns.py

@@ -8,37 +8,33 @@
 
 import marimo
 
-__generated_with = "0.12.0"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Working with Columns
+    mo.md(r"""
+    # Working with Columns
 
-        Author: [Deb Debnath](https://github.com/debajyotid2)
+    Author: [Deb Debnath](https://github.com/debajyotid2)
 
-        **Note**: The following tutorial has been adapted from the Polars [documentation](https://docs.pola.rs/user-guide/expressions/expression-expansion).
-        """
-    )
+    **Note**: The following tutorial has been adapted from the Polars [documentation](https://docs.pola.rs/user-guide/expressions/expression-expansion).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expressions
+    mo.md(r"""
+    ## Expressions
 
-        Data transformations are sometimes complicated, or involve massive computations which are time-consuming. You can make a small version of the dataset with the schema you are trying to work your transformation into. But there is a better way to do it in Polars.
+    Data transformations are sometimes complicated, or involve massive computations which are time-consuming. You can make a small version of the dataset with the schema you are trying to work your transformation into. But there is a better way to do it in Polars.
 
-        A Polars expression is a lazy representation of a data transformation. "Lazy" means that the transformation is not eagerly (immediately) executed. 
+    A Polars expression is a lazy representation of a data transformation. "Lazy" means that the transformation is not eagerly (immediately) executed.
 
-        Expressions are modular and flexible. They can be composed to build more complex expressions. For example, to calculate speed from distance and time, you can have an expression as:
-        """
-    )
+    Expressions are modular and flexible. They can be composed to build more complex expressions. For example, to calculate speed from distance and time, you can have an expression as:
+    """)
     return
 
 
@@ -46,24 +42,24 @@ def _(mo):
 def _(pl):
     speed_expr = pl.col("distance") / (pl.col("time"))
     speed_expr
-    return (speed_expr,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expression expansion
+    mo.md(r"""
+    ## Expression expansion
 
-        Expression expansion lets you write a single expression that can expand to multiple different expressions. So rather than repeatedly defining separate expressions, you can avoid redundancy while adhering to clean code principles (Do not Repeat Yourself - [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)). Since expressions are reusable, they aid in writing concise code.
-        """
-    )
+    Expression expansion lets you write a single expression that can expand to multiple different expressions. So rather than repeatedly defining separate expressions, you can avoid redundancy while adhering to clean code principles (Do not Repeat Yourself - [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)). Since expressions are reusable, they aid in writing concise code.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""For the examples in this notebook, we will use a sliver of the *AI4I 2020 Predictive Maintenance Dataset*. This dataset comprises of measurements taken from sensors in industrial machinery undergoing preventive maintenance checks - basically being tested for failure conditions.""")
+    mo.md("""
+    For the examples in this notebook, we will use a sliver of the *AI4I 2020 Predictive Maintenance Dataset*. This dataset comprises of measurements taken from sensors in industrial machinery undergoing preventive maintenance checks - basically being tested for failure conditions.
+    """)
     return
 
 
@@ -80,32 +76,28 @@ def _(StringIO, pl):
 
     data = pl.read_csv(StringIO(data_csv))
     data
-    return data, data_csv
+    return (data,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Function `col`
+    mo.md(r"""
+    ## Function `col`
 
-        The function `col` is used to refer to one column of a dataframe. It is one of the fundamental building blocks of expressions in Polars. `col` is also really handy in expression expansion.
-        """
-    )
+    The function `col` is used to refer to one column of a dataframe. It is one of the fundamental building blocks of expressions in Polars. `col` is also really handy in expression expansion.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Explicit expansion by column name
+    mo.md(r"""
+    ### Explicit expansion by column name
 
-        The simplest form of expression expansion happens when you provide multiple column names to the function `col`.
+    The simplest form of expression expansion happens when you provide multiple column names to the function `col`.
 
-        Say you wish to convert all temperature values in deg. Kelvin (K) to deg. Fahrenheit (F). One way to do this would be to define individual expressions for each column as follows:
-        """
-    )
+    Say you wish to convert all temperature values in deg. Kelvin (K) to deg. Fahrenheit (F). One way to do this would be to define individual expressions for each column as follows:
+    """)
     return
 
 
@@ -118,12 +110,14 @@ def _(data, pl):
 
     result = data.with_columns(exprs)
     result
-    return exprs, result
+    return (result,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Expression expansion can reduce this verbosity when you list the column names you want the expression to expand to inside the `col` function. The result is the same as before.""")
+    mo.md(r"""
+    Expression expansion can reduce this verbosity when you list the column names you want the expression to expand to inside the `col` function. The result is the same as before.
+    """)
     return
 
 
@@ -139,28 +133,28 @@ def _(data, pl, result):
         ).round(2)
     )
     result_2.equals(result)
-    return (result_2,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""In this case, the expression that does the temperature conversion is expanded to a list of two expressions. The expansion of the expression is predictable and intuitive.""")
+    mo.md(r"""
+    In this case, the expression that does the temperature conversion is expanded to a list of two expressions. The expansion of the expression is predictable and intuitive.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Expansion by data type
+    mo.md(r"""
+    ### Expansion by data type
 
-        Can we do better than explicitly writing the names of every columns we want transformed? Yes.
+    Can we do better than explicitly writing the names of every columns we want transformed? Yes.
 
-        If you provide data types instead of column names, the expression is expanded to all columns that match one of the data types provided.
+    If you provide data types instead of column names, the expression is expanded to all columns that match one of the data types provided.
 
-        The example below performs the exact same computation as before:
-        """
-    )
+    The example below performs the exact same computation as before:
+    """)
     return
 
 
@@ -168,18 +162,16 @@ def _(mo):
 def _(data, pl, result):
     result_3 = data.with_columns(((pl.col(pl.Float64) - 273.15) * 1.8 + 32).round(2))
     result_3.equals(result)
-    return (result_3,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        However, you should be careful to ensure that the transformation is only applied to the columns you want. For ensuring this it is important to know the schema of the data beforehand. 
+    mo.md(r"""
+    However, you should be careful to ensure that the transformation is only applied to the columns you want. For ensuring this it is important to know the schema of the data beforehand.
 
-        `col` accepts multiple data types in case the columns you need have more than one data type.
-        """
-    )
+    `col` accepts multiple data types in case the columns you need have more than one data type.
+    """)
     return
 
 
@@ -195,18 +187,16 @@ def _(data, pl, result):
         ).round(2)
     )
     result.equals(result_4)
-    return (result_4,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Expansion by pattern matching
+    mo.md(r"""
+    ### Expansion by pattern matching
 
-        `col` also accepts regular expressions for selecting columns by pattern matching. Regular expressions start and end with ^ and $, respectively.
-        """
-    )
+    `col` also accepts regular expressions for selecting columns by pattern matching. Regular expressions start and end with ^ and $, respectively.
+    """)
     return
 
 
@@ -218,7 +208,9 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Regular expressions can be combined with exact column names.""")
+    mo.md(r"""
+    Regular expressions can be combined with exact column names.
+    """)
     return
 
 
@@ -230,7 +222,9 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""**Note**: You _cannot_ mix strings (exact names, regular expressions) and data types in a `col` function.""")
+    mo.md(r"""
+    **Note**: You _cannot_ mix strings (exact names, regular expressions) and data types in a `col` function.
+    """)
     return
 
 
@@ -245,13 +239,11 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Selecting all columns
+    mo.md(r"""
+    ## Selecting all columns
 
-        To select all columns, you can use the `all` function.
-        """
-    )
+    To select all columns, you can use the `all` function.
+    """)
     return
 
 
@@ -259,18 +251,16 @@ def _(mo):
 def _(data, pl):
     result_6 = data.select(pl.all())
     result_6.equals(data)
-    return (result_6,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Excluding columns
+    mo.md(r"""
+    ## Excluding columns
 
-        There are scenarios where we might want to exclude specific columns from the ones selected by building expressions, e.g. by the `col` or `all` functions. For this purpose, we use the function `exclude`, which accepts exactly the same types of arguments as `col`:
-        """
-    )
+    There are scenarios where we might want to exclude specific columns from the ones selected by building expressions, e.g. by the `col` or `all` functions. For this purpose, we use the function `exclude`, which accepts exactly the same types of arguments as `col`:
+    """)
     return
 
 
@@ -282,7 +272,9 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""`exclude` can also be used after the function `col`:""")
+    mo.md(r"""
+    `exclude` can also be used after the function `col`:
+    """)
     return
 
 
@@ -294,13 +286,11 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Column renaming
+    mo.md(r"""
+    ## Column renaming
 
-        When applying a transformation with an expression to a column, the data in the column gets overwritten with the transformed data. However, this might not be the intended outcome in all situations - ideally you would want to store transformed data in a new column. Applying multiple transformations to the same column at the same time without renaming leads to errors.
-        """
-    )
+    When applying a transformation with an expression to a column, the data in the column gets overwritten with the transformed data. However, this might not be the intended outcome in all situations - ideally you would want to store transformed data in a new column. Applying multiple transformations to the same column at the same time without renaming leads to errors.
+    """)
     return
 
 
@@ -315,18 +305,16 @@ def _(data, pl):
         )
     except DuplicateError as err:
         print("DuplicateError:", err)
-    return (DuplicateError,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Renaming a single column with `alias`
+    mo.md(r"""
+    ### Renaming a single column with `alias`
 
-        The function `alias` lets you rename a single column:
-        """
-    )
+    The function `alias` lets you rename a single column:
+    """)
     return
 
 
@@ -341,13 +329,11 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Prefixing and suffixing column names
+    mo.md(r"""
+    ### Prefixing and suffixing column names
 
-        As `alias` renames a single column at a time, it cannot be used during expression expansion. If it is sufficient add a static prefix or a static suffix to the existing names, you can use the functions `name.prefix` and `name.suffix` with `col`:
-        """
-    )
+    As `alias` renames a single column at a time, it cannot be used during expression expansion. If it is sufficient add a static prefix or a static suffix to the existing names, you can use the functions `name.prefix` and `name.suffix` with `col`:
+    """)
     return
 
 
@@ -362,13 +348,11 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Dynamic name replacement
+    mo.md(r"""
+    ### Dynamic name replacement
 
-        If a static prefix/suffix is not enough, use `name.map`. `name.map` requires a function that transforms column names to the desired. The transformation should lead to unique names to avoid `DuplicateError`.
-        """
-    )
+    If a static prefix/suffix is not enough, use `name.map`. `name.map` requires a function that transforms column names to the desired. The transformation should lead to unique names to avoid `DuplicateError`.
+    """)
     return
 
 
@@ -381,13 +365,11 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Programmatically generating expressions
+    mo.md(r"""
+    ## Programmatically generating expressions
 
-        For this example, we will first create four additional columns with the rolling mean temperatures of the two temperature columns. Such transformations are sometimes used to create additional features for machine learning models or data analysis.
-        """
-    )
+    For this example, we will first create four additional columns with the rolling mean temperatures of the two temperature columns. Such transformations are sometimes used to create additional features for machine learning models or data analysis.
+    """)
     return
 
 
@@ -402,13 +384,17 @@ def _(data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now, suppose we want to calculate the difference between the rolling mean and actual temperatures. We cannot use expression expansion here as we want differences between specific columns.""")
+    mo.md(r"""
+    Now, suppose we want to calculate the difference between the rolling mean and actual temperatures. We cannot use expression expansion here as we want differences between specific columns.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""At first, you may think about using a `for` loop:""")
+    mo.md(r"""
+    At first, you may think about using a `for` loop:
+    """)
     return
 
 
@@ -421,12 +407,14 @@ def _(ext_temp_data, pl):
                 .round(2).alias(f"Delta {col_name} temperature")
         )
     _result
-    return (col_name,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Using a `for` loop is functional, but not scalable, as each expression needs to be defined in an iteration and executed serially. Instead we can use a generator in Python to programmatically create all expressions at once. In conjunction with the `with_columns` context, we can take advantage of parallel execution of computations and query optimization from Polars.""")
+    mo.md(r"""
+    Using a `for` loop is functional, but not scalable, as each expression needs to be defined in an iteration and executed serially. Instead we can use a generator in Python to programmatically create all expressions at once. In conjunction with the `with_columns` context, we can take advantage of parallel execution of computations and query optimization from Polars.
+    """)
     return
 
 
@@ -439,18 +427,16 @@ def _(ext_temp_data, pl):
 
 
     ext_temp_data.with_columns(delta_expressions(["Air", "Process"]))
-    return (delta_expressions,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## More flexible column selections
+    mo.md(r"""
+    ## More flexible column selections
 
-        For more flexible column selections, you can use column selectors from `selectors`. Column selectors allow for more expressiveness in the way you specify selections. For example, column selectors can perform the familiar set operations of union, intersection, difference, etc. We can use the union operation with the functions `string` and `ends_with` to select all string columns and the columns whose names end with "`_high`":
-        """
-    )
+    For more flexible column selections, you can use column selectors from `selectors`. Column selectors allow for more expressiveness in the way you specify selections. For example, column selectors can perform the familiar set operations of union, intersection, difference, etc. We can use the union operation with the functions `string` and `ends_with` to select all string columns and the columns whose names end with "`_high`":
+    """)
     return
 
 
@@ -464,30 +450,30 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Likewise, you can pick columns based on the category of the type of data, offering more flexibility than the `col` function. As an example, `cs.numeric` selects numeric data types (including `pl.Float32`, `pl.Float64`, `pl.Int32`, etc.) or `cs.temporal` for all dates, times and similar data types.""")
+    mo.md(r"""
+    Likewise, you can pick columns based on the category of the type of data, offering more flexibility than the `col` function. As an example, `cs.numeric` selects numeric data types (including `pl.Float32`, `pl.Float64`, `pl.Int32`, etc.) or `cs.temporal` for all dates, times and similar data types.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Combining selectors with set operations
+    mo.md(r"""
+    ### Combining selectors with set operations
 
-        Multiple selectors can be combined using set operations and the usual Python operators:
+    Multiple selectors can be combined using set operations and the usual Python operators:
 
 
-        | Operator |       Operation      |
-        |:--------:|:--------------------:|
-        | `A | B`   | Union                |
-        | `A & B`    | Intersection         |
-        | `A - B`    | Difference           |
-        | `A ^ B`    | Symmetric difference |
-        | `~A`       | Complement           |
+    | Operator |       Operation      |
+    |:--------:|:--------------------:|
+    | `A | B`   | Union                |
+    | `A & B`    | Intersection         |
+    | `A - B`    | Difference           |
+    | `A ^ B`    | Symmetric difference |
+    | `~A`       | Complement           |
 
-        For example, to select all failure indicator variables excluding the failure variables due to wear, we can perform a set difference between the column selectors.
-        """
-    )
+    For example, to select all failure indicator variables excluding the failure variables due to wear, we can perform a set difference between the column selectors.
+    """)
     return
 
 
@@ -499,13 +485,11 @@ def _(cs, data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Resolving operator ambiguity
+    mo.md(r"""
+    ### Resolving operator ambiguity
 
-        Expression functions can be chained on top of selectors:
-        """
-    )
+    Expression functions can be chained on top of selectors:
+    """)
     return
 
 
@@ -518,13 +502,11 @@ def _(cs, data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        However, operators that perform set operations on column selectors operate on both selectors and on expressions. For example, the operator `~` on a selector represents the set operation “complement” and on an expression represents the Boolean operation of negation.
+    mo.md(r"""
+    However, operators that perform set operations on column selectors operate on both selectors and on expressions. For example, the operator `~` on a selector represents the set operation “complement” and on an expression represents the Boolean operation of negation.
 
-        For instance, if you want to negate the Boolean values in the columns “HDF”, “OSF”, and “RNF”, at first you would think about using the `~` operator with the column selector to choose all failure variables containing "W". Because of the operator ambiguity here, the columns that are not of interest are selected here.
-        """
-    )
+    For instance, if you want to negate the Boolean values in the columns “HDF”, “OSF”, and “RNF”, at first you would think about using the `~` operator with the column selector to choose all failure variables containing "W". Because of the operator ambiguity here, the columns that are not of interest are selected here.
+    """)
     return
 
 
@@ -536,7 +518,9 @@ def _(cs, ext_failure_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""To resolve the operator ambiguity, we use `as_expr`:""")
+    mo.md(r"""
+    To resolve the operator ambiguity, we use `as_expr`:
+    """)
     return
 
 
@@ -548,13 +532,11 @@ def _(cs, ext_failure_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Debugging selectors
+    mo.md(r"""
+    ### Debugging selectors
 
-        The function `cs.is_selector` helps check whether a complex chain of selectors and operators ultimately results in a selector. For example, to resolve any ambiguity with the selector in the last example, we can do:
-        """
-    )
+    The function `cs.is_selector` helps check whether a complex chain of selectors and operators ultimately results in a selector. For example, to resolve any ambiguity with the selector in the last example, we can do:
+    """)
     return
 
 
@@ -566,7 +548,9 @@ def _(cs):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Additionally we can use `expand_selector` to see what columns a selector expands into. Note that for this function we need to provide additional context in the form of the dataframe.""")
+    mo.md(r"""
+    Additionally we can use `expand_selector` to see what columns a selector expands into. Note that for this function we need to provide additional context in the form of the dataframe.
+    """)
     return
 
 
@@ -581,14 +565,12 @@ def _(cs, ext_failure_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### References
+    mo.md(r"""
+    ### References
 
-        1. AI4I 2020 Predictive Maintenance Dataset [Dataset]. (2020). UCI Machine Learning Repository. ([link](https://doi.org/10.24432/C5HS5C)).
-        2. Polars documentation ([link](https://docs.pola.rs/user-guide/expressions/expression-expansion/#more-flexible-column-selections))
-        """
-    )
+    1. AI4I 2020 Predictive Maintenance Dataset [Dataset]. (2020). UCI Machine Learning Repository. ([link](https://doi.org/10.24432/C5HS5C)).
+    2. Polars documentation ([link](https://docs.pola.rs/user-guide/expressions/expression-expansion/#more-flexible-column-selections))
+    """)
     return
 
 
@@ -598,7 +580,7 @@ def _():
     import marimo as mo
     import polars as pl
     from io import StringIO
-    return StringIO, csv, mo, pl
+    return StringIO, mo, pl
 
 
 if __name__ == "__main__":

polars/09_data_types.py

@@ -8,52 +8,46 @@
 
 import marimo
 
-__generated_with = "0.12.0"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Data Types
+    mo.md(r"""
+    # Data Types
 
-        Author: [Deb Debnath](https://github.com/debajyotid2)
+    Author: [Deb Debnath](https://github.com/debajyotid2)
 
-        **Note**: The following tutorial has been adapted from the Polars [documentation](https://docs.pola.rs/user-guide/concepts/data-types-and-structures/).
-        """
-    )
+    **Note**: The following tutorial has been adapted from the Polars [documentation](https://docs.pola.rs/user-guide/concepts/data-types-and-structures/).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Polars supports a variety of data types that fall broadly under the following categories:
+    mo.md(r"""
+    Polars supports a variety of data types that fall broadly under the following categories:
 
-        - Numeric data types: integers and floating point numbers.
-        - Nested data types: lists, structs, and arrays.
-        - Temporal: dates, datetimes, times, and time deltas.
-        - Miscellaneous: strings, binary data, Booleans, categoricals, enums, and objects.
+    - Numeric data types: integers and floating point numbers.
+    - Nested data types: lists, structs, and arrays.
+    - Temporal: dates, datetimes, times, and time deltas.
+    - Miscellaneous: strings, binary data, Booleans, categoricals, enums, and objects.
 
-        All types support missing values represented by `null` which is different from `NaN` used in floating point data types. The numeric datatypes in Polars loosely follow the type system of the Rust language, since its core functionalities are built in Rust.
+    All types support missing values represented by `null` which is different from `NaN` used in floating point data types. The numeric datatypes in Polars loosely follow the type system of the Rust language, since its core functionalities are built in Rust.
 
-        [Here](https://docs.pola.rs/api/python/stable/reference/datatypes.html) is a full list of all data types Polars supports.
-        """
-    )
+    [Here](https://docs.pola.rs/api/python/stable/reference/datatypes.html) is a full list of all data types Polars supports.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Series
+    mo.md(r"""
+    ## Series
 
-        A series is a 1-dimensional data structure that can hold only one data type.
-        """
-    )
+    A series is a 1-dimensional data structure that can hold only one data type.
+    """)
     return
 
 
@@ -61,12 +55,14 @@ def _(mo):
 def _(pl):
     s = pl.Series("emojis", ["😀", "🤣", "🥶", "💀", "🤖"])
     s
-    return (s,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Unless specified, Polars infers the datatype from the supplied values.""")
+    mo.md(r"""
+    Unless specified, Polars infers the datatype from the supplied values.
+    """)
     return
 
 
@@ -75,20 +71,18 @@ def _(pl):
     s1 = pl.Series("friends", ["Евгений", "अभिषेक", "秀良", "Federico", "Bob"])
     s2 = pl.Series("uints", [0x00, 0x01, 0x10, 0x11], dtype=pl.UInt8)
     s1.dtype, s2.dtype
-    return s1, s2
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Dataframe
+    mo.md(r"""
+    ## Dataframe
 
-        A dataframe is a 2-dimensional data structure that contains uniquely named series and can hold multiple data types. Dataframes are more commonly used for data manipulation using the functionality of Polars.
+    A dataframe is a 2-dimensional data structure that contains uniquely named series and can hold multiple data types. Dataframes are more commonly used for data manipulation using the functionality of Polars.
 
-        The snippet below shows how to create a dataframe from a dictionary of lists:
-        """
-    )
+    The snippet below shows how to create a dataframe from a dictionary of lists:
+    """)
     return
 
 
@@ -108,28 +102,24 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Inspecting a dataframe
+    mo.md(r"""
+    ### Inspecting a dataframe
 
-        Polars has various functions to explore the data in a dataframe. We will use the dataframe `data` defined above in our examples. Alongside we can also see a view of the dataframe rendered by `marimo` as the cells are executed.
+    Polars has various functions to explore the data in a dataframe. We will use the dataframe `data` defined above in our examples. Alongside we can also see a view of the dataframe rendered by `marimo` as the cells are executed.
 
-        ///note
-        We can also use `marimo`'s built in data-inspection elements/features such as  [`mo.ui.dataframe`](https://docs.marimo.io/api/inputs/dataframe/#marimo.ui.dataframe) & [`mo.ui.data_explorer`](https://docs.marimo.io/api/inputs/data_explorer/). For more check out our Polars tutorials at [`marimo learn`](https://marimo-team.github.io/learn/)!
-        """
-    )
+    ///note
+    We can also use `marimo`'s built in data-inspection elements/features such as  [`mo.ui.dataframe`](https://docs.marimo.io/api/inputs/dataframe/#marimo.ui.dataframe) & [`mo.ui.data_explorer`](https://docs.marimo.io/api/inputs/data_explorer/). For more check out our Polars tutorials at [`marimo learn`](https://marimo-team.github.io/learn/)!
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        #### Head
+    mo.md("""
+    #### Head
 
-        The function `head` shows the first rows of a dataframe. Unless specified, it shows the first 5 rows.
-        """
-    )
+    The function `head` shows the first rows of a dataframe. Unless specified, it shows the first 5 rows.
+    """)
     return
 
 
@@ -141,13 +131,11 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        #### Glimpse
+    mo.md(r"""
+    #### Glimpse
 
-        The function `glimpse` is an alternative to `head` to view the first few columns, but displays each line of the output corresponding to a single column. That way, it makes inspecting wider dataframes easier.
-        """
-    )
+    The function `glimpse` is an alternative to `head` to view the first few columns, but displays each line of the output corresponding to a single column. That way, it makes inspecting wider dataframes easier.
+    """)
     return
 
 
@@ -159,13 +147,11 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        #### Tail
+    mo.md(r"""
+    #### Tail
 
-        The `tail` function, just like its name suggests, shows the last rows of a dataframe. Unless the number of rows is specified, it will show the last 5 rows.
-        """
-    )
+    The `tail` function, just like its name suggests, shows the last rows of a dataframe. Unless the number of rows is specified, it will show the last 5 rows.
+    """)
     return
 
 
@@ -177,13 +163,11 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        #### Sample
+    mo.md(r"""
+    #### Sample
 
-        `sample` can be used to show a specified number of randomly selected rows from the dataframe. Unless the number of rows is specified, it will show a single row. `sample` does not preserve order of the rows.
-        """
-    )
+    `sample` can be used to show a specified number of randomly selected rows from the dataframe. Unless the number of rows is specified, it will show a single row. `sample` does not preserve order of the rows.
+    """)
     return
 
 
@@ -194,18 +178,16 @@ def _(data):
     random.seed(42)  # For reproducibility.
 
     data.sample(3)
-    return (random,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        #### Describe
+    mo.md(r"""
+    #### Describe
 
-        The function `describe` describes the summary statistics for all columns of a dataframe.
-        """
-    )
+    The function `describe` describes the summary statistics for all columns of a dataframe.
+    """)
     return
 
 
@@ -217,13 +199,11 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Schema
+    mo.md(r"""
+    ## Schema
 
-        A schema is a mapping showing the datatype corresponding to every column of a dataframe. The schema of a dataframe can be viewed using the attribute `schema`.
-        """
-    )
+    A schema is a mapping showing the datatype corresponding to every column of a dataframe. The schema of a dataframe can be viewed using the attribute `schema`.
+    """)
     return
 
 
@@ -235,7 +215,9 @@ def _(data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Since a schema is a mapping, it can be specified in the form of a Python dictionary. Then this dictionary can be used to specify the schema of a dataframe on definition. If not specified or the entry is `None`, Polars infers the datatype from the contents of the column. Note that if the schema is not specified, it will be inferred automatically by default.""")
+    mo.md(r"""
+    Since a schema is a mapping, it can be specified in the form of a Python dictionary. Then this dictionary can be used to specify the schema of a dataframe on definition. If not specified or the entry is `None`, Polars infers the datatype from the contents of the column. Note that if the schema is not specified, it will be inferred automatically by default.
+    """)
     return
 
 
@@ -255,7 +237,9 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Sometimes the automatically inferred schema is enough for some columns, but we might wish to override the inference of only some columns. We can specify the schema for those columns using `schema_overrides`.""")
+    mo.md(r"""
+    Sometimes the automatically inferred schema is enough for some columns, but we might wish to override the inference of only some columns. We can specify the schema for those columns using `schema_overrides`.
+    """)
     return
 
 
@@ -275,13 +259,11 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### References
+    mo.md(r"""
+    ### References
 
-        1. Polars documentation ([link](https://docs.pola.rs/api/python/stable/reference/datatypes.html))
-        """
-    )
+    1. Polars documentation ([link](https://docs.pola.rs/api/python/stable/reference/datatypes.html))
+    """)
     return
 
 

polars/10_strings.py

@@ -10,36 +10,32 @@
 
 import marimo
 
-__generated_with = "0.11.17"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Strings
+    mo.md(r"""
+    # Strings
 
-        _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
+    _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
 
-        In this chapter we're going to dig into string manipulation. For a fun twist, we'll be mostly playing around with a dataset that every Polars user has bumped into without really thinking about it—the source code of the `polars` module itself. More precisely, we'll use a dataframe that pulls together all the Polars expressions and their docstrings, giving us a cool, hands-on way to explore the expression API in a truly data-driven manner.
+    In this chapter we're going to dig into string manipulation. For a fun twist, we'll be mostly playing around with a dataset that every Polars user has bumped into without really thinking about it—the source code of the `polars` module itself. More precisely, we'll use a dataframe that pulls together all the Polars expressions and their docstrings, giving us a cool, hands-on way to explore the expression API in a truly data-driven manner.
 
-        We'll cover parsing, length calculation, case conversion, and much more, with practical examples and visualizations. Finally, we will combine various techniques you learned in prior chapters to build a fully interactive playground in which you can execute the official code examples of Polars expressions.
-        """
-    )
+    We'll cover parsing, length calculation, case conversion, and much more, with practical examples and visualizations. Finally, we will combine various techniques you learned in prior chapters to build a fully interactive playground in which you can execute the official code examples of Polars expressions.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🛠️  Parsing & Conversion
+    mo.md(r"""
+    ## 🛠️  Parsing & Conversion
 
-        Let's warm up with one of the most frequent use cases: parsing raw strings into various formats.
-        We'll take a tiny dataframe with metadata about Python packages represented as raw JSON strings and we'll use Polars string expressions to parse the attributes into their true data types.
-        """
-    )
+    Let's warm up with one of the most frequent use cases: parsing raw strings into various formats.
+    We'll take a tiny dataframe with metadata about Python packages represented as raw JSON strings and we'll use Polars string expressions to parse the attributes into their true data types.
+    """)
     return
 
 
@@ -58,7 +54,9 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can use the [`json_decode`](https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.str.json_decode.html) expression to parse the raw JSON strings into Polars-native structs and we can use the [unnest](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.unnest.html) dataframe operation to have a dedicated column per parsed attribute.""")
+    mo.md(r"""
+    We can use the [`json_decode`](https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.str.json_decode.html) expression to parse the raw JSON strings into Polars-native structs and we can use the [unnest](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.unnest.html) dataframe operation to have a dedicated column per parsed attribute.
+    """)
     return
 
 
@@ -71,13 +69,17 @@ def _(pip_metadata_raw_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""This is already a much friendlier representation of the data we started out with, but note that since the JSON entries had only string attributes, all values are strings, even the temporal `released_at` and numerical `size_mb` columns.""")
+    mo.md(r"""
+    This is already a much friendlier representation of the data we started out with, but note that since the JSON entries had only string attributes, all values are strings, even the temporal `released_at` and numerical `size_mb` columns.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""As we know that the `size_mb` column should have a decimal representation, we go ahead and use [`to_decimal`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_decimal.html#polars.Expr.str.to_decimal) to perform the conversion.""")
+    mo.md(r"""
+    As we know that the `size_mb` column should have a decimal representation, we go ahead and use [`to_decimal`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_decimal.html#polars.Expr.str.to_decimal) to perform the conversion.
+    """)
     return
 
 
@@ -93,25 +95,23 @@ def _(pip_metadata_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Moving on to the `released_at` attribute which indicates the exact time when a given Python package got released, we have a bit more options to consider. We can convert to `Date`, `DateTime`, and `Time` types based on the desired temporal granularity. The [`to_date`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_date.html), [`to_datetime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_datetime.html), and [`to_time`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_time.html) expressions are here to help us with the conversion, all we need is to provide the desired format string.
+    mo.md(r"""
+    Moving on to the `released_at` attribute which indicates the exact time when a given Python package got released, we have a bit more options to consider. We can convert to `Date`, `DateTime`, and `Time` types based on the desired temporal granularity. The [`to_date`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_date.html), [`to_datetime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_datetime.html), and [`to_time`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_time.html) expressions are here to help us with the conversion, all we need is to provide the desired format string.
 
-        Since Polars uses Rust under the hood to implement all its expressions, we need to consult the [`chrono::format`](https://docs.rs/chrono/latest/chrono/format/strftime/index.html) reference to come up with appropriate format strings.
+    Since Polars uses Rust under the hood to implement all its expressions, we need to consult the [`chrono::format`](https://docs.rs/chrono/latest/chrono/format/strftime/index.html) reference to come up with appropriate format strings.
 
-        Here's a quick reference:
+    Here's a quick reference:
 
-        | Specifier | Meaning            |
-        |-----------|--------------------|
-        | `%Y`      | Year (e.g., 2025) |
-        | `%m`      | Month (01-12)     |
-        | `%d`      | Day (01-31)       |
-        | `%H`      | Hour (00-23)      |
-        | `%z`      | UTC offset        |
+    | Specifier | Meaning            |
+    |-----------|--------------------|
+    | `%Y`      | Year (e.g., 2025) |
+    | `%m`      | Month (01-12)     |
+    | `%d`      | Day (01-31)       |
+    | `%H`      | Hour (00-23)      |
+    | `%z`      | UTC offset        |
 
-        The raw strings we are working with look like `"2025-03-02T20:31:12+0000"`. We can match this using the `"%Y-%m-%dT%H:%M:%S%z"` format string.
-        """
-    )
+    The raw strings we are working with look like `"2025-03-02T20:31:12+0000"`. We can match this using the `"%Y-%m-%dT%H:%M:%S%z"` format string.
+    """)
     return
 
 
@@ -129,7 +129,9 @@ def _(pip_metadata_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Alternatively, instead of using three different functions to perform the conversion to date, we can use a single one, [`strptime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strptime.html) which takes the desired temporal data type as its first parameter.""")
+    mo.md(r"""
+    Alternatively, instead of using three different functions to perform the conversion to date, we can use a single one, [`strptime`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strptime.html) which takes the desired temporal data type as its first parameter.
+    """)
     return
 
 
@@ -147,7 +149,9 @@ def _(pip_metadata_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""And to wrap up this section on parsing and conversion, let's consider a final scenario. What if we don't want to parse the entire raw JSON string, because we only need a subset of its attributes? Well, in this case we can leverage the [`json_path_match`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.json_path_match.html) expression to extract only the desired attributes using standard [JSONPath](https://goessner.net/articles/JsonPath/) syntax.""")
+    mo.md(r"""
+    And to wrap up this section on parsing and conversion, let's consider a final scenario. What if we don't want to parse the entire raw JSON string, because we only need a subset of its attributes? Well, in this case we can leverage the [`json_path_match`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.json_path_match.html) expression to extract only the desired attributes using standard [JSONPath](https://goessner.net/articles/JsonPath/) syntax.
+    """)
     return
 
 
@@ -165,17 +169,15 @@ def _(pip_metadata_raw_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 📊 Dataset Overview
+    mo.md(r"""
+    ## 📊 Dataset Overview
 
-        Now that we got our hands dirty, let's consider a somewhat wilder dataset for the subsequent sections: a dataframe of metadata about every single expression in your current Polars module.
+    Now that we got our hands dirty, let's consider a somewhat wilder dataset for the subsequent sections: a dataframe of metadata about every single expression in your current Polars module.
 
-        At the risk of stating the obvious, in the previous section, when we typed `pl.col('raw_json').str.json_decode()`, we accessed the `json_decode` member of the `str` expression namespace through the `pl.col('raw_json')` expression *instance*. Under the hood, deep inside the Polars source code, there is a corresponding `def json_decode(...)` method with a carefully authored docstring explaining the purpose and signature of the member.
+    At the risk of stating the obvious, in the previous section, when we typed `pl.col('raw_json').str.json_decode()`, we accessed the `json_decode` member of the `str` expression namespace through the `pl.col('raw_json')` expression *instance*. Under the hood, deep inside the Polars source code, there is a corresponding `def json_decode(...)` method with a carefully authored docstring explaining the purpose and signature of the member.
 
-        Since Python makes module introspection simple, we can easily enumerate all Polars expressions and organize their metadata in `expressions_df`, to be used for all the upcoming string manipulation examples.
-        """
-    )
+    Since Python makes module introspection simple, we can easily enumerate all Polars expressions and organize their metadata in `expressions_df`, to be used for all the upcoming string manipulation examples.
+    """)
     return
 
 
@@ -214,12 +216,14 @@ def _(pl):
 
     expressions_df = pl.from_dicts(list_expr_meta(), infer_schema_length=None).sort('namespace', 'member')
     expressions_df
-    return expressions_df, list_expr_meta, list_members
+    return (expressions_df,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""As the following visualization shows, `str` is one of the richest Polars expression namespaces with multiple dozens of functions in it.""")
+    mo.md(r"""
+    As the following visualization shows, `str` is one of the richest Polars expression namespaces with multiple dozens of functions in it.
+    """)
     return
 
 
@@ -234,17 +238,15 @@ def _(alt, expressions_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 📏 Length Calculation
+    mo.md(r"""
+    ## 📏 Length Calculation
 
-        A common use case is to compute the length of a string. Most people associate string length exclusively with the number of characters the said string consists of; however, in certain scenarios it is useful to also know how much memory is required for storing, so how many bytes are required to represent the textual data.
+    A common use case is to compute the length of a string. Most people associate string length exclusively with the number of characters the said string consists of; however, in certain scenarios it is useful to also know how much memory is required for storing, so how many bytes are required to represent the textual data.
 
-        The expressions [`len_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_chars.html) and [`len_bytes`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_bytes.html) are here to help us with these calculations.
+    The expressions [`len_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_chars.html) and [`len_bytes`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.len_bytes.html) are here to help us with these calculations.
 
-        Below, we compute `docstring_len_chars` and `docstring_len_bytes` columns to see how many characters and bytes the documentation of each expression is made up of.
-        """
-    )
+    Below, we compute `docstring_len_chars` and `docstring_len_bytes` columns to see how many characters and bytes the documentation of each expression is made up of.
+    """)
     return
 
 
@@ -262,7 +264,9 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""As the dataframe preview above and the scatterplot below show, the docstring length measured in bytes is almost always bigger than the length expressed in characters. This is due to the fact that the docstrings include characters which require more than a single byte to represent, such as "╞" for displaying dataframe header and body separators.""")
+    mo.md(r"""
+    As the dataframe preview above and the scatterplot below show, the docstring length measured in bytes is almost always bigger than the length expressed in characters. This is due to the fact that the docstrings include characters which require more than a single byte to represent, such as "╞" for displaying dataframe header and body separators.
+    """)
     return
 
 
@@ -278,13 +282,11 @@ def _(alt, docstring_length_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔠 Case Conversion
+    mo.md(r"""
+    ## 🔠 Case Conversion
 
-        Another frequent string transformation is lowercasing, uppercasing, and titlecasing. We can use [`to_lowercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html), [`to_uppercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html) and [`to_titlecase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_titlecase.html) for doing so.
-        """
-    )
+    Another frequent string transformation is lowercasing, uppercasing, and titlecasing. We can use [`to_lowercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html), [`to_uppercase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_lowercase.html) and [`to_titlecase`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.to_titlecase.html) for doing so.
+    """)
     return
 
 
@@ -300,15 +302,13 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ➕ Padding
+    mo.md(r"""
+    ## ➕ Padding
 
-        Sometimes we need to ensure that strings have a fixed-size character length. [`pad_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_start.html) and [`pad_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_end.html) can be used to fill the "front" or "back" of a string with a supplied character, while [`zfill`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.zfill.html) is a utility for padding the start of a string with `"0"` until it reaches a particular length. In other words, `zfill` is a more specific version of `pad_start`, where the `fill_char` parameter is explicitly set to `"0"`.
+    Sometimes we need to ensure that strings have a fixed-size character length. [`pad_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_start.html) and [`pad_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.pad_end.html) can be used to fill the "front" or "back" of a string with a supplied character, while [`zfill`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.zfill.html) is a utility for padding the start of a string with `"0"` until it reaches a particular length. In other words, `zfill` is a more specific version of `pad_start`, where the `fill_char` parameter is explicitly set to `"0"`.
 
-        In the example below we take the unique Polars expression namespaces and pad them so that they have a uniform length which you can control via a slider.
-        """
-    )
+    In the example below we take the unique Polars expression namespaces and pad them so that they have a uniform length which you can control via a slider.
+    """)
     return
 
 
@@ -340,15 +340,13 @@ def _(mo, padded_df, padding):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔄 Replacing
+    mo.md(r"""
+    ## 🔄 Replacing
 
-        Let's say we want to convert from `snake_case` API member names to `kebab-case`, that is, we need to replace the underscore character with a hyphen. For operations like that, we can use [`replace`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace.html) and [`replace_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_all.html).
+    Let's say we want to convert from `snake_case` API member names to `kebab-case`, that is, we need to replace the underscore character with a hyphen. For operations like that, we can use [`replace`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace.html) and [`replace_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_all.html).
 
-        As the example below demonstrates, `replace` stops after the first occurrence of the to-be-replaced pattern, while `replace_all` goes all the way through and changes all underscores to hyphens resulting in the `kebab-case` representation we were looking for.
-        """
-    )
+    As the example below demonstrates, `replace` stops after the first occurrence of the to-be-replaced pattern, while `replace_all` goes all the way through and changes all underscores to hyphens resulting in the `kebab-case` representation we were looking for.
+    """)
     return
 
 
@@ -364,13 +362,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        A related expression is [`replace_many`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_many.html), which accepts *many* pairs of to-be-matched patterns and corresponding replacements and uses the [Aho–Corasick algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm) to carry out the operation with great performance.
+    mo.md(r"""
+    A related expression is [`replace_many`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.replace_many.html), which accepts *many* pairs of to-be-matched patterns and corresponding replacements and uses the [Aho–Corasick algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm) to carry out the operation with great performance.
 
-        In the example below we replace all instances of `"min"` with `"minimum"` and `"max"` with `"maximum"` using a single expression.
-        """
-    )
+    In the example below we replace all instances of `"min"` with `"minimum"` and `"max"` with `"maximum"` using a single expression.
+    """)
     return
 
 
@@ -390,15 +386,13 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔍 Searching & Matching
+    mo.md(r"""
+    ## 🔍 Searching & Matching
 
-        A common need when working with strings is to determine whether their content satisfies some condition: whether it starts or ends with a particular substring or contains a certain pattern.
+    A common need when working with strings is to determine whether their content satisfies some condition: whether it starts or ends with a particular substring or contains a certain pattern.
 
-        Let's suppose we want to determine whether a member of the Polars expression API is a "converter", such as `to_decimal`, identified by its `"to_"` prefix. We can use [`starts_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.starts_with.html) to perform this check.
-        """
-    )
+    Let's suppose we want to determine whether a member of the Polars expression API is a "converter", such as `to_decimal`, identified by its `"to_"` prefix. We can use [`starts_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.starts_with.html) to perform this check.
+    """)
     return
 
 
@@ -414,13 +408,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Throughout this course as you have gained familiarity with the expression API you might have noticed that some members end with an underscore such as `or_`, since their "body" is a reserved Python keyword.
+    mo.md(r"""
+    Throughout this course as you have gained familiarity with the expression API you might have noticed that some members end with an underscore such as `or_`, since their "body" is a reserved Python keyword.
 
-        Let's use [`ends_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.ends_with.html) to find all the members which are named after such keywords.
-        """
-    )
+    Let's use [`ends_with`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.ends_with.html) to find all the members which are named after such keywords.
+    """)
     return
 
 
@@ -436,13 +428,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Now let's move on to analyzing the docstrings in a bit more detail. Based on their content we can determine whether a member is deprecated, accepts parameters, comes with examples, or references external URL(s) & related members.
+    mo.md(r"""
+    Now let's move on to analyzing the docstrings in a bit more detail. Based on their content we can determine whether a member is deprecated, accepts parameters, comes with examples, or references external URL(s) & related members.
 
-        As demonstrated below, we can compute all these boolean attributes using [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) to check whether the docstring includes a particular substring.
-        """
-    )
+    As demonstrated below, we can compute all these boolean attributes using [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) to check whether the docstring includes a particular substring.
+    """)
     return
 
 
@@ -462,7 +452,9 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""For scenarios where we want to combine multiple substrings to check for, we can use the [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) expression to check for the presence of various patterns.""")
+    mo.md(r"""
+    For scenarios where we want to combine multiple substrings to check for, we can use the [`contains`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.contains.html) expression to check for the presence of various patterns.
+    """)
     return
 
 
@@ -478,21 +470,19 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        From the above analysis we could see that almost all the members come with code examples. It would be interesting to know how many variable assignments are going on within each of these examples, right? That's not as simple as checking for a pre-defined literal string containment though, because variables can have arbitrary names - any valid Python identifier is allowed. While the `contains` function supports checking for regular expressions instead of literal strings too, it would not suffice for this exercise because it only tells us whether there is at least a single occurrence of the sought pattern rather than telling us the exact number of matches.
+    mo.md(r"""
+    From the above analysis we could see that almost all the members come with code examples. It would be interesting to know how many variable assignments are going on within each of these examples, right? That's not as simple as checking for a pre-defined literal string containment though, because variables can have arbitrary names - any valid Python identifier is allowed. While the `contains` function supports checking for regular expressions instead of literal strings too, it would not suffice for this exercise because it only tells us whether there is at least a single occurrence of the sought pattern rather than telling us the exact number of matches.
 
-        Fortunately, we can take advantage of [`count_matches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.count_matches.html) to achieve exactly what we want. We specify the regular expression `r'[a-zA-Z_][a-zA-Z0-9_]* = '` according to the [`regex` Rust crate](https://docs.rs/regex/latest/regex/) to match Python identifiers and we leave the rest to Polars.
+    Fortunately, we can take advantage of [`count_matches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.count_matches.html) to achieve exactly what we want. We specify the regular expression `r'[a-zA-Z_][a-zA-Z0-9_]* = '` according to the [`regex` Rust crate](https://docs.rs/regex/latest/regex/) to match Python identifiers and we leave the rest to Polars.
 
-        In `count_matches(r'[a-zA-Z_][a-zA-Z0-9_]* = ')`:
+    In `count_matches(r'[a-zA-Z_][a-zA-Z0-9_]* = ')`:
 
-        - `[a-zA-Z_]` matches a letter or underscore (start of a Python identifier).
-        - `[a-zA-Z0-9_]*` matches zero or more letters, digits, or underscores.
-        - ` = ` matches a space, equals sign, and space (indicating assignment).
+    - `[a-zA-Z_]` matches a letter or underscore (start of a Python identifier).
+    - `[a-zA-Z0-9_]*` matches zero or more letters, digits, or underscores.
+    - ` = ` matches a space, equals sign, and space (indicating assignment).
 
-        This finds variable assignments like `x = ` or `df_result = ` in docstrings.
-        """
-    )
+    This finds variable assignments like `x = ` or `df_result = ` in docstrings.
+    """)
     return
 
 
@@ -508,7 +498,9 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""A related application example is to *find* the first index where a particular pattern is present, so that it can be used for downstream processing such as slicing. Below we use the [`find`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.find.html) expression to determine the index at which a code example starts in the docstring - identified by the Python shell substring `">>>"`.""")
+    mo.md(r"""
+    A related application example is to *find* the first index where a particular pattern is present, so that it can be used for downstream processing such as slicing. Below we use the [`find`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.find.html) expression to determine the index at which a code example starts in the docstring - identified by the Python shell substring `">>>"`.
+    """)
     return
 
 
@@ -524,13 +516,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ✂️ Slicing and Substrings
+    mo.md(r"""
+    ## ✂️ Slicing and Substrings
 
-        Sometimes we are only interested in a particular substring. We can use [`head`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.head.html), [`tail`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.tail.html) and [`slice`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.slice.html) to extract a substring from the start, end, or between arbitrary indices.
-        """
-    )
+    Sometimes we are only interested in a particular substring. We can use [`head`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.head.html), [`tail`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.tail.html) and [`slice`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.slice.html) to extract a substring from the start, end, or between arbitrary indices.
+    """)
     return
 
 
@@ -564,17 +554,15 @@ def _(mo, slice, sliced_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ➗ Splitting
+    mo.md(r"""
+    ## ➗ Splitting
 
-        Certain strings follow a well-defined structure and we might be only interested in some parts of them. For example, when dealing with `snake_cased_expression` member names we might be curious to get only the first, second, or $n^{\text{th}}$ word before an underscore. We would need to *split* the string at a particular pattern for downstream processing.
+    Certain strings follow a well-defined structure and we might be only interested in some parts of them. For example, when dealing with `snake_cased_expression` member names we might be curious to get only the first, second, or $n^{\text{th}}$ word before an underscore. We would need to *split* the string at a particular pattern for downstream processing.
 
-        The [`split`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split.html), [`split_exact`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split_exact.html) and [`splitn`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.splitn.html) expressions enable us to achieve this.
+    The [`split`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split.html), [`split_exact`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.split_exact.html) and [`splitn`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.splitn.html) expressions enable us to achieve this.
 
-        The primary difference between these string splitting utilities is that `split` produces a list of variadic length based on the number of resulting segments, `splitn` returns a struct with at least `0` and at most `n` fields while `split_exact` returns a struct of exactly `n` fields.
-        """
-    )
+    The primary difference between these string splitting utilities is that `split` produces a list of variadic length based on the number of resulting segments, `splitn` returns a struct with at least `0` and at most `n` fields while `split_exact` returns a struct of exactly `n` fields.
+    """)
     return
 
 
@@ -591,7 +579,9 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""As a more practical example, we can use the `split` expression with some aggregation to count the number of times a particular word occurs in member names across all namespaces. This enables us to create a word cloud of the API members' constituents!""")
+    mo.md(r"""
+    As a more practical example, we can use the `split` expression with some aggregation to count the number of times a particular word occurs in member names across all namespaces. This enables us to create a word cloud of the API members' constituents!
+    """)
     return
 
 
@@ -640,20 +630,18 @@ def _(alt, expressions_df, pl, random, wordcloud_height, wordcloud_width):
         size=alt.Size("len:Q", legend=None),
         tooltip=["member", "len"],
     ).configure_view(strokeWidth=0)
-    return wordcloud, wordcloud_df
+    return (wordcloud,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔗 Concatenation & Joining
+    mo.md(r"""
+    ## 🔗 Concatenation & Joining
 
-        Often we would like to create longer strings from strings we already have. We might want to create a formatted, sentence-like string or join multiple existing strings in our dataframe into a single one.
+    Often we would like to create longer strings from strings we already have. We might want to create a formatted, sentence-like string or join multiple existing strings in our dataframe into a single one.
 
-        The top-level [`concat_str`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.concat_str.html) expression enables us to combine strings *horizontally* in a dataframe. As the example below shows, we can take the `member` and `namespace` column of each row and construct a `description` column in which each row will correspond to the value ``f"- Expression `{member}` belongs to namespace `{namespace}`"``.
-        """
-    )
+    The top-level [`concat_str`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.concat_str.html) expression enables us to combine strings *horizontally* in a dataframe. As the example below shows, we can take the `member` and `namespace` column of each row and construct a `description` column in which each row will correspond to the value ``f"- Expression `{member}` belongs to namespace `{namespace}`"``.
+    """)
     return
 
 
@@ -679,13 +667,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Now that we have constructed these bullet points through *horizontal* concatenation of strings, we can perform a *vertical* one so that we end up with a single string in which we have a bullet point on each line.
+    mo.md(r"""
+    Now that we have constructed these bullet points through *horizontal* concatenation of strings, we can perform a *vertical* one so that we end up with a single string in which we have a bullet point on each line.
 
-        We will use the [`join`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.join.html) expression to do so.
-        """
-    )
+    We will use the [`join`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.join.html) expression to do so.
+    """)
     return
 
 
@@ -708,17 +694,15 @@ def _(descriptions_df, mo, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔍 Pattern-based Extraction
+    mo.md(r"""
+    ## 🔍 Pattern-based Extraction
 
-        In the vast majority of the cases, when dealing with unstructured text data, all we really want is to extract something structured from it. A common use case is to extract URLs from text to get a better understanding of related content.
+    In the vast majority of the cases, when dealing with unstructured text data, all we really want is to extract something structured from it. A common use case is to extract URLs from text to get a better understanding of related content.
 
-        In the example below that's exactly what we do. We scan the `docstring` of each API member and extract URLs from them using [`extract`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract.html) and [`extract_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_all.html) using a simple regular expression to match http and https URLs.
+    In the example below that's exactly what we do. We scan the `docstring` of each API member and extract URLs from them using [`extract`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract.html) and [`extract_all`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_all.html) using a simple regular expression to match http and https URLs.
 
-        Note that `extract` stops after a first match and returns a scalar result (or `null` if there was no match) while `extract_all` returns a - potentially empty - list of matches.
-        """
-    )
+    Note that `extract` stops after a first match and returns a scalar result (or `null` if there was no match) while `extract_all` returns a - potentially empty - list of matches.
+    """)
     return
 
 
@@ -731,20 +715,18 @@ def _(expressions_df, pl):
         url_match=pl.col('docstring').str.extract(url_pattern),
         url_matches=pl.col('docstring').str.extract_all(url_pattern),
     ).filter(pl.col('url_match').is_not_null())
-    return (url_pattern,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Note that in each `docstring` where a code example involving dataframes is present, we will see an output such as "shape: (5, 2)" indicating the number of rows and columns of the dataframe produced by the sample code. Let's say we would like to *capture* this information in a structured way.
+    mo.md(r"""
+    Note that in each `docstring` where a code example involving dataframes is present, we will see an output such as "shape: (5, 2)" indicating the number of rows and columns of the dataframe produced by the sample code. Let's say we would like to *capture* this information in a structured way.
 
-        [`extract_groups`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_groups.html) is a really powerful expression allowing us to achieve exactly that.
+    [`extract_groups`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.extract_groups.html) is a really powerful expression allowing us to achieve exactly that.
 
-        Below we define the regular expression `r"shape:\s*\((?<height>\S+),\s*(?<width>\S+)\)"` with two capture groups, named `height` and `width` and pass it as the parameter of `extract_groups`. After execution, for each `docstring`, we end up with fully structured data we can further process downstream!
-        """
-    )
+    Below we define the regular expression `r"shape:\s*\((?<height>\S+),\s*(?<width>\S+)\)"` with two capture groups, named `height` and `width` and pass it as the parameter of `extract_groups`. After execution, for each `docstring`, we end up with fully structured data we can further process downstream!
+    """)
     return
 
 
@@ -760,15 +742,13 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🧹 Stripping
+    mo.md(r"""
+    ## 🧹 Stripping
 
-        Strings might require some cleaning before further processing, such as the removal of some characters from the beginning or end of the text. [`strip_chars_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_start.html), [`strip_chars_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_end.html) and [`strip_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars.html) are here to facilitate this.
+    Strings might require some cleaning before further processing, such as the removal of some characters from the beginning or end of the text. [`strip_chars_start`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_start.html), [`strip_chars_end`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars_end.html) and [`strip_chars`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_chars.html) are here to facilitate this.
 
-        All we need to do is to specify a set of characters we would like to get rid of and Polars handles the rest for us.
-        """
-    )
+    All we need to do is to specify a set of characters we would like to get rid of and Polars handles the rest for us.
+    """)
     return
 
 
@@ -785,15 +765,13 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Note that when using the above expressions, the specified characters do not need to form a sequence; they are handled as a set. However, in certain use cases we only want to strip complete substrings, so we would need our input to be strictly treated as a sequence rather than as a set.
+    mo.md(r"""
+    Note that when using the above expressions, the specified characters do not need to form a sequence; they are handled as a set. However, in certain use cases we only want to strip complete substrings, so we would need our input to be strictly treated as a sequence rather than as a set.
 
-        That's exactly the rationale behind [`strip_prefix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_prefix.html) and [`strip_suffix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_suffix.html).
+    That's exactly the rationale behind [`strip_prefix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_prefix.html) and [`strip_suffix`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.strip_suffix.html).
 
-        Below we use these to remove the `"to_"` prefixes and `"_with"` suffixes from each member name.
-        """
-    )
+    Below we use these to remove the `"to_"` prefixes and `"_with"` suffixes from each member name.
+    """)
     return
 
 
@@ -809,13 +787,11 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔑 Encoding & Decoding
+    mo.md(r"""
+    ## 🔑 Encoding & Decoding
 
-        Should you find yourself in the need of encoding your strings into [base64](https://en.wikipedia.org/wiki/Base64) or [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) format, then Polars has your back with its [`encode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.encode.html) expression.
-        """
-    )
+    Should you find yourself in the need of encoding your strings into [base64](https://en.wikipedia.org/wiki/Base64) or [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) format, then Polars has your back with its [`encode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.encode.html) expression.
+    """)
     return
 
 
@@ -832,7 +808,9 @@ def _(expressions_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""And of course, you can convert back into a human-readable representation using the [`decode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.decode.html) expression.""")
+    mo.md(r"""
+    And of course, you can convert back into a human-readable representation using the [`decode`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.decode.html) expression.
+    """)
     return
 
 
@@ -847,19 +825,17 @@ def _(encoded_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🚀 Application: Dynamic Execution of Polars Examples
+    mo.md(r"""
+    ## 🚀 Application: Dynamic Execution of Polars Examples
 
-        Now that we are familiar with string expressions, we can combine them with other Polars operations to build a fully interactive playground where code examples of Polars expressions can be explored.
+    Now that we are familiar with string expressions, we can combine them with other Polars operations to build a fully interactive playground where code examples of Polars expressions can be explored.
 
-        We make use of string expressions to extract the raw Python source code of examples from the docstrings and we leverage the interactive Marimo environment to enable the selection of expressions via a searchable dropdown and a fully functional code editor whose output is rendered with Marimo's rich display utilities.
+    We make use of string expressions to extract the raw Python source code of examples from the docstrings and we leverage the interactive Marimo environment to enable the selection of expressions via a searchable dropdown and a fully functional code editor whose output is rendered with Marimo's rich display utilities.
 
-        In other words, we will use Polars to execute Polars. ❄️ How cool is that?
+    In other words, we will use Polars to execute Polars. ❄️ How cool is that?
 
-        ---
-        """
-    )
+    ---
+    """)
     return
 
 
@@ -894,7 +870,7 @@ def _(mo, selected_expression_record):
 
 
 @app.cell(hide_code=True)
-def _(example_editor, execute_code):
+def _(example_editor):
     execution_result = execute_code(example_editor.value)
     return (execution_result,)
 
@@ -943,50 +919,48 @@ def _(expressions_df, pl):
     return (code_df,)
 
 
-@app.cell(hide_code=True)
-def _():
-    def execute_code(code: str):
-        import ast
-
-        # Create a new local namespace for execution
-        local_namespace = {}
+@app.function(hide_code=True)
+def execute_code(code: str):
+    import ast
 
-        # Parse the code into an AST to identify the last expression
-        parsed_code = ast.parse(code)
+    # Create a new local namespace for execution
+    local_namespace = {}
 
-        # Check if there's at least one statement
-        if not parsed_code.body:
-            return None
+    # Parse the code into an AST to identify the last expression
+    parsed_code = ast.parse(code)
 
-        # If the last statement is an expression, we'll need to get its value
-        last_is_expr = isinstance(parsed_code.body[-1], ast.Expr)
+    # Check if there's at least one statement
+    if not parsed_code.body:
+        return None
 
-        if last_is_expr:
-            # Split the code: everything except the last statement, and the last statement
-            last_expr = ast.Expression(parsed_code.body[-1].value)
+    # If the last statement is an expression, we'll need to get its value
+    last_is_expr = isinstance(parsed_code.body[-1], ast.Expr)
 
-            # Remove the last statement from the parsed code
-            parsed_code.body = parsed_code.body[:-1]
+    if last_is_expr:
+        # Split the code: everything except the last statement, and the last statement
+        last_expr = ast.Expression(parsed_code.body[-1].value)
 
-            # Execute everything except the last statement
-            if parsed_code.body:
-                exec(
-                    compile(parsed_code, "<string>", "exec"),
-                    globals(),
-                    local_namespace,
-                )
+        # Remove the last statement from the parsed code
+        parsed_code.body = parsed_code.body[:-1]
 
-            # Execute the last statement and get its value
-            result = eval(
-                compile(last_expr, "<string>", "eval"), globals(), local_namespace
+        # Execute everything except the last statement
+        if parsed_code.body:
+            exec(
+                compile(parsed_code, "<string>", "exec"),
+                globals(),
+                local_namespace,
             )
-            return result
-        else:
-            # If the last statement is not an expression (e.g., an assignment),
-            # execute the entire code and return None
-            exec(code, globals(), local_namespace)
-            return None
-    return (execute_code,)
+
+        # Execute the last statement and get its value
+        result = eval(
+            compile(last_expr, "<string>", "eval"), globals(), local_namespace
+        )
+        return result
+    else:
+        # If the last statement is not an expression (e.g., an assignment),
+        # execute the entire code and return None
+        exec(code, globals(), local_namespace)
+        return None
 
 
 @app.cell(hide_code=True)

polars/11_missing_data.py

@@ -8,14 +8,13 @@
 
 import marimo
 
-__generated_with = "0.15.3"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Dealing with Missing Data
 
     _by [etrotta](https://github.com/etrotta) and [Felix Najera](https://github.com/folicks)_
@@ -24,20 +23,17 @@ def _(mo):
 
     First we provide an overview of the methods available in polars, then we walk through a mini case study with real world data showing how to use it, and at last we provide some additional information in the 'Bonus Content' section.
     You can navigate to skip around to each header using the menu on the right side
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Methods for working with Nulls
 
     We'll be using the following DataFrame to show the most important methods:
-    """
-    )
+    """)
     return
 
 
@@ -59,13 +55,11 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Counting nulls
 
     A simple yet convenient aggregation
-    """
-    )
+    """)
     return
 
 
@@ -77,13 +71,11 @@ def _(df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Dropping Nulls
 
     The simplest way of dealing with null values is throwing them away, but that is not always a good idea.
-    """
-    )
+    """)
     return
 
 
@@ -101,8 +93,7 @@ def _(df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Filtering null values
 
     To filter in polars, you'll typically use `df.filter(expression)` or `df.remove(expression)` methods.
@@ -112,8 +103,7 @@ def _(mo):
 
     Remove will only remove rows in which the expression evaluates to True.
     It will keep rows in which it evaluates to None.
-    """
-    )
+    """)
     return
 
 
@@ -131,13 +121,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     You may also be tempted to use `== None` or `!= None`, but operators in polars will generally propagate null values.
 
     You can use `.eq_missing()` or `.ne_missing()` methods if you want to be strict about it, but there are also `.is_null()` and `.is_not_null()` methods you can use.
-    """
-    )
+    """)
     return
 
 
@@ -156,8 +144,7 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Filling Null values
 
     You can also fill in the values with constants, calculations or by consulting external data sources.
@@ -165,8 +152,7 @@ def _(mo):
     Be careful not to treat estimated or guessed values as if they a ground truth however, otherwise you may end up making conclusions about a reality that does not exists.
 
     As an exercise, let's guess some values to fill in nulls, then try giving names to the animals with `null` by editing the cells
-    """
-    )
+    """)
     return
 
 
@@ -192,8 +178,7 @@ def _(guesstimates):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### TL;DR
 
     Before we head into the mini case study, a brief review of what we have covered:
@@ -207,24 +192,21 @@ def _(mo):
     You can also refer to the polars [User Guide](https://docs.pola.rs/user-guide/expressions/missing-data/) more more information.
 
     Whichever approach you take, remember to document how you handled it!
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Mini Case Study
 
-    We will be using a dataset from `alertario` about the weather in Rio de Janeiro, originally available in Google Big Query under `datario.clima_pluviometro`. What you need to know about it: 
+    We will be using a dataset from `alertario` about the weather in Rio de Janeiro, originally available in Google Big Query under `datario.clima_pluviometro`. What you need to know about it:
 
     - Contains multiple stations covering the Municipality of Rio de Janeiro
     - Measures the precipitation as millimeters, with a granularity of 15 minutes
     - We filtered to only include data about 2020, 2021 and 2022
-    """
-    )
+    """)
     return
 
 
@@ -257,8 +239,7 @@ def _(pl, px, stations):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Stations
 
     First, let's take a look at some of the stations. Notice how
@@ -267,8 +248,7 @@ def _(mo):
     - There are some columns that do not even contain data at all!
 
     We will remove the empty columns and remove rows without coordinates
-    """
-    )
+    """)
     return
 
 
@@ -295,16 +275,14 @@ def _(dirty_stations, mo, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Precipitation
     Now, let's move on to the Precipitation data.
 
     ## Part 1 - Null Values
 
     First of all, let's check for null values:
-    """
-    )
+    """)
     return
 
 
@@ -328,8 +306,7 @@ def _(dirty_weather, mo, rain):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### First option to fixing it: Dropping data.
 
     We could just remove those rows like we did for the stations, which may be a passable solution for some problems, but is not always the best idea.
@@ -354,8 +331,7 @@ def _(mo):
 
     Let's investigate a bit more before deciding on following with either approach.
     For example, is our current data even complete, or are we already missing some rows beyond those with null values?
-    """
-    )
+    """)
     return
 
 
@@ -387,8 +363,7 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Part 2 - Missing Rows
 
     We can see that we expected there to be 1096 rows for each hour for each station (from the start of 2020 to the end of 2022) , but in reality we see between 1077 and 1096 rows.
@@ -400,8 +375,7 @@ def _(mo):
     Given that we are working with time series data, we will [upsample](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.upsample.html) the data, but you could also create a DataFrame containing all expected rows then use `join(how="...")`
 
     However, that will give us _even more_ null values, so we will want to fill them in afterwards. For this case, we will just use a forward fill followed by a backwards fill.
-    """
-    )
+    """)
     return
 
 
@@ -435,15 +409,13 @@ def _(dirty_weather, mo, pl, rain):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Now that we finally have a clean dataset, let's play around with it a little.
 
     ### Example App
 
     Let's display the amount of precipitation each station measured within a timeframe, aggregated to a lower granularity.
-    """
-    )
+    """)
     return
 
 
@@ -534,13 +506,11 @@ def _(animation_data, pl, px):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     If we were missing some rows, we would have circles popping in and out of existence instead of a smooth animation!
 
     In many scenarios, missing data can also lead to wrong results overall, for example if we were to estimate the total amount of rainfall during the observed period:
-    """
-    )
+    """)
     return
 
 
@@ -556,20 +526,17 @@ def _(dirty_weather, mo, rain, weather):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Which is still a relatively small difference, but every drop counts when you are dealing with the weather.
 
     For datasets with a higher share of missing values, that difference can get much higher.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Bonus Content
 
     ## Appendix A: Missing Time Zones
@@ -577,8 +544,7 @@ def _(mo):
     The original dataset contained naive datetimes instead of timezone-aware, but we can infer whenever it refers to UTC time or local time (for this case, -03:00 UTC) based on the measurements.
 
     For example, we can select one specific interval during which we know that rained a lot, or graph the average amount of precipitation for each hour of the day, then compare the data timestamps with a ground truth.
-    """
-    )
+    """)
     return
 
 
@@ -635,13 +601,11 @@ def _(dirty_weather_naive, pl, rain, stations):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     By externally researching the expected distribution and looking up some of the extreme weather events, we can come to a conclusion about whenever it is aligned with the local time or with UTC.
 
     In this case, the distribution matches the normal weather for this region and we can see that the hours with the most precipitation match those of historical events, so it is safe to say it is using local time (equivalent to the Americas/São Paulo time zone).
-    """
-    )
+    """)
     return
 
 
@@ -655,8 +619,7 @@ def _(dirty_weather_naive, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Appendix B: Not a Number
 
     While some other tools without proper support for missing values may use `NaN` as a way to indicate a value is missing, in polars it is treated exclusively as a float value, much like `0.0`, `1.0` or `infinity`.
@@ -664,8 +627,7 @@ def _(mo):
     You can use `.fill_null(float('nan'))` if you need to convert floats to a format such tools accept, or use `.fill_nan(None)` if you are importing data from them, assuming that there are no values which really are supposed to be the float NaN.
 
     Remember that many calculations can result in NaN, for example dividing by zero:
-    """
-    )
+    """)
     return
 
 
@@ -696,29 +658,25 @@ def _(day_perc, mo, perc_col):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Appendix C: Everything else
 
     As long as this Notebook is, it cannot reasonably cover ***everything*** that may have to deal with missing values, as that is literally everything that may have to deal with data.
 
     This section very briefly covers some other features not mentioned above
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Missing values in Aggregations
 
     Many aggregations methods will ignore/skip missing values, while others take them into consideration.
 
     Always check the documentation of the method you're using, much of the time docstrings will explain their behaviour.
-    """
-    )
+    """)
     return
 
 
@@ -733,13 +691,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Missing values in Joins
 
     By default null values will never produce matches using [join](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.join.html), but you can specify `nulls_equal=True` to join Null values with each other.
-    """
-    )
+    """)
     return
 
 
@@ -772,13 +728,11 @@ def _(age_groups, df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Utilities
 
     Loading data and imports
-    """
-    )
+    """)
     return
 
 

polars/12_aggregations.py

@@ -8,7 +8,7 @@
 
 import marimo
 
-__generated_with = "0.12.9"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -20,14 +20,12 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Aggregations
-        _By [Joram Mutenge](https://www.udemy.com/user/joram-mutenge/)._
+    mo.md(r"""
+    # Aggregations
+    _By [Joram Mutenge](https://www.udemy.com/user/joram-mutenge/)._
 
-        In this notebook, you'll learn how to perform different types of aggregations in Polars, including grouping by categories and time. We'll analyze sales data from a clothing store, focusing on three product categories: hats, socks, and sweaters.
-        """
-    )
+    In this notebook, you'll learn how to perform different types of aggregations in Polars, including grouping by categories and time. We'll analyze sales data from a clothing store, focusing on three product categories: hats, socks, and sweaters.
+    """)
     return
 
 
@@ -44,13 +42,11 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Grouping by category
-        ### With single category
-        Let's find out how many of each product category we sold.
-        """
-    )
+    mo.md(r"""
+    ## Grouping by category
+    ### With single category
+    Let's find out how many of each product category we sold.
+    """)
     return
 
 
@@ -65,13 +61,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        It looks like we sold more sweaters. Maybe this was a winter season.
+    mo.md(r"""
+    It looks like we sold more sweaters. Maybe this was a winter season.
 
-        Let's add another aggregate to see how much was spent on the total units for each product.
-        """
-    )
+    Let's add another aggregate to see how much was spent on the total units for each product.
+    """)
     return
 
 
@@ -87,7 +81,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We could also write aggregate code for the two columns as a single line.""")
+    mo.md(r"""
+    We could also write aggregate code for the two columns as a single line.
+    """)
     return
 
 
@@ -102,7 +98,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Actually, the way we've been writing the aggregate lines is syntactic sugar. Here's a longer way of doing it as shown in the [Polars documentation](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.dataframe.group_by.GroupBy.agg.html).""")
+    mo.md(r"""
+    Actually, the way we've been writing the aggregate lines is syntactic sugar. Here's a longer way of doing it as shown in the [Polars documentation](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.dataframe.group_by.GroupBy.agg.html).
+    """)
     return
 
 
@@ -118,12 +116,10 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### With multiple categories
-        We can also group by multiple categories. Let's find out how many items we sold in each product category for each SKU. This more detailed aggregation will produce more rows than the previous DataFrame.
-        """
-    )
+    mo.md(r"""
+    ### With multiple categories
+    We can also group by multiple categories. Let's find out how many items we sold in each product category for each SKU. This more detailed aggregation will produce more rows than the previous DataFrame.
+    """)
     return
 
 
@@ -138,13 +134,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Aggregations when grouping data are not limited to sums. You can also use functions like [`max`, `min`, `median`, `first`, and `last`](https://docs.pola.rs/user-guide/expressions/aggregation/#basic-aggregations).  
+    mo.md(r"""
+    Aggregations when grouping data are not limited to sums. You can also use functions like [`max`, `min`, `median`, `first`, and `last`](https://docs.pola.rs/user-guide/expressions/aggregation/#basic-aggregations).
 
-        Let's find the largest sale quantity for each product category.
-        """
-    )
+    Let's find the largest sale quantity for each product category.
+    """)
     return
 
 
@@ -159,13 +153,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Let's make the aggregation more interesting. We'll identify the first customer to purchase each item, along with the quantity they bought and the amount they spent.
+    mo.md(r"""
+    Let's make the aggregation more interesting. We'll identify the first customer to purchase each item, along with the quantity they bought and the amount they spent.
 
-        **Note:** To make this work, we'll have to sort the date from earliest to latest.
-        """
-    )
+    **Note:** To make this work, we'll have to sort the date from earliest to latest.
+    """)
     return
 
 
@@ -181,14 +173,12 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Grouping by time
-        Since `datetime` is a special data type in Polars, we can perform various group-by aggregations on it.  
+    mo.md(r"""
+    ## Grouping by time
+    Since `datetime` is a special data type in Polars, we can perform various group-by aggregations on it.
 
-        Our dataset spans a two-year period. Let's calculate the total dollar sales for each year. We'll do it the naive way first so you can appreciate grouping with time.
-        """
-    )
+    Our dataset spans a two-year period. Let's calculate the total dollar sales for each year. We'll do it the naive way first so you can appreciate grouping with time.
+    """)
     return
 
 
@@ -204,13 +194,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        We had more sales in 2014.
+    mo.md(r"""
+    We had more sales in 2014.
 
-        Now let's perform the above operation by grouping with time. This requires sorting the dataframe first.
-        """
-    )
+    Now let's perform the above operation by grouping with time. This requires sorting the dataframe first.
+    """)
     return
 
 
@@ -226,13 +214,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        The beauty of grouping with time is that it allows us to resample the data by selecting whatever time interval we want.
+    mo.md(r"""
+    The beauty of grouping with time is that it allows us to resample the data by selecting whatever time interval we want.
 
-        Let's find out what the quarterly sales were for 2014
-        """
-    )
+    Let's find out what the quarterly sales were for 2014
+    """)
     return
 
 
@@ -249,13 +235,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Here's an interesting question we can answer that takes advantage of grouping by time.
+    mo.md(r"""
+    Here's an interesting question we can answer that takes advantage of grouping by time.
 
-        Let's find the hour of the day where we had the most sales in dollars.
-        """
-    )
+    Let's find the hour of the day where we had the most sales in dollars.
+    """)
     return
 
 
@@ -272,7 +256,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Just for fun, let's find the median number of items sold in each SKU and the total dollar amount in each SKU every six days.""")
+    mo.md(r"""
+    Just for fun, let's find the median number of items sold in each SKU and the total dollar amount in each SKU every six days.
+    """)
     return
 
 
@@ -290,7 +276,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's rename the columns to clearly indicate the type of aggregation performed. This will help us identify the aggregation method used on a column without needing to check the code.""")
+    mo.md(r"""
+    Let's rename the columns to clearly indicate the type of aggregation performed. This will help us identify the aggregation method used on a column without needing to check the code.
+    """)
     return
 
 
@@ -308,15 +296,13 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Grouping with over
+    mo.md(r"""
+    ## Grouping with over
 
-        Sometimes, we may want to perform an aggregation but also keep all the columns and rows of the dataframe.
+    Sometimes, we may want to perform an aggregation but also keep all the columns and rows of the dataframe.
 
-        Let's assign a value to indicate the number of times each customer visited and bought something.
-        """
-    )
+    Let's assign a value to indicate the number of times each customer visited and bought something.
+    """)
     return
 
 
@@ -330,7 +316,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Finally, let's determine which customers visited the store the most and bought something.""")
+    mo.md(r"""
+    Finally, let's determine which customers visited the store the most and bought something.
+    """)
     return
 
 
@@ -347,7 +335,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""There's more you can do with aggregations in Polars such as [sorting with aggregations](https://docs.pola.rs/user-guide/expressions/aggregation/#sorting). We hope that in this notebook, we've armed you with the tools to get started.""")
+    mo.md(r"""
+    There's more you can do with aggregations in Polars such as [sorting with aggregations](https://docs.pola.rs/user-guide/expressions/aggregation/#sorting). We hope that in this notebook, we've armed you with the tools to get started.
+    """)
     return
 
 

polars/13_window_functions.py

@@ -11,14 +11,13 @@
 
 import marimo
 
-__generated_with = "0.13.11"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Window Functions")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     # Window Functions
     _By [Henry Harbeck](https://github.com/henryharbeck)._
 
@@ -26,8 +25,7 @@ def _(mo):
     You'll work with partitions, ordering and Polars' available "mapping strategies".
 
     We'll use a dataset with a few days of paid and organic digital revenue data.
-    """
-    )
+    """)
     return
 
 
@@ -53,8 +51,7 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## What is a window function?
 
     A window function performs a calculation across a set of rows that are related to the current row.
@@ -64,32 +61,27 @@ def _(mo):
 
     Window functions can be used by specifying the [`over`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.over.html)
     method on an expression.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Partitions
     Partitions are the "group by" columns. We will have one "window" of data per unique value in the partition column(s), to
     which the function will be applied.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Partitioning by a single column
 
     Let's get the total revenue per date...
-    """
-    )
+    """)
     return
 
 
@@ -103,7 +95,9 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""And then see what percentage of the daily total was Paid and what percentage was Organic.""")
+    mo.md(r"""
+    And then see what percentage of the daily total was Paid and what percentage was Organic.
+    """)
     return
 
 
@@ -115,12 +109,10 @@ def _(daily_revenue, df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Let's now calculate the maximum revenue, cumulative revenue, rank the revenue and calculate the day-on-day change,
     all partitioned (split) by channel.
-    """
-    )
+    """)
     return
 
 
@@ -137,28 +129,24 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Note that aggregation functions such as `sum` and `max` have their value applied back to each row in the partition
     (group). Non-aggregate functions such as `cum_sum`, `rank` and `diff` can produce different values per row, but
     still only consider rows within their partition.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Partitioning by multiple columns
 
     We can also partition by multiple columns.
 
     Let's add a column to see whether it is a weekday (business day), then get the maximum revenue by that and
     the channel.
-    """
-    )
+    """)
     return
 
 
@@ -176,15 +164,13 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Partitioning by expressions
 
     Polars also lets you partition by expressions without needing to create them as columns first.
 
     So, we could re-write the previous window function as...
-    """
-    )
+    """)
     return
 
 
@@ -200,20 +186,17 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     Window functions fit into Polars' composable [expressions API](https://docs.pola.rs/user-guide/concepts/expressions-and-contexts/#expressions),
     so can be combined with all [aggregation methods](https://docs.pola.rs/api/python/stable/reference/expressions/aggregation.html)
     and methods that consider more than 1 row (e.g., `cum_sum`, `rank` and `diff` as we just saw).
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Ordering
 
     The `order_by` parameter controls how to order the data within the window. The function is applied to the data in this
@@ -221,21 +204,18 @@ def _(mo):
 
     Up until this point, we have been letting Polars do the window function calculations based on the order of the rows in the
     DataFrame. There can be times where we would like order of the calculation and the order of the output itself to differ.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ### Ordering in a window function
 
     Let's say we want the DataFrame ordered by day of week, but we still want cumulative revenue and the first revenue observation, both
     ordered by date and partitioned by channel...
-    """
-    )
+    """)
     return
 
 
@@ -261,21 +241,19 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Note about window function ordering compared to SQL
 
     It is worth noting that traditionally in SQL, many more functions require an `ORDER BY` within `OVER` than in
     equivalent functions in Polars.
 
     For example, an SQL `RANK()` expression like...
-    """
-    )
+    """)
     return
 
 
 @app.cell
-def _(df, mo):
+def _(mo):
     _df = mo.sql(
         f"""
         SELECT
@@ -293,12 +271,10 @@ def _(df, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ...does not require an `order_by` in Polars as the column and the function are already bound (including with the
     `descending=True` argument).
-    """
-    )
+    """)
     return
 
 
@@ -315,13 +291,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Descending order
 
     We can also order in descending order by passing `descending=True`...
-    """
-    )
+    """)
     return
 
 
@@ -348,29 +322,25 @@ def _(df_sorted, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ## Mapping Strategies
 
     Mapping Strategies control how Polars maps the result of the window function back to the original DataFrame
 
     Generally (by default) the result of a window function is assigned back to rows within the group. Through Polars' mapping
     strategies, we will explore other possibilities.
-    """
-    )
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ### Group to rows
 
     "group_to_rows" is the default mapping strategy and assigns the result of the window function back to the rows in the
     window.
-    """
-    )
+    """)
     return
 
 
@@ -384,13 +354,11 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
+    mo.md("""
     ### Join
 
     The "join" mapping strategy aggregates the resulting values in a list and repeats the list for all rows in the group.
-    """
-    )
+    """)
     return
 
 
@@ -404,8 +372,7 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Explode
 
     The "explode" mapping strategy is similar to "group_to_rows", but is typically faster and does not preserve the order of
@@ -413,8 +380,7 @@ def _(mo):
     It should also only be used in a `select` context and not `with_columns`.
 
     The result of "explode" is similar to a `group_by` followed by an `agg` followed by an `explode`.
-    """
-    )
+    """)
     return
 
 
@@ -431,26 +397,28 @@ def _(df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Note the modified order of the rows in the output, (but data is the same)...""")
+    mo.md(r"""
+    Note the modified order of the rows in the output, (but data is the same)...
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Other tips and tricks""")
+    mo.md(r"""
+    ## Other tips and tricks
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Reusing a window
 
     In SQL there is a `WINDOW` keyword, which easily allows the re-use of the same window specification across expressions
     without needing to repeat it. In Polars, this can be achieved by using `dict` unpacking to pass arguments to `over`.
-    """
-    )
+    """)
     return
 
 
@@ -472,8 +440,7 @@ def _(df_sorted, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ### Rolling Windows
 
     Much like in SQL, Polars also gives you the ability to do rolling window computations. In Polars, the rolling calculation
@@ -481,8 +448,7 @@ def _(mo):
 
     Let's look at an example of that now by filtering out one day of our data and then calculating both a 3-day and 3-row
     max revenue split by channel...
-    """
-    )
+    """)
     return
 
 
@@ -503,27 +469,29 @@ def _(date, df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Notice the difference in the 2nd last row...""")
+    mo.md(r"""
+    Notice the difference in the 2nd last row...
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We hope you enjoyed this notebook, demonstrating window functions in Polars!""")
+    mo.md(r"""
+    We hope you enjoyed this notebook, demonstrating window functions in Polars!
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
+    mo.md(r"""
     ## Additional References
 
     - [Polars User guide - Window functions](https://docs.pola.rs/user-guide/expressions/window-functions/)
     - [Polars over method API reference](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.over.html)
     - [PostgreSQL window function documentation](https://www.postgresql.org/docs/current/tutorial-window.html)
-    """
-    )
+    """)
     return
 
 

polars/14_user_defined_functions.py

@@ -14,58 +14,52 @@
 
 import marimo
 
-__generated_with = "0.11.17"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # User-Defined Functions
+    mo.md(r"""
+    # User-Defined Functions
 
-        _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
+    _By [Péter Ferenc Gyarmati](http://github.com/peter-gy)_.
 
-        Throughout the previous chapters, you've seen how Polars provides a comprehensive set of built-in expressions for flexible data transformation.  But what happens when you need something *more*? Perhaps your project has unique requirements, or you need to integrate functionality from an external Python library. This is where User-Defined Functions (UDFs) come into play, allowing you to extend Polars with your own custom logic.
+    Throughout the previous chapters, you've seen how Polars provides a comprehensive set of built-in expressions for flexible data transformation.  But what happens when you need something *more*? Perhaps your project has unique requirements, or you need to integrate functionality from an external Python library. This is where User-Defined Functions (UDFs) come into play, allowing you to extend Polars with your own custom logic.
 
-        In this chapter, we'll weigh the performance trade-offs of UDFs, pinpoint situations where they're truly beneficial, and explore different ways to effectively incorporate them into your Polars workflows. We'll walk through a complete, practical example.
-        """
-    )
+    In this chapter, we'll weigh the performance trade-offs of UDFs, pinpoint situations where they're truly beneficial, and explore different ways to effectively incorporate them into your Polars workflows. We'll walk through a complete, practical example.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ⚖️ The Cost of UDFs
+    mo.md(r"""
+    ## ⚖️ The Cost of UDFs
 
-        > Performance vs. Flexibility
+    > Performance vs. Flexibility
 
-        Polars' built-in expressions are highly optimized for speed and parallel processing. User-defined functions (UDFs), however, introduce a significant performance overhead because they rely on standard Python code, which often runs in a single thread and bypasses Polars' logical optimizations. Therefore, always prioritize native Polars operations *whenever possible*.
+    Polars' built-in expressions are highly optimized for speed and parallel processing. User-defined functions (UDFs), however, introduce a significant performance overhead because they rely on standard Python code, which often runs in a single thread and bypasses Polars' logical optimizations. Therefore, always prioritize native Polars operations *whenever possible*.
 
-        However, UDFs become inevitable when you need to:
+    However, UDFs become inevitable when you need to:
 
-        -  **Integrate external libraries:**  Use functionality not directly available in Polars.
-        -  **Implement custom logic:** Handle complex transformations that can't be easily expressed with Polars' built-in functions.
+    -  **Integrate external libraries:**  Use functionality not directly available in Polars.
+    -  **Implement custom logic:** Handle complex transformations that can't be easily expressed with Polars' built-in functions.
 
-        Let's dive into a real-world project where UDFs were the only way to get the job done, demonstrating a scenario where native Polars expressions simply weren't sufficient.
-        """
-    )
+    Let's dive into a real-world project where UDFs were the only way to get the job done, demonstrating a scenario where native Polars expressions simply weren't sufficient.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 📊 Project Overview
+    mo.md(r"""
+    ## 📊 Project Overview
 
-        > Scraping and Analyzing Observable Notebook Statistics
+    > Scraping and Analyzing Observable Notebook Statistics
 
-        If you're into data visualization, you've probably seen [D3.js](https://d3js.org/) and [Observable Plot](https://observablehq.com/plot/). Both have extensive galleries showcasing amazing visualizations. Each gallery item is a standalone [Observable notebook](https://observablehq.com/documentation/notebooks/), with metrics like stars, comments, and forks – indicators of popularity. But getting and analyzing these statistics directly isn't straightforward. We'll need to scrape the web.
-        """
-    )
+    If you're into data visualization, you've probably seen [D3.js](https://d3js.org/) and [Observable Plot](https://observablehq.com/plot/). Both have extensive galleries showcasing amazing visualizations. Each gallery item is a standalone [Observable notebook](https://observablehq.com/documentation/notebooks/), with metrics like stars, comments, and forks – indicators of popularity. But getting and analyzing these statistics directly isn't straightforward. We'll need to scrape the web.
+    """)
     return
 
 
@@ -90,7 +84,9 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Our goal is to use Polars UDFs to fetch the HTML content of these gallery pages. Then, we'll use the `BeautifulSoup` Python library to parse the HTML and extract the relevant metadata.  After some data wrangling with native Polars expressions, we'll have a DataFrame listing each visualization notebook. Then, we'll use another UDF to retrieve the number of likes, forks, and comments for each notebook. Finally, we will create our own high-performance UDF to implement a custom notebook ranking scheme. This will involve multiple steps, showcasing different UDF approaches.""")
+    mo.md(r"""
+    Our goal is to use Polars UDFs to fetch the HTML content of these gallery pages. Then, we'll use the `BeautifulSoup` Python library to parse the HTML and extract the relevant metadata.  After some data wrangling with native Polars expressions, we'll have a DataFrame listing each visualization notebook. Then, we'll use another UDF to retrieve the number of likes, forks, and comments for each notebook. Finally, we will create our own high-performance UDF to implement a custom notebook ranking scheme. This will involve multiple steps, showcasing different UDF approaches.
+    """)
     return
 
 
@@ -109,7 +105,9 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Our starting point, `url_df`, is a simple DataFrame with a single `url` column containing the URLs of the D3 and Observable Plot gallery notebooks.""")
+    mo.md(r"""
+    Our starting point, `url_df`, is a simple DataFrame with a single `url` column containing the URLs of the D3 and Observable Plot gallery notebooks.
+    """)
     return
 
 
@@ -129,19 +127,17 @@ def _(pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🔂 Element-Wise UDFs
+    mo.md(r"""
+    ## 🔂 Element-Wise UDFs
 
-        > Processing Value by Value
+    > Processing Value by Value
 
-        The most common way to use UDFs is to apply them element-wise.  This means our custom function will execute for *each individual row* in a specified column.  Our first task is to fetch the HTML content for each URL in `url_df`.
+    The most common way to use UDFs is to apply them element-wise.  This means our custom function will execute for *each individual row* in a specified column.  Our first task is to fetch the HTML content for each URL in `url_df`.
 
-        We'll define a Python function that takes a `url` (a string) as input, uses the `httpx` library (an HTTP client) to fetch the content, and returns the HTML as a string. We then integrate this function into Polars using the [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) expression.
+    We'll define a Python function that takes a `url` (a string) as input, uses the `httpx` library (an HTTP client) to fetch the content, and returns the HTML as a string. We then integrate this function into Polars using the [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) expression.
 
-        You'll notice we have to explicitly specify the `return_dtype`.  This is *crucial*.  Polars doesn't automatically know what our custom function will return.  We're responsible for defining the function's logic and, therefore, its output type. By providing the `return_dtype`, we help Polars maintain its internal representation of the DataFrame's schema, enabling query optimization. Think of it as giving Polars a "heads-up" about the data type it should expect.
-        """
-    )
+    You'll notice we have to explicitly specify the `return_dtype`.  This is *crucial*.  Polars doesn't automatically know what our custom function will return.  We're responsible for defining the function's logic and, therefore, its output type. By providing the `return_dtype`, we help Polars maintain its internal representation of the DataFrame's schema, enabling query optimization. Think of it as giving Polars a "heads-up" about the data type it should expect.
+    """)
     return
 
 
@@ -159,13 +155,11 @@ def _(httpx, pl, url_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Now, `html_df` holds the HTML for each URL.  We need to parse it. Again, a UDF is the way to go. Parsing HTML with native Polars expressions would be a nightmare! Instead, we'll use the [`beautifulsoup4`](https://pypi.org/project/beautifulsoup4/) library, a standard tool for this.
+    mo.md(r"""
+    Now, `html_df` holds the HTML for each URL.  We need to parse it. Again, a UDF is the way to go. Parsing HTML with native Polars expressions would be a nightmare! Instead, we'll use the [`beautifulsoup4`](https://pypi.org/project/beautifulsoup4/) library, a standard tool for this.
 
-        These Observable pages are built with [Next.js](https://nextjs.org/), which helpfully serializes page properties as JSON within the HTML. This simplifies our UDF: we'll extract the raw JSON from the `<script id="__NEXT_DATA__" type="application/json">` tag. We'll use [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) again.  For clarity, we'll define this UDF as a named function, `extract_nextjs_data`, since it's a bit more complex than a simple HTTP request.
-        """
-    )
+    These Observable pages are built with [Next.js](https://nextjs.org/), which helpfully serializes page properties as JSON within the HTML. This simplifies our UDF: we'll extract the raw JSON from the `<script id="__NEXT_DATA__" type="application/json">` tag. We'll use [`map_elements`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_elements.html) again.  For clarity, we'll define this UDF as a named function, `extract_nextjs_data`, since it's a bit more complex than a simple HTTP request.
+    """)
     return
 
 
@@ -193,7 +187,9 @@ def _(extract_nextjs_data, html_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""With some data wrangling of the raw JSON (using *native* Polars expressions!), we get `notebooks_df`, containing the metadata for each notebook.""")
+    mo.md(r"""
+    With some data wrangling of the raw JSON (using *native* Polars expressions!), we get `notebooks_df`, containing the metadata for each notebook.
+    """)
     return
 
 
@@ -276,19 +272,17 @@ def _(parsed_html_df, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 📦 Batch-Wise UDFs
+    mo.md(r"""
+    ## 📦 Batch-Wise UDFs
 
-        > Processing Entire Series
+    > Processing Entire Series
 
-        `map_elements` calls the UDF for *each row*. Fine for our tiny, two-rows-tall `url_df`. But `notebooks_df` has almost 400 rows! Individual HTTP requests for each would be painfully slow.
+    `map_elements` calls the UDF for *each row*. Fine for our tiny, two-rows-tall `url_df`. But `notebooks_df` has almost 400 rows! Individual HTTP requests for each would be painfully slow.
 
-        We want stats for each notebook in `notebooks_df`. To avoid sequential requests, we'll use Polars' [`map_batches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_batches.html). This lets us process an *entire Series* (a column) at once.
+    We want stats for each notebook in `notebooks_df`. To avoid sequential requests, we'll use Polars' [`map_batches`](https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.map_batches.html). This lets us process an *entire Series* (a column) at once.
 
-        Our UDF, `fetch_html_batch`, will take a *Series* of URLs and use `asyncio` to make concurrent requests – a huge performance boost.
-        """
-    )
+    Our UDF, `fetch_html_batch`, will take a *Series* of URLs and use `asyncio` to make concurrent requests – a huge performance boost.
+    """)
     return
 
 
@@ -372,19 +366,19 @@ def _(mo, notebook_stats_df):
     return notebook_height, notebooks
 
 
-@app.cell(hide_code=True)
-def _():
-    def nb_iframe(notebook_url: str, height=825) -> str:
-        embed_url = notebook_url.replace(
-            "https://observablehq.com", "https://observablehq.com/embed"
-        )
-        return f'<iframe width="100%" height="{height}" frameborder="0" src="{embed_url}?cell=*"></iframe>'
-    return (nb_iframe,)
+@app.function(hide_code=True)
+def nb_iframe(notebook_url: str, height=825) -> str:
+    embed_url = notebook_url.replace(
+        "https://observablehq.com", "https://observablehq.com/embed"
+    )
+    return f'<iframe width="100%" height="{height}" frameborder="0" src="{embed_url}?cell=*"></iframe>'
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now that we have access to notebook-level statistics, we can rank the visualizations by the number of likes they received & display them interactively.""")
+    mo.md(r"""
+    Now that we have access to notebook-level statistics, we can rank the visualizations by the number of likes they received & display them interactively.
+    """)
     return
 
 
@@ -395,7 +389,7 @@ def _(mo):
 
 
 @app.cell(hide_code=True)
-def _(category, mo, nb_iframe, notebook_height, notebooks):
+def _(category, mo, notebook_height, notebooks):
     notebook = notebooks.value.to_dicts()[0]
     mo.vstack(
         [
@@ -406,60 +400,56 @@ def _(category, mo, nb_iframe, notebook_height, notebooks):
             mo.md(nb_iframe(notebook["notebook_url"], notebook_height.value)),
         ]
     )
-    return (notebook,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ⚙️ Row-Wise UDFs
+    mo.md(r"""
+    ## ⚙️ Row-Wise UDFs
 
-        > Accessing All Columns at Once
+    > Accessing All Columns at Once
 
-        Sometimes, you need to work with *all* columns of a row at once.  This is where [`map_rows`](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.map_rows.html) comes in. It operates directly on the DataFrame, passing each row to your UDF *as a tuple*.
+    Sometimes, you need to work with *all* columns of a row at once.  This is where [`map_rows`](https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.map_rows.html) comes in. It operates directly on the DataFrame, passing each row to your UDF *as a tuple*.
 
-        Below, `create_notebook_summary` takes a row from `notebook_stats_df` (as a tuple) and returns a formatted Markdown string summarizing the notebook's key stats.  We're essentially reducing the DataFrame to a single column.  While this *could* be done with native Polars expressions, it would be much more cumbersome. This example demonstrates a case where a row-wise UDF simplifies the code, even if the underlying operation isn't inherently complex.
-        """
-    )
+    Below, `create_notebook_summary` takes a row from `notebook_stats_df` (as a tuple) and returns a formatted Markdown string summarizing the notebook's key stats.  We're essentially reducing the DataFrame to a single column.  While this *could* be done with native Polars expressions, it would be much more cumbersome. This example demonstrates a case where a row-wise UDF simplifies the code, even if the underlying operation isn't inherently complex.
+    """)
     return
 
 
-@app.cell(hide_code=True)
-def _():
-    def create_notebook_summary(row: tuple) -> str:
-        (
-            thumbnail_src,
-            category,
-            title,
-            likes,
-            forks,
-            comments,
-            license,
-            description,
-            notebook_url,
-        ) = row
-        return (
-            f"""
-    ### [{title}]({notebook_url})
-
-    <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin: 12px 0;">
-        <div>⭐ <strong>Likes:</strong> {likes}</div>
-        <div>↗️ <strong>Forks:</strong> {forks}</div>
-        <div>💬 <strong>Comments:</strong> {comments}</div>
-        <div>⚖️ <strong>License:</strong> {license}</div>
-    </div>
-
-    <a href="{notebook_url}" target="_blank">
-        <img src="{thumbnail_src}" style="height: 300px;" />
-    <a/>
-    """.strip('\n')
-        )
-    return (create_notebook_summary,)
+@app.function(hide_code=True)
+def create_notebook_summary(row: tuple) -> str:
+    (
+        thumbnail_src,
+        category,
+        title,
+        likes,
+        forks,
+        comments,
+        license,
+        description,
+        notebook_url,
+    ) = row
+    return (
+        f"""
+### [{title}]({notebook_url})
+
+<div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin: 12px 0;">
+    <div>⭐ <strong>Likes:</strong> {likes}</div>
+    <div>↗️ <strong>Forks:</strong> {forks}</div>
+    <div>💬 <strong>Comments:</strong> {comments}</div>
+    <div>⚖️ <strong>License:</strong> {license}</div>
+</div>
+
+<a href="{notebook_url}" target="_blank">
+    <img src="{thumbnail_src}" style="height: 300px;" />
+<a/>
+""".strip('\n')
+    )
 
 
 @app.cell(hide_code=True)
-def _(create_notebook_summary, notebook_stats_df, pl):
+def _(notebook_stats_df, pl):
     notebook_summary_df = notebook_stats_df.map_rows(
         create_notebook_summary,
         return_dtype=pl.String,
@@ -487,37 +477,33 @@ def _(mo, notebook_summary_df):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🚀 Higher-performance UDFs
+    mo.md(r"""
+    ## 🚀 Higher-performance UDFs
 
-        > Leveraging Numba to Make Python Fast
+    > Leveraging Numba to Make Python Fast
 
-        Python code doesn't *always* mean slow code. While UDFs *often* introduce performance overhead, there are exceptions. NumPy's universal functions ([`ufuncs`](https://numpy.org/doc/stable/reference/ufuncs.html)) and generalized universal functions ([`gufuncs`](https://numpy.org/neps/nep-0005-generalized-ufuncs.html)) provide high-performance operations on NumPy arrays, thanks to low-level implementations.
+    Python code doesn't *always* mean slow code. While UDFs *often* introduce performance overhead, there are exceptions. NumPy's universal functions ([`ufuncs`](https://numpy.org/doc/stable/reference/ufuncs.html)) and generalized universal functions ([`gufuncs`](https://numpy.org/neps/nep-0005-generalized-ufuncs.html)) provide high-performance operations on NumPy arrays, thanks to low-level implementations.
 
-        But NumPy's built-in functions are predefined. We can't easily use them for *custom* logic. Enter [`numba`](https://numba.pydata.org/).  Numba is a just-in-time (JIT) compiler that translates Python functions into optimized machine code *at runtime*. It provides decorators like [`numba.guvectorize`](https://numba.readthedocs.io/en/stable/user/vectorize.html#the-guvectorize-decorator) that let us create our *own* high-performance `gufuncs` – *without* writing low-level code!
-        """
-    )
+    But NumPy's built-in functions are predefined. We can't easily use them for *custom* logic. Enter [`numba`](https://numba.pydata.org/).  Numba is a just-in-time (JIT) compiler that translates Python functions into optimized machine code *at runtime*. It provides decorators like [`numba.guvectorize`](https://numba.readthedocs.io/en/stable/user/vectorize.html#the-guvectorize-decorator) that let us create our *own* high-performance `gufuncs` – *without* writing low-level code!
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Let's create a custom popularity metric to rank notebooks, considering likes, forks, *and* comments (not just likes).  We'll define `weighted_popularity_numba`, decorated with `@numba.guvectorize`.  The decorator arguments specify that we're taking three integer vectors of length `n` and returning a float vector of length `n`.
+    mo.md(r"""
+    Let's create a custom popularity metric to rank notebooks, considering likes, forks, *and* comments (not just likes).  We'll define `weighted_popularity_numba`, decorated with `@numba.guvectorize`.  The decorator arguments specify that we're taking three integer vectors of length `n` and returning a float vector of length `n`.
 
-        The weighted popularity score for each notebook is calculated using the following formula:
+    The weighted popularity score for each notebook is calculated using the following formula:
 
-        $$
-        \begin{equation}
-        \text{score}_i = w_l \cdot l_i^{f} + w_f \cdot f_i^{f} + w_c \cdot c_i^{f}
-        \end{equation}
-        $$
+    $$
+    \begin{equation}
+    \text{score}_i = w_l \cdot l_i^{f} + w_f \cdot f_i^{f} + w_c \cdot c_i^{f}
+    \end{equation}
+    $$
 
-        with:
-        """
-    )
+    with:
+    """)
     return
 
 
@@ -606,12 +592,14 @@ def _(
                 + w_f * (forks[i] ** nlf)
                 + w_c * (comments[i] ** nlf)
             )
-    return nlf, w_c, w_f, w_l, weighted_popularity_numba
+    return (weighted_popularity_numba,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We apply our JIT-compiled UDF using `map_batches`, as before.  The key is that we're passing entire columns directly to `weighted_popularity_numba`. Polars and Numba handle the conversion to NumPy arrays behind the scenes. This direct integration is a major benefit of using `guvectorize`.""")
+    mo.md(r"""
+    We apply our JIT-compiled UDF using `map_batches`, as before.  The key is that we're passing entire columns directly to `weighted_popularity_numba`. Polars and Numba handle the conversion to NumPy arrays behind the scenes. This direct integration is a major benefit of using `guvectorize`.
+    """)
     return
 
 
@@ -665,7 +653,9 @@ def _(
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""As the slope chart below demonstrates, this new ranking strategy significantly changes the notebook order, as it considers forks and comments, not just likes.""")
+    mo.md(r"""
+    As the slope chart below demonstrates, this new ranking strategy significantly changes the notebook order, as it considers forks and comments, not just likes.
+    """)
     return
 
 
@@ -700,27 +690,25 @@ def _(alt, notebook_popularity_df, pl):
         fill="title:N",
     )
     (points + lines).properties(width=400)
-    return lines, notebook_ranks_df, points
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## ⏱️ Quantifying the Overhead
+    mo.md(r"""
+    ## ⏱️ Quantifying the Overhead
 
-        > UDF Performance Comparison
+    > UDF Performance Comparison
 
-        To truly understand the performance implications of using UDFs, let's conduct a benchmark.  We'll create a DataFrame with random numbers and perform the same numerical operation using four different methods:
+    To truly understand the performance implications of using UDFs, let's conduct a benchmark.  We'll create a DataFrame with random numbers and perform the same numerical operation using four different methods:
 
-        1. **Native Polars:** Using Polars' built-in expressions.
-        2. **`map_elements`:**  Applying a Python function element-wise.
-        3. **`map_batches`:** **Applying** a Python function to the entire Series.
-        4. **`map_batches` with Numba:** Applying a JIT-compiled function to batches, similar to a generalized universal function.
+    1. **Native Polars:** Using Polars' built-in expressions.
+    2. **`map_elements`:**  Applying a Python function element-wise.
+    3. **`map_batches`:** **Applying** a Python function to the entire Series.
+    4. **`map_batches` with Numba:** Applying a JIT-compiled function to batches, similar to a generalized universal function.
 
-        We'll use a simple, but non-trivial, calculation:  `result = (x * 2.5 + 5) / (x + 1)`. This involves multiplication, addition, and division, giving us a realistic representation of a common numerical operation. We'll use the `timeit` module, to accurately measure execution times over multiple trials.
-        """
-    )
+    We'll use a simple, but non-trivial, calculation:  `result = (x * 2.5 + 5) / (x + 1)`. This involves multiplication, addition, and division, giving us a realistic representation of a common numerical operation. We'll use the `timeit` module, to accurately measure execution times over multiple trials.
+    """)
     return
 
 
@@ -750,15 +738,13 @@ def _(benchmark_plot, mo, num_samples, num_trials):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        As anticipated, the `Batch-Wise UDF (Python)` and `Element-Wise UDF` exhibit significantly worse performance, essentially acting as pure-Python for-each loops.  
+    mo.md(r"""
+    As anticipated, the `Batch-Wise UDF (Python)` and `Element-Wise UDF` exhibit significantly worse performance, essentially acting as pure-Python for-each loops.
 
-        However, when Python serves as an interface to lower-level, high-performance libraries, we observe substantial improvements. The `Batch-Wise UDF (NumPy)` lags behind both `Batch-Wise UDF (Numba)` and `Native Polars`, but it still represents a considerable improvement over pure-Python UDFs due to its vectorized computations. 
+    However, when Python serves as an interface to lower-level, high-performance libraries, we observe substantial improvements. The `Batch-Wise UDF (NumPy)` lags behind both `Batch-Wise UDF (Numba)` and `Native Polars`, but it still represents a considerable improvement over pure-Python UDFs due to its vectorized computations.
 
-        Numba's Just-In-Time (JIT) compilation delivers a dramatic performance boost, achieving speeds comparable to native Polars expressions. This demonstrates that UDFs, particularly when combined with tools like Numba, don't inevitably lead to bottlenecks in numerical computations.
-        """
-    )
+    Numba's Just-In-Time (JIT) compilation delivers a dramatic performance boost, achieving speeds comparable to native Polars expressions. This demonstrates that UDFs, particularly when combined with tools like Numba, don't inevitably lead to bottlenecks in numerical computations.
+    """)
     return
 
 
@@ -789,7 +775,7 @@ def _(mo):
 def _(np, num_samples, pl):
     rng = np.random.default_rng(42)
     sample_df = pl.from_dict({"x": rng.random(num_samples.value)})
-    return rng, sample_df
+    return (sample_df,)
 
 
 @app.cell(hide_code=True)
@@ -861,14 +847,7 @@ def _(np, num_trials, numba, pl, sample_df, timeit):
     def time_method(callable_name: str, number=num_trials.value) -> float:
         fn = globals()[callable_name]
         return timeit.timeit(fn, number=number)
-    return (
-        run_map_batches_numba,
-        run_map_batches_numpy,
-        run_map_batches_python,
-        run_map_elements,
-        run_native,
-        time_method,
-    )
+    return (time_method,)
 
 
 @app.cell(hide_code=True)
@@ -906,7 +885,7 @@ def _(alt, pl, time_method):
         x=alt.X("title:N", title="Method", sort="-y"),
         y=alt.Y("time:Q", title="Execution Time (s)", axis=alt.Axis(format=".3f")),
     ).properties(width=400)
-    return benchmark_df, benchmark_plot
+    return (benchmark_plot,)
 
 
 @app.cell(hide_code=True)
@@ -934,7 +913,6 @@ def _():
         asyncio,
         httpx,
         mo,
-        nest_asyncio,
         np,
         numba,
         pl,

polars/16_lazy_execution.py

@@ -15,19 +15,17 @@
 
 import marimo
 
-__generated_with = "0.12.6"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Lazy Execution (a.k.a. the Lazy API)
+    mo.md(r"""
+    # Lazy Execution (a.k.a. the Lazy API)
 
-        Author: [Deb Debnath](https://github.com/debajyotid2)
-        """
-    )
+    Author: [Deb Debnath](https://github.com/debajyotid2)
+    """)
     return
 
 
@@ -51,14 +49,9 @@ def _():
         Generator,
         datetime,
         np,
-        numba,
-        pd,
         pl,
-        plt,
         random,
         re,
-        spl,
-        st,
         time,
         timedelta,
         timezone,
@@ -67,47 +60,43 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        We saw the benefits of lazy evaluation when we learned about the Expressions API in Polars. Lazy execution is further extended as a philosophy by the Lazy API. It offers significant performance enhancements over eager (immediate) execution of queries and is one of the reasons why Polars is faster at working with large (GB scale) datasets than other libraries. The lazy API optimizes the full query pipeline instead of executing individual queries optimally, unlike eager execution. Some of the advantages of using the Lazy API over eager execution include
-
-        - automatic query optimization with the query optimizer.
-        - ability to process datasets larger than memory using streaming.
-        - ability to catch schema errors before data processing.
-        """
-    )
+    mo.md(r"""
+    We saw the benefits of lazy evaluation when we learned about the Expressions API in Polars. Lazy execution is further extended as a philosophy by the Lazy API. It offers significant performance enhancements over eager (immediate) execution of queries and is one of the reasons why Polars is faster at working with large (GB scale) datasets than other libraries. The lazy API optimizes the full query pipeline instead of executing individual queries optimally, unlike eager execution. Some of the advantages of using the Lazy API over eager execution include
+
+    - automatic query optimization with the query optimizer.
+    - ability to process datasets larger than memory using streaming.
+    - ability to catch schema errors before data processing.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Setup
+    mo.md(r"""
+    ## Setup
 
-        For this notebook, we are going to work with logs from an Apache/Nginx web server - these logs contain useful information that can be utilized for performance optimization, security monitoring, etc. Such logs comprise of entries that look something like this:
+    For this notebook, we are going to work with logs from an Apache/Nginx web server - these logs contain useful information that can be utilized for performance optimization, security monitoring, etc. Such logs comprise of entries that look something like this:
 
-        ```
-        10.23.97.15 - - [05/Jul/2024:11:35:05 +0000] "GET /index.html HTTP/1.1" 200 1342 "https://www.example.com" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/528.32 (KHTML, like Gecko) Chrome/19.0.1220.985 Safari/528.32" "-"
-        ```
+    ```
+    10.23.97.15 - - [05/Jul/2024:11:35:05 +0000] "GET /index.html HTTP/1.1" 200 1342 "https://www.example.com" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/528.32 (KHTML, like Gecko) Chrome/19.0.1220.985 Safari/528.32" "-"
+    ```
 
-        Different parts of the entry mean different things: 
+    Different parts of the entry mean different things:
 
-        - `10.23.97.15` is the client IP address.
-        - `- -` represent identity and username of the client, respectively and are typically unused.
-        - `05/Jul/2024:11:35:05 +0000` indicates the timestamp for the request.
-        - `"GET /index.html HTTP/1.1"` represents the HTTP method, requested resource and the protocol version for HTTP, respectively.
-        - `200 1342` mean the response status code and size of the response in bytes, respectively
-        - `"https://www.example.com"` is the "referer", or the webpage URL that brought the client to the resource.
-        - `"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/528.32 (KHTML, like Gecko) Chrome/19.0.1220.985 Safari/528.32"` is the "User agent" or the details of the client device making the request (including browser version, operating system, etc.)
+    - `10.23.97.15` is the client IP address.
+    - `- -` represent identity and username of the client, respectively and are typically unused.
+    - `05/Jul/2024:11:35:05 +0000` indicates the timestamp for the request.
+    - `"GET /index.html HTTP/1.1"` represents the HTTP method, requested resource and the protocol version for HTTP, respectively.
+    - `200 1342` mean the response status code and size of the response in bytes, respectively
+    - `"https://www.example.com"` is the "referer", or the webpage URL that brought the client to the resource.
+    - `"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/528.32 (KHTML, like Gecko) Chrome/19.0.1220.985 Safari/528.32"` is the "User agent" or the details of the client device making the request (including browser version, operating system, etc.)
 
-        Normally, you would get your log files from a server that you have access to. In our case, we will generate fake data to simulate log records. We will simulate 7 days of server activity with 90,000 recorded lines.
+    Normally, you would get your log files from a server that you have access to. In our case, we will generate fake data to simulate log records. We will simulate 7 days of server activity with 90,000 recorded lines.
 
-        ///Note
-        1. If you are interested in the process of generating fake log entries, unhide the code cells immediately below the next one.
-        2. You can adjust the size of the dataset by resetting the `num_log_lines` variables to a size of your choice. It may be helpful if the data takes a long time to generate.
-        """
-    )
+    ///Note
+    1. If you are interested in the process of generating fake log entries, unhide the code cells immediately below the next one.
+    2. You can adjust the size of the dataset by resetting the `num_log_lines` variables to a size of your choice. It may be helpful if the data takes a long time to generate.
+    """)
     return
 
 
@@ -179,7 +168,6 @@ def _(Faker, datetime, np, num_log_lines, time):
         responses,
         rng,
         sleep,
-        timestr,
         tz,
         user_agents,
         verbs,
@@ -222,19 +210,17 @@ def _(
                                   faker=faker, rng=rng, resources=resources, 
                                   user_agents=user_agents, responses=responses, verbs=verbs)
             yield list(re.findall(pattern, log_line)[0])
-    return generator, pattern
+    return (generator,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Since we are generating data using a Python generator, we create a `pl.LazyFrame` directly, but we can start with either a file or an existing `DataFrame`. When using a file, the functions beginning with `pl.scan_` from the Polars API can be used, while in the case of an existing `pl.DataFrame`, we can simply call `.lazy()` to convert it to a `pl.LazyFrame`.
+    mo.md(r"""
+    Since we are generating data using a Python generator, we create a `pl.LazyFrame` directly, but we can start with either a file or an existing `DataFrame`. When using a file, the functions beginning with `pl.scan_` from the Polars API can be used, while in the case of an existing `pl.DataFrame`, we can simply call `.lazy()` to convert it to a `pl.LazyFrame`.
 
-        ///Note
-        Depending on your machine, the following cell may take some time to execute.
-        """
-    )
+    ///Note
+    Depending on your machine, the following cell may take some time to execute.
+    """)
     return
 
 
@@ -249,15 +235,13 @@ def _(generator, num_log_lines, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Schema
+    mo.md(r"""
+    ## Schema
 
-        A schema denotes the names and respective datatypes of columns in a DataFrame or LazyFrame. It can be specified when a DataFrame or LazyFrame is generated (as you may have noticed in the cell creating the LazyFrame above).
+    A schema denotes the names and respective datatypes of columns in a DataFrame or LazyFrame. It can be specified when a DataFrame or LazyFrame is generated (as you may have noticed in the cell creating the LazyFrame above).
 
-        You can see the schema with the .collect_schema method on a DataFrame or LazyFrame.
-        """
-    )
+    You can see the schema with the .collect_schema method on a DataFrame or LazyFrame.
+    """)
     return
 
 
@@ -269,26 +253,28 @@ def _(log_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Since our generator yields strings, Polars defaults to the `pl.String` datatype while reading in the data from the generator, unless specified. This, however, is not the most space or computation efficient form of data storage, so we would like to convert the datatypes of some of the columns in our LazyFrame.
+    mo.md(r"""
+    Since our generator yields strings, Polars defaults to the `pl.String` datatype while reading in the data from the generator, unless specified. This, however, is not the most space or computation efficient form of data storage, so we would like to convert the datatypes of some of the columns in our LazyFrame.
 
-        ///Note
-        The data type conversion can also be done by specifying it in the schema when creating the LazyFrame or DataFrame. We are skipping doing this for demonstration. For more details on specifying data types in LazyFrames, please refer to the Polars [documentation](https://docs.pola.rs/api/python/stable/reference/lazyframe/index.html).
-        """
-    )
+    ///Note
+    The data type conversion can also be done by specifying it in the schema when creating the LazyFrame or DataFrame. We are skipping doing this for demonstration. For more details on specifying data types in LazyFrames, please refer to the Polars [documentation](https://docs.pola.rs/api/python/stable/reference/lazyframe/index.html).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The Lazy API validates a query pipeline end-to-end for schema consistency and correctness. The checks make sure that if there is a mistake in your query, you can correct it before the data gets processed.""")
+    mo.md(r"""
+    The Lazy API validates a query pipeline end-to-end for schema consistency and correctness. The checks make sure that if there is a mistake in your query, you can correct it before the data gets processed.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The `log_data_erroneous` query below throws an `InvalidOperationError` because Polars finds inconsistencies between the timestamps we parsed from the logs and the timestamp format specified. It turns out that the time stamps in string format still have trailing whitespace which leads to errors during conversion to `datetime[μs]` objects.""")
+    mo.md(r"""
+    The `log_data_erroneous` query below throws an `InvalidOperationError` because Polars finds inconsistencies between the timestamps we parsed from the logs and the timestamp format specified. It turns out that the time stamps in string format still have trailing whitespace which leads to errors during conversion to `datetime[μs]` objects.
+    """)
     return
 
 
@@ -311,13 +297,11 @@ def _(log_data_erroneous):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Polars uses a **query optimizer** to make sure that a query pipeline is executed with the least computational cost (more on this later). In order to be able to do the optimization, the optimizer must know the schema for each step of the pipeline (query plan). For example, if you have a `.pivot` operation somewhere in your pipeline, you are generating new columns based on the data. This is new information unknown to the query optimizer that it cannot work with, and so the lazy API does not support `.pivot` operations. 
+    mo.md(r"""
+    Polars uses a **query optimizer** to make sure that a query pipeline is executed with the least computational cost (more on this later). In order to be able to do the optimization, the optimizer must know the schema for each step of the pipeline (query plan). For example, if you have a `.pivot` operation somewhere in your pipeline, you are generating new columns based on the data. This is new information unknown to the query optimizer that it cannot work with, and so the lazy API does not support `.pivot` operations.
 
-        For example, suppose you would like to know how many requests of each kind were received at a given time that were not "POST" requests. For this we would want to create a pivot table as follows, except that it throws an error as the lazy API does not support pivot operations.
-        """
-    )
+    For example, suppose you would like to know how many requests of each kind were received at a given time that were not "POST" requests. For this we would want to create a pivot table as follows, except that it throws an error as the lazy API does not support pivot operations.
+    """)
     return
 
 
@@ -334,13 +318,11 @@ def _(log_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        As a workaround, we can jump between "lazy mode" and "eager mode" by converting a LazyFrame to a DataFrame just before the unsupported operation (e.g. `.pivot`). We can do this by calling `.collect()` on the LazyFrame. Once done with the "eager mode" operations, we can jump back to "lazy mode" by calling ".lazy()" on the DataFrame!
+    mo.md(r"""
+    As a workaround, we can jump between "lazy mode" and "eager mode" by converting a LazyFrame to a DataFrame just before the unsupported operation (e.g. `.pivot`). We can do this by calling `.collect()` on the LazyFrame. Once done with the "eager mode" operations, we can jump back to "lazy mode" by calling ".lazy()" on the DataFrame!
 
-        As an example, see the fix to the query in the previous cell below:
-        """
-    )
+    As an example, see the fix to the query in the previous cell below:
+    """)
     return
 
 
@@ -360,21 +342,21 @@ def _(log_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Query plan""")
+    mo.md(r"""
+    ## Query plan
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Polars has a query optimizer that works on a "query plan" to create a computationally efficient query pipeline. It builds the query plan/query graph from the user-specified lazy operations.
+    mo.md(r"""
+    Polars has a query optimizer that works on a "query plan" to create a computationally efficient query pipeline. It builds the query plan/query graph from the user-specified lazy operations.
 
-        We can understand query graphs with visualization and by printing them as text.
+    We can understand query graphs with visualization and by printing them as text.
 
-        Say we want to convert the data in our log dataset from `pl.String` more space efficient data types. We also would like to view all "GET" requests that resulted in errors (client side). We build our query first, and then we visualize the query graph using `.show_graph()` and print it using `.request_code()`.
-        """
-    )
+    Say we want to convert the data in our log dataset from `pl.String` more space efficient data types. We also would like to view all "GET" requests that resulted in errors (client side). We build our query first, and then we visualize the query graph using `.show_graph()` and print it using `.request_code()`.
+    """)
     return
 
 
@@ -409,21 +391,21 @@ def _(a_query):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Execution""")
+    mo.md(r"""
+    ## Execution
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        As mentioned before, Polars builds a query graph by going lazy operation by operation and then optimizes it by running a query optimizer on the graph. This optimized graph is run by default.
+    mo.md(r"""
+    As mentioned before, Polars builds a query graph by going lazy operation by operation and then optimizes it by running a query optimizer on the graph. This optimized graph is run by default.
 
-        We can execute our query on the full dataset by calling the .collect method on the query. But since this option processes all data in one batch, it is not memory efficient, and can crash if the size of the data exceeds the amount of memory your query can support.
+    We can execute our query on the full dataset by calling the .collect method on the query. But since this option processes all data in one batch, it is not memory efficient, and can crash if the size of the data exceeds the amount of memory your query can support.
 
-        For fast iterative development running `.collect` on the entire dataset is not a good idea due to slow runtimes. If your dataset is partitioned, you can use a few of them for testing. Another option is to use `.head` to limit the number of records processed, and `.collect` as few times as possible and toward the end of your query, as shown below.
-        """
-    )
+    For fast iterative development running `.collect` on the entire dataset is not a good idea due to slow runtimes. If your dataset is partitioned, you can use a few of them for testing. Another option is to use `.head` to limit the number of records processed, and `.collect` as few times as possible and toward the end of your query, as shown below.
+    """)
     return
 
 
@@ -448,7 +430,9 @@ def _(log_data, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""For large datasets Polars supports streaming mode by collecting data in batches. Streaming mode can be used by passing the keyword `engine="streaming"` into the `collect` method.""")
+    mo.md(r"""
+    For large datasets Polars supports streaming mode by collecting data in batches. Streaming mode can be used by passing the keyword `engine="streaming"` into the `collect` method.
+    """)
     return
 
 
@@ -460,13 +444,11 @@ def _(a_query):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Optimizations
+    mo.md(r"""
+    ## Optimizations
 
-        The lazy API runs a query optimizer on every Polars query. To do this, first it builds a non-optimized plan with the set of steps in the order they were specified by the user. Then it checks for optimization opportunities within the plan and reorders operations following specific rules to create an optimized query plan. Some of them are executed up front, others are determined just in time as the materialized data comes in. For the query that we built before and saw the query graph, we can view the unoptimized and optimized versions below.
-        """
-    )
+    The lazy API runs a query optimizer on every Polars query. To do this, first it builds a non-optimized plan with the set of steps in the order they were specified by the user. Then it checks for optimization opportunities within the plan and reorders operations following specific rules to create an optimized query plan. Some of them are executed up front, others are determined just in time as the materialized data comes in. For the query that we built before and saw the query graph, we can view the unoptimized and optimized versions below.
+    """)
     return
 
 
@@ -484,25 +466,33 @@ def _(a_query):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""One difference between the optimized and the unoptimized versions above is that all of the datatype cast operations except for the conversion of the `"status"` column to `pl.Int16` are performed at the end together. Also, the `filter()` operation is "pushed down" the graph, but after the datatype cast operation for `"status"`. This is called **predicate pushdown**, and the lazy API optimizes the query graph for filters to be performed as early as possible. Since the datatype coercion makes the filter operation more efficient, the graph preserves its order to be before the filter.""")
+    mo.md(r"""
+    One difference between the optimized and the unoptimized versions above is that all of the datatype cast operations except for the conversion of the `"status"` column to `pl.Int16` are performed at the end together. Also, the `filter()` operation is "pushed down" the graph, but after the datatype cast operation for `"status"`. This is called **predicate pushdown**, and the lazy API optimizes the query graph for filters to be performed as early as possible. Since the datatype coercion makes the filter operation more efficient, the graph preserves its order to be before the filter.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Sources and Sinks""")
+    mo.md(r"""
+    ## Sources and Sinks
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""For data sources like Parquets, CSVs, etc, the lazy API provides `scan_*` (`scan_parquet`, `scan_csv`, etc.) to lazily read in the data into LazyFrames. If queries are chained to the `scan_*` method, Polars will run the usual query optimizations and delay execution until the query is collected. An added benefit of chaining queries to `scan_*` operations is that the "scanners" can skip reading columns and rows that aren't required. This is helpful when streaming large datasets as well, as rows are processed in batches before the entire file is read.""")
+    mo.md(r"""
+    For data sources like Parquets, CSVs, etc, the lazy API provides `scan_*` (`scan_parquet`, `scan_csv`, etc.) to lazily read in the data into LazyFrames. If queries are chained to the `scan_*` method, Polars will run the usual query optimizations and delay execution until the query is collected. An added benefit of chaining queries to `scan_*` operations is that the "scanners" can skip reading columns and rows that aren't required. This is helpful when streaming large datasets as well, as rows are processed in batches before the entire file is read.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""The results of a query from a lazyframe can be saved in streaming mode using `sink_*` (e.g. `sink_parquet`) functions. Sinks support saving data to disk or cloud, and are especially helpful with large datasets. The data being sunk can also be partitioned into multiple files if needed, after specifying a suitable partitioning strategy, as shown below.""")
+    mo.md(r"""
+    The results of a query from a lazyframe can be saved in streaming mode using `sink_*` (e.g. `sink_parquet`) functions. Sinks support saving data to disk or cloud, and are especially helpful with large datasets. The data being sunk can also be partitioned into multiple files if needed, after specifying a suitable partitioning strategy, as shown below.
+    """)
     return
 
 
@@ -522,7 +512,9 @@ def _(a_query, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""We can also write to multiple sinks at the same time. We just need to specify two separate lazy sinks and combine them by calling `pl.collect_all` and mentioning both sinks.""")
+    mo.md(r"""
+    We can also write to multiple sinks at the same time. We just need to specify two separate lazy sinks and combine them by calling `pl.collect_all` and mentioning both sinks.
+    """)
     return
 
 
@@ -536,13 +528,11 @@ def _(a_query, pl):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## References
+    mo.md(r"""
+    ## References
 
-        1. Polars [documentation](https://docs.pola.rs/user-guide/lazy/)
-        """
-    )
+    1. Polars [documentation](https://docs.pola.rs/user-guide/lazy/)
+    """)
     return
 
 

polars/README.md

@@ -1,3 +1,8 @@
+---
+title: Readme
+marimo-version: 0.18.4
+---
+
 # Learn Polars
 
 _🚧 This collection is a work in progress. Please help us add notebooks!_
@@ -24,4 +29,4 @@ You can also open notebooks in our online playground by appending marimo.app/ to
 * [Péter Gyarmati](https://github.com/peter-gy)
 * [Joram Mutenge](https://github.com/jorammutenge)
 * [etrotta](https://github.com/etrotta)
-* [Debajyoti Das](https://github.com/debajyotid2)
+* [Debajyoti Das](https://github.com/debajyotid2)

probability/01_sets.py

@@ -7,45 +7,47 @@
 
 import marimo
 
-__generated_with = "0.11.0"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Sets
+    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.
+    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.
+    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:
+    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)}\}$
+    - ☀️ 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.
-        """
-    )
+    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""")
+    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:""")
+    mo.md(r"""
+    In Python, sets are made with the `set` function:
+    """)
     return
 
 
@@ -65,15 +67,13 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        Below we explain common operations on sets.
+    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._
+    _**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.
-        """
-    )
+    The **union** $A \cup B$ of sets $A$ and $B$ is the set of elements in $A$, $B$, or both.
+    """)
     return
 
 
@@ -85,7 +85,9 @@ def _(A, B):
 
 @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$""")
+    mo.md(r"""
+    The **intersection** $A \cap B$ is the set of elements in both $A$ and $B$
+    """)
     return
 
 
@@ -97,7 +99,9 @@ def _(A, B):
 
 @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$.""")
+    mo.md(r"""
+    The **difference** $A \setminus B$ is the set of elements in $A$ that are not in $B$.
+    """)
     return
 
 
@@ -109,13 +113,11 @@ def _(A, B):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ### 🎬 An interactive example
+    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.
-        """
-    )
+    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
 
 
@@ -175,7 +177,7 @@ def _(mo, recommendations, viewer_type):
     **Why these shows?** 
     {explanation[viewer_type.value]}
     """)
-    return explanation, result
+    return
 
 
 @app.cell(hide_code=True)
@@ -214,58 +216,54 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🧮 Set properties
+    mo.md(r"""
+    ## 🧮 Set properties
 
-        Here are some important properties of the set operations:
+    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)$
-        """
-    )
+    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
+    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.
+    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:
+    For example, here is how to specify the set of positive numbers less than 10:
 
-        \[
-        \{x \mid 0 < x < 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.
+    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."
-        """
-    )
+    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.function
+def predicate(x):
+    return x > 0 and x < 10
 
 
 @app.cell
-def _(predicate):
+def _():
     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.""")
+    mo.md("""
+    **Try it!** Try modifying the `predicate` function above and see how the set changes.
+    """)
     return
 
 

probability/02_axioms.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.2"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -21,49 +21,43 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Axioms of Probability
+    mo.md(r"""
+    # Axioms of Probability
 
-        Probability theory is built on three fundamental axioms, known as the [Kolmogorov axioms](https://en.wikipedia.org/wiki/Probability_axioms). These axioms form 
-        the mathematical foundation for all of probability theory[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/probability).
+    Probability theory is built on three fundamental axioms, known as the [Kolmogorov axioms](https://en.wikipedia.org/wiki/Probability_axioms). These axioms form
+    the mathematical foundation for all of probability theory[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/probability).
 
-        Let's explore each axiom and understand why they make intuitive sense:
-        """
-    )
+    Let's explore each axiom and understand why they make intuitive sense:
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The Three Axioms
-
-        | Axiom | Mathematical Form | Meaning |
-        |-------|------------------|----------|
-        | **Axiom 1** | $0 \leq P(E) \leq 1$ | All probabilities are between 0 and 1 |
-        | **Axiom 2** | $P(S) = 1$ | The probability of the sample space is 1 |
-        | **Axiom 3** | $P(E \cup F) = P(E) + P(F)$ | For mutually exclusive events, probabilities add |
-
-        where the set $S$ is the sample space (all possible outcomes), and $E$ and $F$ are sets that represent events. The notation $P(E)$ denotes the probability of $E$, which you can interpret as the chance that something happens. $P(E) = 0$ means that the event cannot happen, while $P(E) = 1$ means the event will happen no matter what; $P(E) = 0.5$ means that $E$ has a 50% chance of happening.
-        
-        For an example, when rolling a fair six-sided die once, the sample space $S$ is the set of die faces ${1, 2, 3, 4, 5, 6}$, and there are many possible events; we'll see some examples below.
-        """
-    )
+    mo.md(r"""
+    ## The Three Axioms
+
+    | Axiom | Mathematical Form | Meaning |
+    |-------|------------------|----------|
+    | **Axiom 1** | $0 \leq P(E) \leq 1$ | All probabilities are between 0 and 1 |
+    | **Axiom 2** | $P(S) = 1$ | The probability of the sample space is 1 |
+    | **Axiom 3** | $P(E \cup F) = P(E) + P(F)$ | For mutually exclusive events, probabilities add |
+
+    where the set $S$ is the sample space (all possible outcomes), and $E$ and $F$ are sets that represent events. The notation $P(E)$ denotes the probability of $E$, which you can interpret as the chance that something happens. $P(E) = 0$ means that the event cannot happen, while $P(E) = 1$ means the event will happen no matter what; $P(E) = 0.5$ means that $E$ has a 50% chance of happening.
+
+    For an example, when rolling a fair six-sided die once, the sample space $S$ is the set of die faces ${1, 2, 3, 4, 5, 6}$, and there are many possible events; we'll see some examples below.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Understanding Through Examples
+    mo.md(r"""
+    ## Understanding Through Examples
 
-        Let's explore these axioms using a simple experiment: rolling a fair six-sided die.
-        We'll use this to demonstrate why each axiom makes intuitive sense.
-        """
-    )
+    Let's explore these axioms using a simple experiment: rolling a fair six-sided die.
+    We'll use this to demonstrate why each axiom makes intuitive sense.
+    """)
     return
 
 
@@ -144,62 +138,58 @@ def _(event, mo, np, plt):
     """)
 
     mo.hstack([plt.gcf(), explanation])
-    return ax, colors, dice, event_map, explanation, fig, outcomes, prob
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Why These Axioms Matter
+    mo.md(r"""
+    ## Why These Axioms Matter
 
-        These axioms are more than just rules - they provide the foundation for all of probability theory:
+    These axioms are more than just rules - they provide the foundation for all of probability theory:
 
-        1. **Non-negativity** (Axiom 1) makes intuitive sense: you can't have a negative number of occurrences 
-           in any experiment.
+    1. **Non-negativity** (Axiom 1) makes intuitive sense: you can't have a negative number of occurrences
+       in any experiment.
 
-        2. **Normalization** (Axiom 2) ensures that something must happen - the total probability must be 1.
+    2. **Normalization** (Axiom 2) ensures that something must happen - the total probability must be 1.
 
-        3. **Additivity** (Axiom 3) lets us build complex probabilities from simple ones, but only for events 
-           that can't happen together (mutually exclusive events).
+    3. **Additivity** (Axiom 3) lets us build complex probabilities from simple ones, but only for events
+       that can't happen together (mutually exclusive events).
 
-        From these simple rules, we can derive all the powerful tools of probability theory that are used in 
-        statistics, machine learning, and other fields.
-        """
-    )
+    From these simple rules, we can derive all the powerful tools of probability theory that are used in
+    statistics, machine learning, and other fields.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
 
-        Consider rolling two dice. Which of these statements follow from the axioms?
+    Consider rolling two dice. Which of these statements follow from the axioms?
 
-        <details>
-        <summary>1. P(sum is 13) = 0</summary>
+    <details>
+    <summary>1. P(sum is 13) = 0</summary>
 
-        ✅ Correct! This follows from Axiom 1. Since no combination of dice can sum to 13, 
-        the probability must be non-negative but can be 0.
-        </details>
+    ✅ Correct! This follows from Axiom 1. Since no combination of dice can sum to 13,
+    the probability must be non-negative but can be 0.
+    </details>
 
-        <details>
-        <summary>2. P(sum is 7) + P(sum is not 7) = 1</summary>
+    <details>
+    <summary>2. P(sum is 7) + P(sum is not 7) = 1</summary>
 
-        ✅ Correct! This follows from Axioms 2 and 3. These events are mutually exclusive and cover 
-        the entire sample space.
-        </details>
+    ✅ Correct! This follows from Axioms 2 and 3. These events are mutually exclusive and cover
+    the entire sample space.
+    </details>
 
-        <details>
-        <summary>3. P(first die is 6 or second die is 6) = P(first die is 6) + P(second die is 6)</summary>
+    <details>
+    <summary>3. P(first die is 6 or second die is 6) = P(first die is 6) + P(second die is 6)</summary>
 
-        ❌ Incorrect! This doesn't follow from Axiom 3 because the events are not mutually exclusive - 
-        you could roll (6,6).
-        </details>
-        """
-    )
+    ❌ Incorrect! This doesn't follow from Axiom 3 because the events are not mutually exclusive -
+    you could roll (6,6).
+    </details>
+    """)
     return
 
 

probability/03_probability_of_or.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.2"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -24,43 +24,39 @@ def _():
     import matplotlib.pyplot as plt
     from matplotlib_venn import venn2
     import numpy as np
-    return np, plt, venn2
+    return plt, venn2
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Probability of Or
+    mo.md(r"""
+    # Probability of Or
 
-        When calculating the probability of either one event _or_ another occurring, we need to be careful about how we combine probabilities. The method depends on whether the events can happen together[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/prob_or/).
+    When calculating the probability of either one event _or_ another occurring, we need to be careful about how we combine probabilities. The method depends on whether the events can happen together[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/prob_or/).
 
-        Let's explore how to calculate $P(E \cup F)$, i.e. $P(E \text{ or } F)$, in different scenarios.
-        """
-    )
+    Let's explore how to calculate $P(E \cup F)$, i.e. $P(E \text{ or } F)$, in different scenarios.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Mutually Exclusive Events
+    mo.md(r"""
+    ## Mutually Exclusive Events
 
-        Two events $E$ and $F$ are **mutually exclusive** if they cannot occur simultaneously. 
-        In set notation, this means:
+    Two events $E$ and $F$ are **mutually exclusive** if they cannot occur simultaneously.
+    In set notation, this means:
 
-        $E \cap F = \emptyset$
+    $E \cap F = \emptyset$
 
-        For example:
+    For example:
 
-        - Rolling an even number (2,4,6) vs rolling an odd number (1,3,5)
-        - Drawing a heart vs drawing a spade from a deck
-        - Passing vs failing a test
+    - Rolling an even number (2,4,6) vs rolling an odd number (1,3,5)
+    - Drawing a heart vs drawing a spade from a deck
+    - Passing vs failing a test
 
-        Here's a Python function to check if two sets of outcomes are mutually exclusive:
-        """
-    )
+    Here's a Python function to check if two sets of outcomes are mutually exclusive:
+    """)
     return
 
 
@@ -90,21 +86,19 @@ def _(are_mutually_exclusive, even_numbers, prime_numbers):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Or with Mutually Exclusive Events
+    mo.md(r"""
+    ## Or with Mutually Exclusive Events
 
-        For mutually exclusive events, the probability of either event occurring is simply the sum of their individual probabilities:
+    For mutually exclusive events, the probability of either event occurring is simply the sum of their individual probabilities:
 
-        $P(E \cup F) = P(E) + P(F)$
+    $P(E \cup F) = P(E) + P(F)$
 
-        This extends to multiple events. For $n$ mutually exclusive events $E_1, E_2, \ldots, E_n$:
+    This extends to multiple events. For $n$ mutually exclusive events $E_1, E_2, \ldots, E_n$:
 
-        $P(E_1 \cup E_2 \cup \cdots \cup E_n) = \sum_{i=1}^n P(E_i)$
+    $P(E_1 \cup E_2 \cup \cdots \cup E_n) = \sum_{i=1}^n P(E_i)$
 
-        Let's implement this calculation:
-        """
-    )
+    Let's implement this calculation:
+    """)
     return
 
 
@@ -121,34 +115,28 @@ def _():
     # P(prime) = P(2) + P(3) + P(5)
     p_prime_mutually_exclusive = prob_union_mutually_exclusive([1/6, 1/6, 1/6])
     print(f"P(rolling a prime number) = {p_prime_mutually_exclusive}")
-    return (
-        p_even_mutually_exclusive,
-        p_prime_mutually_exclusive,
-        prob_union_mutually_exclusive,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Or with Non-Mutually Exclusive Events
+    mo.md(r"""
+    ## Or with Non-Mutually Exclusive Events
 
-        When events can occur together, we need to use the **inclusion-exclusion principle**:
+    When events can occur together, we need to use the **inclusion-exclusion principle**:
 
-        $P(E \cup F) = P(E) + P(F) - P(E \cap F)$
+    $P(E \cup F) = P(E) + P(F) - P(E \cap F)$
 
-        Why subtract $P(E \cap F)$? Because when we add $P(E)$ and $P(F)$, we count the overlap twice!
+    Why subtract $P(E \cap F)$? Because when we add $P(E)$ and $P(F)$, we count the overlap twice!
 
-        For example, consider calculating $P(\text{prime or even})$ when rolling a die:
+    For example, consider calculating $P(\text{prime or even})$ when rolling a die:
 
-        - Prime numbers: {2, 3, 5}
-        - Even numbers: {2, 4, 6}
-        - The number 2 is counted twice unless we subtract its probability
+    - Prime numbers: {2, 3, 5}
+    - Even numbers: {2, 4, 6}
+    - The number 2 is counted twice unless we subtract its probability
 
-        Here's how to implement this calculation:
-        """
-    )
+    Here's how to implement this calculation:
+    """)
     return
 
 
@@ -166,40 +154,34 @@ def _():
 
     result = prob_union_general(p_prime_general, p_even_general, p_intersection)
     print(f"P(prime or even) = {p_prime_general} + {p_even_general} - {p_intersection} = {result}")
-    return (
-        p_even_general,
-        p_intersection,
-        p_prime_general,
-        prob_union_general,
-        result,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Extension to Three Events
+    mo.md(r"""
+    ### Extension to Three Events
 
-        For three events, the inclusion-exclusion principle becomes:
+    For three events, the inclusion-exclusion principle becomes:
 
-        $P(E_1 \cup E_2 \cup E_3) = P(E_1) + P(E_2) + P(E_3)$
-        $- P(E_1 \cap E_2) - P(E_1 \cap E_3) - P(E_2 \cap E_3)$
-        $+ P(E_1 \cap E_2 \cap E_3)$
+    $P(E_1 \cup E_2 \cup E_3) = P(E_1) + P(E_2) + P(E_3)$
+    $- P(E_1 \cap E_2) - P(E_1 \cap E_3) - P(E_2 \cap E_3)$
+    $+ P(E_1 \cap E_2 \cap E_3)$
 
-        The pattern is:
+    The pattern is:
 
-        1. Add individual probabilities
-        2. Subtract probabilities of pairs
-        3. Add probability of triple intersection
-        """
-    )
+    1. Add individual probabilities
+    2. Subtract probabilities of pairs
+    3. Add probability of triple intersection
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Interactive example:""")
+    mo.md(r"""
+    ### Interactive example:
+    """)
     return
 
 
@@ -298,57 +280,53 @@ def _(event_type, mo, plt, venn2):
         plt.gcf(),
         mo.md(data["explanation"])
     ])
-    return data, events_data, v
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
 
-        Consider rolling a six-sided die. Which of these statements are true?
+    Consider rolling a six-sided die. Which of these statements are true?
 
-        <details>
-        <summary>1. P(even or less than 3) = P(even) + P(less than 3)</summary>
+    <details>
+    <summary>1. P(even or less than 3) = P(even) + P(less than 3)</summary>
 
-        ❌ Incorrect! These events are not mutually exclusive (2 is both even and less than 3).
-        We need to use the inclusion-exclusion principle.
-        </details>
+    ❌ Incorrect! These events are not mutually exclusive (2 is both even and less than 3).
+    We need to use the inclusion-exclusion principle.
+    </details>
 
-        <details>
-        <summary>2. P(even or greater than 4) = 4/6</summary>
+    <details>
+    <summary>2. P(even or greater than 4) = 4/6</summary>
 
-        ✅ Correct! {2,4,6} ∪ {5,6} = {2,4,5,6}, so probability is 4/6.
-        </details>
+    ✅ Correct! {2,4,6} ∪ {5,6} = {2,4,5,6}, so probability is 4/6.
+    </details>
 
-        <details>
-        <summary>3. P(prime or odd) = 5/6</summary>
+    <details>
+    <summary>3. P(prime or odd) = 5/6</summary>
 
-        ✅ Correct! {2,3,5} ∪ {1,3,5} = {1,2,3,5}, so probability is 5/6.
-        </details>
-        """
-    )
+    ✅ Correct! {2,3,5} ∪ {1,3,5} = {1,2,3,5}, so probability is 5/6.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - How to identify mutually exclusive events
-        - The addition rule for mutually exclusive events
-        - The inclusion-exclusion principle for overlapping events
-        - How to extend these concepts to multiple events
+    - How to identify mutually exclusive events
+    - The addition rule for mutually exclusive events
+    - The inclusion-exclusion principle for overlapping events
+    - How to extend these concepts to multiple events
 
-        In the next lesson, we'll explore **conditional probability** - how the probability 
-        of one event changes when we know another event has occurred.
-        """
-    )
+    In the next lesson, we'll explore **conditional probability** - how the probability
+    of one event changes when we know another event has occurred.
+    """)
     return
 
 

probability/04_conditional_probability.py

@@ -10,7 +10,7 @@
 
 import marimo
 
-__generated_with = "0.11.4"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Conditional Probability")
 
 
@@ -22,42 +22,38 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Conditional Probability
+    mo.md(r"""
+    # Conditional Probability
 
-        _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/cond_prob/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/cond_prob/), by Stanford professor Chris Piech._
 
-        In probability theory, we often want to update our beliefs when we receive new information. 
-        Conditional probability helps us formalize this process by calculating "_what is the chance of 
-        event $E$ happening given that we have already observed some other event $F$?_"[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/cond_prob/)
+    In probability theory, we often want to update our beliefs when we receive new information.
+    Conditional probability helps us formalize this process by calculating "_what is the chance of
+    event $E$ happening given that we have already observed some other event $F$?_"[<sup>1</sup>](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/cond_prob/)
 
-        When we condition on an event $F$:
+    When we condition on an event $F$:
 
-        - We enter the universe where $F$ has occurred
-        - Only outcomes consistent with $F$ are possible
-        - Our sample space reduces to $F$
-        """
-    )
+    - We enter the universe where $F$ has occurred
+    - Only outcomes consistent with $F$ are possible
+    - Our sample space reduces to $F$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Definition of Conditional Probability
+    mo.md(r"""
+    ## Definition of Conditional Probability
 
-        The probability of event $E$ given that event $F$ has occurred is denoted as $P(E \mid F)$ and is defined as:
+    The probability of event $E$ given that event $F$ has occurred is denoted as $P(E \mid F)$ and is defined as:
 
-        $$P(E \mid F) = \frac{P(E \cap F)}{P(F)}$$
+    $$P(E \mid F) = \frac{P(E \cap F)}{P(F)}$$
 
-        This formula tells us that the conditional probability is the probability of both events occurring 
-        divided by the probability of the conditioning event.
+    This formula tells us that the conditional probability is the probability of both events occurring
+    divided by the probability of the conditioning event.
 
-        Let's start with a visual example.
-        """
-    )
+    Let's start with a visual example.
+    """)
     return
 
 
@@ -66,7 +62,7 @@ def _():
     import matplotlib.pyplot as plt
     from matplotlib_venn import venn3
     import numpy as np
-    return np, plt, venn3
+    return plt, venn3
 
 
 @app.cell(hide_code=True)
@@ -138,75 +134,73 @@ def _(mo, plt, venn3):
     """)
 
     mo.vstack([mo.center(plt.gcf()), explanation])
-    return explanation, id, rect, v
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"Next, here's a function that computes $P(E \mid F)$, given $P( E \cap F)$ and $P(F)$"
-    )
+    mo.md(r"""
+    Next, here's a function that computes $P(E \mid F)$, given $P( E \cap F)$ and $P(F)$
+    """)
     return
 
 
-@app.cell
-def _():
-    def conditional_probability(p_intersection, p_condition):
-        if p_condition == 0:
-            raise ValueError("Cannot condition on an impossible event")
-        if p_intersection > p_condition:
-            raise ValueError("P(E∩F) cannot be greater than P(F)")
+@app.function
+def conditional_probability(p_intersection, p_condition):
+    if p_condition == 0:
+        raise ValueError("Cannot condition on an impossible event")
+    if p_intersection > p_condition:
+        raise ValueError("P(E∩F) cannot be greater than P(F)")
 
-        return p_intersection / p_condition
-    return (conditional_probability,)
+    return p_intersection / p_condition
 
 
 @app.cell
-def _(conditional_probability):
+def _():
     # Example 1: Rolling a die
     # E: Rolling an even number (2,4,6)
     # F: Rolling a number greater than 3 (4,5,6)
     p_even_given_greater_than_3 = conditional_probability(2 / 6, 3 / 6)
     print("Example 1: Rolling a die")
     print(f"P(Even | >3) = {p_even_given_greater_than_3}")  # Should be 2/3
-    return (p_even_given_greater_than_3,)
+    return
 
 
 @app.cell
-def _(conditional_probability):
+def _():
     # Example 2: Cards
     # E: Drawing a Heart
     # F: Drawing a Face card (J,Q,K)
     p_heart_given_face = conditional_probability(3 / 52, 12 / 52)
     print("\nExample 2: Drawing cards")
     print(f"P(Heart | Face card) = {p_heart_given_face}")  # Should be 1/4
-    return (p_heart_given_face,)
+    return
 
 
 @app.cell
-def _(conditional_probability):
+def _():
     # Example 3: Student grades
     # E: Getting an A
     # F: Studying more than 3 hours
     p_a_given_study = conditional_probability(0.24, 0.40)
     print("\nExample 3: Student grades")
     print(f"P(A | Studied >3hrs) = {p_a_given_study}")  # Should be 0.6
-    return (p_a_given_study,)
+    return
 
 
 @app.cell
-def _(conditional_probability):
+def _():
     # Example 4: Weather
     # E: Raining
     # F: Cloudy
     p_rain_given_cloudy = conditional_probability(0.15, 0.30)
     print("\nExample 4: Weather")
     print(f"P(Rain | Cloudy) = {p_rain_given_cloudy}")  # Should be 0.5
-    return (p_rain_given_cloudy,)
+    return
 
 
 @app.cell
-def _(conditional_probability):
+def _():
     # Example 5: Error cases
     print("\nExample 5: Error cases")
     try:
@@ -225,72 +219,66 @@ def _(conditional_probability):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The Conditional Paradigm
+    mo.md(r"""
+    ## The Conditional Paradigm
 
-        When we condition on an event, we enter a new probability universe. In this universe:
+    When we condition on an event, we enter a new probability universe. In this universe:
 
-        1. All probability axioms still hold
-        2. We must consistently condition on the same event
-        3. Our sample space becomes the conditioning event
+    1. All probability axioms still hold
+    2. We must consistently condition on the same event
+    3. Our sample space becomes the conditioning event
 
-        Here's how our familiar probability rules look when conditioned on event $G$:
+    Here's how our familiar probability rules look when conditioned on event $G$:
 
-        | Rule | Original | Conditioned on $G$ |
-        |------|----------|-------------------|
-        | Axiom 1 | $0 \leq P(E) \leq 1$ | $0 \leq P(E \mid G) \leq 1$ |
-        | Axiom 2 | $P(S) = 1$ | $P(S \mid G) = 1$ |
-        | Axiom 3* | $P(E \cup F) = P(E) + P(F)$ | $P(E \cup F \mid G) = P(E \mid G) + P(F \mid G)$ |
-        | Complement | $P(E^C) = 1 - P(E)$ | $P(E^C \mid G) = 1 - P(E \mid G)$ |
+    | Rule | Original | Conditioned on $G$ |
+    |------|----------|-------------------|
+    | Axiom 1 | $0 \leq P(E) \leq 1$ | $0 \leq P(E \mid G) \leq 1$ |
+    | Axiom 2 | $P(S) = 1$ | $P(S \mid G) = 1$ |
+    | Axiom 3* | $P(E \cup F) = P(E) + P(F)$ | $P(E \cup F \mid G) = P(E \mid G) + P(F \mid G)$ |
+    | Complement | $P(E^C) = 1 - P(E)$ | $P(E^C \mid G) = 1 - P(E \mid G)$ |
 
-        *_For mutually exclusive events_
-        """
-    )
+    *_For mutually exclusive events_
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Multiple Conditions
+    mo.md(r"""
+    ## Multiple Conditions
 
-        We can condition on multiple events. The notation $P(E \mid F,G)$ means "_the probability of $E$ 
-        occurring, given that both $F$ and $G$ have occurred._"
+    We can condition on multiple events. The notation $P(E \mid F,G)$ means "_the probability of $E$
+    occurring, given that both $F$ and $G$ have occurred._"
 
-        The conditional probability formula still holds in the universe where $G$ has occurred:
+    The conditional probability formula still holds in the universe where $G$ has occurred:
 
-        $$P(E \mid F,G) = \frac{P(E \cap F \mid G)}{P(F \mid G)}$$
+    $$P(E \mid F,G) = \frac{P(E \cap F \mid G)}{P(F \mid G)}$$
 
-        This is a powerful extension that allows us to update our probabilities as we receive 
-        multiple pieces of information.
-        """
-    )
+    This is a powerful extension that allows us to update our probabilities as we receive
+    multiple pieces of information.
+    """)
     return
 
 
-@app.cell
-def _():
-    def multiple_conditional_probability(
-        p_intersection_all, p_intersection_conditions, p_condition
-    ):
-        """Calculate P(E|F,G) = P(E∩F|G)/P(F|G) = P(E∩F∩G)/P(F∩G)"""
-        if p_condition == 0:
-            raise ValueError("Cannot condition on an impossible event")
-        if p_intersection_conditions == 0:
-            raise ValueError(
-                "Cannot condition on an impossible combination of events"
-            )
-        if p_intersection_all > p_intersection_conditions:
-            raise ValueError("P(E∩F∩G) cannot be greater than P(F∩G)")
-
-        return p_intersection_all / p_intersection_conditions
-    return (multiple_conditional_probability,)
+@app.function
+def multiple_conditional_probability(
+    p_intersection_all, p_intersection_conditions, p_condition
+):
+    """Calculate P(E|F,G) = P(E∩F|G)/P(F|G) = P(E∩F∩G)/P(F∩G)"""
+    if p_condition == 0:
+        raise ValueError("Cannot condition on an impossible event")
+    if p_intersection_conditions == 0:
+        raise ValueError(
+            "Cannot condition on an impossible combination of events"
+        )
+    if p_intersection_all > p_intersection_conditions:
+        raise ValueError("P(E∩F∩G) cannot be greater than P(F∩G)")
+
+    return p_intersection_all / p_intersection_conditions
 
 
 @app.cell
-def _(multiple_conditional_probability):
+def _():
     # Example: College admissions
     # E: Getting admitted
     # F: High GPA
@@ -310,58 +298,54 @@ def _(multiple_conditional_probability):
         multiple_conditional_probability(0.3, 0.2, 0.2)
     except ValueError as e:
         print(f"\nError case: {e}")
-    return (p_admit_given_both,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
-
-        Which of these statements about conditional probability are true?
-
-        <details>
-        <summary>Knowing F occurred always decreases the probability of E</summary>
-        ❌ False! Conditioning on F can either increase or decrease P(E), depending on how E and F are related.
-        </details>
-
-        <details>
-        <summary>P(E|F) represents entering a new probability universe where F has occurred</summary>
-        ✅ True! We restrict ourselves to only the outcomes where F occurred, making F our new sample space.
-        </details>
-
-        <details>
-        <summary>If P(E|F) = P(E), then E and F must be the same event</summary>
-        ❌ False! This actually means E and F are independent - knowing one doesn't affect the other.
-        </details>
-
-        <details>
-        <summary>P(E|F) can be calculated by dividing P(E∩F) by P(F)</summary>
-        ✅ True! This is the fundamental definition of conditional probability.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
+
+    Which of these statements about conditional probability are true?
+
+    <details>
+    <summary>Knowing F occurred always decreases the probability of E</summary>
+    ❌ False! Conditioning on F can either increase or decrease P(E), depending on how E and F are related.
+    </details>
+
+    <details>
+    <summary>P(E|F) represents entering a new probability universe where F has occurred</summary>
+    ✅ True! We restrict ourselves to only the outcomes where F occurred, making F our new sample space.
+    </details>
+
+    <details>
+    <summary>If P(E|F) = P(E), then E and F must be the same event</summary>
+    ❌ False! This actually means E and F are independent - knowing one doesn't affect the other.
+    </details>
+
+    <details>
+    <summary>P(E|F) can be calculated by dividing P(E∩F) by P(F)</summary>
+    ✅ True! This is the fundamental definition of conditional probability.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - How conditional probability updates our beliefs with new information
-        - The formula $P(E \mid F) = P(E \cap F)/P(F)$ and its intuition
-        - How probability rules work in conditional universes
-        - How to handle multiple conditions
+    - How conditional probability updates our beliefs with new information
+    - The formula $P(E \mid F) = P(E \cap F)/P(F)$ and its intuition
+    - How probability rules work in conditional universes
+    - How to handle multiple conditions
 
-        In the next lesson, we'll explore **independence** - when knowing about one event 
-        tells us nothing about another.
-        """
-    )
+    In the next lesson, we'll explore **independence** - when knowing about one event
+    tells us nothing about another.
+    """)
     return
 
 

probability/05_independence.py

@@ -7,7 +7,7 @@
 
 import marimo
 
-__generated_with = "0.11.4"
+__generated_with = "0.18.4"
 app = marimo.App()
 
 
@@ -19,88 +19,84 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        # Independence in Probability Theory
+    mo.md("""
+    # Independence in Probability Theory
 
-        _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/independence/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/independence/), by Stanford professor Chris Piech._
 
-        In probability theory, independence is a fundamental concept that helps us understand 
-        when events don't influence each other. Two events are independent if knowing the 
-        outcome of one event doesn't change our belief about the other event occurring.
+    In probability theory, independence is a fundamental concept that helps us understand
+    when events don't influence each other. Two events are independent if knowing the
+    outcome of one event doesn't change our belief about the other event occurring.
 
-        ## Definition of Independence
+    ## Definition of Independence
 
-        Two events $E$ and $F$ are independent if:
+    Two events $E$ and $F$ are independent if:
 
-        $$P(E|F) = P(E)$$
+    $$P(E|F) = P(E)$$
 
-        This means that knowing $F$ occurred doesn't change the probability of $E$ occurring.
+    This means that knowing $F$ occurred doesn't change the probability of $E$ occurring.
 
-        ### _Alternative Definition_
+    ### _Alternative Definition_
 
-        Using the chain rule, we can derive another equivalent definition:
+    Using the chain rule, we can derive another equivalent definition:
 
-        $$P(E \cap F) = P(E) \cdot P(F)$$
-        """
-    )
+    $$P(E \cap F) = P(E) \cdot P(F)$$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Independence is Symmetric
+    mo.md(r"""
+    ## Independence is Symmetric
 
-        This property is symmetric: if $E$ is independent of $F$, then $F$ is independent of $E$. 
-        We can prove this using Bayes' Theorem:
+    This property is symmetric: if $E$ is independent of $F$, then $F$ is independent of $E$.
+    We can prove this using Bayes' Theorem:
 
-        \[P(E|F) = \frac{P(F|E)P(E)}{P(F)}\]
+    \[P(E|F) = \frac{P(F|E)P(E)}{P(F)}\]
 
-        \[= \frac{P(F)P(E)}{P(F)}\]
+    \[= \frac{P(F)P(E)}{P(F)}\]
 
-        \[= P(E)\]
+    \[= P(E)\]
 
-        ## Independence and Complements
+    ## Independence and Complements
 
-        Given independent events $A$ and $B$, we can prove that $A$ and $B^C$ are also independent:
+    Given independent events $A$ and $B$, we can prove that $A$ and $B^C$ are also independent:
 
 
-        \[P(AB^C) = P(A) - P(AB)\]
+    \[P(AB^C) = P(A) - P(AB)\]
 
-        \[= P(A) - P(A)P(B)\]
+    \[= P(A) - P(A)P(B)\]
 
-        \[= P(A)(1 - P(B))\]
+    \[= P(A)(1 - P(B))\]
 
-        \[= P(A)P(B^C)\]
+    \[= P(A)P(B^C)\]
 
-        ## Generalized Independence
+    ## Generalized Independence
 
-        Events $E_1, E_2, \ldots, E_n$ are independent if for every subset with $r$ elements (where $r \leq n$):
+    Events $E_1, E_2, \ldots, E_n$ are independent if for every subset with $r$ elements (where $r \leq n$):
 
-        \[P(E_1, E_2, \ldots, E_r) = \prod_{i=1}^r P(E_i)\]
+    \[P(E_1, E_2, \ldots, E_r) = \prod_{i=1}^r P(E_i)\]
 
-        For example, consider getting 5 heads on 5 coin flips. Let $H_i$ be the event that the $i$th flip is heads:
+    For example, consider getting 5 heads on 5 coin flips. Let $H_i$ be the event that the $i$th flip is heads:
 
 
-        \[P(H_1, H_2, H_3, H_4, H_5) = P(H_1)P(H_2)P(H_3)P(H_4)P(H_5)\]
+    \[P(H_1, H_2, H_3, H_4, H_5) = P(H_1)P(H_2)P(H_3)P(H_4)P(H_5)\]
 
-        \[= \prod_{i=1}^5 P(H_i)\]
+    \[= \prod_{i=1}^5 P(H_i)\]
 
-        \[= \left(\frac{1}{2}\right)^5 = 0.03125\]
+    \[= \left(\frac{1}{2}\right)^5 = 0.03125\]
 
-        ## Conditional Independence
+    ## Conditional Independence
 
-        Events $E_1, E_2, E_3$ are conditionally independent given event $F$ if:
+    Events $E_1, E_2, E_3$ are conditionally independent given event $F$ if:
 
-        \[P(E_1, E_2, E_3 | F) = P(E_1|F)P(E_2|F)P(E_3|F)\]
+    \[P(E_1, E_2, E_3 | F) = P(E_1|F)P(E_2|F)P(E_3|F)\]
 
-        This can be written more succinctly using product notation:
+    This can be written more succinctly using product notation:
 
-        \[P(E_1, E_2, E_3 | F) = \prod_{i=1}^3 P(E_i|F)\]
-        """
-    )
+    \[P(E_1, E_2, E_3 | F) = \prod_{i=1}^3 P(E_i|F)\]
+    """)
     return
 
 
@@ -121,21 +117,19 @@ def _(mo):
         callout_text,
         kind="warn"
     )
-    return (callout_text,)
+    return
 
 
-@app.cell
-def _():
-    def check_independence(p_e, p_f, p_intersection):
-        expected = p_e * p_f
-        tolerance = 1e-5  # Stricter tolerance for comparison
+@app.function
+def check_independence(p_e, p_f, p_intersection):
+    expected = p_e * p_f
+    tolerance = 1e-5  # Stricter tolerance for comparison
 
-        return abs(p_intersection - expected) < tolerance
-    return (check_independence,)
+    return abs(p_intersection - expected) < tolerance
 
 
 @app.cell
-def _(check_independence, mo):
+def _(mo):
     # Example 1: Rolling dice
     p_first_even = 0.5      # P(First die is even)
     p_second_six = 1/6      # P(Second die is 6)
@@ -157,11 +151,11 @@ def _(check_independence, mo):
     </details>
     """
     mo.md(example1)
-    return dice_independent, example1, p_both, p_first_even, p_second_six
+    return
 
 
 @app.cell
-def _(check_independence, mo):
+def _(mo):
     # Example 2: Drawing cards (dependent events)
     p_first_heart = 13/52    # P(First card is heart)
     p_second_heart = 12/51   # P(Second card is heart | First was heart)
@@ -192,18 +186,11 @@ def _(check_independence, mo):
     </details>
     """
     mo.md(example2)
-    return (
-        cards_independent,
-        example2,
-        p_both_hearts,
-        p_first_heart,
-        p_second_heart,
-        theoretical_if_independent,
-    )
+    return
 
 
 @app.cell
-def _(check_independence, mo):
+def _(mo):
     # Example 3: Computer system
     p_hardware = 0.02       # P(Hardware failure)
     p_software = 0.03       # P(Software crash)
@@ -224,60 +211,54 @@ def _(check_independence, mo):
     </details>
     """
     mo.md(example3)
-    return (
-        example3,
-        p_both_failure,
-        p_hardware,
-        p_software,
-        system_independent,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Establishing Independence
+    mo.md("""
+    ## Establishing Independence
 
-        In practice, we can establish independence through:
+    In practice, we can establish independence through:
 
-        1. **Mathematical Verification**: Show that P(E∩F) = P(E)P(F)
-        2. **Empirical Testing**: Analyze data to check if events appear independent
-        3. **Domain Knowledge**: Use understanding of the system to justify independence
+    1. **Mathematical Verification**: Show that P(E∩F) = P(E)P(F)
+    2. **Empirical Testing**: Analyze data to check if events appear independent
+    3. **Domain Knowledge**: Use understanding of the system to justify independence
 
-        > **Note**: Perfect independence is rare in real data. We often make independence assumptions 
-        when dependencies are negligible and the simplification is useful.
+    > **Note**: Perfect independence is rare in real data. We often make independence assumptions
+    when dependencies are negligible and the simplification is useful.
 
-        ## Backup Systems in Space Missions
+    ## Backup Systems in Space Missions
 
-        Consider a space mission with two backup life support systems:
+    Consider a space mission with two backup life support systems:
 
-        $$P(\text{Primary fails}) = p_1$$
+    $$P(	ext{Primary fails}) = p_1$$
 
-        $$P(\text{Secondary fails}) = p_2$$
+    $$P(	ext{Secondary fails}) = p_2$$
 
-        If the systems are truly independent (different power sources, separate locations, distinct technologies):
+    If the systems are truly independent (different power sources, separate locations, distinct technologies):
 
-        $$P(\text{Life support fails}) = p_1p_2$$
+    $$P(	ext{Life support fails}) = p_1p_2$$
 
-        For example:
+    For example:
 
-        - If $p_1 = 0.01$ and $p_2 = 0.02$ (99% and 98% reliable)
-        - Then $P(\text{Total failure}) = 0.0002$ (99.98% reliable)
+    - If $p_1 = 0.01$ and $p_2 = 0.02$ (99% and 98% reliable)
+    - Then $P(	ext{Total failure}) = 0.0002$ (99.98% reliable)
 
-        However, if both systems share vulnerabilities (same radiation exposure, temperature extremes):
+    However, if both systems share vulnerabilities (same radiation exposure, temperature extremes):
 
-        $$P(\text{Life support fails}) > p_1p_2$$
+    $$P(	ext{Life support fails}) > p_1p_2$$
 
-        This example shows why space agencies invest heavily in ensuring true independence of backup systems.
-        """
-    )
+    This example shows why space agencies invest heavily in ensuring true independence of backup systems.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Interactive Example""")
+    mo.md(r"""
+    ## Interactive Example
+    """)
     return
 
 
@@ -292,7 +273,7 @@ def _(mo):
     flip_button = mo.ui.run_button(label="Flip Coins!", kind="info")
     reset_button = mo.ui.run_button(label="Reset", kind="danger")
     stats_display = mo.md("*Click 'Flip Coins!' to start simulation*")
-    return flip_button, reset_button, stats_display
+    return flip_button, reset_button
 
 
 @app.cell(hide_code=True)
@@ -337,95 +318,80 @@ def _(flip_button, mo, np, reset_button):
 
     new_stats_display = mo.md(stats)
     new_stats_display
-    return (
-        coin1,
-        coin2,
-        new_stats_display,
-        p_both_h,
-        p_h1,
-        p_h2,
-        p_product,
-        stats,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Understanding the Simulation
+    mo.md("""
+    ## Understanding the Simulation
 
-        This simulation demonstrates independence using coin flips, where each coin's outcome is unaffected by the other.
+    This simulation demonstrates independence using coin flips, where each coin's outcome is unaffected by the other.
 
-        ### Reading the Results
+    ### Reading the Results
 
-        1. **Individual Probabilities:**
+    1. **Individual Probabilities:**
 
-               - P(H₁): 1 if heads, 0 if tails on first coin
-               - P(H₂): 1 if heads, 0 if tails on second coin
+           - P(H₁): 1 if heads, 0 if tails on first coin
+           - P(H₂): 1 if heads, 0 if tails on second coin
 
-        2. **Testing Independence:**
+    2. **Testing Independence:**
 
-               - P(Both Heads): 1 if both show heads, 0 otherwise
-               - P(H₁)P(H₂): Product of individual results
+           - P(Both Heads): 1 if both show heads, 0 otherwise
+           - P(H₁)P(H₂): Product of individual results
 
-        > **Note**: Each click performs a new independent trial. While a single flip shows binary outcomes (0 or 1), 
-        the theoretical probability is 0.5 for each coin and 0.25 for both heads.
-        """
-    )
+    > **Note**: Each click performs a new independent trial. While a single flip shows binary outcomes (0 or 1),
+    the theoretical probability is 0.5 for each coin and 0.25 for both heads.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
-
-        Which of these statements about independence are true?
-
-        <details>
-        <summary>If P(E|F) = P(E), then E and F are independent</summary>
-        ✅ True! This is one definition of independence - knowing F occurred doesn't change the probability of E.
-        </details>
-
-        <details>
-        <summary>Independent events cannot occur simultaneously</summary>
-        ❌ False! Independent events can and do occur together - their joint probability is just the product of their individual probabilities.
-        </details>
-
-        <details>
-        <summary>If P(E∩F) = P(E)P(F), then E and F are independent</summary>
-        ✅ True! This is the multiplicative definition of independence.
-        </details>
-
-        <details>
-        <summary>Independence is symmetric: if E is independent of F, then F is independent of E</summary>
-        ✅ True! The definition P(E∩F) = P(E)P(F) is symmetric in E and F.
-        </details>
-
-        <details>
-        <summary>Three events being pairwise independent means they are mutually independent</summary>
-        ❌ False! Pairwise independence doesn't guarantee mutual independence - we need to check all combinations.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
+
+    Which of these statements about independence are true?
+
+    <details>
+    <summary>If P(E|F) = P(E), then E and F are independent</summary>
+    ✅ True! This is one definition of independence - knowing F occurred doesn't change the probability of E.
+    </details>
+
+    <details>
+    <summary>Independent events cannot occur simultaneously</summary>
+    ❌ False! Independent events can and do occur together - their joint probability is just the product of their individual probabilities.
+    </details>
+
+    <details>
+    <summary>If P(E∩F) = P(E)P(F), then E and F are independent</summary>
+    ✅ True! This is the multiplicative definition of independence.
+    </details>
+
+    <details>
+    <summary>Independence is symmetric: if E is independent of F, then F is independent of E</summary>
+    ✅ True! The definition P(E∩F) = P(E)P(F) is symmetric in E and F.
+    </details>
+
+    <details>
+    <summary>Three events being pairwise independent means they are mutually independent</summary>
+    ❌ False! Pairwise independence doesn't guarantee mutual independence - we need to check all combinations.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        In this exploration of probability independence, we've discovered how to recognize when events truly don't influence each other. Through the lens of both mathematical definitions and interactive examples, we've seen how independence manifests in scenarios ranging from simple coin flips to critical system designs.
+    In this exploration of probability independence, we've discovered how to recognize when events truly don't influence each other. Through the lens of both mathematical definitions and interactive examples, we've seen how independence manifests in scenarios ranging from simple coin flips to critical system designs.
 
-        The power of independence lies in its simplicity: when events are independent, we can multiply their individual probabilities to understand their joint behavior. Yet, as our examples showed, true independence is often more nuanced than it first appears. What seems independent might harbor hidden dependencies, and what appears dependent might be independent under certain conditions.
+    The power of independence lies in its simplicity: when events are independent, we can multiply their individual probabilities to understand their joint behavior. Yet, as our examples showed, true independence is often more nuanced than it first appears. What seems independent might harbor hidden dependencies, and what appears dependent might be independent under certain conditions.
 
-        _The art lies not just in calculating probabilities, but in developing the intuition to recognize independence in real-world scenarios—a skill essential for making informed decisions in uncertain situations._
-        """
-    )
+    _The art lies not just in calculating probabilities, but in developing the intuition to recognize independence in real-world scenarios—a skill essential for making informed decisions in uncertain situations._
+    """)
     return
 
 
@@ -433,7 +399,7 @@ def _(mo):
 def _():
     import numpy as np
     import pandas as pd
-    return np, pd
+    return (np,)
 
 
 if __name__ == "__main__":

probability/06_probability_of_and.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.4"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -28,38 +28,34 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Probability of And
-        _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/prob_and/), by Stanford professor Chris Piech._
-
-        When calculating the probability of both events occurring together, we need to consider whether the events are independent or dependent.
-        Let's explore how to calculate $P(E \cap F)$, i.e. $P(E \text{ and } F)$, in different scenarios.
-        """
-    )
+    mo.md(r"""
+    # Probability of And
+    _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/prob_and/), by Stanford professor Chris Piech._
+
+    When calculating the probability of both events occurring together, we need to consider whether the events are independent or dependent.
+    Let's explore how to calculate $P(E \cap F)$, i.e. $P(E \text{ and } F)$, in different scenarios.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## And with Independent Events
+    mo.md(r"""
+    ## And with Independent Events
 
-        Two events $E$ and $F$ are **independent** if knowing one event occurred doesn't affect the probability of the other. 
-        For independent events:
+    Two events $E$ and $F$ are **independent** if knowing one event occurred doesn't affect the probability of the other.
+    For independent events:
 
-        $P(E \text{ and } F) = P(E) \cdot P(F)$
+    $P(E \text{ and } F) = P(E) \cdot P(F)$
 
-        For example:
+    For example:
 
-        - Rolling a 6 on one die and getting heads on a coin flip
-        - Drawing a heart from a deck, replacing it, and drawing another heart
-        - Getting a computer error on Monday vs. Tuesday
+    - Rolling a 6 on one die and getting heads on a coin flip
+    - Drawing a heart from a deck, replacing it, and drawing another heart
+    - Getting a computer error on Monday vs. Tuesday
 
-        Here's a Python function to calculate probability for independent events:
-        """
-    )
+    Here's a Python function to calculate probability for independent events:
+    """)
     return
 
 
@@ -73,7 +69,7 @@ def _():
     p_heads = 1/2         # P(getting heads)
     p_both = calc_independent_prob(p_six, p_heads)
     print(f"Example 1: P(rolling 6 AND getting heads) = {p_six:.3f} × {p_heads:.3f} = {p_both:.3f}")
-    return calc_independent_prob, p_both, p_heads, p_six
+    return (calc_independent_prob,)
 
 
 @app.cell
@@ -83,30 +79,28 @@ def _(calc_independent_prob):
     p_disk_fail = 0.03    # P(disk failure)
     p_both_fail = calc_independent_prob(p_cpu_fail, p_disk_fail)
     print(f"Example 2: P(both CPU and disk failing) = {p_cpu_fail:.3f} × {p_disk_fail:.3f} = {p_both_fail:.3f}")
-    return p_both_fail, p_cpu_fail, p_disk_fail
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## And with Dependent Events
+    mo.md(r"""
+    ## And with Dependent Events
 
-        For dependent events, we use the **chain rule**:
+    For dependent events, we use the **chain rule**:
 
-        $P(E \text{ and } F) = P(E) \cdot P(F|E)$
+    $P(E \text{ and } F) = P(E) \cdot P(F|E)$
 
-        where $P(F|E)$ is the probability of $F$ occurring given that $E$ has occurred.
+    where $P(F|E)$ is the probability of $F$ occurring given that $E$ has occurred.
 
-        For example:
+    For example:
 
-        - Drawing two hearts without replacement
-        - Getting two consecutive heads in poker
-        - System failures in connected components
+    - Drawing two hearts without replacement
+    - Getting two consecutive heads in poker
+    - System failures in connected components
 
-        Let's implement this calculation:
-        """
-    )
+    Let's implement this calculation:
+    """)
     return
 
 
@@ -120,7 +114,7 @@ def _():
     p_second_heart = 12/51       # P(second heart | first heart)
     p_both_hearts = calc_dependent_prob(p_first_heart, p_second_heart)
     print(f"Example 1: P(two hearts) = {p_first_heart:.3f} × {p_second_heart:.3f} = {p_both_hearts:.3f}")
-    return calc_dependent_prob, p_both_hearts, p_first_heart, p_second_heart
+    return (calc_dependent_prob,)
 
 
 @app.cell
@@ -130,32 +124,32 @@ def _(calc_dependent_prob):
     p_second_ace = 3/51         # P(second ace | first ace)
     p_both_aces = calc_dependent_prob(p_first_ace, p_second_ace)
     print(f"Example 2: P(two aces) = {p_first_ace:.3f} × {p_second_ace:.3f} = {p_both_aces:.3f}")
-    return p_both_aces, p_first_ace, p_second_ace
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Multiple Events
+    mo.md(r"""
+    ## Multiple Events
 
-        For multiple independent events:
+    For multiple independent events:
 
-        $P(E_1 \text{ and } E_2 \text{ and } \cdots \text{ and } E_n) = \prod_{i=1}^n P(E_i)$
+    $P(E_1 \text{ and } E_2 \text{ and } \cdots \text{ and } E_n) = \prod_{i=1}^n P(E_i)$
 
-        For dependent events:
+    For dependent events:
 
-        $P(E_1 \text{ and } E_2 \text{ and } \cdots \text{ and } E_n) = P(E_1) \cdot P(E_2|E_1) \cdot P(E_3|E_1,E_2) \cdots P(E_n|E_1,\ldots,E_{n-1})$
+    $P(E_1 \text{ and } E_2 \text{ and } \cdots \text{ and } E_n) = P(E_1) \cdot P(E_2|E_1) \cdot P(E_3|E_1,E_2) \cdots P(E_n|E_1,\ldots,E_{n-1})$
 
-        Let's visualize these probabilities:
-        """
-    )
+    Let's visualize these probabilities:
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""### Interactive example""")
+    mo.md(r"""
+    ### Interactive example
+    """)
     return
 
 
@@ -250,65 +244,61 @@ def _(event_type, mo, plt, venn2):
 
     # Display explanation alongside visualization
     mo.hstack([plt.gcf(), mo.md(data["explanation"])])
-    return data, events_data, v
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
 
-        Which of these statements about AND probability are true?
+    Which of these statements about AND probability are true?
 
-        <details>
-        <summary>1. The probability of getting two sixes in a row with a fair die is 1/36</summary>
+    <details>
+    <summary>1. The probability of getting two sixes in a row with a fair die is 1/36</summary>
 
-        ✅ True! Since die rolls are independent events:
-        P(two sixes) = P(first six) × P(second six) = 1/6 × 1/6 = 1/36
-        </details>
+    ✅ True! Since die rolls are independent events:
+    P(two sixes) = P(first six) × P(second six) = 1/6 × 1/6 = 1/36
+    </details>
 
-        <details>
-        <summary>2. When drawing cards without replacement, P(two kings) = 4/52 × 4/52</summary>
+    <details>
+    <summary>2. When drawing cards without replacement, P(two kings) = 4/52 × 4/52</summary>
 
-        ❌ False! This is a dependent event. The correct calculation is:
-        P(two kings) = P(first king) × P(second king | first king) = 4/52 × 3/51
-        </details>
+    ❌ False! This is a dependent event. The correct calculation is:
+    P(two kings) = P(first king) × P(second king | first king) = 4/52 × 3/51
+    </details>
 
-        <details>
-        <summary>3. If P(A) = 0.3 and P(B) = 0.4, then P(A and B) must be 0.12</summary>
+    <details>
+    <summary>3. If P(A) = 0.3 and P(B) = 0.4, then P(A and B) must be 0.12</summary>
 
-        ❌ False! P(A and B) = 0.12 only if A and B are independent events.
-        If they're dependent, we need P(B|A) to calculate P(A and B).
-        </details>
+    ❌ False! P(A and B) = 0.12 only if A and B are independent events.
+    If they're dependent, we need P(B|A) to calculate P(A and B).
+    </details>
 
-        <details>
-        <summary>4. The probability of rolling a six AND getting tails is (1/6 × 1/2)</summary>
+    <details>
+    <summary>4. The probability of rolling a six AND getting tails is (1/6 × 1/2)</summary>
 
-        ✅ True! These are independent events, so we multiply their individual probabilities:
-        P(six and tails) = P(six) × P(tails) = 1/6 × 1/2 = 1/12
-        </details>
-        """
-    )
+    ✅ True! These are independent events, so we multiply their individual probabilities:
+    P(six and tails) = P(six) × P(tails) = 1/6 × 1/2 = 1/12
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - How to identify independent vs dependent events
-        - The multiplication rule for independent events
-        - The chain rule for dependent events
-        - How to extend these concepts to multiple events
+    - How to identify independent vs dependent events
+    - The multiplication rule for independent events
+    - The chain rule for dependent events
+    - How to extend these concepts to multiple events
 
-        In the next lesson, we'll explore **law of total probability** in more detail, building on our understanding of various topics.
-        """
-    )
+    In the next lesson, we'll explore **law of total probability** in more detail, building on our understanding of various topics.
+    """)
     return
 
 

probability/07_law_of_total_probability.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.7"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium")
 
 
@@ -24,56 +24,52 @@ def _():
     import matplotlib.pyplot as plt
     from matplotlib_venn import venn2
     import numpy as np
-    return np, plt, venn2
+    return plt, venn2
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Law of Total Probability
+    mo.md(r"""
+    # Law of Total Probability
 
-        _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/law_total/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/law_total/), by Stanford professor Chris Piech._
 
-        The Law of Total Probability is a fundamental rule that helps us calculate probabilities by breaking down complex events into simpler parts. It's particularly useful when we want to compute the probability of an event that can occur through multiple distinct scenarios.
-        """
-    )
+    The Law of Total Probability is a fundamental rule that helps us calculate probabilities by breaking down complex events into simpler parts. It's particularly useful when we want to compute the probability of an event that can occur through multiple distinct scenarios.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The Core Concept
+    mo.md(r"""
+    ## The Core Concept
 
-        The Law of Total Probability emerged from a simple but powerful observation: any event E can be broken down into parts based on another event F and its complement Fᶜ.
+    The Law of Total Probability emerged from a simple but powerful observation: any event E can be broken down into parts based on another event F and its complement Fᶜ.
 
-        ### From Simple Observation to Powerful Law
+    ### From Simple Observation to Powerful Law
 
-        Consider an event E that can occur in two ways:
+    Consider an event E that can occur in two ways:
 
-        1. When F occurs (E ∩ F)
-        2. When F doesn't occur (E ∩ Fᶜ)
+    1. When F occurs (E ∩ F)
+    2. When F doesn't occur (E ∩ Fᶜ)
 
-        This leads to our first insight:
+    This leads to our first insight:
 
-        $P(E) = P(E \cap F) + P(E \cap F^c)$
+    $P(E) = P(E \cap F) + P(E \cap F^c)$
 
-        Applying the chain rule to each term:
+    Applying the chain rule to each term:
 
-        \begin{align}
-        P(E) &= P(E \cap F) + P(E \cap F^c) \\
-        &= P(E|F)P(F) + P(E|F^c)P(F^c)
-        \end{align}
+    \begin{align}
+    P(E) &= P(E \cap F) + P(E \cap F^c) \\
+    &= P(E|F)P(F) + P(E|F^c)P(F^c)
+    \end{align}
 
-        This two-part version generalizes to any number of [mutually exclusive](marimo.app/https://github.com/marimo-team/learn/blob/main/probability/03_probability_of_or.py) events that cover the sample space:
+    This two-part version generalizes to any number of [mutually exclusive](marimo.app/https://github.com/marimo-team/learn/blob/main/probability/03_probability_of_or.py) events that cover the sample space:
 
-        $P(A) = \sum_{i=1}^n P(A|B_i)P(B_i)$
+    $P(A) = \sum_{i=1}^n P(A|B_i)P(B_i)$
 
-        where {B₁, B₂, ..., Bₙ} forms a partition of the sample space.
-        """
-    )
+    where {B₁, B₂, ..., Bₙ} forms a partition of the sample space.
+    """)
     return
 
 
@@ -98,7 +94,7 @@ def _():
 
     print("Odd/Even partition:", is_valid_partition(partition1, sample_space))
     print("Number pairs partition:", is_valid_partition(partition2, sample_space))
-    return is_valid_partition, partition1, partition2, sample_space
+    return (is_valid_partition,)
 
 
 @app.cell
@@ -111,7 +107,7 @@ def _(is_valid_partition):
     print("Student Grades Examples:")
     print("Pass/Fail partition:", is_valid_partition(passing_partition, grade_space))
     print("Individual grades partition:", is_valid_partition(letter_groups, grade_space))
-    return grade_space, letter_groups, passing_partition
+    return
 
 
 @app.cell
@@ -124,7 +120,7 @@ def _(is_valid_partition):
     print("\nPlaying Cards Examples:")
     print("Color-based partition:", is_valid_partition(color_partition, card_space))  # True
     print("Invalid partition:", is_valid_partition(invalid_partition, card_space))    # False
-    return card_space, color_partition, invalid_partition
+    return
 
 
 @app.cell(hide_code=True)
@@ -151,75 +147,71 @@ def _(mo, plt, venn2):
     """)
 
     mo.hstack([plt.gca(), viz_explanation])
-    return v, viz_explanation
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Computing Total Probability
-
-        To use the Law of Total Probability:
-
-        1. Identify a partition of the sample space
-        2. Calculate $P(B_i)$ for each part
-        3. Calculate $P(A|B_i)$ for each part
-        4. Sum the products $P(A|B_i)P(B_i)$
-        """
-    )
+    mo.md(r"""
+    ## Computing Total Probability
+
+    To use the Law of Total Probability:
+
+    1. Identify a partition of the sample space
+    2. Calculate $P(B_i)$ for each part
+    3. Calculate $P(A|B_i)$ for each part
+    4. Sum the products $P(A|B_i)P(B_i)$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Let's implement this calculation:""")
+    mo.md(r"""
+    Let's implement this calculation:
+    """)
     return
 
 
-@app.cell
-def _():
-    def total_probability(conditional_probs, partition_probs):
-        """Calculate total probability using Law of Total Probability
-        conditional_probs: List of P(A|Bi)
-        partition_probs: List of P(Bi)
-        """
-        if len(conditional_probs) != len(partition_probs):
-            raise ValueError("Must have same number of conditional and partition probabilities")
+@app.function
+def total_probability(conditional_probs, partition_probs):
+    """Calculate total probability using Law of Total Probability
+    conditional_probs: List of P(A|Bi)
+    partition_probs: List of P(Bi)
+    """
+    if len(conditional_probs) != len(partition_probs):
+        raise ValueError("Must have same number of conditional and partition probabilities")
 
-        if abs(sum(partition_probs) - 1) > 1e-10:
-            raise ValueError("Partition probabilities must sum to 1")
+    if abs(sum(partition_probs) - 1) > 1e-10:
+        raise ValueError("Partition probabilities must sum to 1")
 
-        return sum(c * p for c, p in zip(conditional_probs, partition_probs))
-    return (total_probability,)
+    return sum(c * p for c, p in zip(conditional_probs, partition_probs))
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Example: System Reliability
+    mo.md(r"""
+    ## Example: System Reliability
 
-        Consider a computer system that can be in three states:
+    Consider a computer system that can be in three states:
 
-        - Normal (70% of time)
-        - Degraded (20% of time)
-        - Critical (10% of time)
+    - Normal (70% of time)
+    - Degraded (20% of time)
+    - Critical (10% of time)
 
-        The probability of errors in each state:
+    The probability of errors in each state:
 
-        - P(Error | Normal) = 0.01 (1%)
-        - P(Error | Degraded) = 0.15 (15%)
-        - P(Error | Critical) = 0.45 (45%)
+    - P(Error | Normal) = 0.01 (1%)
+    - P(Error | Degraded) = 0.15 (15%)
+    - P(Error | Critical) = 0.45 (45%)
 
-        Let's calculate the overall probability of encountering an error:
-        """
-    )
+    Let's calculate the overall probability of encountering an error:
+    """)
     return
 
 
 @app.cell
-def _(mo, total_probability):
+def _(mo):
     # System states and probabilities
     states = ["Normal", "Degraded", "Critical"]
     state_probs = [0.7, 0.2, 0.1]  # System spends 70%, 20%, 10% of time in each state
@@ -252,12 +244,14 @@ def _(mo, total_probability):
     Total: {total_error:.3f} or {total_error:.1%} chance of error
     """)
     explanation
-    return error_probs, explanation, state_probs, states, total_error
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Interactive Example:""")
+    mo.md(r"""
+    ## Interactive Example:
+    """)
     return
 
 
@@ -311,24 +305,22 @@ def _(late_given_dry, late_given_rain, mo, plt, venn2, weather_prob):
     plt.title("Weather and Traffic Probability")
 
     mo.hstack([plt.gca(), explanation_example])
-    return explanation_example, p_dry, p_late, p_rain
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Visual Intuition
+    mo.md(r"""
+    ## Visual Intuition
 
-        The Law of Total Probability works because:
+    The Law of Total Probability works because:
 
-        1. The partition divides the sample space into non-overlapping regions
-        2. Every outcome belongs to exactly one region
-        3. We account for all possible ways an event can occur
+    1. The partition divides the sample space into non-overlapping regions
+    2. Every outcome belongs to exactly one region
+    3. We account for all possible ways an event can occur
 
-        Let's visualize this with a tree diagram:
-        """
-    )
+    Let's visualize this with a tree diagram:
+    """)
     return
 
 
@@ -371,49 +363,45 @@ def _(plt):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
-
-        For a fair six-sided die with partitions:
-        - B₁: Numbers less than 3 {1,2}
-        - B₂: Numbers from 3 to 4 {3,4}
-        - B₃: Numbers greater than 4 {5,6}
-
-        **Question 1**: Which of these statements correctly describes the partition?
-        <details>
-        <summary>The sets overlap at number 3</summary>
-        ❌ Incorrect! The sets are clearly separated with no overlapping numbers.
-        </details>
-        <details>
-        <summary>Some numbers are missing from the partition</summary>
-        ❌ Incorrect! All numbers from 1 to 6 are included exactly once.
-        </details>
-        <details>
-        <summary>The sets form a valid partition of {1,2,3,4,5,6}</summary>
-        ✅ Correct! The sets are mutually exclusive and their union covers all outcomes.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
+
+    For a fair six-sided die with partitions:
+    - B₁: Numbers less than 3 {1,2}
+    - B₂: Numbers from 3 to 4 {3,4}
+    - B₃: Numbers greater than 4 {5,6}
+
+    **Question 1**: Which of these statements correctly describes the partition?
+    <details>
+    <summary>The sets overlap at number 3</summary>
+    ❌ Incorrect! The sets are clearly separated with no overlapping numbers.
+    </details>
+    <details>
+    <summary>Some numbers are missing from the partition</summary>
+    ❌ Incorrect! All numbers from 1 to 6 are included exactly once.
+    </details>
+    <details>
+    <summary>The sets form a valid partition of {1,2,3,4,5,6}</summary>
+    ✅ Correct! The sets are mutually exclusive and their union covers all outcomes.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - How to identify valid partitions of a sample space
-        - The Law of Total Probability formula and its components
-        - How to break down complex probability calculations
-        - Applications to real-world scenarios
+    - How to identify valid partitions of a sample space
+    - The Law of Total Probability formula and its components
+    - How to break down complex probability calculations
+    - Applications to real-world scenarios
 
-        In the next lesson, we'll explore **Bayes' Theorem**, which builds on these concepts to solve even more sophisticated probability problems.
-        """
-    )
+    In the next lesson, we'll explore **Bayes' Theorem**, which builds on these concepts to solve even more sophisticated probability problems.
+    """)
     return
 
 

probability/08_bayes_theorem.py

@@ -9,7 +9,7 @@
 
 import marimo
 
-__generated_with = "0.11.8"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Bayes Theorem")
 
 
@@ -23,140 +23,128 @@ def _():
 def _():
     import matplotlib.pyplot as plt
     import numpy as np
-    return np, plt
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Bayes' Theorem
+    mo.md(r"""
+    # Bayes' Theorem
 
-        _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/bayes_theorem/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to the book ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part1/bayes_theorem/), by Stanford professor Chris Piech._
 
-        In the 1740s, an English minister named Thomas Bayes discovered a profound mathematical relationship that would revolutionize how we reason about uncertainty. His theorem provides an elegant framework for calculating the probability of a hypothesis being true given observed evidence.
+    In the 1740s, an English minister named Thomas Bayes discovered a profound mathematical relationship that would revolutionize how we reason about uncertainty. His theorem provides an elegant framework for calculating the probability of a hypothesis being true given observed evidence.
 
-        At its core, Bayes' Theorem connects two different types of probabilities: the probability of a hypothesis given evidence $P(H|E)$, and its reverse - the probability of evidence given a hypothesis $P(E|H)$. This relationship is particularly powerful because it allows us to compute difficult probabilities using ones that are easier to measure.
-        """
-    )
+    At its core, Bayes' Theorem connects two different types of probabilities: the probability of a hypothesis given evidence $P(H|E)$, and its reverse - the probability of evidence given a hypothesis $P(E|H)$. This relationship is particularly powerful because it allows us to compute difficult probabilities using ones that are easier to measure.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The Heart of Bayesian Reasoning
+    mo.md(r"""
+    ## The Heart of Bayesian Reasoning
 
-        The fundamental insight of Bayes' Theorem lies in its ability to relate what we want to know with what we can measure. When we observe evidence $E$, we often want to know the probability of a hypothesis $H$ being true. However, it's typically much easier to measure how likely we are to observe the evidence when we know the hypothesis is true.
+    The fundamental insight of Bayes' Theorem lies in its ability to relate what we want to know with what we can measure. When we observe evidence $E$, we often want to know the probability of a hypothesis $H$ being true. However, it's typically much easier to measure how likely we are to observe the evidence when we know the hypothesis is true.
 
-        This reversal of perspective - from $P(H|E)$ to $P(E|H)$ - is powerful because it lets us:
-        1. Start with what we know (prior beliefs)
-        2. Use easily measurable relationships (likelihood)
-        3. Update our beliefs with new evidence
+    This reversal of perspective - from $P(H|E)$ to $P(E|H)$ - is powerful because it lets us:
+    1. Start with what we know (prior beliefs)
+    2. Use easily measurable relationships (likelihood)
+    3. Update our beliefs with new evidence
 
-        This approach mirrors both how humans naturally learn and the scientific method: we begin with prior beliefs, gather evidence, and update our understanding based on that evidence. This makes Bayes' Theorem not just a mathematical tool, but a framework for rational thinking.
-        """
-    )
+    This approach mirrors both how humans naturally learn and the scientific method: we begin with prior beliefs, gather evidence, and update our understanding based on that evidence. This makes Bayes' Theorem not just a mathematical tool, but a framework for rational thinking.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## The Formula
+    mo.md(r"""
+    ## The Formula
 
-        Bayes' Theorem states:
+    Bayes' Theorem states:
 
-        $P(H|E) = \frac{P(E|H)P(H)}{P(E)}$
+    $P(H|E) = \frac{P(E|H)P(H)}{P(E)}$
 
-        Where:
+    Where:
 
-        - $P(H|E)$ is the **posterior probability** - probability of hypothesis H given evidence E
-        - $P(E|H)$ is the **likelihood** - probability of evidence E given hypothesis H
-        - $P(H)$ is the **prior probability** - initial probability of hypothesis H
-        - $P(E)$ is the **evidence** - total probability of observing evidence E
+    - $P(H|E)$ is the **posterior probability** - probability of hypothesis H given evidence E
+    - $P(E|H)$ is the **likelihood** - probability of evidence E given hypothesis H
+    - $P(H)$ is the **prior probability** - initial probability of hypothesis H
+    - $P(E)$ is the **evidence** - total probability of observing evidence E
 
-        The denominator $P(E)$ can be expanded using the [Law of Total Probability](https://marimo.app/gh/marimo-team/learn/main?entrypoint=probability%2F07_law_of_total_probability.py):
+    The denominator $P(E)$ can be expanded using the [Law of Total Probability](https://marimo.app/gh/marimo-team/learn/main?entrypoint=probability%2F07_law_of_total_probability.py):
 
-        $P(E) = P(E|H)P(H) + P(E|H^c)P(H^c)$
-        """
-    )
+    $P(E) = P(E|H)P(H) + P(E|H^c)P(H^c)$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Understanding Each Component
-
-        ### 1. Prior Probability - $P(H)$
-        - Initial belief about hypothesis before seeing evidence
-        - Based on previous knowledge or assumptions
-        - Example: Probability of having a disease before any tests
-
-        ### 2. Likelihood - $P(E|H)$
-        - Probability of evidence given hypothesis is true
-        - Often known from data or scientific studies
-        - Example: Probability of positive test given disease present
-
-        ### 3. Evidence - $P(E)$
-        - Total probability of observing the evidence
-        - Acts as a normalizing constant
-        - Can be calculated using Law of Total Probability
-
-        ### 4. Posterior - $P(H|E)$
-        - Updated probability after considering evidence
-        - Combines prior knowledge with new evidence
-        - Becomes new prior for future updates
-        """
-    )
+    mo.md(r"""
+    ## Understanding Each Component
+
+    ### 1. Prior Probability - $P(H)$
+    - Initial belief about hypothesis before seeing evidence
+    - Based on previous knowledge or assumptions
+    - Example: Probability of having a disease before any tests
+
+    ### 2. Likelihood - $P(E|H)$
+    - Probability of evidence given hypothesis is true
+    - Often known from data or scientific studies
+    - Example: Probability of positive test given disease present
+
+    ### 3. Evidence - $P(E)$
+    - Total probability of observing the evidence
+    - Acts as a normalizing constant
+    - Can be calculated using Law of Total Probability
+
+    ### 4. Posterior - $P(H|E)$
+    - Updated probability after considering evidence
+    - Combines prior knowledge with new evidence
+    - Becomes new prior for future updates
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Real-World Examples
+    mo.md(r"""
+    ## Real-World Examples
 
-        ### 1. Medical Testing
-        - **Want to know**: $P(\text{Disease}|\text{Positive})$ - Probability of disease given positive test
-        - **Easy to know**: $P(\text{Positive}|\text{Disease})$ - Test accuracy for sick people
-        - **Causality**: Disease causes test results, not vice versa
+    ### 1. Medical Testing
+    - **Want to know**: $P(\text{Disease}|\text{Positive})$ - Probability of disease given positive test
+    - **Easy to know**: $P(\text{Positive}|\text{Disease})$ - Test accuracy for sick people
+    - **Causality**: Disease causes test results, not vice versa
 
-        ### 2. Student Ability
-        - **Want to know**: $P(\text{High Ability}|\text{Good Grade})$ - Probability student is skilled given good grade
-        - **Easy to know**: $P(\text{Good Grade}|\text{High Ability})$ - Probability good students get good grades
-        - **Causality**: Ability influences grades, not vice versa
+    ### 2. Student Ability
+    - **Want to know**: $P(\text{High Ability}|\text{Good Grade})$ - Probability student is skilled given good grade
+    - **Easy to know**: $P(\text{Good Grade}|\text{High Ability})$ - Probability good students get good grades
+    - **Causality**: Ability influences grades, not vice versa
 
-        ### 3. Cell Phone Location
-        - **Want to know**: $P(\text{Location}|\text{Signal Strength})$ - Probability of phone location given signal
-        - **Easy to know**: $P(\text{Signal Strength}|\text{Location})$ - Signal strength at known locations
-        - **Causality**: Location determines signal strength, not vice versa
+    ### 3. Cell Phone Location
+    - **Want to know**: $P(\text{Location}|\text{Signal Strength})$ - Probability of phone location given signal
+    - **Easy to know**: $P(\text{Signal Strength}|\text{Location})$ - Signal strength at known locations
+    - **Causality**: Location determines signal strength, not vice versa
 
-        These examples highlight a common pattern: what we want to know (posterior) is harder to measure directly than its reverse (likelihood).
-        """
-    )
+    These examples highlight a common pattern: what we want to know (posterior) is harder to measure directly than its reverse (likelihood).
+    """)
     return
 
 
-@app.cell
-def _():
-    def calculate_posterior(prior, likelihood, false_positive_rate):
-        # Calculate P(E) using Law of Total Probability
-        p_e = likelihood * prior + false_positive_rate * (1 - prior)
+@app.function
+def calculate_posterior(prior, likelihood, false_positive_rate):
+    # Calculate P(E) using Law of Total Probability
+    p_e = likelihood * prior + false_positive_rate * (1 - prior)
 
-        # Calculate posterior using Bayes' Theorem
-        posterior = (likelihood * prior) / p_e
-        return posterior, p_e
-    return (calculate_posterior,)
+    # Calculate posterior using Bayes' Theorem
+    posterior = (likelihood * prior) / p_e
+    return posterior, p_e
 
 
 @app.cell
-def _(calculate_posterior):
+def _():
     # Medical test example
     p_disease = 0.01  # Prior: 1% have the disease
     p_positive_given_disease = 0.95  # Likelihood: 95% test accuracy
@@ -167,13 +155,7 @@ def _(calculate_posterior):
         p_positive_given_disease,
         p_positive_given_healthy
     )
-    return (
-        medical_evidence,
-        medical_posterior,
-        p_disease,
-        p_positive_given_disease,
-        p_positive_given_healthy,
-    )
+    return (medical_posterior,)
 
 
 @app.cell
@@ -203,7 +185,7 @@ def _(medical_posterior, mo):
 
 
 @app.cell
-def _(calculate_posterior):
+def _():
     # Student ability example
     p_high_ability = 0.30  # Prior: 30% of students have high ability
     p_good_grade_given_high = 0.90  # Likelihood: 90% of high ability students get good grades
@@ -214,13 +196,7 @@ def _(calculate_posterior):
         p_good_grade_given_high,
         p_good_grade_given_low
     )
-    return (
-        p_good_grade_given_high,
-        p_good_grade_given_low,
-        p_high_ability,
-        student_evidence,
-        student_posterior,
-    )
+    return (student_posterior,)
 
 
 @app.cell
@@ -250,7 +226,7 @@ def _(mo, student_posterior):
 
 
 @app.cell
-def _(calculate_posterior):
+def _():
     # Cell phone location example
     p_location_a = 0.25  # Prior probability of being in location A
     p_strong_signal_at_a = 0.85  # Likelihood of strong signal at A
@@ -261,13 +237,7 @@ def _(calculate_posterior):
         p_strong_signal_at_a,
         p_strong_signal_elsewhere
     )
-    return (
-        location_evidence,
-        location_posterior,
-        p_location_a,
-        p_strong_signal_at_a,
-        p_strong_signal_elsewhere,
-    )
+    return (location_posterior,)
 
 
 @app.cell
@@ -298,7 +268,9 @@ def _(location_posterior, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Interactive example""")
+    mo.md(r"""
+    ## Interactive example
+    """)
     return
 
 
@@ -394,87 +366,79 @@ def _(
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Applications in Computer Science
+    mo.md(r"""
+    ## Applications in Computer Science
 
-        Bayes' Theorem is fundamental in many computing applications:
+    Bayes' Theorem is fundamental in many computing applications:
 
-        1. **Spam Filtering**
+    1. **Spam Filtering**
 
-            - $P(\text{Spam}|\text{Words})$ = Probability email is spam given its words
-            - Updates as new emails are classified
+        - $P(\text{Spam}|\text{Words})$ = Probability email is spam given its words
+        - Updates as new emails are classified
 
-        2. **Machine Learning**
+    2. **Machine Learning**
 
-            - Naive Bayes classifiers
-            - Probabilistic graphical models
-            - Bayesian neural networks
+        - Naive Bayes classifiers
+        - Probabilistic graphical models
+        - Bayesian neural networks
 
-        3. **Computer Vision**
+    3. **Computer Vision**
 
-            - Object detection confidence
-            - Face recognition systems
-            - Image classification
-        """
-    )
+        - Object detection confidence
+        - Face recognition systems
+        - Image classification
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## 🤔 Test Your Understanding
+    mo.md("""
+    ## 🤔 Test Your Understanding
 
-        Pick which of these statements about Bayes' Theorem you think are correct:
+    Pick which of these statements about Bayes' Theorem you think are correct:
 
-        <details>
-        <summary>The posterior probability will always be larger than the prior probability</summary>
-        ❌ Incorrect! Evidence can either increase or decrease our belief in the hypothesis. For example, a negative medical test decreases the probability of having a disease.
-        </details>
+    <details>
+    <summary>The posterior probability will always be larger than the prior probability</summary>
+    ❌ Incorrect! Evidence can either increase or decrease our belief in the hypothesis. For example, a negative medical test decreases the probability of having a disease.
+    </details>
 
-        <details>
-        <summary>If the likelihood is 0.9 and the prior is 0.5, then the posterior must equal 0.9</summary>
-        ❌ Incorrect! We also need the false positive rate to calculate the posterior probability. The likelihood alone doesn't determine the posterior.
-        </details>
+    <details>
+    <summary>If the likelihood is 0.9 and the prior is 0.5, then the posterior must equal 0.9</summary>
+    ❌ Incorrect! We also need the false positive rate to calculate the posterior probability. The likelihood alone doesn't determine the posterior.
+    </details>
 
-        <details>
-        <summary>The denominator acts as a normalizing constant to ensure the posterior is a valid probability</summary>
-        ✅ Correct! The denominator ensures the posterior probability is between 0 and 1 by considering all ways the evidence could occur.
-        </details>
-        """
-    )
+    <details>
+    <summary>The denominator acts as a normalizing constant to ensure the posterior is a valid probability</summary>
+    ✅ Correct! The denominator ensures the posterior probability is between 0 and 1 by considering all ways the evidence could occur.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - The components and intuition behind Bayes' Theorem
-        - How to update probabilities when new evidence arrives
-        - Why posterior probabilities can be counterintuitive
-        - Real-world applications in computer science
+    - The components and intuition behind Bayes' Theorem
+    - How to update probabilities when new evidence arrives
+    - Why posterior probabilities can be counterintuitive
+    - Real-world applications in computer science
 
-        In the next lesson, we'll explore Random Variables, which help us work with numerical outcomes in probability.
-        """
-    )
+    In the next lesson, we'll explore Random Variables, which help us work with numerical outcomes in probability.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Appendix
-        Below (hidden) cell blocks are responsible for the interactive example above
-        """
-    )
+    mo.md(r"""
+    ### Appendix
+    Below (hidden) cell blocks are responsible for the interactive example above
+    """)
     return
 
 

probability/09_random_variables.py

@@ -10,7 +10,7 @@
 
 import marimo
 
-__generated_with = "0.11.10"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Random Variables")
 
 
@@ -30,90 +30,82 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Random Variables
+    mo.md(r"""
+    # Random Variables
 
-        _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/rvs/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/rvs/), by Stanford professor Chris Piech._
 
-        Random variables are functions that map outcomes from a probability space to numbers. This mathematical abstraction allows us to:
+    Random variables are functions that map outcomes from a probability space to numbers. This mathematical abstraction allows us to:
 
-        - Work with numerical outcomes in probability
-        - Calculate expected values and variances
-        - Model real-world phenomena quantitatively
-        """
-    )
+    - Work with numerical outcomes in probability
+    - Calculate expected values and variances
+    - Model real-world phenomena quantitatively
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Types of Random Variables
-
-        ### Discrete Random Variables
-        - Take on countable values (finite or infinite)
-        - Described by a probability mass function (PMF)
-        - Example: Number of heads in 3 coin flips
-
-        ### Continuous Random Variables
-        - Take on uncountable values in an interval
-        - Described by a probability density function (PDF)
-        - Example: Height of a randomly selected person
-        """
-    )
+    mo.md(r"""
+    ## Types of Random Variables
+
+    ### Discrete Random Variables
+    - Take on countable values (finite or infinite)
+    - Described by a probability mass function (PMF)
+    - Example: Number of heads in 3 coin flips
+
+    ### Continuous Random Variables
+    - Take on uncountable values in an interval
+    - Described by a probability density function (PDF)
+    - Example: Height of a randomly selected person
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Properties of Random Variables
-
-        Each random variable has several key properties:
-
-        | Property | Description | Example |
-        |----------|-------------|---------|
-        | Meaning | Semantic description | Number of successes in n trials |
-        | Symbol | Notation used | $X$, $Y$, $Z$ |
-        | Support/Range | Possible values | $\{0,1,2,...,n\}$ for binomial |
-        | Distribution | PMF or PDF | $p_X(x)$ or $f_X(x)$ |
-        | Expectation | Weighted average | $E[X]$ |
-        | Variance | Measure of spread | $\text{Var}(X)$ |
-        | Standard Deviation | Square root of variance | $\sigma_X$ |
-        | Mode | Most likely value | argmax$_x$ $p_X(x)$ |
-
-        Additional properties include:
-
-        - [Entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)) (measure of uncertainty)
-        - [Median](https://en.wikipedia.org/wiki/Median) (middle value)
-        - [Skewness](https://en.wikipedia.org/wiki/Skewness) (asymmetry measure)
-        - [Kurtosis](https://en.wikipedia.org/wiki/Kurtosis) (tail heaviness measure)
-        """
-    )
+    mo.md(r"""
+    ## Properties of Random Variables
+
+    Each random variable has several key properties:
+
+    | Property | Description | Example |
+    |----------|-------------|---------|
+    | Meaning | Semantic description | Number of successes in n trials |
+    | Symbol | Notation used | $X$, $Y$, $Z$ |
+    | Support/Range | Possible values | $\{0,1,2,...,n\}$ for binomial |
+    | Distribution | PMF or PDF | $p_X(x)$ or $f_X(x)$ |
+    | Expectation | Weighted average | $E[X]$ |
+    | Variance | Measure of spread | $\text{Var}(X)$ |
+    | Standard Deviation | Square root of variance | $\sigma_X$ |
+    | Mode | Most likely value | argmax$_x$ $p_X(x)$ |
+
+    Additional properties include:
+
+    - [Entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)) (measure of uncertainty)
+    - [Median](https://en.wikipedia.org/wiki/Median) (middle value)
+    - [Skewness](https://en.wikipedia.org/wiki/Skewness) (asymmetry measure)
+    - [Kurtosis](https://en.wikipedia.org/wiki/Kurtosis) (tail heaviness measure)
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Probability Mass Functions (PMF)
+    mo.md(r"""
+    ## Probability Mass Functions (PMF)
 
-        For discrete random variables, the PMF $p_X(x)$ gives the probability that $X$ equals $x$:
+    For discrete random variables, the PMF $p_X(x)$ gives the probability that $X$ equals $x$:
 
-        $p_X(x) = P(X = x)$
+    $p_X(x) = P(X = x)$
 
-        Properties of a PMF:
+    Properties of a PMF:
 
-        1. $p_X(x) \geq 0$ for all $x$
-        2. $\sum_x p_X(x) = 1$
+    1. $p_X(x) \geq 0$ for all $x$
+    2. $\sum_x p_X(x) = 1$
 
-        Let's implement a PMF for rolling a fair die:
-        """
-    )
+    Let's implement a PMF for rolling a fair die:
+    """)
     return
 
 
@@ -135,27 +127,25 @@ def _(np, plt):
     plt.ylabel("Probability")
     plt.grid(True, alpha=0.3)
     plt.gca()
-    return die_pmf, probabilities
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Probability Density Functions (PDF)
+    mo.md(r"""
+    ## Probability Density Functions (PDF)
 
-        For continuous random variables, we use a PDF $f_X(x)$. The probability of $X$ falling in an interval $[a,b]$ is:
+    For continuous random variables, we use a PDF $f_X(x)$. The probability of $X$ falling in an interval $[a,b]$ is:
 
-        $P(a \leq X \leq b) = \int_a^b f_X(x)dx$
+    $P(a \leq X \leq b) = \int_a^b f_X(x)dx$
 
-        Properties of a PDF:
+    Properties of a PDF:
 
-        1. $f_X(x) \geq 0$ for all $x$
-        2. $\int_{-\infty}^{\infty} f_X(x)dx = 1$
+    1. $f_X(x) \geq 0$ for all $x$
+    2. $\int_{-\infty}^{\infty} f_X(x)dx = 1$
 
-        Let's look at the normal distribution, a common continuous random variable:
-        """
-    )
+    Let's look at the normal distribution, a common continuous random variable:
+    """)
     return
 
 
@@ -178,24 +168,22 @@ def _(np, plt, stats):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expected Value
+    mo.md(r"""
+    ## Expected Value
 
-        The expected value $E[X]$ is the long-run average of a random variable.
+    The expected value $E[X]$ is the long-run average of a random variable.
 
-        For discrete random variables:
-        $E[X] = \sum_x x \cdot p_X(x)$
+    For discrete random variables:
+    $E[X] = \sum_x x \cdot p_X(x)$
 
-        For continuous random variables:
-        $E[X] = \int_{-\infty}^{\infty} x \cdot f_X(x)dx$
+    For continuous random variables:
+    $E[X] = \int_{-\infty}^{\infty} x \cdot f_X(x)dx$
 
-        Properties:
+    Properties:
 
-        1. $E[aX + b] = aE[X] + b$
-        2. $E[X + Y] = E[X] + E[Y]$
-        """
-    )
+    1. $E[aX + b] = aE[X] + b$
+    2. $E[X + Y] = E[X] + E[Y]$
+    """)
     return
 
 
@@ -209,7 +197,7 @@ def _(np):
     die_probs = np.ones(6) / 6
 
     E_X = expected_value_discrete(die_values, die_probs)
-    return E_X, die_probs, die_values, expected_value_discrete
+    return E_X, die_probs, die_values
 
 
 @app.cell
@@ -220,23 +208,21 @@ def _(E_X):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Variance
+    mo.md(r"""
+    ## Variance
 
-        The variance $\text{Var}(X)$ measures the spread of a random variable around its mean:
+    The variance $\text{Var}(X)$ measures the spread of a random variable around its mean:
 
-        $\text{Var}(X) = E[(X - E[X])^2]$
+    $\text{Var}(X) = E[(X - E[X])^2]$
 
-        This can be computed as:
-        $\text{Var}(X) = E[X^2] - (E[X])^2$
+    This can be computed as:
+    $\text{Var}(X) = E[X^2] - (E[X])^2$
 
-        Properties:
+    Properties:
 
-        1. $\text{Var}(aX) = a^2Var(X)$
-        2. $\text{Var}(X + b) = Var(X)$
-        """
-    )
+    1. $\text{Var}(aX) = a^2Var(X)$
+    2. $\text{Var}(X + b) = Var(X)$
+    """)
     return
 
 
@@ -278,7 +264,7 @@ def _(variance_discrete):
     coin_probs = [0.5, 0.5]
     coin_mean = sum(x * p for x, p in zip(coin_values, coin_probs))
     coin_var = variance_discrete(coin_values, coin_probs, coin_mean)
-    return coin_mean, coin_probs, coin_values, coin_var
+    return (coin_var,)
 
 
 @app.cell
@@ -289,7 +275,7 @@ def _(np, stats, variance_discrete):
     normal_probs = normal_probs / sum(normal_probs)  # normalize
     normal_mean = 0
     normal_var = variance_discrete(normal_values, normal_probs, normal_mean)
-    return normal_mean, normal_probs, normal_values, normal_var
+    return (normal_var,)
 
 
 @app.cell
@@ -299,7 +285,7 @@ def _(np, variance_discrete):
     uniform_probs = np.ones_like(uniform_values) / len(uniform_values)
     uniform_mean = 0.5
     uniform_var = variance_discrete(uniform_values, uniform_probs, uniform_mean)
-    return uniform_mean, uniform_probs, uniform_values, uniform_var
+    return (uniform_var,)
 
 
 @app.cell(hide_code=True)
@@ -318,44 +304,40 @@ def _(coin_var, mo, normal_var, uniform_var):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Common Distributions
+    mo.md(r"""
+    ## Common Distributions
 
-        1. Bernoulli Distribution
-            - Models a single success/failure experiment
-            - $P(X = 1) = p$, $P(X = 0) = 1-p$
-            - $E[X] = p$, $\text{Var}(X) = p(1-p)$
+    1. Bernoulli Distribution
+        - Models a single success/failure experiment
+        - $P(X = 1) = p$, $P(X = 0) = 1-p$
+        - $E[X] = p$, $\text{Var}(X) = p(1-p)$
 
-        2. Binomial Distribution
+    2. Binomial Distribution
 
-            - Models number of successes in $n$ independent trials
-            - $P(X = k) = \binom{n}{k}p^k(1-p)^{n-k}$
-            - $E[X] = np$, $\text{Var}(X) = np(1-p)$
+        - Models number of successes in $n$ independent trials
+        - $P(X = k) = \binom{n}{k}p^k(1-p)^{n-k}$
+        - $E[X] = np$, $\text{Var}(X) = np(1-p)$
 
-        3. Normal Distribution
+    3. Normal Distribution
 
-            - Bell-shaped curve defined by mean $\mu$ and variance $\sigma^2$
-            - PDF: $f_X(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}$
-            - $E[X] = \mu$, $\text{Var}(X) = \sigma^2$
-        """
-    )
+        - Bell-shaped curve defined by mean $\mu$ and variance $\sigma^2$
+        - PDF: $f_X(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}$
+        - $E[X] = \mu$, $\text{Var}(X) = \sigma^2$
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Example: Comparing Discrete and Continuous Distributions
+    mo.md(r"""
+    ### Example: Comparing Discrete and Continuous Distributions
 
-        This example shows the relationship between a Binomial distribution (discrete) and its Normal approximation (continuous).
-        The parameters control both distributions:
+    This example shows the relationship between a Binomial distribution (discrete) and its Normal approximation (continuous).
+    The parameters control both distributions:
 
-        - **Number of Trials**: Controls the range of possible values and the shape's width
-        - **Success Probability**: Affects the distribution's center and skewness
-        """
-    )
+    - **Number of Trials**: Controls the range of possible values and the shape's width
+    - **Success Probability**: Affects the distribution's center and skewness
+    """)
     return
 
 
@@ -405,7 +387,7 @@ def _(n_trials, np, p_success, plt, stats):
 
     plt.tight_layout()
     plt.gca()
-    return ax1, ax2, fig, k, mu, pdf, pmf, sigma, x
+    return
 
 
 @app.cell(hide_code=True)
@@ -426,42 +408,40 @@ def _(mo, n_trials, np, p_success):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Practice Problems
-
-        ### Problem 1: Discrete Random Variable
-        Let $X$ be the sum when rolling two fair dice. Find:
-
-        1. The support of $X$
-        2. The PMF $p_X(x)$
-        3. $E[X]$ and $\text{Var}(X)$
-
-        <details>
-        <summary>Solution</summary>
-        Let's solve this step by step:
-        ```python
-        def two_dice_pmf(x):
-            outcomes = [(i,j) for i in range(1,7) for j in range(1,7)]
-            favorable = [pair for pair in outcomes if sum(pair) == x]
-            return len(favorable)/36
-
-        # Support: {2,3,...,12}
-        # E[X] = 7
-        # Var(X) = 5.83
-        ```
-        </details>
-
-        ### Problem 2: Continuous Random Variable
-        For a uniform random variable on $[0,1]$, verify that:
-
-        1. The PDF integrates to 1
-        2. $E[X] = 1/2$
-        3. $\text{Var}(X) = 1/12$
-
-        Try solving this yourself first, then check the solution below.
-        """
-    )
+    mo.md(r"""
+    ## Practice Problems
+
+    ### Problem 1: Discrete Random Variable
+    Let $X$ be the sum when rolling two fair dice. Find:
+
+    1. The support of $X$
+    2. The PMF $p_X(x)$
+    3. $E[X]$ and $\text{Var}(X)$
+
+    <details>
+    <summary>Solution</summary>
+    Let's solve this step by step:
+    ```python
+    def two_dice_pmf(x):
+        outcomes = [(i,j) for i in range(1,7) for j in range(1,7)]
+        favorable = [pair for pair in outcomes if sum(pair) == x]
+        return len(favorable)/36
+
+    # Support: {2,3,...,12}
+    # E[X] = 7
+    # Var(X) = 5.83
+    ```
+    </details>
+
+    ### Problem 2: Continuous Random Variable
+    For a uniform random variable on $[0,1]$, verify that:
+
+    1. The PDF integrates to 1
+    2. $E[X] = 1/2$
+    3. $\text{Var}(X) = 1/12$
+
+    Try solving this yourself first, then check the solution below.
+    """)
     return
 
 
@@ -479,72 +459,66 @@ def _(mktext, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mktext = mo.md(
-        r"""
-        Let's solve each part:
+    mktext=mo.md(r"""
+    Let's solve each part:
 
-        1. **PDF integrates to 1**:
-           $\int_0^1 1 \, dx = [x]_0^1 = 1 - 0 = 1$
+    1. **PDF integrates to 1**:
+       $\int_0^1 1 \, dx = [x]_0^1 = 1 - 0 = 1$
 
-        2. **Expected Value**:
-           $E[X] = \int_0^1 x \cdot 1 \, dx = [\frac{x^2}{2}]_0^1 = \frac{1}{2} - 0 = \frac{1}{2}$
+    2. **Expected Value**:
+       $E[X] = \int_0^1 x \cdot 1 \, dx = [\frac{x^2}{2}]_0^1 = \frac{1}{2} - 0 = \frac{1}{2}$
 
-        3. **Variance**:
-           $\text{Var}(X) = E[X^2] - (E[X])^2$
+    3. **Variance**:
+       $\text{Var}(X) = E[X^2] - (E[X])^2$
 
-           First calculate $E[X^2]$:
-           $E[X^2] = \int_0^1 x^2 \cdot 1 \, dx = [\frac{x^3}{3}]_0^1 = \frac{1}{3}$
+       First calculate $E[X^2]$:
+       $E[X^2] = \int_0^1 x^2 \cdot 1 \, dx = [\frac{x^3}{3}]_0^1 = \frac{1}{3}$
 
-           Then:
-           $\text{Var}(X) = \frac{1}{3} - (\frac{1}{2})^2 = \frac{1}{3} - \frac{1}{4} = \frac{1}{12}$
-        """
-    )
+       Then:
+       $\text{Var}(X) = \frac{1}{3} - (\frac{1}{2})^2 = \frac{1}{3} - \frac{1}{4} = \frac{1}{12}$
+    """)
     return (mktext,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
 
-        Pick which of these statements about random variables you think are correct:
+    Pick which of these statements about random variables you think are correct:
 
-        <details>
-        <summary>The probability density function can be greater than 1</summary>
-        ✅ Correct! Unlike PMFs, PDFs can exceed 1 as long as the total area equals 1.
-        </details>
+    <details>
+    <summary>The probability density function can be greater than 1</summary>
+    ✅ Correct! Unlike PMFs, PDFs can exceed 1 as long as the total area equals 1.
+    </details>
 
-        <details>
-        <summary>The expected value of a random variable must equal one of its possible values</summary>
-        ❌ Incorrect! For example, the expected value of a fair die is 3.5, which is not a possible outcome.
-        </details>
+    <details>
+    <summary>The expected value of a random variable must equal one of its possible values</summary>
+    ❌ Incorrect! For example, the expected value of a fair die is 3.5, which is not a possible outcome.
+    </details>
 
-        <details>
-        <summary>Adding a constant to a random variable changes its variance</summary>
-        ❌ Incorrect! Adding a constant shifts the distribution but doesn't affect its spread.
-        </details>
-        """
-    )
+    <details>
+    <summary>Adding a constant to a random variable changes its variance</summary>
+    ❌ Incorrect! Adding a constant shifts the distribution but doesn't affect its spread.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Summary
+    mo.md("""
+    ## Summary
 
-        You've learned:
+    You've learned:
 
-        - The difference between discrete and continuous random variables
-        - How PMFs and PDFs describe probability distributions
-        - Methods for calculating expected values and variances
-        - Properties of common probability distributions
+    - The difference between discrete and continuous random variables
+    - How PMFs and PDFs describe probability distributions
+    - Methods for calculating expected values and variances
+    - Properties of common probability distributions
 
-        In the next lesson, we'll explore Probability Mass Functions in detail, focusing on their properties and applications.
-        """
-    )
+    In the next lesson, we'll explore Probability Mass Functions in detail, focusing on their properties and applications.
+    """)
     return
 
 

probability/10_probability_mass_function.py

@@ -10,57 +10,51 @@
 
 import marimo
 
-__generated_with = "0.12.6"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Probability Mass Functions")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Probability Mass Functions
+    mo.md(r"""
+    # Probability Mass Functions
 
-        _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/pmf/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/pmf/), by Stanford professor Chris Piech._
 
-        PMFs are really important in discrete probability. They tell us how likely each possible outcome is for a discrete random variable.
+    PMFs are really important in discrete probability. They tell us how likely each possible outcome is for a discrete random variable.
 
-        What's interesting about PMFs is that they can be represented in multiple ways - equations, graphs, or even empirical data. The core idea is simple: they map each possible value to its probability.
-        """
-    )
+    What's interesting about PMFs is that they can be represented in multiple ways - equations, graphs, or even empirical data. The core idea is simple: they map each possible value to its probability.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Properties of a PMF
+    mo.md(r"""
+    ## Properties of a PMF
 
-        For a function $p_X(x)$ to be a valid PMF:
+    For a function $p_X(x)$ to be a valid PMF:
 
-        1. **Non-negativity**: probability can't be negative, so $p_X(x) \geq 0$ for all $x$
-        2. **Unit total probability**: all probabilities sum to 1, i.e., $\sum_x p_X(x) = 1$
+    1. **Non-negativity**: probability can't be negative, so $p_X(x) \geq 0$ for all $x$
+    2. **Unit total probability**: all probabilities sum to 1, i.e., $\sum_x p_X(x) = 1$
 
-        The second property makes intuitive sense - a random variable must take some value, and the sum of all possibilities should be 100%.
-        """
-    )
+    The second property makes intuitive sense - a random variable must take some value, and the sum of all possibilities should be 100%.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## PMFs as Graphs
+    mo.md(r"""
+    ## PMFs as Graphs
 
-        Let's start by looking at PMFs as graphs where the $x$-axis is the values that the random variable could take on and the $y$-axis is the probability of the random variable taking on said value.
+    Let's start by looking at PMFs as graphs where the $x$-axis is the values that the random variable could take on and the $y$-axis is the probability of the random variable taking on said value.
 
-        In the following example, we show two PMFs:
+    In the following example, we show two PMFs:
 
-        - On the left: PMF for the random variable $X$ = the value of a single six-sided die roll
-        - On the right: PMF for the random variable $Y$ = value of the sum of two dice rolls
-        """
-    )
+    - On the left: PMF for the random variable $X$ = the value of a single six-sided die roll
+    - On the right: PMF for the random variable $Y$ = value of the sum of two dice rolls
+    """)
     return
 
 
@@ -102,53 +96,39 @@ def _(np, plt):
 
     plt.tight_layout()
     plt.gca()
-    return (
-        dice_ax1,
-        dice_ax2,
-        dice_fig,
-        dice_prob,
-        dice_sum,
-        single_die_probs,
-        single_die_values,
-        two_dice_probs,
-        two_dice_values,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        These graphs really show us how likely each value is when we roll the dice.
+    mo.md(r"""
+    These graphs really show us how likely each value is when we roll the dice.
 
-        looking at the right graph, when we see "6" on the $x$-axis with probability $\frac{5}{36}$ on the $y$-axis, that's telling us there's a $\frac{5}{36}$ chance of rolling a sum of 6 with two dice. or more formally: $P(Y = 6) = \frac{5}{36}$.
+    looking at the right graph, when we see "6" on the $x$-axis with probability $\frac{5}{36}$ on the $y$-axis, that's telling us there's a $\frac{5}{36}$ chance of rolling a sum of 6 with two dice. or more formally: $P(Y = 6) = \frac{5}{36}$.
 
-        Similarly, the value "2" has probability "$\frac{1}{36}$" - that's because there's only one way to get a sum of 2 (rolling 1 on both dice). and you'll notice there's no value for "1" since you can't get a sum of 1 with two dice - the minimum possible is 2.
-        """
-    )
+    Similarly, the value "2" has probability "$\frac{1}{36}$" - that's because there's only one way to get a sum of 2 (rolling 1 on both dice). and you'll notice there's no value for "1" since you can't get a sum of 1 with two dice - the minimum possible is 2.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## PMFs as Equations
+    mo.md(r"""
+    ## PMFs as Equations
 
-        Here is the exact same information in equation form:
+    Here is the exact same information in equation form:
 
-        For a single die roll $X$:
-        $$P(X=x) = \frac{1}{6} \quad \text{ if } 1 \leq x \leq 6$$
+    For a single die roll $X$:
+    $$P(X=x) = \frac{1}{6} \quad \text{ if } 1 \leq x \leq 6$$
 
-        For the sum of two dice $Y$:
-        $$P(Y=y) = \begin{cases}
-        \frac{(y-1)}{36} & \text{ if } 2 \leq y \leq 7\\
-        \frac{(13-y)}{36} & \text{ if } 8 \leq y \leq 12
-        \end{cases}$$
+    For the sum of two dice $Y$:
+    $$P(Y=y) = \begin{cases}
+    \frac{(y-1)}{36} & \text{ if } 2 \leq y \leq 7\\
+    \frac{(13-y)}{36} & \text{ if } 8 \leq y \leq 12
+    \end{cases}$$
 
-        Let's implement the PMF for $Y$, the sum of two dice, in Python code:
-        """
-    )
+    Let's implement the PMF for $Y$, the sum of two dice, in Python code:
+    """)
     return
 
 
@@ -167,12 +147,14 @@ def _():
     test_values = [1, 2, 7, 12, 13]
     for test_y in test_values:
         print(f"P(Y = {test_y}) = {pmf_sum_two_dice(test_y)}")
-    return pmf_sum_two_dice, test_values, test_y
+    return (pmf_sum_two_dice,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Now, let's verify that our PMF satisfies the property that the sum of all probabilities equals 1:""")
+    mo.md(r"""
+    Now, let's verify that our PMF satisfies the property that the sum of all probabilities equals 1:
+    """)
     return
 
 
@@ -183,7 +165,7 @@ def _(pmf_sum_two_dice):
     # Round to 10 decimal places to handle floating-point precision
     verify_total_prob_rounded = round(verify_total_prob, 10)
     print(f"Sum of all probabilities: {verify_total_prob_rounded}")
-    return verify_total_prob, verify_total_prob_rounded
+    return
 
 
 @app.cell(hide_code=True)
@@ -205,18 +187,16 @@ def _(plt, pmf_sum_two_dice):
         plt.text(verify_y_values[verify_i], verify_prob + 0.001, f'{verify_prob:.3f}', ha='center')
 
     plt.gca()  # Return the current axes to ensure proper display
-    return verify_i, verify_prob, verify_probabilities, verify_y_values
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Data to Histograms to Probability Mass Functions
+    mo.md(r"""
+    ## Data to Histograms to Probability Mass Functions
 
-        Here's something I find interesting — one way to represent a likelihood function is just through raw data. instead of mathematical formulas, we can actually approximate a PMF by collecting data points. let's see this in action by simulating lots of dice rolls and building an empirical PMF:
-        """
-    )
+    Here's something I find interesting — one way to represent a likelihood function is just through raw data. instead of mathematical formulas, we can actually approximate a PMF by collecting data points. let's see this in action by simulating lots of dice rolls and building an empirical PMF:
+    """)
     return
 
 
@@ -236,7 +216,7 @@ def _(np):
     # Display a small sample of the data
     print(f"First 20 dice sums: {sim_dice_sums[:20]}")
     print(f"Total number of trials: {sim_num_trials}")
-    return sim_dice_sums, sim_die1, sim_die2, sim_num_trials
+    return (sim_dice_sums,)
 
 
 @app.cell(hide_code=True)
@@ -296,32 +276,16 @@ def _(collections, np, plt, sim_dice_sums):
         plt.text(sim_sorted_values[sim_i], sim_count + 19, str(sim_count), ha='center')
 
     plt.gca()  # Return the current axes to ensure proper display
-    return (
-        sim_ax1,
-        sim_ax2,
-        sim_count,
-        sim_counter,
-        sim_counts,
-        sim_empirical_pmf,
-        sim_fig,
-        sim_i,
-        sim_prob,
-        sim_sorted_values,
-        sim_theoretical_pmf,
-        sim_theoretical_values,
-        sim_y,
-    )
+    return (sim_counter,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        When we normalize a histogram (divide each count by total sample size), we get a pretty good approximation of the true PMF. it's a simple yet powerful idea - count how many times each value appears, then divide by the total number of trials.
+    mo.md(r"""
+    When we normalize a histogram (divide each count by total sample size), we get a pretty good approximation of the true PMF. it's a simple yet powerful idea - count how many times each value appears, then divide by the total number of trials.
 
-        let's make this concrete. say we want to estimate $P(Y=3)$ - the probability of rolling a sum of 3 with two dice. we just count how many 3's show up in our simulated rolls and divide by the total number of rolls:
-        """
-    )
+    let's make this concrete. say we want to estimate $P(Y=3)$ - the probability of rolling a sum of 3 with two dice. we just count how many 3's show up in our simulated rolls and divide by the total number of rolls:
+    """)
     return
 
 
@@ -338,20 +302,18 @@ def _(sim_counter, sim_dice_sums):
     print(f"Empirical P(Y=3): {sim_count_of_3}/{len(sim_dice_sums)} = {sim_empirical_prob:.4f}")
     print(f"Theoretical P(Y=3): 2/36 = {sim_theoretical_prob:.4f}")
     print(f"Difference: {abs(sim_empirical_prob - sim_theoretical_prob):.4f}")
-    return sim_count_of_3, sim_empirical_prob, sim_theoretical_prob
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        As we can see, with a large number of trials, the empirical PMF becomes a very good approximation of the theoretical PMF. This is an example of the [Law of Large Numbers](https://en.wikipedia.org/wiki/Law_of_large_numbers) in action.
+    mo.md(r"""
+    As we can see, with a large number of trials, the empirical PMF becomes a very good approximation of the theoretical PMF. This is an example of the [Law of Large Numbers](https://en.wikipedia.org/wiki/Law_of_large_numbers) in action.
 
-        ## Interactive Example: Exploring PMFs
+    ## Interactive Example: Exploring PMFs
 
-        Let's create an interactive tool to explore different PMFs:
-        """
-    )
+    Let's create an interactive tool to explore different PMFs:
+    """)
     return
 
 
@@ -482,38 +444,20 @@ def _(dist_param1, dist_param2, dist_selection, np, plt, stats):
              bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
 
     plt.gca()  # Return the current axes to ensure proper display
-    return (
-        dist_baseline,
-        dist_lam,
-        dist_markerline,
-        dist_max_x,
-        dist_mean,
-        dist_n,
-        dist_p,
-        dist_pmf_values,
-        dist_props_text,
-        dist_std_dev,
-        dist_stemlines,
-        dist_title,
-        dist_variance,
-        dist_x_label,
-        dist_x_values,
-    )
+    return dist_pmf_values, dist_x_values
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expected Value from a PMF
+    mo.md(r"""
+    ## Expected Value from a PMF
 
-        The expected value (or mean) of a discrete random variable is calculated using its PMF:
+    The expected value (or mean) of a discrete random variable is calculated using its PMF:
 
-        $$E[X] = \sum_x x \cdot p_X(x)$$
+    $$E[X] = \sum_x x \cdot p_X(x)$$
 
-        This represents the long-run average value of the random variable.
-        """
-    )
+    This represents the long-run average value of the random variable.
+    """)
     return
 
 
@@ -527,24 +471,22 @@ def _(dist_pmf_values, dist_x_values):
     ev_dist_mean = calc_expected_value(dist_x_values, dist_pmf_values)
 
     print(f"Expected value: {ev_dist_mean:.4f}")
-    return calc_expected_value, ev_dist_mean
+    return (ev_dist_mean,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Variance from a PMF
+    mo.md(r"""
+    ## Variance from a PMF
 
-        The variance measures the spread or dispersion of a random variable around its mean:
+    The variance measures the spread or dispersion of a random variable around its mean:
 
-        $$\text{Var}(X) = E[(X - E[X])^2] = \sum_x (x - E[X])^2 \cdot p_X(x)$$
+    $$\text{Var}(X) = E[(X - E[X])^2] = \sum_x (x - E[X])^2 \cdot p_X(x)$$
 
-        An alternative formula is:
+    An alternative formula is:
 
-        $$\text{Var}(X) = E[X^2] - (E[X])^2 = \sum_x x^2 \cdot p_X(x) - \left(\sum_x x \cdot p_X(x)\right)^2$$
-        """
-    )
+    $$\text{Var}(X) = E[X^2] - (E[X])^2 = \sum_x x^2 \cdot p_X(x) - \left(\sum_x x \cdot p_X(x)\right)^2$$
+    """)
     return
 
 
@@ -560,22 +502,20 @@ def _(dist_pmf_values, dist_x_values, ev_dist_mean, np):
 
     print(f"Variance: {var_dist_var:.4f}")
     print(f"Standard deviation: {var_dist_std_dev:.4f}")
-    return calc_variance, var_dist_std_dev, var_dist_var
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## PMF vs. CDF
+    mo.md(r"""
+    ## PMF vs. CDF
 
-        The **Cumulative Distribution Function (CDF)** is related to the PMF but gives the probability that the random variable $X$ is less than or equal to a value $x$:
+    The **Cumulative Distribution Function (CDF)** is related to the PMF but gives the probability that the random variable $X$ is less than or equal to a value $x$:
 
-        $$F_X(x) = P(X \leq x) = \sum_{k \leq x} p_X(k)$$
+    $$F_X(x) = P(X \leq x) = \sum_{k \leq x} p_X(k)$$
 
-        While the PMF gives the probability mass at each point, the CDF accumulates these probabilities.
-        """
-    )
+    While the PMF gives the probability mass at each point, the CDF accumulates these probabilities.
+    """)
     return
 
 
@@ -612,77 +552,69 @@ def _(dist_pmf_values, dist_x_values, np, plt):
 
     plt.tight_layout()
     plt.gca()  # Return the current axes to ensure proper display
-    return cdf_ax1, cdf_ax2, cdf_dist_values, cdf_fig, x_max, x_min
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        The graphs above illustrate the key difference between PMF and CDF:
+    mo.md(r"""
+    The graphs above illustrate the key difference between PMF and CDF:
 
-        - **PMF (left)**: Shows the probability of the random variable taking each specific value: P(X = x)
-        - **CDF (right)**: Shows the probability of the random variable being less than or equal to each value: P(X ≤ x)
+    - **PMF (left)**: Shows the probability of the random variable taking each specific value: P(X = x)
+    - **CDF (right)**: Shows the probability of the random variable being less than or equal to each value: P(X ≤ x)
 
-        The CDF at any point is the sum of all PMF values up to and including that point. This is why the CDF is always non-decreasing and eventually reaches 1. For discrete distributions like this one, the CDF forms a step function that jumps at each value in the support of the random variable.
-        """
-    )
+    The CDF at any point is the sum of all PMF values up to and including that point. This is why the CDF is always non-decreasing and eventually reaches 1. For discrete distributions like this one, the CDF forms a step function that jumps at each value in the support of the random variable.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Test Your Understanding
-
-        Choose what you believe are the correct options in the questions below:
-
-        <details>
-        <summary>If X is a discrete random variable with PMF p(x), then p(x) must always be less than 1</summary>
-        ❌ False! While most values in a PMF are typically less than 1, a PMF can have p(x) = 1 for a specific value if the random variable always takes that value (with 100% probability).
-        </details>
-
-        <details>
-        <summary>The sum of all probabilities in a PMF must equal exactly 1</summary>
-        ✅ True! This is a fundamental property of any valid PMF. The total probability across all possible values must be 1, as the random variable must take some value.
-        </details>
-
-        <details>
-        <summary>A PMF can be estimated from data by creating a normalized histogram</summary>
-        ✅ True! Counting the frequency of each value and dividing by the total number of observations gives an empirical PMF.
-        </details>
-
-        <details>
-        <summary>The expected value of a discrete random variable is always one of the possible values of the variable</summary>
-        ❌ False! The expected value is a weighted average and may not be a value the random variable can actually take. For example, the expected value of a fair die roll is 3.5, which is not a possible outcome.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## Test Your Understanding
+
+    Choose what you believe are the correct options in the questions below:
+
+    <details>
+    <summary>If X is a discrete random variable with PMF p(x), then p(x) must always be less than 1</summary>
+    ❌ False! While most values in a PMF are typically less than 1, a PMF can have p(x) = 1 for a specific value if the random variable always takes that value (with 100% probability).
+    </details>
+
+    <details>
+    <summary>The sum of all probabilities in a PMF must equal exactly 1</summary>
+    ✅ True! This is a fundamental property of any valid PMF. The total probability across all possible values must be 1, as the random variable must take some value.
+    </details>
+
+    <details>
+    <summary>A PMF can be estimated from data by creating a normalized histogram</summary>
+    ✅ True! Counting the frequency of each value and dividing by the total number of observations gives an empirical PMF.
+    </details>
+
+    <details>
+    <summary>The expected value of a discrete random variable is always one of the possible values of the variable</summary>
+    ❌ False! The expected value is a weighted average and may not be a value the random variable can actually take. For example, the expected value of a fair die roll is 3.5, which is not a possible outcome.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Practical Applications of PMFs
+    mo.md(r"""
+    ## Practical Applications of PMFs
 
-        PMFs pop up everywhere - network engineers use them to model traffic patterns, reliability teams predict equipment failures, and marketers analyze purchase behavior. In finance, they help price options; in gaming, they're behind every dice roll. Machine learning algorithms like Naive Bayes rely on them, and they're essential for modeling rare events like genetic mutations or system failures.
-        """
-    )
+    PMFs pop up everywhere - network engineers use them to model traffic patterns, reliability teams predict equipment failures, and marketers analyze purchase behavior. In finance, they help price options; in gaming, they're behind every dice roll. Machine learning algorithms like Naive Bayes rely on them, and they're essential for modeling rare events like genetic mutations or system failures.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Key Takeaways
+    mo.md(r"""
+    ## Key Takeaways
 
-        PMFs give us the probability picture for discrete random variables - they tell us how likely each value is, must be non-negative, and always sum to 1. We can write them as equations, draw them as graphs, or estimate them from data. They're the foundation for calculating expected values and variances, which we'll explore in our next notebook on Expectation, where we'll learn how to summarize random variables with a single, most "expected" value.
-        """
-    )
+    PMFs give us the probability picture for discrete random variables - they tell us how likely each value is, must be non-negative, and always sum to 1. We can write them as equations, draw them as graphs, or estimate them from data. They're the foundation for calculating expected values and variances, which we'll explore in our next notebook on Expectation, where we'll learn how to summarize random variables with a single, most "expected" value.
+    """)
     return
 
 

probability/11_expectation.py

@@ -10,55 +10,49 @@
 
 import marimo
 
-__generated_with = "0.12.6"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Expectation")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Expectation
+    mo.md(r"""
+    # Expectation
 
-        _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/expectation/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/expectation/), by Stanford professor Chris Piech._
 
-        Expectations are fascinating — they represent the "center of mass" of a probability distribution. while they're often called "expected values" or "averages," they don't always match our intuition about what's "expected" to happen.
+    Expectations are fascinating — they represent the "center of mass" of a probability distribution. while they're often called "expected values" or "averages," they don't always match our intuition about what's "expected" to happen.
 
-        For me, the most interesting part about expectations is how they quantify what happens "on average" in the long run, even if that average isn't a possible outcome (like expecting 3.5 on a standard die roll).
-        """
-    )
+    For me, the most interesting part about expectations is how they quantify what happens "on average" in the long run, even if that average isn't a possible outcome (like expecting 3.5 on a standard die roll).
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Definition of Expectation
+    mo.md(r"""
+    ## Definition of Expectation
 
-        Expectation (written as $E[X]$) is basically the "average outcome" of a random variable, but with a twist - we weight each possible value by how likely it is to occur. I like to think of it as the "center of gravity" for probability.
+    Expectation (written as $E[X]$) is basically the "average outcome" of a random variable, but with a twist - we weight each possible value by how likely it is to occur. I like to think of it as the "center of gravity" for probability.
 
-        $$E[X] = \sum_x x \cdot P(X=x)$$
+    $$E[X] = \sum_x x \cdot P(X=x)$$
 
-        People call this concept by different names - mean, weighted average, center of mass, or 1st moment if you're being fancy. They're all calculated the same way, though: multiply each value by its probability, then add everything up.
-        """
-    )
+    People call this concept by different names - mean, weighted average, center of mass, or 1st moment if you're being fancy. They're all calculated the same way, though: multiply each value by its probability, then add everything up.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Intuition Behind Expectation
+    mo.md(r"""
+    ## Intuition Behind Expectation
 
-        The expected value represents the long-run average value of a random variable over many independent repetitions of an experiment.
+    The expected value represents the long-run average value of a random variable over many independent repetitions of an experiment.
 
-        For example, if you roll a fair six-sided die many times and calculate the average of all rolls, that average will approach the expected value of 3.5 as the number of rolls increases.
+    For example, if you roll a fair six-sided die many times and calculate the average of all rolls, that average will approach the expected value of 3.5 as the number of rolls increases.
 
-        Let's visualize this concept:
-        """
-    )
+    Let's visualize this concept:
+    """)
     return
 
 
@@ -91,12 +85,14 @@ def _(np, plt):
                 arrowprops=dict(facecolor='black', shrink=0.05, width=1.5))
 
     plt.gca()
-    return exp_die_rolls, exp_num_rolls, exp_running_avg
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Properties of Expectation""")
+    mo.md(r"""
+    ## Properties of Expectation
+    """)
     return
 
 
@@ -145,25 +141,23 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Calculating Expectation
+    mo.md(r"""
+    ## Calculating Expectation
 
-        Let's calculate the expected value for some common examples:
+    Let's calculate the expected value for some common examples:
 
-        ### Example 1: Fair Die Roll
+    ### Example 1: Fair Die Roll
 
-        For a fair six-sided die, the PMF is:
+    For a fair six-sided die, the PMF is:
 
-        $$P(X=x) = \frac{1}{6} \text{ for } x \in \{1, 2, 3, 4, 5, 6\}$$
+    $$P(X=x) = \frac{1}{6} \text{ for } x \in \{1, 2, 3, 4, 5, 6\}$$
 
-        The expected value is:
+    The expected value is:
 
-        $$E[X] = 1 \cdot \frac{1}{6} + 2 \cdot \frac{1}{6} + 3 \cdot \frac{1}{6} + 4 \cdot \frac{1}{6} + 5 \cdot \frac{1}{6} + 6 \cdot \frac{1}{6} = \frac{21}{6} = 3.5$$
+    $$E[X] = 1 \cdot \frac{1}{6} + 2 \cdot \frac{1}{6} + 3 \cdot \frac{1}{6} + 4 \cdot \frac{1}{6} + 5 \cdot \frac{1}{6} + 6 \cdot \frac{1}{6} = \frac{21}{6} = 3.5$$
 
-        Let's implement this calculation in Python:
-        """
-    )
+    Let's implement this calculation in Python:
+    """)
     return
 
 
@@ -179,18 +173,16 @@ def _():
 
     exp_die_result = calc_expectation_die()
     print(f"Expected value of a fair die roll: {exp_die_result}")
-    return calc_expectation_die, exp_die_result
+    return (exp_die_result,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Example 2: Sum of Two Dice
+    mo.md(r"""
+    ### Example 2: Sum of Two Dice
 
-        Now let's calculate the expected value for the sum of two fair dice. First, we need the PMF:
-        """
-    )
+    Now let's calculate the expected value for the sum of two fair dice. First, we need the PMF:
+    """)
     return
 
 
@@ -210,7 +202,7 @@ def _():
     exp_test_values = [2, 7, 12]
     for exp_test_y in exp_test_values:
         print(f"P(Y = {exp_test_y}) = {pmf_sum_two_dice(exp_test_y)}")
-    return exp_test_values, exp_test_y, pmf_sum_two_dice
+    return (pmf_sum_two_dice,)
 
 
 @app.cell
@@ -239,24 +231,16 @@ def _(pmf_sum_two_dice):
 
     # Verify that this equals 7
     print(f"Is the expected value exactly 7? {abs(exp_sum_result - 7) < 1e-10}")
-    return (
-        calc_expectation_sum_two_dice,
-        exp_direct_calc,
-        exp_direct_calc_rounded,
-        exp_sum_result,
-        exp_sum_result_rounded,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Visualizing Expectation
+    mo.md(r"""
+    ### Visualizing Expectation
 
-        Let's visualize the expectation for the sum of two dice. The expected value is the "center of mass" of the PMF:
-        """
-    )
+    Let's visualize the expectation for the sum of two dice. The expected value is the "center of mass" of the PMF:
+    """)
     return
 
 
@@ -283,18 +267,16 @@ def _(plt, pmf_sum_two_dice):
 
     plt.tight_layout()
     plt.gca()
-    return dice_ax, dice_fig, exp_i, exp_prob, exp_probabilities, exp_y_values
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Demonstrating the Properties of Expectation
+    mo.md(r"""
+    ## Demonstrating the Properties of Expectation
 
-        Let's demonstrate some of these properties with examples:
-        """
-    )
+    Let's demonstrate some of these properties with examples:
+    """)
     return
 
 
@@ -321,25 +303,16 @@ def _(exp_die_result):
 
     # Verify they match
     print(f"Do they match? {abs(prop_expected_using_property - prop_expected_direct) < 1e-10}")
-    return (
-        prop_a,
-        prop_b,
-        prop_expected_direct,
-        prop_expected_direct_rounded,
-        prop_expected_using_property,
-        prop_expected_using_property_rounded,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ### Law of the Unconscious Statistician (LOTUS)
+    mo.md(r"""
+    ### Law of the Unconscious Statistician (LOTUS)
 
-        Let's use LOTUS to calculate $E[X^2]$ for a die roll, which will be useful when we study variance:
-        """
-    )
+    Let's use LOTUS to calculate $E[X^2]$ for a die roll, which will be useful when we study variance:
+    """)
     return
 
 
@@ -358,38 +331,27 @@ def _():
 
     print(f"E[X^2] for a die roll = {lotus_expected_x_squared_rounded}")
     print(f"(E[X])^2 for a die roll = {expected_x_squared_rounded}")
-    return (
-        expected_x_squared,
-        expected_x_squared_rounded,
-        lotus_die_probs,
-        lotus_die_values,
-        lotus_expected_x_squared,
-        lotus_expected_x_squared_rounded,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// Note
-        Note that E[X^2] != (E[X])^2
-        """
-    )
+    mo.md(r"""
+    /// Note
+    Note that E[X^2] != (E[X])^2
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Interactive Example
+    mo.md(r"""
+    ## Interactive Example
 
-        Let's explore how the expected value changes as we adjust the parameters of common probability distributions. This interactive visualization focuses specifically on the relationship between distribution parameters and expected values.
+    Let's explore how the expected value changes as we adjust the parameters of common probability distributions. This interactive visualization focuses specifically on the relationship between distribution parameters and expected values.
 
-        Use the controls below to select a distribution and adjust its parameters. The graph will show how the expected value changes across a range of parameter values.
-        """
-    )
+    Use the controls below to select a distribution and adjust its parameters. The graph will show how the expected value changes across a range of parameter values.
+    """)
     return
 
 
@@ -423,7 +385,9 @@ def _(dist_description):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""### Adjust Parameters""")
+    mo.md("""
+    ### Adjust Parameters
+    """)
     return
 
 
@@ -549,37 +513,16 @@ def _(
 
     plt.tight_layout()
     plt.gca()
-    return (
-        annotation_x,
-        annotation_y,
-        current_expected,
-        current_param,
-        dist_ax,
-        dist_fig,
-        dist_props,
-        expected_values,
-        formula,
-        lambda_max,
-        lambda_min,
-        max_y,
-        n,
-        p_max,
-        p_min,
-        param_values,
-        title,
-        x_label,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expectation vs. Mode
+    mo.md(r"""
+    ## Expectation vs. Mode
 
-        The expected value (mean) of a random variable is not always the same as its most likely value (mode). Let's explore this with an example:
-        """
-    )
+    The expected value (mean) of a random variable is not always the same as its most likely value (mode). Let's explore this with an example:
+    """)
     return
 
 
@@ -633,94 +576,75 @@ def _(np, plt, stats):
 
     plt.tight_layout()
     plt.gca()
-    return (
-        max_x,
-        mid_x,
-        min_x,
-        skew_ax,
-        skew_expected,
-        skew_expected_rounded,
-        skew_fig,
-        skew_mode,
-        skew_n,
-        skew_p,
-        skew_pmf_values,
-        skew_x_values,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// NOTE
-        For the sum of two dice we calculated earlier, we found the expected value to be exactly 7. In that case, 7 also happens to be the mode (most likely outcome) of the distribution. However, this is just a coincidence for this particular example!
+    mo.md(r"""
+    /// NOTE
+    For the sum of two dice we calculated earlier, we found the expected value to be exactly 7. In that case, 7 also happens to be the mode (most likely outcome) of the distribution. However, this is just a coincidence for this particular example!
 
-        As we can see from the binomial distribution above, the expected value (2.50) and the mode (2) are often different values (this is common in skewed distributions). The expected value represents the "center of mass" of the distribution, while the mode represents the most likely single outcome.
-        """
-    )
+    As we can see from the binomial distribution above, the expected value (2.50) and the mode (2) are often different values (this is common in skewed distributions). The expected value represents the "center of mass" of the distribution, while the mode represents the most likely single outcome.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
-
-        Choose what you believe are the correct options in the questions below:
-
-        <details>
-        <summary>The expected value of a random variable is always one of the possible values the random variable can take.</summary>
-        ❌ False! The expected value is a weighted average and may not be a value the random variable can actually take. For example, the expected value of a fair die roll is 3.5, which is not a possible outcome.
-        </details>
-
-        <details>
-        <summary>If X and Y are independent random variables, then E[X·Y] = E[X]·E[Y].</summary>
-        ✅ True! For independent random variables, the expectation of their product equals the product of their expectations.
-        </details>
-
-        <details>
-        <summary>The expected value of a constant random variable (one that always takes the same value) is that constant.</summary>
-        ✅ True! If X = c with probability 1, then E[X] = c.
-        </details>
-
-        <details>
-        <summary>The expected value of the sum of two random variables is always the sum of their expected values, regardless of whether they are independent.</summary>
-        ✅ True! This is the linearity of expectation property: E[X + Y] = E[X] + E[Y], which holds regardless of dependence.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
+
+    Choose what you believe are the correct options in the questions below:
+
+    <details>
+    <summary>The expected value of a random variable is always one of the possible values the random variable can take.</summary>
+    ❌ False! The expected value is a weighted average and may not be a value the random variable can actually take. For example, the expected value of a fair die roll is 3.5, which is not a possible outcome.
+    </details>
+
+    <details>
+    <summary>If X and Y are independent random variables, then E[X·Y] = E[X]·E[Y].</summary>
+    ✅ True! For independent random variables, the expectation of their product equals the product of their expectations.
+    </details>
+
+    <details>
+    <summary>The expected value of a constant random variable (one that always takes the same value) is that constant.</summary>
+    ✅ True! If X = c with probability 1, then E[X] = c.
+    </details>
+
+    <details>
+    <summary>The expected value of the sum of two random variables is always the sum of their expected values, regardless of whether they are independent.</summary>
+    ✅ True! This is the linearity of expectation property: E[X + Y] = E[X] + E[Y], which holds regardless of dependence.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Practical Applications of Expectation
+    mo.md(r"""
+    ## Practical Applications of Expectation
 
-        Expected values show up everywhere - from investment decisions and insurance pricing to machine learning algorithms and game design. Engineers use them to predict system reliability, data scientists to understand customer behavior, and economists to model market outcomes. They're essential for risk assessment in project management and for optimizing resource allocation in operations research.
-        """
-    )
+    Expected values show up everywhere - from investment decisions and insurance pricing to machine learning algorithms and game design. Engineers use them to predict system reliability, data scientists to understand customer behavior, and economists to model market outcomes. They're essential for risk assessment in project management and for optimizing resource allocation in operations research.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Key Takeaways
+    mo.md(r"""
+    ## Key Takeaways
 
-        Expectation gives us a single value that summarizes a random variable's central tendency - it's the weighted average of all possible outcomes, where the weights are probabilities. The linearity property makes expectations easy to work with, even for complex combinations of random variables. While a PMF gives the complete probability picture, expectation provides an essential summary that helps us make decisions under uncertainty. In our next notebook, we'll explore variance, which measures how spread out a random variable's values are around its expectation.
-        """
-    )
+    Expectation gives us a single value that summarizes a random variable's central tendency - it's the weighted average of all possible outcomes, where the weights are probabilities. The linearity property makes expectations easy to work with, even for complex combinations of random variables. While a PMF gives the complete probability picture, expectation provides an essential summary that helps us make decisions under uncertainty. In our next notebook, we'll explore variance, which measures how spread out a random variable's values are around its expectation.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""#### Appendix (containing helper code)""")
+    mo.md(r"""
+    #### Appendix (containing helper code)
+    """)
     return
 
 
@@ -736,7 +660,7 @@ def _():
     import numpy as np
     from scipy import stats
     import collections
-    return collections, np, plt, stats
+    return np, plt, stats
 
 
 @app.cell(hide_code=True)

probability/12_variance.py

@@ -11,77 +11,69 @@
 
 import marimo
 
-__generated_with = "0.11.20"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Variance")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Variance
+    mo.md(r"""
+    # Variance
 
-        _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/variance/), by Stanford professor Chris Piech._
+    _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/variance/), by Stanford professor Chris Piech._
 
-        In our previous exploration of random variables, we learned about expectation - a measure of central tendency. However, knowing the average value alone doesn't tell us everything about a distribution. Consider these questions:
+    In our previous exploration of random variables, we learned about expectation - a measure of central tendency. However, knowing the average value alone doesn't tell us everything about a distribution. Consider these questions:
 
-        - How spread out are the values around the mean?
-        - How reliable is the expectation as a predictor of individual outcomes?
-        - How much do individual samples typically deviate from the average?
+    - How spread out are the values around the mean?
+    - How reliable is the expectation as a predictor of individual outcomes?
+    - How much do individual samples typically deviate from the average?
 
-        This is where **variance** comes in - it measures the spread or dispersion of a random variable around its expected value.
-        """
-    )
+    This is where **variance** comes in - it measures the spread or dispersion of a random variable around its expected value.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Definition of Variance
+    mo.md(r"""
+    ## Definition of Variance
 
-        The variance of a random variable $X$ with expected value $\mu = E[X]$ is defined as:
+    The variance of a random variable $X$ with expected value $\mu = E[X]$ is defined as:
 
-        $$\text{Var}(X) = E[(X-\mu)^2]$$
+    $$\text{Var}(X) = E[(X-\mu)^2]$$
 
-        This definition captures the average squared deviation from the mean. There's also an equivalent, often more convenient formula:
+    This definition captures the average squared deviation from the mean. There's also an equivalent, often more convenient formula:
 
-        $$\text{Var}(X) = E[X^2] - (E[X])^2$$
+    $$\text{Var}(X) = E[X^2] - (E[X])^2$$
 
-        /// tip
-        The second formula is usually easier to compute, as it only requires calculating $E[X^2]$ and $E[X]$, rather than working with deviations from the mean.
-        """
-    )
+    /// tip
+    The second formula is usually easier to compute, as it only requires calculating $E[X^2]$ and $E[X]$, rather than working with deviations from the mean.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Intuition Through Example
+    mo.md(r"""
+    ## Intuition Through Example
 
-        Let's look at a real-world example that illustrates why variance is important. Consider three different groups of graders evaluating assignments in a massive online course. Each grader has their own "grading distribution" - their pattern of assigning scores to work that deserves a 70/100.
+    Let's look at a real-world example that illustrates why variance is important. Consider three different groups of graders evaluating assignments in a massive online course. Each grader has their own "grading distribution" - their pattern of assigning scores to work that deserves a 70/100.
 
-        The visualization below shows the probability distributions for three types of graders. Try clicking and dragging the blue numbers to adjust the parameters and see how they affect the variance.
-        """
-    )
+    The visualization below shows the probability distributions for three types of graders. Try clicking and dragging the blue numbers to adjust the parameters and see how they affect the variance.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// TIP
-        Try adjusting the blue numbers above to see how:
-
-        - Increasing spread increases variance
-        - The mixture ratio affects how many outliers appear in Grader C's distribution
-        - Changing the true grade shifts all distributions but maintains their relative variances
-        """
-    )
+    mo.md(r"""
+    /// TIP
+    Try adjusting the blue numbers above to see how:
+
+    - Increasing spread increases variance
+    - The mixture ratio affects how many outliers appear in Grader C's distribution
+    - Changing the true grade shifts all distributions but maintains their relative variances
+    """)
     return
 
 
@@ -165,50 +157,35 @@ def _(
 
     plt.tight_layout()
     plt.gca()
-    return (
-        ax1,
-        ax2,
-        ax3,
-        grader_a,
-        grader_b,
-        grader_c,
-        grader_fig,
-        var_a,
-        var_b,
-        var_c,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// note
-        All three distributions have the same expected value (the true grade), but they differ significantly in their spread:
-
-        - **Grader A** has high variance - grades vary widely from the true value
-        - **Grader B** has low variance - grades consistently stay close to the true value
-        - **Grader C** has a mixture distribution - mostly consistent but with occasional extreme values
-
-        This illustrates why variance is crucial: two distributions can have the same mean but behave very differently in practice.
-        """
-    )
+    mo.md(r"""
+    /// note
+    All three distributions have the same expected value (the true grade), but they differ significantly in their spread:
+
+    - **Grader A** has high variance - grades vary widely from the true value
+    - **Grader B** has low variance - grades consistently stay close to the true value
+    - **Grader C** has a mixture distribution - mostly consistent but with occasional extreme values
+
+    This illustrates why variance is crucial: two distributions can have the same mean but behave very differently in practice.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Computing Variance
+    mo.md(r"""
+    ## Computing Variance
 
-        Let's work through some concrete examples to understand how to calculate variance.
+    Let's work through some concrete examples to understand how to calculate variance.
 
-        ### Example 1: Fair Die Roll
+    ### Example 1: Fair Die Roll
 
-        Consider rolling a fair six-sided die. We'll calculate its variance step by step:
-        """
-    )
+    Consider rolling a fair six-sided die. We'll calculate its variance step by step:
+    """)
     return
 
 
@@ -234,75 +211,62 @@ def _(np):
     print(f"E[X^2] = {expected_square:.2f}")
     print(f"Var(X) = {variance:.2f}")
     print(f"Standard Deviation = {std_dev:.2f}")
-    return (
-        die_probs,
-        die_values,
-        expected_square,
-        expected_value,
-        std_dev,
-        variance,
-    )
+    return die_probs, die_values
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// NOTE
-        For a fair die:
-
-        - The expected value (3.50) tells us the average roll
-        - The variance (2.92) tells us how much typical rolls deviate from this average
-        - The standard deviation (1.71) gives us this spread in the original units
-        """
-    )
+    mo.md(r"""
+    /// NOTE
+    For a fair die:
+
+    - The expected value (3.50) tells us the average roll
+    - The variance (2.92) tells us how much typical rolls deviate from this average
+    - The standard deviation (1.71) gives us this spread in the original units
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Properties of Variance
+    mo.md(r"""
+    ## Properties of Variance
 
-        Variance has several important properties that make it useful for analyzing random variables:
+    Variance has several important properties that make it useful for analyzing random variables:
 
-        1. **Non-negativity**: $\text{Var}(X) \geq 0$ for any random variable $X$
-        2. **Variance of a constant**: $\text{Var}(c) = 0$ for any constant $c$
-        3. **Scaling**: $\text{Var}(aX) = a^2\text{Var}(X)$ for any constant $a$
-        4. **Translation**: $\text{Var}(X + b) = \text{Var}(X)$ for any constant $b$
-        5. **Independence**: If $X$ and $Y$ are independent, then $\text{Var}(X + Y) = \text{Var}(X) + \text{Var}(Y)$
+    1. **Non-negativity**: $\text{Var}(X) \geq 0$ for any random variable $X$
+    2. **Variance of a constant**: $\text{Var}(c) = 0$ for any constant $c$
+    3. **Scaling**: $\text{Var}(aX) = a^2\text{Var}(X)$ for any constant $a$
+    4. **Translation**: $\text{Var}(X + b) = \text{Var}(X)$ for any constant $b$
+    5. **Independence**: If $X$ and $Y$ are independent, then $\text{Var}(X + Y) = \text{Var}(X) + \text{Var}(Y)$
 
-        Let's verify a property with an example.
-        """
-    )
+    Let's verify a property with an example.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Proof of Variance Formula
-
-        The equivalence of the two variance formulas is a fundamental result in probability theory. Here's the proof:
-
-        Starting with the definition $\text{Var}(X) = E[(X-\mu)^2]$ where $\mu = E[X]$:
-
-        \begin{align}
-        \text{Var}(X) &= E[(X-\mu)^2] \\
-        &= \sum_x(x-\mu)^2P(x) && \text{Definition of Expectation}\\
-        &= \sum_x (x^2 -2\mu x + \mu^2)P(x) && \text{Expanding the square}\\
-        &= \sum_x x^2P(x)- 2\mu \sum_x xP(x) + \mu^2 \sum_x P(x) && \text{Distributing the sum}\\
-        &= E[X^2]- 2\mu E[X] + \mu^2 && \text{Definition of expectation}\\
-        &= E[X^2]- 2(E[X])^2 + (E[X])^2 && \text{Since }\mu = E[X]\\
-        &= E[X^2]- (E[X])^2 && \text{Simplifying}
-        \end{align}
-
-        /// tip
-        This proof shows why the formula $\text{Var}(X) = E[X^2] - (E[X])^2$ is so useful - it's much easier to compute $E[X^2]$ and $E[X]$ separately than to work with deviations directly.
-        """
-    )
+    mo.md(r"""
+    ## Proof of Variance Formula
+
+    The equivalence of the two variance formulas is a fundamental result in probability theory. Here's the proof:
+
+    Starting with the definition $\text{Var}(X) = E[(X-\mu)^2]$ where $\mu = E[X]$:
+
+    \begin{align}
+    \text{Var}(X) &= E[(X-\mu)^2] \\
+    &= \sum_x(x-\mu)^2P(x) && \text{Definition of Expectation}\\
+    &= \sum_x (x^2 -2\mu x + \mu^2)P(x) && \text{Expanding the square}\\
+    &= \sum_x x^2P(x)- 2\mu \sum_x xP(x) + \mu^2 \sum_x P(x) && \text{Distributing the sum}\\
+    &= E[X^2]- 2\mu E[X] + \mu^2 && \text{Definition of expectation}\\
+    &= E[X^2]- 2(E[X])^2 + (E[X])^2 && \text{Since }\mu = E[X]\\
+    &= E[X^2]- (E[X])^2 && \text{Simplifying}
+    \end{align}
+
+    /// tip
+    This proof shows why the formula $\text{Var}(X) = E[X^2] - (E[X])^2$ is so useful - it's much easier to compute $E[X^2]$ and $E[X]$ separately than to work with deviations directly.
+    """)
     return
 
 
@@ -322,7 +286,7 @@ def _(die_probs, die_values, np):
     print(f"Scaled Variance (a={a}): {scaled_var:.2f}")
     print(f"a^2 * Original Variance: {a**2 * original_var:.2f}")
     print(f"Property holds: {abs(scaled_var - a**2 * original_var) < 1e-10}")
-    return a, original_var, scaled_values, scaled_var
+    return
 
 
 @app.cell
@@ -333,23 +297,21 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Standard Deviation
+    mo.md(r"""
+    ## Standard Deviation
 
-        While variance is mathematically convenient, it has one practical drawback: its units are squared. For example, if we're measuring grades (0-100), the variance is in "grade points squared." This makes it hard to interpret intuitively.
+    While variance is mathematically convenient, it has one practical drawback: its units are squared. For example, if we're measuring grades (0-100), the variance is in "grade points squared." This makes it hard to interpret intuitively.
 
-        The **standard deviation**, denoted by $\sigma$ or $\text{SD}(X)$, is the square root of variance:
+    The **standard deviation**, denoted by $\sigma$ or $\text{SD}(X)$, is the square root of variance:
 
-        $$\sigma = \sqrt{\text{Var}(X)}$$
+    $$\sigma = \sqrt{\text{Var}(X)}$$
 
-        /// tip
-        Standard deviation is often more intuitive because it's in the same units as the original data. For a normal distribution, approximately:
-        - 68% of values fall within 1 standard deviation of the mean
-        - 95% of values fall within 2 standard deviations
-        - 99.7% of values fall within 3 standard deviations
-        """
-    )
+    /// tip
+    Standard deviation is often more intuitive because it's in the same units as the original data. For a normal distribution, approximately:
+    - 68% of values fall within 1 standard deviation of the mean
+    - 95% of values fall within 2 standard deviations
+    - 99.7% of values fall within 3 standard deviations
+    """)
     return
 
 
@@ -452,93 +414,80 @@ def _(normal_mean, normal_std, np, plt, stats):
 
     plt.tight_layout()
     plt.gca()
-    return (
-        normal_ax,
-        normal_fig,
-        one_sigma_left,
-        one_sigma_right,
-        three_sigma_left,
-        three_sigma_right,
-        two_sigma_left,
-        two_sigma_right,
-    )
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        /// tip
-        The interactive visualization above demonstrates how standard deviation (σ) affects the shape of a normal distribution:
-
-        - The **red region** covers μ ± 1σ, containing approximately 68% of the probability
-        - The **green region** covers μ ± 2σ, containing approximately 95% of the probability
-        - The **blue region** covers μ ± 3σ, containing approximately 99.7% of the probability
-
-        This is known as the "68-95-99.7 rule" or the "empirical rule" and is a useful heuristic for understanding the spread of data.
-        """
-    )
+    mo.md(r"""
+    /// tip
+    The interactive visualization above demonstrates how standard deviation (σ) affects the shape of a normal distribution:
+
+    - The **red region** covers μ ± 1σ, containing approximately 68% of the probability
+    - The **green region** covers μ ± 2σ, containing approximately 95% of the probability
+    - The **blue region** covers μ ± 3σ, containing approximately 99.7% of the probability
+
+    This is known as the "68-95-99.7 rule" or the "empirical rule" and is a useful heuristic for understanding the spread of data.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
-
-        Choose what you believe are the correct options in the questions below:
-
-        <details>
-        <summary>The variance of a random variable can be negative.</summary>
-        ❌ False! Variance is defined as an expected value of squared deviations, and squares are always non-negative.
-        </details>
-
-        <details>
-        <summary>If X and Y are independent random variables, then Var(X + Y) = Var(X) + Var(Y).</summary>
-        ✅ True! This is one of the key properties of variance for independent random variables.
-        </details>
-
-        <details>
-        <summary>Multiplying a random variable by 2 multiplies its variance by 2.</summary>
-        ❌ False! Multiplying a random variable by a constant a multiplies its variance by a². So multiplying by 2 multiplies variance by 4.
-        </details>
-
-        <details>
-        <summary>Standard deviation is always equal to the square root of variance.</summary>
-        ✅ True! By definition, standard deviation σ = √Var(X).
-        </details>
-
-        <details>
-        <summary>If Var(X) = 0, then X must be a constant.</summary>
-        ✅ True! Zero variance means there is no spread around the mean, so X can only take one value.
-        </details>
-        """
-    )
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
+
+    Choose what you believe are the correct options in the questions below:
+
+    <details>
+    <summary>The variance of a random variable can be negative.</summary>
+    ❌ False! Variance is defined as an expected value of squared deviations, and squares are always non-negative.
+    </details>
+
+    <details>
+    <summary>If X and Y are independent random variables, then Var(X + Y) = Var(X) + Var(Y).</summary>
+    ✅ True! This is one of the key properties of variance for independent random variables.
+    </details>
+
+    <details>
+    <summary>Multiplying a random variable by 2 multiplies its variance by 2.</summary>
+    ❌ False! Multiplying a random variable by a constant a multiplies its variance by a². So multiplying by 2 multiplies variance by 4.
+    </details>
+
+    <details>
+    <summary>Standard deviation is always equal to the square root of variance.</summary>
+    ✅ True! By definition, standard deviation σ = √Var(X).
+    </details>
+
+    <details>
+    <summary>If Var(X) = 0, then X must be a constant.</summary>
+    ✅ True! Zero variance means there is no spread around the mean, so X can only take one value.
+    </details>
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Key Takeaways
+    mo.md(r"""
+    ## Key Takeaways
 
-        Variance gives us a way to measure how spread out a random variable is around its mean. It's like the "uncertainty" in our expectation - a high variance means individual outcomes can differ widely from what we expect on average.
+    Variance gives us a way to measure how spread out a random variable is around its mean. It's like the "uncertainty" in our expectation - a high variance means individual outcomes can differ widely from what we expect on average.
 
-        Standard deviation brings this measure back to the original units, making it easier to interpret. For grades, a standard deviation of 10 points means typical grades fall within about 10 points of the average.
+    Standard deviation brings this measure back to the original units, making it easier to interpret. For grades, a standard deviation of 10 points means typical grades fall within about 10 points of the average.
 
-        Variance pops up everywhere - from weather forecasts (how reliable is the predicted temperature?) to financial investments (how risky is this stock?) to quality control (how consistent is our manufacturing process?).
+    Variance pops up everywhere - from weather forecasts (how reliable is the predicted temperature?) to financial investments (how risky is this stock?) to quality control (how consistent is our manufacturing process?).
 
-        In our next notebook, we'll explore more properties of random variables and see how they combine to form more complex distributions.
-        """
-    )
+    In our next notebook, we'll explore more properties of random variables and see how they combine to form more complex distributions.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""Appendix (containing helper code):""")
+    mo.md(r"""
+    Appendix (containing helper code):
+    """)
     return
 
 

probability/13_bernoulli_distribution.py

@@ -10,60 +10,54 @@
 
 import marimo
 
-__generated_with = "0.12.6"
+__generated_with = "0.18.4"
 app = marimo.App(width="medium", app_title="Bernoulli Distribution")
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        # Bernoulli Distribution
+    mo.md(r"""
+    # Bernoulli Distribution
 
-        > _Note:_ This notebook builds on concepts from ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/bernoulli/) by Chris Piech.
+    > _Note:_ This notebook builds on concepts from ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/bernoulli/) by Chris Piech.
 
-        ## Parametric Random Variables
+    ## Parametric Random Variables
 
-        Probability has a bunch of classic random variable patterns that show up over and over. Let's explore some of the most important parametric discrete distributions.
+    Probability has a bunch of classic random variable patterns that show up over and over. Let's explore some of the most important parametric discrete distributions.
 
-        Bernoulli is honestly the simplest distribution you'll ever see, but it's ridiculously powerful in practice. What makes it fascinating to me is how it captures any yes/no scenario: success/failure, heads/tails, 1/0.
+    Bernoulli is honestly the simplest distribution you'll ever see, but it's ridiculously powerful in practice. What makes it fascinating to me is how it captures any yes/no scenario: success/failure, heads/tails, 1/0.
 
-        I think of these distributions as the atoms of probability — they're the fundamental building blocks that everything else is made from.
-        """
-    )
+    I think of these distributions as the atoms of probability — they're the fundamental building blocks that everything else is made from.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Bernoulli Random Variables
+    mo.md(r"""
+    ## Bernoulli Random Variables
 
-        A Bernoulli random variable boils down to just two possible values: 1 (success) or 0 (failure). dead simple, but incredibly useful.
+    A Bernoulli random variable boils down to just two possible values: 1 (success) or 0 (failure). dead simple, but incredibly useful.
 
-        Some everyday examples where I see these:
+    Some everyday examples where I see these:
 
-        - Coin flip (heads=1, tails=0)
-        - Whether that sketchy email is spam  
-        - If someone actually clicks my ad
-        - Whether my code compiles first try (almost always 0 for me)
+    - Coin flip (heads=1, tails=0)
+    - Whether that sketchy email is spam
+    - If someone actually clicks my ad
+    - Whether my code compiles first try (almost always 0 for me)
 
-        All you need (the classic expression) is a single parameter $p$ - the probability of success.
-        """
-    )
+    All you need (the classic expression) is a single parameter $p$ - the probability of success.
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Key Properties of a Bernoulli Random Variable
+    mo.md(r"""
+    ## Key Properties of a Bernoulli Random Variable
 
-        If $X$ is declared to be a Bernoulli random variable with parameter $p$, denoted $X \sim \text{Bern}(p)$, it has the following properties:
-        """
-    )
+    If $X$ is declared to be a Bernoulli random variable with parameter $p$, denoted $X \sim \text{Bern}(p)$, it has the following properties:
+    """)
     return
 
 
@@ -72,31 +66,29 @@ def _(stats):
     # Define the Bernoulli distribution function
     def Bern(p):
         return stats.bernoulli(p)
-    return (Bern,)
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Bernoulli Distribution Properties
-
-        $\begin{array}{lll}
-        \text{Notation:} & X \sim \text{Bern}(p) \\
-        \text{Description:} & \text{A boolean variable that is 1 with probability } p \\
-        \text{Parameters:} & p, \text{ the probability that } X = 1 \\
-        \text{Support:} & x \text{ is either 0 or 1} \\
-        \text{PMF equation:} & P(X = x) = 
-            \begin{cases}
-                p & \text{if }x = 1\\
-                1-p & \text{if }x = 0
-            \end{cases} \\
-        \text{PMF (smooth):} & P(X = x) = p^x(1-p)^{1-x} \\
-        \text{Expectation:} & E[X] = p \\
-        \text{Variance:} & \text{Var}(X) = p(1-p) \\
-        \end{array}$
-        """
-    )
+    mo.md(r"""
+    ## Bernoulli Distribution Properties
+
+    $\begin{array}{lll}
+    \text{Notation:} & X \sim \text{Bern}(p) \\
+    \text{Description:} & \text{A boolean variable that is 1 with probability } p \\
+    \text{Parameters:} & p, \text{ the probability that } X = 1 \\
+    \text{Support:} & x \text{ is either 0 or 1} \\
+    \text{PMF equation:} & P(X = x) =
+        \begin{cases}
+            p & \text{if }x = 1\\
+            1-p & \text{if }x = 0
+        \end{cases} \\
+    \text{PMF (smooth):} & P(X = x) = p^x(1-p)^{1-x} \\
+    \text{Expectation:} & E[X] = p \\
+    \text{Variance:} & \text{Var}(X) = p(1-p) \\
+    \end{array}$
+    """)
     return
 
 
@@ -158,62 +150,58 @@ def _(expected_value, p_slider, plt, probabilities, values, variance):
     ax.legend()
     plt.tight_layout()
     plt.gca()
-    return ax, fig
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Expectation and Variance of a Bernoulli
-
-        > _Note:_ The following derivations are included as reference material. The credit for these mathematical formulations belongs to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/bernoulli/) by Chris Piech.
-
-        Let's work through why $E[X] = p$ for a Bernoulli:
-
-        \begin{align}
-        E[X] &= \sum_x x \cdot (X=x) && \text{Definition of expectation} \\
-        &= 1 \cdot p + 0 \cdot (1-p) &&
-        X \text{ can take on values 0 and 1} \\
-        &= p && \text{Remove the 0 term}
-        \end{align}
-
-        And for variance, we first need $E[X^2]$:
-
-        \begin{align}
-        E[X^2]
-        &= \sum_x x^2 \cdot (X=x) &&\text{LOTUS}\\
-        &= 0^2 \cdot (1-p) + 1^2 \cdot p\\
-        &= p
-        \end{align}
-
-        \begin{align}
-        (X)
-        &= E[X^2] - E[X]^2&& \text{Def of variance} \\
-        &= p - p^2 && \text{Substitute }E[X^2]=p, E[X] = p \\
-        &= p (1-p) && \text{Factor out }p
-        \end{align}
-        """
-    )
+    mo.md(r"""
+    ## Expectation and Variance of a Bernoulli
+
+    > _Note:_ The following derivations are included as reference material. The credit for these mathematical formulations belongs to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/bernoulli/) by Chris Piech.
+
+    Let's work through why $E[X] = p$ for a Bernoulli:
+
+    \begin{align}
+    E[X] &= \sum_x x \cdot (X=x) && \text{Definition of expectation} \\
+    &= 1 \cdot p + 0 \cdot (1-p) &&
+    X \text{ can take on values 0 and 1} \\
+    &= p && \text{Remove the 0 term}
+    \end{align}
+
+    And for variance, we first need $E[X^2]$:
+
+    \begin{align}
+    E[X^2]
+    &= \sum_x x^2 \cdot (X=x) &&\text{LOTUS}\\
+    &= 0^2 \cdot (1-p) + 1^2 \cdot p\\
+    &= p
+    \end{align}
+
+    \begin{align}
+    (X)
+    &= E[X^2] - E[X]^2&& \text{Def of variance} \\
+    &= p - p^2 && \text{Substitute }E[X^2]=p, E[X] = p \\
+    &= p (1-p) && \text{Factor out }p
+    \end{align}
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Indicator Random Variables
+    mo.md(r"""
+    ## Indicator Random Variables
 
-        Indicator variables are a clever trick I like to use — they turn events into numbers. Instead of dealing with "did the event happen?" (yes/no), we get "1" if it happened and "0" if it didn't.
+    Indicator variables are a clever trick I like to use — they turn events into numbers. Instead of dealing with "did the event happen?" (yes/no), we get "1" if it happened and "0" if it didn't.
 
-        Formally: an indicator variable $I$ for event $A$ equals 1 when $A$ occurs and 0 otherwise. These are just bernoulli variables where $p = P(A)$. people often use notation like $I_A$ to name them.
+    Formally: an indicator variable $I$ for event $A$ equals 1 when $A$ occurs and 0 otherwise. These are just bernoulli variables where $p = P(A)$. people often use notation like $I_A$ to name them.
 
-        Two key properties that make them super useful:
+    Two key properties that make them super useful:
 
-        - $P(I=1)=P(A)$ - probability of getting a 1 is just the probability of the event
-        - $E[I]=P(A)$ - the expected value equals the probability (this one's a game-changer!)
-        """
-    )
+    - $P(I=1)=P(A)$ - probability of getting a 1 is just the probability of the event
+    - $E[I]=P(A)$ - the expected value equals the probability (this one's a game-changer!)
+    """)
     return
 
 
@@ -234,7 +222,9 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Simulation""")
+    mo.md(r"""
+    ## Simulation
+    """)
     return
 
 
@@ -276,7 +266,7 @@ def _(np, num_trials_slider, p_sim_slider, plt):
 
     plt.tight_layout()
     plt.gca()
-    return cumulative_mean, p, trials
+    return (trials,)
 
 
 @app.cell(hide_code=True)
@@ -296,88 +286,84 @@ def _(mo, np, trials):
 
     This demonstrates how the sample proportion approaches the true probability $p$ as the number of trials increases.
     """)
-    return num_successes, num_trials, proportion
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## 🤔 Test Your Understanding
+    mo.md(r"""
+    ## 🤔 Test Your Understanding
 
-        Pick which of these statements about Bernoulli random variables you think are correct:
+    Pick which of these statements about Bernoulli random variables you think are correct:
 
-        /// details | The variance of a Bernoulli random variable is always less than or equal to 0.25
-        ✅ Correct! The variance $p(1-p)$ reaches its maximum value of 0.25 when $p = 0.5$.
-        ///
+    /// details | The variance of a Bernoulli random variable is always less than or equal to 0.25
+    ✅ Correct! The variance $p(1-p)$ reaches its maximum value of 0.25 when $p = 0.5$.
+    ///
 
-        /// details | The expected value of a Bernoulli random variable must be either 0 or 1
-        ❌ Incorrect! The expected value is $p$, which can be any value between 0 and 1.
-        ///
+    /// details | The expected value of a Bernoulli random variable must be either 0 or 1
+    ❌ Incorrect! The expected value is $p$, which can be any value between 0 and 1.
+    ///
 
-        /// details | If $X \sim \text{Bern}(0.3)$ and $Y \sim \text{Bern}(0.7)$, then $X$ and $Y$ have the same variance
-        ✅ Correct! $\text{Var}(X) = 0.3 \times 0.7 = 0.21$ and $\text{Var}(Y) = 0.7 \times 0.3 = 0.21$.
-        ///
+    /// details | If $X \sim \text{Bern}(0.3)$ and $Y \sim \text{Bern}(0.7)$, then $X$ and $Y$ have the same variance
+    ✅ Correct! $\text{Var}(X) = 0.3 \times 0.7 = 0.21$ and $\text{Var}(Y) = 0.7 \times 0.3 = 0.21$.
+    ///
 
-        /// details | Two independent coin flips can be modeled as the sum of two Bernoulli random variables
-        ✅ Correct! The sum would follow a Binomial distribution with $n=2$.
-        ///
-        """
-    )
+    /// details | Two independent coin flips can be modeled as the sum of two Bernoulli random variables
+    ✅ Correct! The sum would follow a Binomial distribution with $n=2$.
+    ///
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Applications of Bernoulli Random Variables
+    mo.md(r"""
+    ## Applications of Bernoulli Random Variables
 
-        Bernoulli random variables are used in many real-world scenarios:
+    Bernoulli random variables are used in many real-world scenarios:
 
-        1. **Quality Control**: Testing if a manufactured item is defective (1) or not (0)
+    1. **Quality Control**: Testing if a manufactured item is defective (1) or not (0)
 
-        2. **A/B Testing**: Determining if a user clicks (1) or doesn't click (0) on a website button
+    2. **A/B Testing**: Determining if a user clicks (1) or doesn't click (0) on a website button
 
-        3. **Medical Testing**: Checking if a patient tests positive (1) or negative (0) for a disease
+    3. **Medical Testing**: Checking if a patient tests positive (1) or negative (0) for a disease
 
-        4. **Election Modeling**: Modeling if a particular voter votes for candidate A (1) or not (0)
+    4. **Election Modeling**: Modeling if a particular voter votes for candidate A (1) or not (0)
 
-        5. **Financial Markets**: Modeling if a stock price goes up (1) or down (0) in a simplified model
+    5. **Financial Markets**: Modeling if a stock price goes up (1) or down (0) in a simplified model
 
-        Because Bernoulli random variables are parametric, as soon as you declare a random variable to be of type Bernoulli, you automatically know all of its pre-derived properties!
-        """
-    )
+    Because Bernoulli random variables are parametric, as soon as you declare a random variable to be of type Bernoulli, you automatically know all of its pre-derived properties!
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        r"""
-        ## Summary
+    mo.md(r"""
+    ## Summary
 
-        And that's a wrap on Bernoulli distributions! We've learnt the simplest of all probability distributions — the one that only has two possible outcomes. Flip a coin, check if an email is spam, see if your blind date shows up — these are all Bernoulli trials with success probability $p$. 
+    And that's a wrap on Bernoulli distributions! We've learnt the simplest of all probability distributions — the one that only has two possible outcomes. Flip a coin, check if an email is spam, see if your blind date shows up — these are all Bernoulli trials with success probability $p$.
 
-        The beauty of Bernoulli is in its simplicity: just set $p$ (the probability of success) and you're good to go! The PMF gives us $P(X=1) = p$ and $P(X=0) = 1-p$, while expectation is simply $p$ and variance is $p(1-p)$. Oh, and when you're tracking whether specific events happen or not? That's an indicator random variable — just another Bernoulli in disguise!
+    The beauty of Bernoulli is in its simplicity: just set $p$ (the probability of success) and you're good to go! The PMF gives us $P(X=1) = p$ and $P(X=0) = 1-p$, while expectation is simply $p$ and variance is $p(1-p)$. Oh, and when you're tracking whether specific events happen or not? That's an indicator random variable — just another Bernoulli in disguise!
 
-        Two key things to remember:
+    Two key things to remember:
 
-        /// note
-        💡 **Maximum Variance**: A Bernoulli's variance $p(1-p)$ reaches its maximum at $p=0.5$, making a fair coin the most "unpredictable" Bernoulli random variable.
+    /// note
+    💡 **Maximum Variance**: A Bernoulli's variance $p(1-p)$ reaches its maximum at $p=0.5$, making a fair coin the most "unpredictable" Bernoulli random variable.
 
-        💡 **Instant Properties**: When you identify a random variable as Bernoulli, you instantly know all its properties—expectation, variance, PMF—without additional calculations.
-        ///
+    💡 **Instant Properties**: When you identify a random variable as Bernoulli, you instantly know all its properties—expectation, variance, PMF—without additional calculations.
+    ///
 
-        Next up: Binomial distribution—where we'll see what happens when we let Bernoulli trials have a party and add themselves together!
-        """
-    )
+    Next up: Binomial distribution—where we'll see what happens when we let Bernoulli trials have a party and add themselves together!
+    """)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""#### Appendix (containing helper code for the notebook)""")
+    mo.md(r"""
+    #### Appendix (containing helper code for the notebook)
+    """)
     return
 
 
@@ -390,7 +376,7 @@ def _():
 @app.cell(hide_code=True)
 def _():
     from marimo import Html
-    return (Html,)
+    return
 
 
 @app.cell(hide_code=True)
@@ -407,7 +393,7 @@ def _():
 
     # Set random seed for reproducibility
     np.random.seed(42)
-    return math, np, plt, stats
+    return np, plt, stats
 
 
 @app.cell(hide_code=True)