Update app.py

app.py

@@ -1,470 +1,309 @@
 import marimo
 
-__generated_with = "0.9.2"
-app = marimo.App()
+__generated_with = "0.11.5"
+app = marimo.App(width="medium")
 
 
-@app.cell
-def __():
-    import marimo as mo
-
-    mo.md("# Welcome to marimo! 🌊🍃")
-    return (mo,)
-
-
-@app.cell
-def __(mo):
-    slider = mo.ui.slider(1, 22)
-    return (slider,)
-
-
-@app.cell
-def __(mo, slider):
+@app.cell(hide_code=True)
+def _(mo):
     mo.md(
-        f"""
-        marimo is a **reactive** Python notebook.
-
-        This means that unlike traditional notebooks, marimo notebooks **run
-        automatically** when you modify them or
-        interact with UI elements, like this slider: {slider}.
-
-        {"##" + "🍃" * slider.value}
+        r"""
+        # Generate random flat quantum permutation matrices
+        #
         """
     )
     return
 
 
 @app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: disabling automatic execution": mo.md(
-                rf"""
-            marimo lets you disable automatic execution: just go into the
-            notebook settings and set
-
-            "Runtime > On Cell Change" to "lazy".
-
-            When the runtime is lazy, after running a cell, marimo marks its
-            descendants as stale instead of automatically running them. The
-            lazy runtime puts you in control over when cells are run, while
-            still giving guarantees about the notebook state.
-            """
-            )
-        }
-    )
-    return
+def _(mo):
+    mo.md(
+        r"""
+        Let $A$ be a unital $C^*$-algebra. An $n \times n$ matrix $u = (u_{ij})_{1\le i,j\le n} \in \mathcal M_n(A)$
+        is called a **quantum permtuation matrix** if it satisfies the conditions below:
 
+        1. *Projection Entries:* Each entry is a projection:
+           $$u_{ij}^2 = u_{ij} \quad \text{and} \quad u_{ij}^* = u_{ij} \quad \text{for all } i,j.$$
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        Tip: This is a tutorial notebook. You can create your own notebooks
-        by entering `marimo edit` at the command line.
+        2. *Row and Column Sums:* The entries in each row and each column sum to the unit of $A$:
+        $$\sum_{j=1}^n u_{ij} = 1_A \quad \text{for all } i=1,\dots,n,$$
+        $$\sum_{i=1}^n u_{ij} = 1_A \quad \text{for all } j=1,\dots,n.$$
         """
-    ).callout()
+    )
     return
 
 
 @app.cell(hide_code=True)
-def __(mo):
+def _(mo):
     mo.md(
         """
-        ## 1. Reactive execution
+        We are interested here in the special case where: 
 
-        A marimo notebook is made up of small blocks of Python code called
-        cells.
-
-        marimo reads your cells and models the dependencies among them: whenever
-        a cell that defines a global variable  is run, marimo
-        **automatically runs** all cells that reference that variable.
-
-        Reactivity keeps your program state and outputs in sync with your code,
-        making for a dynamic programming environment that prevents bugs before they
-        happen.
+        1. the algebra $A$ is finite dimensional: $A = \mathcal M_d(\mathbb C)$
+        2. the projections $u_{ij}$ have *unit rank* (we call $u$ *flat*); in particular $d=n$.
         """
     )
     return
 
 
-@app.cell(hide_code=True)
-def __(changed, mo):
-    (
-        mo.md(
-            f"""
-            **✨ Nice!** The value of `changed` is now {changed}.
-
-            When you updated the value of the variable `changed`, marimo
-            **reacted** by running this cell automatically, because this cell
-            references the global variable `changed`.
-
-            Reactivity ensures that your notebook state is always
-            consistent, which is crucial for doing good science; it's also what
-            enables marimo notebooks to double as tools and  apps.
-            """
-        )
-        if changed
-        else mo.md(
-            """
-            **🌊 See it in action.** In the next cell, change the value of the
-            variable  `changed` to `True`, then click the run button.
-            """
-        )
-    )
-    return
-
-
 @app.cell
-def __():
-    changed = False
-    return (changed,)
-
-
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: execution order": (
-                """
-                The order of cells on the page has no bearing on
-                the order in which cells are executed: marimo knows that a cell
-                reading a variable must run after the cell that  defines it. This
-                frees you to organize your code in the way that makes the most
-                sense for you.
-                """
-            )
-        }
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def __(mo):
+def _(mo):
     mo.md(
         """
-        **Global names must be unique.** To enable reactivity, marimo imposes a
-        constraint on how names appear in cells: no two cells may define the same
-        variable.
+        ## An alogrithm for generating random flat quantum permutation matrices
+        ##
         """
     )
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: encapsulation": (
-                """
-                By encapsulating logic in functions, classes, or Python modules,
-                you can minimize the number of global variables in your notebook.
-                """
-            )
-        }
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        We propose the following very simple algorithm for generating quantum permutation matrices, based on normalizing the rows and the columns of a matrix of unit rank projections. The alternating normalization of rows and columns is inspired by the **Sinkhorn algorithm** for producing random bistochastic matrices. 
+
+        1. Start from a random matrix: $u_{ij}$ is the orthogonal projection on a random gaussian vector
+        2. While the error is larger than some predefined constant and the maximal number of steps has not been attained:
+        3. Normalize each row of $u$
+        4. Normalize each column of $u$
+        5. End-while
+        6. Output the matrix $u$
+        """
     )
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.accordion(
-        {
-            "Tip: private variables": (
-                """
-                Variables prefixed with an underscore are "private" to a cell, so
-                they can be defined by multiple cells.
-                """
-            )
-        }
+@app.cell
+def _(mo):
+    mo.md(
+        r"""
+        The row (respectively the column) normalization procedures are performed as follows. Collect all the vectors appearing on the $i$-th row of $u$ in a matrix $R_i$. Replace $R_i$ by $\tilde R_i$, the *closest unitary matrix* to $R_i$. This matrix can be obtained from the *singular value decomposition* of $R_i$: 
+        $$\text{ if } R_i = V_i \Delta_i W_i^*, \, \text{ then }\, \tilde R_i = V_i W_i^*.$$
+        """
     )
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
+@app.cell
+def _(mo):
     mo.md(
         """
-        ## 2. UI elements
-
-        Cells can output interactive UI elements. Interacting with a UI
-        element **automatically triggers notebook execution**: when
-        you interact with a UI element, its value is sent back to Python, and
-        every cell that references that element is re-run.
-
-        marimo provides a library of UI elements to choose from under
-        `marimo.ui`.
+        ## Implementation
+        ##
         """
     )
     return
 
 
 @app.cell
-def __(mo):
-    mo.md("""**🌊 Some UI elements.** Try interacting with the below elements.""")
-    return
+def _(mo):
+    eps_slider =  mo.ui.slider(0, 10, value=6)
+    max_iter_slider =  mo.ui.slider(1, 10000, value=2000)
+    n_slider =  mo.ui.slider(2, 20, step=1, value=4)
+    return eps_slider, max_iter_slider, n_slider
 
 
 @app.cell
-def __(mo):
-    icon = mo.ui.dropdown(["🍃", "🌊", "✨"], value="🍃")
-    return (icon,)
+def _(eps_slider, mo):
+    mo.md(f"-lg(Error tolerance): {eps_slider} \t error_tolerance = 1e-{eps_slider.value}")
+    return
 
 
 @app.cell
-def __(icon, mo):
-    repetitions = mo.ui.slider(1, 16, label=f"number of {icon.value}: ")
-    return (repetitions,)
+def _(max_iter_slider, mo):
+    mo.md(f"Max iterations: {max_iter_slider} \t max_iter = {max_iter_slider.value}")
+    return
 
 
 @app.cell
-def __(icon, repetitions):
-    icon, repetitions
+def _(mo, n_slider):
+    mo.md(f"Matrix dimension: {n_slider} \t n = {n_slider.value}")
     return
 
 
 @app.cell
-def __(icon, mo, repetitions):
-    mo.md("# " + icon.value * repetitions.value)
-    return
+def _(mo):
+    button = mo.ui.run_button(label="Randomize!")
+    button
+    return (button,)
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 3. marimo is just Python
+@app.cell
+def _(errors, plt, scalar_products):
 
-        marimo cells parse Python (and only Python), and marimo notebooks are
-        stored as pure Python files — outputs are _not_ included. There's no
-        magical syntax.
 
-        The Python files generated by marimo are:
+    # Create a figure with two subplots side by side
+    fig, axs = plt.subplots(1, 2, figsize=(12, 5))
 
-        - easily versioned with git, yielding minimal diffs
-        - legible for both humans and machines
-        - formattable using your tool of choice,
-        - usable as Python  scripts, with UI  elements taking their default
-        values, and
-        - importable by other modules (more on that in the future).
-        """
-    )
-    return
+    # Plot the errors on a log scale in the first subplot
+    axs[0].semilogy(errors)
+    axs[0].set_xlabel('Iteration')
+    axs[0].set_ylabel('Error (log scale)')
+    axs[0].set_title('Error Convergence')
+    axs[0].grid(True)
 
+    # Plot the histogram in the second subplot
+    axs[1].hist(scalar_products, bins=30, edgecolor='black')
+    axs[1].set_xlabel('Absolute Values Squared of Scalar Products')
+    axs[1].set_ylabel('Frequency')
+    axs[1].set_title('Histogram of Absolute Values Squared of Scalar Products')
+    axs[1].grid(True)
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        ## 4. Running notebooks as apps
+    # Adjust layout to prevent overlap
+    plt.tight_layout()
+    plt.gca()
+    return axs, fig
 
-        marimo notebooks can double as apps. Click the app window icon in the
-        bottom-right to see this notebook in "app view."
 
-        Serve a notebook as an app with `marimo run` at the command-line.
-        Of course, you can use marimo just to level-up your
-        notebooking, without ever making apps.
-        """
-    )
+@app.cell
+def _(mo):
+    mo.md(r"""Note that for $n=2,3$ the histogram of scalar product shows only 0's and 1's: the vectors are either colinear or orthogonal. In other words, the elements $u_{ij}$ **commute**. For $n \geq 4$ this is no longer the case: the scalar product between vectors can take arbitrary values.""")
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
+@app.cell
+def _(mo):
     mo.md(
-        """
-        ## 5. The `marimo` command-line tool
-
-        **Creating and editing notebooks.** Use
-
-        ```
-        marimo edit
-        ```
-
-        in a terminal to start the marimo notebook server. From here
-        you can create a new notebook or edit existing ones.
-
-
-        **Running as apps.** Use
-
-        ```
-        marimo run notebook.py
-        ```
-
-        to start a webserver that serves your notebook as an app in read-only mode,
-        with code cells hidden.
-
-        **Convert a Jupyter notebook.** Convert a Jupyter notebook to a marimo
-        notebook using `marimo convert`:
-
-        ```
-        marimo convert your_notebook.ipynb > your_app.py
-        ```
-
-        **Tutorials.** marimo comes packaged with tutorials:
-
-        - `dataflow`: more on marimo's automatic execution
-        - `ui`: how to use UI elements
-        - `markdown`: how to write markdown, with interpolated values and
-           LaTeX
-        - `plots`: how plotting works in marimo
-        - `sql`: how to use SQL
-        - `layout`: layout elements in marimo
-        - `fileformat`: how marimo's file format works
-        - `markdown-format`: for using `.md` files in marimo
-        - `for-jupyter-users`: if you are coming from Jupyter
-
-        Start a tutorial with `marimo tutorial`; for example,
-
-        ```
-        marimo tutorial dataflow
-        ```
-
-        In addition to tutorials, we have examples in our
-        [our GitHub repo](https://www.github.com/marimo-team/marimo/tree/main/examples).
+        r"""
+        ## Open questions
+        ##
+
+        1. Prove the convergence of the algorithm for generic initializations.
+        2. Find the speed of convergence for arbitrary $n$
+        3. What is the distribution of the scalar products for (large / given) $n$? How about the maximal norm of a commutator
+        $$[u_{ij}, u_{kl}] \, ?$$
         """
     )
     return
 
 
-@app.cell(hide_code=True)
-def __(mo):
+@app.cell
+def _(mo):
     mo.md(
-        """
-        ## 6. The marimo editor
+        r"""
+        ## References
+        ## 
 
-        Here are some tips to help you get started with the marimo editor.
+        1. S. Wang, “Quantum symmetry groups of finite spaces,” _Communications in mathematical physics_, vol. 195, no. 1, pp. 195–211, 1998.
+        2. T. Banica, J. Bichon, and B. Collins, “Quantum permutation groups: a survey,” _Banach Center Publications_, vol. 78, no. 1, pp. 13–34, 2007.
+        3. T. Banica, I. Nechita, "Flat matrix models for quantum permutation groups," _Adv. Appl. Math._ 83, 24-46 (2017)
         """
     )
     return
 
 
 @app.cell
-def __(mo, tips):
-    mo.accordion(tips)
-    return
+def _(np):
+    def generate_random_complex_gaussian_matrix(n):
+        matrix = np.empty((n, n, n), dtype=np.complex128)
+        for i in range(n):
+            for j in range(n):
+                real_part = np.random.normal(size=n)
+                imag_part = np.random.normal(size=n)
+                matrix[i, j] = (real_part + 1j * imag_part) / np.sqrt(2)
+        return matrix
+
+    def orthonormalize_vectors_svd(vectors):
+        u, _, v = np.linalg.svd(vectors)
+        return u @ v
+
+    def error_QPM(u):
+        err = -1;
+
+        for i in range(u.shape[0]):
+            slice = u[i, :, :]
+            err = max(err, np.linalg.norm(slice @ slice.conj().T - np.eye(slice.shape[0])))
+            slice = u[:, i, :]
+            err = max(err, np.linalg.norm(slice @ slice.conj().T - np.eye(slice.shape[0])))
+
+        return err
+
+    def scalar_products_QPM(u):
+        # Calculate the absolute values squared of the scalar products of the vectors in the matrix u
+        scalar_products = []
+        for i in range(u.shape[0]):
+            for j in range(1, u.shape[0]):
+                for k in range(1, u.shape[0]):
+                    for l in range(1, u.shape[0]):
+                        scalar_product = np.abs(np.dot(u[i,j,:], u[k,l,:].conj()))**2
+                        scalar_products.append(scalar_product)
+
+        return scalar_products
+        
+
+    return (
+        error_QPM,
+        generate_random_complex_gaussian_matrix,
+        orthonormalize_vectors_svd,
+        scalar_products_QPM,
+    )
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md("""## Finally, a fun fact""")
-    return
+@app.cell
+def _():
+    import marimo as mo
+    import numpy as np
+    import matplotlib.pyplot as plt
+    return mo, np, plt
 
 
-@app.cell(hide_code=True)
-def __(mo):
-    mo.md(
-        """
-        The name "marimo" is a reference to a type of algae that, under
-        the right conditions, clumps together to form a small sphere
-        called a "marimo moss ball". Made of just strands of algae, these
-        beloved assemblages are greater than the sum of their parts.
-        """
+@app.cell
+def _(
+    button,
+    eps_slider,
+    error_QPM,
+    generate_random_complex_gaussian_matrix,
+    max_iter_slider,
+    n_slider,
+    orthonormalize_vectors_svd,
+    scalar_products_QPM,
+):
+    button
+
+    u = generate_random_complex_gaussian_matrix(n_slider.value)
+
+    error_tolerance = 10**(-eps_slider.value)
+    max_iter = max_iter_slider.value
+
+    iter = 0
+    error = error_QPM(u)
+    errors = [error]  # Initialize a list to store errors
+    scalar_products = scalar_products_QPM(u) # Initialize the scalar product list
+
+    while error > error_tolerance and iter < max_iter:
+
+        # orthonormalize rows
+        for i in range(n_slider.value):
+            u[i, :, :] = orthonormalize_vectors_svd(u[i, :, :]) 
+
+        # orthonormalize columns
+        for j in range(n_slider.value):
+            u[:, j, :] = orthonormalize_vectors_svd(u[:, j, :]) 
+
+        error = error_QPM(u)
+        errors.append(error)  # Append the current error to the list    
+
+        if iter % 10 == 0:
+            scalar_products = scalar_products_QPM(u) # Update scalar prodcuts
+        iter += 1
+    return (
+        error,
+        error_tolerance,
+        errors,
+        i,
+        iter,
+        j,
+        max_iter,
+        scalar_products,
+        u,
     )
-    return
 
 
-@app.cell(hide_code=True)
-def __():
-    tips = {
-        "Saving": (
-            """
-            **Saving**
-
-            - _Name_ your app using the box at the top of the screen, or
-              with `Ctrl/Cmd+s`. You can also create a named app at the
-              command line, e.g., `marimo edit app_name.py`.
-
-            - _Save_ by clicking the save icon on the bottom right, or by
-              inputting `Ctrl/Cmd+s`. By default marimo is configured
-              to autosave.
-            """
-        ),
-        "Running": (
-            """
-            1. _Run a cell_ by clicking the play ( ▷ ) button on the top
-            right of a cell, or by inputting `Ctrl/Cmd+Enter`.
-
-            2. _Run a stale cell_  by clicking the yellow run button on the
-            right of the cell, or by inputting `Ctrl/Cmd+Enter`. A cell is
-            stale when its code has been modified but not run.
-
-            3. _Run all stale cells_ by clicking the play ( ▷ ) button on
-            the bottom right of the screen, or input `Ctrl/Cmd+Shift+r`.
-            """
-        ),
-        "Console Output": (
-            """
-            Console output (e.g., `print()` statements) is shown below a
-            cell.
-            """
-        ),
-        "Creating, Moving, and Deleting Cells": (
-            """
-            1. _Create_ a new cell above or below a given one by clicking
-                the plus button to the left of the cell, which appears on
-                mouse hover.
-
-            2. _Move_ a cell up or down by dragging on the handle to the 
-                right of the cell, which appears on mouse hover.
-
-            3. _Delete_ a cell by clicking the trash bin icon. Bring it
-                back by clicking the undo button on the bottom right of the
-                screen, or with `Ctrl/Cmd+Shift+z`.
-            """
-        ),
-        "Disabling Automatic Execution": (
-            """
-            Via the notebook settings (gear icon) or footer panel, you
-            can disable automatic execution. This is helpful when
-            working with expensive notebooks or notebooks that have
-            side-effects like database transactions.
-            """
-        ),
-        "Disabling Cells": (
-            """
-            You can disable a cell via the cell context menu.
-            marimo will never run a disabled cell or any cells that depend on it.
-            This can help prevent accidental execution of expensive computations
-            when editing a notebook.
-            """
-        ),
-        "Code Folding": (
-            """
-            You can collapse or fold the code in a cell by clicking the arrow
-            icons in the line number column to the left, or by using keyboard
-            shortcuts.
-
-            Use the command palette (`Ctrl/Cmd+k`) or a keyboard shortcut to
-            quickly fold or unfold all cells.
-            """
-        ),
-        "Code Formatting": (
-            """
-            If you have [ruff](https://github.com/astral-sh/ruff) installed,
-            you can format a cell with the keyboard shortcut `Ctrl/Cmd+b`.
-            """
-        ),
-        "Command Palette": (
-            """
-            Use `Ctrl/Cmd+k` to open the command palette.
-            """
-        ),
-        "Keyboard Shortcuts": (
-            """
-            Open the notebook menu (top-right) or input `Ctrl/Cmd+Shift+h` to
-            view a list of all keyboard shortcuts.
-            """
-        ),
-        "Configuration": (
-            """
-           Configure the editor by clicking the gears icon near the top-right
-           of the screen.
-           """
-        ),
-    }
-    return (tips,)
+@app.cell
+def _():
+    return
 
 
 if __name__ == "__main__":
-    app.run()
+    app.run()