pyzx-param 0.9.0__tar.gz

pyzx_param-0.9.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pyzx_param-0.9.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include pyzx_param/js/zx_editor_model.js
+include pyzx_param/js/zx_editor_widget.js
+include pyzx_param/js/zx_viewer.js
+include pyzx_param/js/d3.v5.min.js
+include pyzx_param/js/zx_viewer.inline.js
+include pyzx_param/js/zx_viewer3d.js
+include pyzx_param/py.typed
+include readme.md
+include LICENSE

pyzx_param-0.9.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: pyzx-param
+Version: 0.9.0
+Summary: Library for quantum circuit rewriting and optimisation using the ZX-calculus
+Home-page: https://github.com/rafaelha/pyzx.git
+Author: Quantomatic
+Author-email: john@vdwetering.name
+License: Apache2
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions>=3.7.4
+Requires-Dist: numpy>=1.14
+Requires-Dist: pyperclip>=1.8.1
+Requires-Dist: tqdm>=4.56.0
+Requires-Dist: lark>=1.2.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## PyZX-Param
+
+[![PyPI version](https://badge.fury.io/py/pyzx-param.svg)](https://badge.fury.io/py/pyzx-param)
+
+> **Note:** This is a fork of [PyZX](https://github.com/zxcalc/pyzx) with extensions for parameterized Pauli vertices, based on [mjsutcliffe99/ParamZX](https://github.com/mjsutcliffe99/ParamZX). It can be installed alongside the original PyZX without conflicts.
+
+PyZX (pronounce as *Pisics*) is a **Py**thon tool implementing the theory of **ZX**-calculus for the creation, visualisation, and automated rewriting of large-scale quantum circuits. Please watch [this 2-minute video](https://www.youtube.com/watch?v=iC-KVdB8pf0) for a short introduction.
+
+PyZX currently allows you to:
+
+* Read in quantum circuits in the file format of [QASM](https://en.wikipedia.org/wiki/OpenQASM), [Quipper](https://www.mathstat.dal.ca/~selinger/quipper/doc/) or [Quantomatic](https://quantomatic.github.io/).
+* Rewrite circuits into a pseudo-normal form using the ZX-calculus.
+* Extract new simplified circuits from these reduced graphs.
+* Visualise the ZX-graphs and rewrites using either [Matplotlib](https://matplotlib.org/), Quantomatic or as a TikZ file for use in LaTeX documents.
+* Output the optimised circuits in QASM, QC or QUIPPER format.
+
+You can try out the in-browser demo which shows some of these features [here](http://zxcalculus.com/pyzx.html).
+
+## About the ZX-calculus
+
+ZX-diagrams are a type of tensor network built out of combinations of linear maps known as *spiders*. There are 2 types of spiders: the Z-spiders (represented as green dots in PyZX) and the X-spiders (represented as red dots). Every linear map between some set of qubits can be represented by a ZX-diagram.
+The ZX-calculus is a set of rewrite rules for ZX-diagrams. There are various extensive set of rewrite rules. PyZX however, uses only rewrite rules concerning the Clifford fragment of the ZX-calculus. Importantly, this set of rewrite rules is *complete* for Clifford diagrams, meaning that two representations of a Clifford map can be rewritten into one another if and only if the two linear maps they represent are equal.
+
+[Here](http://zxcalculus.com) is a website with resources and information about the ZX-calculus. For a short introduction to the ZX-calculus see [this paper](https://arxiv.org/abs/1602.04744) while for a complete overview we recommend [this book](https://www.amazon.com/Picturing-Quantum-Processes-Diagrammatic-Reasoning/dp/110710422X). PyZX extensively uses two derived rewrite rules known as *local complementation* and *pivoting*. More information about these operations can be found in [this paper](https://arxiv.org/abs/1307.7048).
+
+
+## Installation
+
+If you wish to use PyZX-Param as a Python module for use in other projects, we recommend installing via pip:
+```
+pip install pyzx-param
+```
+
+This installs the module as `pyzx_param`, allowing it to coexist with the original `pyzx`:
+```python
+import pyzx_param as zx  # This fork
+import pyzx              # Original PyZX (if needed)
+```
+
+If you want to use the demos or the benchmark circuits you should install PyZX-Param from source by cloning the git repository.
+
+PyZX-Param has no strict dependencies, although some functionality requires numpy. It is built to interact well with Jupyter, so we additionally recommend you have Jupyter and matplotlib installed.
+
+## Usage
+
+See the [Documentation](https://pyzx.readthedocs.io/en/latest/) for a full overview of the features of PyZX.
+
+If you have [Jupyter](https://jupyter.org/) installed you can use one of the demonstration notebooks in the demos folder for an illustration of what PyZX can do.
+
+This is some example Python code for generating a random circuit, optimizing it, and finally displaying it:
+
+```python
+import pyzx_param as zx
+qubit_amount = 5
+gate_count = 80
+#Generate random circuit of Clifford gates
+circuit = zx.generate.cliffordT(qubit_amount, gate_count)
+#If running in Jupyter, draw the circuit
+zx.draw(circuit)
+#Use one of the built-in rewriting strategies to simplify the circuit
+zx.simplify.full_reduce(circuit)
+#See the result
+zx.draw(circuit)
+```
+
+PyZX-Param can also be run from the commandline. To optimise a circuit you can for instance run
+```python -m pyzx_param opt input_circuit.qasm```
+
+## Attribution
+
+This is a fork of [PyZX](https://github.com/zxcalc/pyzx) by Aleks Kissinger and John van de Wetering. If you wish to cite PyZX in an academic work, please cite the [original paper](https://arxiv.org/abs/1904.04735):
+<pre>
+  @inproceedings{kissinger2020Pyzx,
+    author = {Kissinger, Aleks and van de Wetering, John},
+    title = {{PyZX: Large Scale Automated Diagrammatic Reasoning}},
+    year = {2020},
+    booktitle = {{\rm Proceedings 16th International Conference on} Quantum Physics and Logic, {\rm Chapman University, Orange, CA, USA., 10-14 June 2019}},
+    editor = {Coecke, Bob and Leifer, Matthew},
+    series = {Electronic Proceedings in Theoretical Computer Science},
+    volume = {318},
+    pages = {229-241},
+    publisher = {Open Publishing Association},
+    doi = {10.4204/EPTCS.318.14}
+}
+</pre>
+
+Here's a plane that says PYZX:
+![PYZX](https://github.com/zxcalc/pyzx/raw/master/images/F-PYZX.jpg)

pyzx_param-0.9.0/pyzx_param/__init__.py

@@ -0,0 +1,66 @@
+# PyZX - Python library for quantum circuit rewriting
+#        and optimisation using the ZX-calculus
+# Copyright (C) 2018 - Aleks Kissinger and John van de Wetering
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#    http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.9.0"
+
+from .graph.graph import Graph
+from .circuit import Circuit, gates, id
+from .linalg import Mat2
+from .utils import settings, VertexType, EdgeType, original_colors, rgb_colors, grayscale_colors
+from .quimb import to_quimb_tensor
+from .drawing import *
+from .simplify import *
+from .optimize import *
+from .extract import *
+from .graph.jsonparser import *
+from .tensor import *
+from .local_search.simulated_annealing import anneal
+from .local_search.genetic import GeneticOptimizer
+from .circuit.qasmparser import qasm
+from .circuit.sqasm import sqasm
+from . import generate
+from . import todd
+from . import linalg
+from . import extract
+from .rewrite_rules import rules
+from .rewrite_rules import hrules
+from .rewrite_rules import basicrules
+from .rewrite_rules import editor_actions
+from . import optimize
+from . import simplify
+from . import hsimplify
+from . import d3
+from . import tikz
+from . import simulate
+from . import editor
+from . import routing
+from . import local_search
+from .routing.parity_maps import CNOT_tracker
+
+# some common scalars
+from .graph.base import Scalar
+ONE = Scalar()
+SQRT_TWO = Scalar()
+SQRT_TWO.add_power(1)
+TWO = Scalar()
+TWO.add_power(2)
+SQRT_TWO_INV = Scalar()
+SQRT_TWO_INV.add_power(-1)
+TWO_INV = Scalar()
+TWO_INV.add_power(-2)
+
+if __name__ == '__main__':
+    print("Please execute this as a module by running 'python -m pyzx'")

pyzx_param-0.9.0/pyzx_param/__main__.py

@@ -0,0 +1,26 @@
+# PyZX - Python library for quantum circuit rewriting 
+#        and optimization using the ZX-calculus
+# Copyright (C) 2018 - Aleks Kissinger and John van de Wetering
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#    http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+if __name__ == '__main__':
+    import sys
+    try:
+        from .scripts import main
+    except (SystemError, ImportError):
+        print("Please run as a module by using 'python -m pyzx'")
+        exit(1)
+
+    main(sys.argv)

pyzx_param-0.9.0/pyzx_param/altextract.py

@@ -0,0 +1,250 @@
+from fractions import Fraction
+import itertools
+import math
+
+from .utils import EdgeType, VertexType, toggle_edge
+from .linalg import Mat2, Z2
+from .simplify import id_simp, tcount
+from .rewrite_rules.rules import apply_rule, pivot, match_spider_parallel, spider
+from .circuit import Circuit
+from .circuit.gates import Gate, ParityPhase, CNOT, HAD, ZPhase, CZ, InitAncilla
+from .graph.base import BaseGraph, VT, ET
+
+from typing import List, Optional, Tuple, Dict, Set, Union
+
+from .extract import bi_adj, connectivity_from_biadj, max_overlap
+# , greedy_reduction, find_minimal_sums, xor_rows, column_optimal_swap
+
+
+# permute the rows of "m" such that as many rows as possible have
+# 1s in position given by "pos"
+# TODO: this can be done in poly-time with graph matching algo
+# (e.g. Hopcroft-Karp)
+def ones_in_pos(m, pos):
+    winner = -1
+
+    perm = None
+    for p in itertools.permutations(range(m.rows())):
+        score = sum(m[p[i],pos[i]] for i in range(m.rows()))
+        if score > winner:
+            winner = score
+            perm = p
+        if score == m.rows():
+            break
+    m1 = m.copy()
+
+    if not perm is None:
+        for i in range(m.rows()):
+            m[perm[i],:] = m1[i,:]
+
+# produce a parity matrix that extracts all of the extractable
+# vertices in convenient places and ignores the rest
+def compute_row_ops(m):
+    ops = Mat2.id(m.rows())
+    m1 = m.copy()
+    m1.gauss(full_reduce=True,x=ops)
+    #extr_rows = [r for r,row in enumerate(m1.data) if sum(row)==1]
+
+    # keep only the rows corresponding to extractable verts
+    #ops_rows = []
+    ops_rows = [ops.data[r]
+                   for r,row in enumerate(m1.data)
+                   if sum(row)==1]
+    #ops_rows.sort(key=lambda row: sum(row), reverse=False)
+    ops_rows.sort(reverse=True)
+    #ops_rows = ops_rows[0:2]
+    ops = Mat2(ops_rows)
+
+
+    # for r,row in enumerate(m1.data):
+    #     if sum(row)==1:
+    #         ops_rows.append(ops.data[r])
+    # ops = Mat2(ops_rows)
+    # ops = Mat2([ops.data[r]
+    #               for r,row in enumerate(m1.data)
+    #               if sum(row)==1])
+    # list.sort(ops.data, reverse=True)
+    
+    # find pivot columns
+    pivot_cols = []
+    ops.copy().gauss(pivot_cols=pivot_cols)
+    #ones_in_pos(ops,pivot_cols)
+
+    # augment ops by adding unit vectors for all non-pivot columns
+    ops2 = Mat2.id(m.rows())
+    for r in range(ops.rows()):
+        ops2[pivot_cols[r],:] = ops[r,:]
+    return ops2
+
+
+def alt_extract_circuit(
+        g:BaseGraph[VT,ET], 
+        optimize_czs:bool=True, 
+        optimize_cnots:int=2, 
+        quiet:bool=True
+        ) -> Circuit:
+    """
+    Experiments with the extractor. (not ready for primetime :)
+
+
+    Args:
+        g: The ZX-diagram graph to be extracted into a Circuit.
+        optimize_czs: Whether to try to optimize the CZ-subcircuits by exploiting overlap between the CZ gates
+        optimize_cnots: (0,1,2,3) Level of CNOT optimization to apply.
+        quiet: Whether to print detailed output of the extraction process.
+    """
+    qs = g.qubits() # We are assuming that these are objects that update...
+    rs = g.rows()   # ...to reflect changes to the graph, so that when...
+    # ty = g.types()  # ... g.set_row/g.set_qubit is called, these things update directly to reflect that
+    phases = g.phases()
+    c = Circuit(g.qubit_count())
+
+    gadgets = {}
+    inputs = g.inputs()
+    outputs = g.outputs()
+    for v in g.vertices():
+        if g.vertex_degree(v) == 1 and v not in inputs and v not in outputs:
+            n = list(g.neighbors(v))[0]
+            gadgets[n] = v
+    
+    qubit_map: Dict[VT,int] = dict()
+    frontier = []
+    for i,o in enumerate(outputs):
+        v = list(g.neighbors(o))[0]
+        if v in inputs: continue
+        frontier.append(v)
+        qubit_map[v] = i
+        
+    czs_saved = 0
+    q: Union[float,int]
+    
+    while True:
+        # preprocessing
+
+        for v in frontier: # First removing single qubit gates
+            q = qubit_map[v]
+            b = [w for w in g.neighbors(v) if w in outputs][0]
+            e = g.edge(v,b)
+            if g.edge_type(e) == 2: # Hadamard edge
+                c.add_gate("HAD",q)
+                g.set_edge_type(e, EdgeType.SIMPLE)
+            if phases[v]: 
+                c.add_gate("ZPhase", q, phases[v])
+                g.set_phase(v,0)
+
+        # And now on to CZ gates
+        cz_mat = Mat2([[0 for i in range(g.qubit_count())] for j in range(g.qubit_count())])
+        for v in frontier:
+            for w in list(g.neighbors(v)):
+                if w in frontier:
+                    cz_mat.data[qubit_map[v]][qubit_map[w]] = 1
+                    cz_mat.data[qubit_map[w]][qubit_map[v]] = 1
+                    g.remove_edge(g.edge(v,w))
+
+        if optimize_czs:
+            overlap_data = max_overlap(cz_mat)
+            while len(overlap_data[1]) > 2: #there are enough common qubits to be worth optimizing
+                i,j = overlap_data[0][0], overlap_data[0][1]
+                czs_saved += len(overlap_data[1])-2
+                c.add_gate("CNOT",i,j)
+                for qb in overlap_data[1]:
+                    c.add_gate("CZ",j,qb)
+                    cz_mat.data[i][qb]=0
+                    cz_mat.data[j][qb]=0
+                    cz_mat.data[qb][i]=0
+                    cz_mat.data[qb][j]=0
+                c.add_gate("CNOT",i,j)
+                overlap_data = max_overlap(cz_mat)
+
+        for i in range(g.qubit_count()):
+            for j in range(i+1,g.qubit_count()):
+                if cz_mat.data[i][j]==1:
+                    c.add_gate("CZ",i,j)
+        
+        # Now we can proceed with the actual extraction
+        # First make sure that frontier is connected in correct way to inputs
+        neighbor_set = set()
+        for v in frontier.copy():
+            d = [w for w in g.neighbors(v) if w not in outputs]
+            if any(w in inputs for w in d): #frontier vertex v is connected to an input
+                if len(d) == 1: # Only connected to input, remove from frontier
+                    frontier.remove(v)
+                    continue
+                # We disconnect v from the input b via a new spider
+                b = [w for w in d if w in inputs][0]
+                q = qs[b]
+                r = rs[b]
+                w = g.add_vertex(VertexType.Z, q, r+1)
+                e = g.edge(v,b)
+                et = g.edge_type(e)
+                g.remove_edge(e)
+                g.add_edge((v, w), EdgeType.HADAMARD)
+                g.add_edge((w,b),toggle_edge(et))
+                d.remove(b)
+                d.append(w)
+            neighbor_set.update(d)
+        
+        if not frontier: break # No more vertices to be processed. We are done.
+        
+        # First we check if there is a phase gadget in the way
+        removed_gadget = False
+        for w in neighbor_set:
+            if w not in gadgets: continue
+            for v in g.neighbors(w):
+                if v in frontier:
+                    apply_rule(g,pivot,[(w,v,[],[o for o in g.neighbors(v) if o in g.outputs])]) # type: ignore
+                    frontier.remove(v)
+                    del gadgets[w]
+                    frontier.append(w)
+                    qubit_map[w] = qubit_map[v]
+                    removed_gadget = True
+                    break
+        if removed_gadget: # There was indeed a gadget in the way. Go back to the top
+            continue
+            
+        neighbors = list(neighbor_set)
+        m = bi_adj(g,neighbors,frontier)
+        ops = compute_row_ops(m)
+        m1 = ops * m
+
+        cnots = Circuit(g.qubit_count())
+        blocksize = math.ceil(math.log(g.qubit_count(),2)) * 2
+        winner = -1
+        for bs in range(1,blocksize):
+            cnots1 = Circuit(g.qubit_count())
+            ops.copy().gauss(full_reduce=True,
+                y=cnots1, blocksize=bs)
+            if winner == -1 or len(cnots1.gates) < winner:
+                cnots = cnots1
+
+        #return m, ops
+
+        connectivity_from_biadj(g,m1,neighbors,frontier)
+
+        good_verts = dict()
+        for i, row in enumerate(m1.data):
+            if sum(row) == 1:
+                v = frontier[i]
+                w = neighbors[[j for j in range(len(row)) if row[j]][0]]
+                good_verts[v] = w
+        
+        # if not quiet: print("good_verts:", good_verts)
+        if not good_verts: #raise Exception("No extractable vertex found. Something went wrong")
+            print("No extractable vertex found. Something went wrong")
+            break
+        hads = []
+        for v,w in good_verts.items(): # Update frontier vertices
+            hads.append(qubit_map[v])
+            #c.add_gate("HAD",qubit_map[v])
+            qubit_map[w] = qubit_map[v]
+            b = [o for o in g.neighbors(v) if o in outputs][0]
+            g.remove_vertex(v)
+            g.add_edge((w,b))
+            frontier.remove(v)
+            frontier.append(w)
+        if not quiet: print("Vertices extracted:", len(good_verts))
+        #for cnot in cnots: c.add_gate(cnot)
+        c.add_circuit(cnots)
+        for h in hads: c.add_gate("HAD",h)
+    return c
+    # TODO: finalise