Upload 2 files

generate-qpm.py

@@ -0,0 +1,85 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+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 random_quantum_permutation_matrix(n, error_tolerance=1e-6, max_iter=1000):
+    u = generate_random_complex_gaussian_matrix(n)
+
+    iter = 0
+    error = error_QPM(u)
+    errors = [error]  # Initialize a list to store errors
+    
+    while error > error_tolerance and iter < max_iter:
+
+        # orthonormalize rows
+        for i in range(n):
+            u[i, :, :] = orthonormalize_vectors_svd(u[i, :, :]) 
+
+        # orthonormalize columns
+        for j in range(n):
+            u[:, j, :] = orthonormalize_vectors_svd(u[:, j, :]) 
+
+        error = error_QPM(u)
+        errors.append(error)  # Append the current error to the list    
+        iter += 1
+
+    return u, errors  # Return both the matrix and the list of errors
+
+
+# Example usage
+u, errors = random_quantum_permutation_matrix(6)
+
+# Create a figure with two subplots side by side
+fig, axs = plt.subplots(1, 2, figsize=(12, 5))
+
+# 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)
+
+# 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)
+
+# 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)
+
+# Adjust layout to prevent overlap
+plt.tight_layout()
+plt.show()
+
+

qpm-marimo.py

@@ -0,0 +1,303 @@
+import marimo
+
+__generated_with = "0.11.5"
+app = marimo.App(width="medium")
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # Generate random flat quantum permutation matrices
+        #
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+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.$$
+
+        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.$$
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        We are interested here in the special case where: 
+
+        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
+def _(mo):
+    mo.md(
+        """
+        ## An alogrithm for generating random flat quantum permutation matrices
+        ##
+        """
+    )
+    return
+
+
+@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
+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
+def _(mo):
+    mo.md(
+        """
+        ## Implementation
+        ##
+        """
+    )
+    return
+
+
+@app.cell
+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 _(eps_slider, mo):
+    mo.md(f"-lg(Error tolerance): {eps_slider} \t error_tolerance = 1e-{eps_slider.value}")
+    return
+
+
+@app.cell
+def _(max_iter_slider, mo):
+    mo.md(f"Max iterations: {max_iter_slider} \t max_iter = {max_iter_slider.value}")
+    return
+
+
+@app.cell
+def _(mo, n_slider):
+    mo.md(f"Matrix dimension: {n_slider} \t n = {n_slider.value}")
+    return
+
+
+@app.cell
+def _(mo):
+    button = mo.ui.run_button(label="Randomize!")
+    button
+    return (button,)
+
+
+@app.cell
+def _(errors, plt, scalar_products):
+    # Create a figure with two subplots side by side
+    fig, axs = plt.subplots(1, 2, figsize=(12, 5))
+
+    # 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)
+
+    # Adjust layout to prevent overlap
+    plt.tight_layout()
+    plt.gca()
+    return axs, fig
+
+
+@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
+def _(mo):
+    mo.md(
+        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
+def _(mo):
+    mo.md(
+        r"""
+        ## References
+        ## 
+
+        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 _(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
+def _():
+    import marimo as mo
+    import numpy as np
+    import matplotlib.pyplot as plt
+    return mo, np, plt
+
+
+@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,
+    )
+
+
+@app.cell
+def _():
+    return
+
+
+if __name__ == "__main__":
+    app.run()