Fix #168: Remove Pauli measurements

CHANGELOG.md

@@ -11,12 +11,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - #490: Introduced new `Instruction` and `Command` namespace classes for instruction and command instantiation.
 
-- #476 Introduced new methods `OpenGraph.extract_circuit`, `CliffordMap.to_tableau` and new function `graphix.circ_ext.compilation.cm_berg_pass`. Circuit extraction can be done natively in Graphix.
+- #476: Introduced new methods `OpenGraph.extract_circuit`, `CliffordMap.to_tableau` and new function `graphix.circ_ext.compilation.cm_berg_pass`. Circuit extraction can be done natively in Graphix.
 
 ### Fixed
 
 ### Changed
 
+- #168, #498: `Pattern.remove_pauli_measurements` replaces `Pattern.perform_pauli_measurements`.  The new algorithm removes all non-input Pauli nodes from patterns that have a flow and returns a pattern that is equivalent for every input state.
+  - Field `Pattern.results` and function `incorporate_pauli_results` removed.
+
 - #490: Exposed more common classes and methods to top level `__init__.py`.
   - Renamed `Instruction`, `InstructionWithoutRZZ` and `Command` to `InstructionType`, `InstructionTypeWithoutRZZ` and `CommandType` respectively.
   - Moved `InstructionType`, `InstructionTypeWithoutRZZ`, `CommandType`, `Correction` and `CommandOrNoise` to `TYPE_CHECKING` blocks.

README.md

@@ -69,7 +69,7 @@ pattern.draw_graph(flow_from_pattern=False)
 ### preprocessing Pauli measurements (Clifford gates)
 
 ```python
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements()
 pattern.draw_graph()
 ```
 

docs/source/intro.rst

@@ -124,16 +124,17 @@ which we can express by a long sequence,
 Note that the input state has *teleported* to qubits 6 and 7 after the computation.
 
 ..
-    We can inspect the graph state using :class:`~graphix.graphsim.GraphState` class:
+    We can inspect the graph state using :class:`~graphix.opengraph.OpenGraph` class:
 
     .. code-block:: python
 
-        from graphix import GraphState
-        g = GraphState(nodes=[0,1],edges=[(0,1)])
+        from graphix import OpenGraph
+        import networkx as nx
+        og = OpenGraph(nx.Graph([0, 1]), output_nodes=[0, 1])
 
-    >>> print(g.to_statevector())
-    Statevec, data=[[ 0.5+0.j  0.5+0.j]
-    [ 0.5+0.j -0.5+0.j]], shape=(2, 2)
+    >>> print(og.to_pattern().simulate_pattern())
+    Statevec object with statevector [[ 0.5+0.j  0.5+0.j]
+    [ 0.5+0.j -0.5+0.j]] and length (2, 2).
 
 
 

docs/source/modifier.rst

@@ -32,7 +32,9 @@ Pattern Manipulation
 
     .. automethod:: remove_input_nodes
 
-    .. automethod:: perform_pauli_measurements
+    .. automethod:: perform_pauli_pushing
+
+    .. automethod:: remove_pauli_measurements
 
     .. automethod:: to_ascii
 
@@ -83,4 +85,4 @@ Pattern Manipulation
     .. automethod:: to_bloch
 
 
-.. autofunction:: measure_pauli
+.. autofunction:: shift_outcomes

docs/source/optimization.rst

@@ -16,3 +16,13 @@ This module defines space minimization procedures for patterns.
 
 .. automodule:: graphix.space_minimization
     :members:
+
+:mod:`graphix.remove_pauli_measurements` module
++++++++++++++++++++++++++++++++++++++++++++++++
+
+This module provides procedures for pushing Pauli measurements in
+front of a pattern and for subsequently removing them from the
+pattern.
+
+.. automodule:: graphix.remove_pauli_measurements
+    :members:

docs/source/tutorial.rst

@@ -172,14 +172,12 @@ Performing Pauli measurements
 +++++++++++++++++++++++++++++
 
 It is known that quantum circuit consisting of Pauli basis states, Clifford gates and Pauli measurements can be simulated classically (see `Gottesman-Knill theorem
-<https://en.wikipedia.org/wiki/Gottesman%E2%80%93Knill_theorem>`_; e.g. the graph state simulator runs in :math:`\mathcal{O}(n \log n)` time).
-The Pauli measurement part of the MBQC is exactly this, and they can be preprocessed by our graph state simulator :class:`~graphix.graphsim.GraphState` - see :doc:`lc-mbqc` for more detailed description.
+<https://en.wikipedia.org/wiki/Gottesman%E2%80%93Knill_theorem>`_).
 
-We can call this in a line by calling :meth:`~graphix.pattern.Pattern.remove_input_nodes` followed by :meth:`~graphix.pattern.Pattern.perform_pauli_measurements()` (both methods of the :class:`~graphix.pattern.Pattern` object). The first method removes the input nodes, while the second method optimizes the measurement pattern.
+We can call :meth:`~graphix.pattern.Pattern.remove_pauli_measurements()` (method of the :class:`~graphix.pattern.Pattern` object) to optimize the measurement pattern.
 We get an updated measurement pattern without Pauli measurements as follows:
 
->>> pattern.remove_input_nodes()
->>> pattern.perform_pauli_measurements()
+>>> pattern.remove_pauli_measurements()
 >>> pattern
 Pattern(input_nodes=[], cmds=[N(0), N(1), N(3), N(7), E((0, 3)), E((1, 3)), E((1, 7)), M(0, Plane.YZ, 0.2907266109187514), M(1, Plane.YZ, 0.01258854060311348), C(3, Clifford.I), C(7, Clifford.I), Z(3, {0, 1, 5}), Z(7, {1, 5}), X(3, {2}), X(7, {2, 4, 6})], output_nodes=[3, 7])
 

examples/deutsch_jozsa.py

@@ -73,8 +73,7 @@
 # %%
 # Now we preprocess all Pauli measurements, which requires that we move inputs to N commands
 
-pattern.remove_input_nodes()
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements()
 print(
     pattern.to_ascii(
         left_to_right=True,

examples/fusion_extraction.py

@@ -18,19 +18,23 @@
 
 import itertools
 
-import graphix
+import matplotlib.pyplot as plt
+import networkx as nx
+
 from graphix import extraction
-from graphix.extraction import graph_to_fusion_network
+from graphix.extraction import Graph, graph_to_fusion_network
 
 # %%
 # Here we say we want a graph state with 9 nodes and 12 edges.
 # We can obtain resource graph for a measurement pattern by using :code:`pattern.extract_graph()`.
-gs = graphix.GraphState()
+gs = Graph()
 nodes = [0, 1, 2, 3, 4, 5, 6, 7, 8]
 edges = [(0, 1), (1, 2), (2, 3), (3, 0), (3, 4), (0, 5), (4, 5), (5, 6), (6, 7), (7, 0), (7, 8), (8, 1)]
 gs.add_nodes_from(nodes)
 gs.add_edges_from(edges)
-gs.draw()
+labels = {i: i for i in iter(nodes)}
+nx.draw(gs, labels=labels, node_color="C0", edgecolors="k")
+plt.show()
 
 # %%
 # Decomposition with GHZ and linear cluster resource states with no limitation in their sizes.

examples/mbqc_vqe.py

@@ -92,8 +92,7 @@ def build_mbqc_pattern(self, params: Iterable[ParameterizedAngle]) -> Pattern:
         pattern = circuit.transpile().pattern
         pattern.standardize()
         pattern.shift_signals()
-        pattern.remove_input_nodes()
-        pattern.perform_pauli_measurements()  # Perform Pauli measurements
+        pattern.remove_pauli_measurements()  # Perform Pauli measurements
         return pattern
 
     # %%

examples/qaoa.py

@@ -40,8 +40,7 @@
 # %%
 # perform Pauli measurements and plot the new (minimal) graph to perform the same quantum computation
 
-pattern.remove_input_nodes()
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements()
 pattern.draw(flow_from_pattern=False)
 
 # %%

examples/qft_with_tn.py

@@ -64,10 +64,10 @@ def qft(circuit: Circuit, n: int) -> None:
 print(f"Number of edges: {len(graph.edges)}")
 
 # %%
-# Using efficient graph state simulator `graphix.graphsim`, we can classically preprocess Pauli measurements.
+# Using graph rewriting rules, we can classically preprocess Pauli measurements.
 # We are currently improving the speed of this process by using rust-based graph manipulation backend.
 pattern.remove_input_nodes()
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements(standardize=True)
 
 
 # %%

examples/tn_simulation.py

@@ -83,9 +83,9 @@ def ansatz(
 print(f"Number of edges: {len(graph.edges)}")
 
 # %%
-# Optimizing by performing Pauli measurements in the pattern using efficient stabilizer simulator.
+# Optimizing by removing Pauli measurements in the pattern.
 pattern.remove_input_nodes()
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements(standardize=True)
 
 # %%
 # Simulate using the TN backend of graphix, which will return an MBQCTensorNet object.
@@ -203,7 +203,7 @@ def cost(
     pattern.standardize()
     pattern.shift_signals()
     pattern.remove_input_nodes()
-    pattern.perform_pauli_measurements()
+    pattern.remove_pauli_measurements(standardize=True)
     mbqc_tn = pattern.simulate_pattern(backend="tensornetwork", graph_prep="parallel")
     exp_val: float = 0
     for op in ham:

examples/visualization.py

@@ -37,8 +37,7 @@
 
 # %%
 # next, show the gflow:
-pattern.remove_input_nodes()
-pattern.perform_pauli_measurements()
+pattern.remove_pauli_measurements()
 pattern.draw(flow_from_pattern=False, measurement_labels=True)
 
 

graphix/__init__.py

@@ -4,6 +4,7 @@
 
 from graphix._version import __version__
 from graphix.branch_selector import ConstBranchSelector, FixedBranchSelector, RandomBranchSelector
+from graphix.channels import KrausChannel
 from graphix.circ_ext import CliffordMap, PauliExponential, PauliExponentialDAG, PauliString
 from graphix.clifford import Clifford
 from graphix.command import Command

graphix/command.py

@@ -14,6 +14,9 @@
 from graphix.repr_mixins import DataclassReprMixin
 from graphix.states import BasicStates, State
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 Node: TypeAlias = int
 
 logger = logging.getLogger(__name__)
@@ -141,6 +144,22 @@ def clifford(self, clifford_gate: Clifford) -> M:
             domains.t_domain,
         )
 
+    def map(self, f: Callable[[Measurement], Measurement]) -> M:
+        """Return a measurement command where the function ``f`` has been applied to the measurement.
+
+        Parameters
+        ----------
+        f: Callable[[Measurement], Measurement]
+            Function applied to the measurement.
+
+        Returns
+        -------
+        M
+            The resulting command.
+
+        """
+        return M(self.node, f(self.measurement), self.s_domain, self.t_domain)
+
 
 @dataclasses.dataclass(repr=False)
 class E(_KindChecker, BaseCommand):

graphix/extraction.py

@@ -6,11 +6,17 @@
 import dataclasses
 import operator
 from enum import Enum
+from typing import TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
 
-from graphix.graphsim import GraphState
+if TYPE_CHECKING:
+    from typing import TypeAlias
+
+    Graph: TypeAlias = nx.Graph[int]
+else:
+    Graph = nx.Graph
 
 
 class ResourceType(Enum):
@@ -33,12 +39,12 @@ class ResourceGraph:
     ----------
     cltype : :class:`ResourceType` object
         Type of the cluster.
-    graph : :class:`~graphix.graphsim.GraphState` object
+    graph : :class:`Graph` object
         Graph state of the cluster.
     """
 
     cltype: ResourceType
-    graph: GraphState
+    graph: Graph
 
     def __eq__(self, other: object) -> bool:
         """Return `True` if two resource graphs are equal, `False` otherwise."""
@@ -49,19 +55,19 @@ def __eq__(self, other: object) -> bool:
 
 
 def graph_to_fusion_network(
-    graph: GraphState,
+    graph: Graph,
     max_ghz: float = np.inf,
     max_lin: float = np.inf,
 ) -> list[ResourceGraph]:
-    """Extract GHZ and linear cluster graph state decomposition of desired resource state :class:`~graphix.graphsim.GraphState`.
+    """Extract GHZ and linear cluster graph state decomposition of desired resource state :class:`Graph`.
 
     Extraction algorithm is based on [1].
 
     [1] Zilk et al., A compiler for universal photonic quantum computers, 2022 `arXiv:2210.09251 <https://arxiv.org/abs/2210.09251>`_
 
     Parameters
     ----------
-    graph : :class:`~graphix.graphsim.GraphState` object
+    graph : :class:`Graph` object
         Graph state.
     phasedict : dict
         Dictionary of phases for each node.
@@ -161,7 +167,7 @@ def create_resource_graph(node_ids: list[int], root: int | None = None) -> Resou
     else:
         edges = [(node_ids[i], node_ids[i + 1]) for i in range(len(node_ids)) if i + 1 < len(node_ids)]
         cluster_type = ResourceType.LINEAR
-    tmp_graph = GraphState()
+    tmp_graph = Graph()
     tmp_graph.add_nodes_from(node_ids)
     tmp_graph.add_edges_from(edges)
     return ResourceGraph(cltype=cluster_type, graph=tmp_graph)