Release version 0.3.2

Co-authored-by: Ian Fan <ian.fan@quantinuum.com>
Co-authored-by: Dimitri Kartsaklis <dimitri.kartsaklis@quantinuum.com>
Co-authored-by: Nikhil Khatri <nikhil.khatri@quantinuum.com>
Co-authored-by: Charles London <charles.london@quantinuum.com>
Co-authored-by: Alexis Toumi <alexis@toumi.email>

Author: 6 people

.github/workflows/build_test.yml

@@ -7,6 +7,7 @@ on:
       - 'beta'
       - 'release'
   pull_request:
+  workflow_dispatch:
 
 env:
   SRC_DIR: lambeq
@@ -103,7 +104,7 @@ jobs:
         path: ${{ steps.loc-depccg-cache.outputs.dir }}
         key: depccg
     - name: Download depccg pre-trained model if needed
-      if: steps.depccg-cache.outputs.cache-hit == 'false'
+      if: steps.depccg-enabled.outcome == 'success' && steps.depccg-cache.outputs.cache-hit != 'true'
       run: python -c 'import tarfile, urllib;from depccg.instance_models import MODEL_DIRECTORY;tarfile.open(urllib.request.urlretrieve("https://qnlp.cambridgequantum.com/models/tri_headfirst.tar.gz")[0]).extractall(MODEL_DIRECTORY)'
     - name: Test DepCCGParser
       if: steps.depccg-enabled.outcome == 'success'
@@ -123,7 +124,6 @@ jobs:
       run: >
         pytest --nbmake ${{ env.DOCS_DIR }}/tutorials/
         --nbmake-timeout=60
-        --ignore ${{ env.DOCS_DIR }}/tutorials/trainer_hybrid.ipynb
         --ignore ${{ env.DOCS_DIR }}/tutorials/code
     - name: Coverage report
       run: coverage report -m

docs/clean_notebooks.py

@@ -47,7 +47,7 @@
 ]
 
 intersphinx_mapping = {
-    'discopy': ("https://docs.discopy.org/en/0.5.1.1/", None),
+    'discopy': ("https://docs.discopy.org/en/main/", None),
     'pennylane': ("https://pennylane.readthedocs.io/en/stable/", None),
 }
 

docs/conf.py

@@ -121,7 +121,7 @@ Package containing the interfaces for the :term:`CCG <Combinatory Categorial Gra
 
 .. inheritance-diagram::
     lambeq.text2diagram.BobcatParser
-    lambeq.text2diagram.CCGAtomicType
+    lambeq.text2diagram.CCGType
     lambeq.text2diagram.CCGBankParser
     lambeq.text2diagram.CCGRule
     lambeq.text2diagram.CCGTree

docs/examples/circuit.ipynb

@@ -4,6 +4,44 @@ Release notes
 =============
 
 
+.. _rel-0.3.2:
+
+`0.3.2 <https://github.com/CQCL/lambeq/releases/tag/0.3.2>`_
+------------------------------------------------------------
+
+Added:
+
+- Support for :term:`DisCoPy` >= 1.1.4 (credit: `toumix <https://github.com/CQCL/lambeq/pull/89>`_).
+    - replaced ``discopy.rigid`` with :py:mod:`discopy.grammar.pregroup` everywhere.
+    - replaced ``discopy.biclosed`` with :py:mod:`discopy.grammar.categorial` everywhere.
+    - Use ``Diagram.decode`` to account for the change in contructor signature ``Diagram(inside, dom, cod)``.
+    - updated attribute names that were previously hidden, e.g. ``._data`` becomes ``.data``.
+    - replaced diagrammatic conjugate with transpose.
+    - swapped left and right currying.
+    - dropped support for legacy DisCoPy.
+- Added :py:class:`~lambeq.CCGType` class for utilisation in the ``biclosed_type`` attribute of :py:class:`~lambeq.CCGTree`, allowing conversion to and from a discopy categorial object using :py:meth:`~lambeq.CCGType.discopy` and :py:meth:`~lambeq.CCGType.from_discopy` methods.
+- :py:class:`~lambeq.CCGTree`: added reference to the original tree from parsing by introducing a ``metadata`` field.
+
+
+Changed:
+
+- Internalised DisCoPy quantum ansätze in lambeq.
+- :py:class:`~lambeq.IQPAnsatz` now ends with a layer of Hadamard gates in the multi-qubit case and the post-selection basis is set to be the computational basis (Pauli Z).
+
+Fixed:
+
+- Fixed a bottleneck during the initialisation of the :py:class:`~lambeq.PennyLaneModel` caused by the inefficient substitution of Sympy symbols in the circuits.
+- Escape special characters in box labels for symbol creation.
+- Documentation: fixed broken links to DisCoPy documentation.
+- Documentation: enabled sphinxcontrib.jquery extension for Read the Docs theme.
+- Fixed disentangling ``RealAnsatz`` in extend-lambeq tutorial notebook.
+- Fixed model loading in PennyLane notebooks.
+- Fixed typo in :py:class:`~lambeq.SPSAOptimizer` (credit: `Gopal-Dahale <https://github.com/CQCL/lambeq/pull/102>`_)
+
+Removed:
+
+- Removed support for Python 3.8.
+
 .. _rel-0.3.1:
 
 `0.3.1 <https://github.com/CQCL/lambeq/releases/tag/0.3.1>`_

docs/examples/pennylane.ipynb

@@ -0,0 +1,20 @@
+# check_errors.py
+import sys
+from nbformat import read
+
+def check_error_tags(nbfile) -> bool:
+    with open(nbfile) as f:
+        nb = read(f, as_version=4)
+
+    for cell in nb['cells']:
+        if cell['cell_type'] == 'code':
+            for output in cell.get('outputs', []):
+                if output['output_type'] == 'error':
+                    return True
+    return False
+
+if __name__ == '__main__':
+    file_path = sys.argv[1]
+    if check_error_tags(file_path):
+        sys.exit(1)
+    sys.exit(0)

docs/examples/quantum_pipeline.ipynb

@@ -0,0 +1,65 @@
+"""
+This script performs the following actions on example and
+tutorial notebooks:
+
+- Removes cell IDs
+- Keeps only `useful_metadata` for each cell
+- Renumbers code cells, ignoring hidden ones
+- Keeps only necessary notebook metadata
+- Pins nbformat version
+"""
+
+from pathlib import Path
+from itertools import chain
+import nbformat as nbf
+
+
+print("Cleaning notebooks...")
+
+nbs_path = Path("examples")
+tut_path = Path("tutorials")
+useful_metadata = ["nbsphinx", "raw_mimetype"]
+
+for file in chain(nbs_path.iterdir(), tut_path.iterdir()):
+    if not (file.is_file() and file.suffix == ".ipynb"):
+        continue
+
+    ntbk = nbf.read(file, nbf.NO_CONVERT)
+
+    exec_count = 0
+
+    for cell in ntbk.cells:
+        # Delete cell ID if it's there
+        cell.pop("id", None)
+        if cell.get("attachments") == {}:
+            cell.pop("attachments", None)
+
+        # Keep only useful metadata
+        new_metadata = {x: cell.metadata[x]
+                        for x in useful_metadata
+                        if x in cell.metadata}
+        cell.metadata = new_metadata
+
+        # Renumber execution counts, ignoring hidden cells
+        if cell.cell_type == "code":
+            if cell.metadata.get("nbsphinx") == "hidden":
+                cell.execution_count = None
+            else:
+                exec_count += 1
+                cell.execution_count = exec_count
+
+            # Adjust the output execution count, if present
+            if len(cell.outputs) > 0:
+                output = cell.outputs[-1]  # execute_result must be
+                                           # the last entry
+                if output.output_type == "execute_result":
+                    output.execution_count = cell.execution_count
+
+    ntbk.metadata = {"language_info": {"name": "python"}}
+
+    # We need the version of nbformat to be x.4, otherwise cells IDs
+    # are regenerated automatically
+    ntbk.nbformat = 4
+    ntbk.nbformat_minor = 4
+
+    nbf.write(ntbk, file, version=nbf.NO_CONVERT)

docs/examples/quantum_pipeline_jax.ipynb

@@ -0,0 +1,96 @@
+import os
+import pandas as pd
+import matplotlib.pyplot as plt
+import argparse
+import numpy as np
+
+
+PLOT_SAVE_PATH = 'notebook_execution_time_comparison.png'
+
+# Function to load data from CSV files
+def load_data(csv_path):
+    data = pd.read_csv(csv_path)
+    # cut path from notebook name
+    data['notebook'] = data['notebook'].apply(lambda x: x.rpartition('/')[2])
+    data['source'] = csv_path
+    data['median'] = data.filter(regex='run_').median(1)
+    data['min'] = data.filter(regex='run_').min(1)
+    data['std'] = data.filter(regex='run_').std(1)
+    return data
+
+
+def plot_data(data: pd.DataFrame, title='Notebook Execution Time Comparison'):
+    # Read out mean and standard deviation
+    mean_data = data.groupby(['notebook', 'source'])['median'].mean().unstack().fillna(0)
+    std_data = data.groupby(['notebook', 'source'])['std'].mean().unstack().fillna(0)
+    min_data = data.groupby(['notebook', 'source'])['min'].mean().unstack().fillna(0)
+
+    # Create a figure and a set of subplots
+    _, ax = plt.subplots(figsize=(15, 8))
+
+    # Define variable bar width
+    samples = len(mean_data.keys())
+    bar_width = 1/(2*samples)
+
+    # Define notebook positions
+    notebook_positions = np.arange(len(mean_data.index))
+
+    n_samples = len(mean_data.columns)
+
+    # Generate bar plots with error bars for each source
+    for i, source in enumerate(mean_data.columns):
+        label = source.split('/')[1]
+        offset = ((i - n_samples//2 + 1/2) if n_samples % 2 == 0 else
+                    (n_samples//2 - i))
+        # Plot medium values as bar plot
+        ax.bar(notebook_positions - offset * bar_width,
+               mean_data[source],
+               bar_width,
+               alpha=0.2,
+               color='bgrcmyk'[i],
+               yerr=std_data[source],
+               ecolor='gray',
+               label='_nolegend_')
+        # Plot minimum values as bar plot
+        ax.bar(notebook_positions - offset * bar_width,
+               min_data[source],
+               bar_width,
+               alpha=0.8,
+               color='bgrcmyk'[i],
+               label=label)
+
+    ax.set_title(title)
+    ax.set_xlabel('Notebook')
+    ax.set_ylabel('Time (s)')
+    ax.set_xticks(notebook_positions)
+    ax.set_xticklabels(mean_data.index, rotation=45, ha='right')
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(PLOT_SAVE_PATH)
+    plt.show()
+
+
+def main(notebook_runtimes_dir):
+    # Traverse the 'notebook_runtimes_dir' and its subdirectories for CSV files
+    data_frames = []
+    for root, _, files in os.walk(notebook_runtimes_dir):
+        for file in files:
+            if file.endswith(".csv"):
+                csv_path = os.path.join(root, file)
+                data = load_data(csv_path)
+                data_frames.append(data)
+
+    # Concatenate all dataframes
+    all_data = pd.concat(data_frames, ignore_index=True)
+
+    # Plot the data
+    plot_data(all_data)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Compare notebook execution times.')
+    parser.add_argument('notebook_runtimes_dir', type=str,
+                        help='Path to the directory containing the CSV files.')
+
+    args = parser.parse_args()
+
+    main(args.notebook_runtimes_dir)