qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/synthesis/linear/linear_matrix_utils.py

@@ -0,0 +1,175 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Utility functions for handling binary matrices."""
+
+from typing import Optional, Union
+import numpy as np
+from qiskit.exceptions import QiskitError
+
+
+def check_invertible_binary_matrix(mat: np.ndarray):
+    """Check that a binary matrix is invertible.
+
+    Args:
+        mat: a binary matrix.
+
+    Returns:
+        bool: True if mat in invertible and False otherwise.
+    """
+    if len(mat.shape) != 2 or mat.shape[0] != mat.shape[1]:
+        return False
+
+    rank = _compute_rank(mat)
+    return rank == mat.shape[0]
+
+
+def random_invertible_binary_matrix(
+    num_qubits: int, seed: Optional[Union[np.random.Generator, int]] = None
+):
+    """Generates a random invertible n x n binary matrix.
+
+    Args:
+        num_qubits: the matrix size.
+        seed: a random seed.
+
+    Returns:
+        np.ndarray: A random invertible binary matrix of size num_qubits.
+    """
+    if isinstance(seed, np.random.Generator):
+        rng = seed
+    else:
+        rng = np.random.default_rng(seed)
+
+    rank = 0
+    while rank != num_qubits:
+        mat = rng.integers(2, size=(num_qubits, num_qubits))
+        rank = _compute_rank(mat)
+    return mat
+
+
+def _gauss_elimination(mat, ncols=None, full_elim=False):
+    """Gauss elimination of a matrix mat with m rows and n columns.
+    If full_elim = True, it allows full elimination of mat[:, 0 : ncols]
+    Returns the matrix mat."""
+
+    mat, _ = _gauss_elimination_with_perm(mat, ncols, full_elim)
+    return mat
+
+
+def _gauss_elimination_with_perm(mat, ncols=None, full_elim=False):
+    """Gauss elimination of a matrix mat with m rows and n columns.
+    If full_elim = True, it allows full elimination of mat[:, 0 : ncols]
+    Returns the matrix mat, and the permutation perm that was done on the rows during the process.
+    perm[0 : rank] represents the indices of linearly independent rows in the original matrix."""
+
+    # Treat the matrix A as containing integer values
+    mat = np.array(mat, dtype=int, copy=True)
+
+    m = mat.shape[0]  # no. of rows
+    n = mat.shape[1]  # no. of columns
+    if ncols is not None:
+        n = min(n, ncols)  # no. of active columns
+
+    perm = np.array(range(m))  # permutation on the rows
+
+    r = 0  # current rank
+    k = 0  # current pivot column
+    while (r < m) and (k < n):
+        is_non_zero = False
+        new_r = r
+        for j in range(k, n):
+            for i in range(r, m):
+                if mat[i][j]:
+                    is_non_zero = True
+                    k = j
+                    new_r = i
+                    break
+            if is_non_zero:
+                break
+        if not is_non_zero:
+            return mat, perm  # A is in the canonical form
+
+        if new_r != r:
+            mat[[r, new_r]] = mat[[new_r, r]]
+            perm[r], perm[new_r] = perm[new_r], perm[r]
+
+        if full_elim:
+            for i in range(0, r):
+                if mat[i][k]:
+                    mat[i] = mat[i] ^ mat[r]
+
+        for i in range(r + 1, m):
+            if mat[i][k]:
+                mat[i] = mat[i] ^ mat[r]
+        r += 1
+
+    return mat, perm
+
+
+def calc_inverse_matrix(mat: np.ndarray, verify: bool = False):
+    """Given a square numpy(dtype=int) matrix mat, tries to compute its inverse.
+
+    Args:
+        mat: a boolean square matrix.
+        verify: if True asserts that the multiplication of mat and its inverse is the identity matrix.
+
+    Returns:
+        np.ndarray: the inverse matrix.
+
+    Raises:
+         QiskitError: if the matrix is not square.
+         QiskitError: if the matrix is not invertible.
+    """
+
+    if mat.shape[0] != mat.shape[1]:
+        raise QiskitError("Matrix to invert is a non-square matrix.")
+
+    n = mat.shape[0]
+    # concatenate the matrix and identity
+    mat1 = np.concatenate((mat, np.eye(n, dtype=int)), axis=1)
+    mat1 = _gauss_elimination(mat1, None, full_elim=True)
+
+    r = _compute_rank_after_gauss_elim(mat1[:, 0:n])
+
+    if r < n:
+        raise QiskitError("The matrix is not invertible.")
+
+    matinv = mat1[:, n : 2 * n]
+
+    if verify:
+        mat2 = np.dot(mat, matinv) % 2
+        assert np.array_equal(mat2, np.eye(n))
+
+    return matinv
+
+
+def _compute_rank_after_gauss_elim(mat):
+    """Given a matrix A after Gaussian elimination, computes its rank
+    (i.e. simply the number of nonzero rows)"""
+    return np.sum(mat.any(axis=1))
+
+
+def _compute_rank(mat):
+    """Given a matrix A computes its rank"""
+    mat = _gauss_elimination(mat)
+    return np.sum(mat.any(axis=1))
+
+
+def _row_op(mat, ctrl, trgt):
+    # Perform ROW operation on a matrix mat
+    mat[trgt] = mat[trgt] ^ mat[ctrl]
+
+
+def _col_op(mat, ctrl, trgt):
+    # Perform COL operation on a matrix mat
+    mat[:, ctrl] = mat[:, trgt] ^ mat[:, ctrl]

qiskit/synthesis/linear_phase/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017 - 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Module containing cnot-phase circuits"""
+
+from .cz_depth_lnn import synth_cz_depth_line_mr
+from .cx_cz_depth_lnn import synth_cx_cz_depth_line_my
+from .cnot_phase_synth import synth_cnot_phase_aam

qiskit/synthesis/linear_phase/cnot_phase_synth.py

@@ -0,0 +1,203 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Implementation of the GraySynth algorithm for synthesizing CNOT-Phase
+circuits with efficient CNOT cost, and the Patel-Hayes-Markov algorithm
+for optimal synthesis of linear (CNOT-only) reversible circuits.
+"""
+
+import copy
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.synthesis.linear import synth_cnot_count_full_pmh
+
+
+def synth_cnot_phase_aam(cnots, angles, section_size=2):
+    """This function is an implementation of the GraySynth algorithm of
+    Amy, Azimadeh and Mosca.
+
+    GraySynth is a heuristic algorithm from [1] for synthesizing small parity networks.
+    It is inspired by Gray codes. Given a set of binary strings S
+    (called "cnots" bellow), the algorithm synthesizes a parity network for S by
+    repeatedly choosing an index i to expand and then effectively recursing on
+    the co-factors S_0 and S_1, consisting of the strings y in S,
+    with y_i = 0 or 1 respectively. As a subset S is recursively expanded,
+    CNOT gates are applied so that a designated target bit contains the
+    (partial) parity ksi_y(x) where y_i = 1 if and only if y'_i = 1 for all
+    y' in S. If S is a singleton {y'}, then y = y', hence the target bit contains
+    the value ksi_y'(x) as desired.
+
+    Notably, rather than uncomputing this sequence of CNOT gates when a subset S
+    is finished being synthesized, the algorithm maintains the invariant
+    that the remaining parities to be computed are expressed over the current state
+    of bits. This allows the algorithm to avoid the 'backtracking' inherent in
+    uncomputing-based methods.
+
+    The algorithm is described in detail in section 4 of [1].
+
+    Args:
+        cnots (list[list]): a matrix whose columns are the parities to be synthesized
+            e.g.::
+
+                [[0, 1, 1, 1, 1, 1],
+                 [1, 0, 0, 1, 1, 1],
+                 [1, 0, 0, 1, 0, 0],
+                 [0, 0, 1, 0, 1, 0]]
+
+            corresponds to::
+
+                 x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1
+
+        angles (list): a list containing all the phase-shift gates which are
+            to be applied, in the same order as in "cnots". A number is
+            interpreted as the angle of p(angle), otherwise the elements
+            have to be 't', 'tdg', 's', 'sdg' or 'z'.
+
+        section_size (int): the size of every section, used in _lwr_cnot_synth(), in the
+            Patel–Markov–Hayes algorithm. section_size must be a factor of num_qubits.
+
+    Returns:
+        QuantumCircuit: the decomposed quantum circuit.
+
+    Raises:
+        QiskitError: when dimensions of cnots and angles don't align.
+
+    References:
+        1. Matthew Amy, Parsiad Azimzadeh, and Michele Mosca.
+           *On the controlled-NOT complexity of controlled-NOT–phase circuits.*,
+           Quantum Science and Technology 4.1 (2018): 015002.
+           `arXiv:1712.01859 <https://arxiv.org/abs/1712.01859>`_
+    """
+    num_qubits = len(cnots)
+
+    # Create a quantum circuit on num_qubits
+    qcir = QuantumCircuit(num_qubits)
+
+    if len(cnots[0]) != len(angles):
+        raise QiskitError('Size of "cnots" and "angles" do not match.')
+
+    range_list = list(range(num_qubits))
+    epsilon = num_qubits
+    sta = []
+    cnots_copy = np.transpose(np.array(copy.deepcopy(cnots)))
+    # This matrix keeps track of the state in the algorithm
+    state = np.eye(num_qubits).astype("int")
+
+    # Check if some phase-shift gates can be applied, before adding any C-NOT gates
+    for qubit in range(num_qubits):
+        index = 0
+        for icnots in cnots_copy:
+            if np.array_equal(icnots, state[qubit]):
+                if angles[index] == "t":
+                    qcir.t(qubit)
+                elif angles[index] == "tdg":
+                    qcir.tdg(qubit)
+                elif angles[index] == "s":
+                    qcir.s(qubit)
+                elif angles[index] == "sdg":
+                    qcir.sdg(qubit)
+                elif angles[index] == "z":
+                    qcir.z(qubit)
+                else:
+                    qcir.p(angles[index] % np.pi, qubit)
+                del angles[index]
+                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                if index == len(cnots_copy):
+                    break
+                index -= 1
+            index += 1
+
+    # Implementation of the pseudo-code (Algorithm 1) in the aforementioned paper
+    sta.append([cnots, range_list, epsilon])
+    while sta != []:
+        [cnots, ilist, qubit] = sta.pop()
+        if cnots == []:
+            continue
+        if 0 <= qubit < num_qubits:
+            condition = True
+            while condition:
+                condition = False
+                for j in range(num_qubits):
+                    if (j != qubit) and (sum(cnots[j]) == len(cnots[j])):
+                        condition = True
+                        qcir.cx(j, qubit)
+                        state[qubit] ^= state[j]
+                        index = 0
+                        for icnots in cnots_copy:
+                            if np.array_equal(icnots, state[qubit]):
+                                if angles[index] == "t":
+                                    qcir.t(qubit)
+                                elif angles[index] == "tdg":
+                                    qcir.tdg(qubit)
+                                elif angles[index] == "s":
+                                    qcir.s(qubit)
+                                elif angles[index] == "sdg":
+                                    qcir.sdg(qubit)
+                                elif angles[index] == "z":
+                                    qcir.z(qubit)
+                                else:
+                                    qcir.p(angles[index] % np.pi, qubit)
+                                del angles[index]
+                                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                                if index == len(cnots_copy):
+                                    break
+                                index -= 1
+                            index += 1
+                        for x in _remove_duplicates(sta + [[cnots, ilist, qubit]]):
+                            [cnotsp, _, _] = x
+                            if cnotsp == []:
+                                continue
+                            for ttt in range(len(cnotsp[j])):
+                                cnotsp[j][ttt] ^= cnotsp[qubit][ttt]
+        if ilist == []:
+            continue
+        # See line 18 in pseudo-code of Algorithm 1 in the aforementioned paper
+        # this choice of j maximizes the size of the largest subset (S_0 or S_1)
+        # and the larger a subset, the closer it gets to the ideal in the
+        # Gray code of one CNOT per string.
+        j = ilist[np.argmax([[max(row.count(0), row.count(1)) for row in cnots][k] for k in ilist])]
+        cnots0 = []
+        cnots1 = []
+        for y in list(map(list, zip(*cnots))):
+            if y[j] == 0:
+                cnots0.append(y)
+            elif y[j] == 1:
+                cnots1.append(y)
+        cnots0 = list(map(list, zip(*cnots0)))
+        cnots1 = list(map(list, zip(*cnots1)))
+        if qubit == epsilon:
+            sta.append([cnots1, list(set(ilist).difference([j])), j])
+        else:
+            sta.append([cnots1, list(set(ilist).difference([j])), qubit])
+        sta.append([cnots0, list(set(ilist).difference([j])), qubit])
+    qcir &= synth_cnot_count_full_pmh(state, section_size).inverse()
+    return qcir
+
+
+def _remove_duplicates(lists):
+    """
+    Remove duplicates in list
+
+    Args:
+        lists (list): a list which may contain duplicate elements.
+
+    Returns:
+        list: a list which contains only unique elements.
+    """
+
+    unique_list = []
+    for element in lists:
+        if element not in unique_list:
+            unique_list.append(element)
+    return unique_list

qiskit/synthesis/linear_phase/cx_cz_depth_lnn.py

@@ -0,0 +1,262 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Given -CZ-CX- transformation (a layer consisting only CNOT gates
+    followed by a layer consisting only CZ gates)
+Return a depth-5n circuit implementation of the -CZ-CX- transformation over LNN.
+
+Args:
+    mat_z: n*n symmetric binary matrix representing a -CZ- circuit
+    mat_x: n*n invertable binary matrix representing a -CX- transformation
+
+Output:
+    QuantumCircuit: QuantumCircuit object containing a depth-5n circuit to implement -CZ-CX-
+
+References:
+    [1] S. A. Kutin, D. P. Moulton, and L. M. Smithline, "Computation at a distance," 2007.
+    [2] D. Maslov and W. Yang, "CNOT circuits need little help to implement arbitrary
+        Hadamard-free Clifford transformations they generate," 2022.
+"""
+
+from copy import deepcopy
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.synthesis.linear.linear_matrix_utils import calc_inverse_matrix
+from qiskit.synthesis.linear.linear_depth_lnn import _optimize_cx_circ_depth_5n_line
+
+
+def _initialize_phase_schedule(mat_z):
+    """
+    Given a CZ layer (represented as an n*n CZ matrix Mz)
+    Return a scheudle of phase gates implementing Mz in a SWAP-only netwrok
+    (c.f. Alg 1, [2])
+    """
+    n = len(mat_z)
+    phase_schedule = np.zeros((n, n), dtype=int)
+    for i, j in zip(*np.where(mat_z)):
+        if i >= j:
+            continue
+
+        phase_schedule[i, j] = 3
+        phase_schedule[i, i] += 1
+        phase_schedule[j, j] += 1
+
+    return phase_schedule
+
+
+def _shuffle(labels, odd):
+    """
+    Args:
+        labels : a list of indices
+        odd : a boolean indicating whether this layer is odd or even,
+    Shuffle the indices in labels by swapping adjacent elements
+    (c.f. Fig.2, [2])
+    """
+    swapped = [v for p in zip(labels[1::2], labels[::2]) for v in p]
+    return swapped + labels[-1:] if odd else swapped
+
+
+def _make_seq(n):
+    """
+    Given the width of the circuit n,
+    Return the labels of the boxes in order from left to right, top to bottom
+    (c.f. Fig.2, [2])
+    """
+    seq = []
+    wire_labels = list(range(n - 1, -1, -1))
+
+    for i in range(n):
+        wire_labels_new = (
+            _shuffle(wire_labels, n % 2)
+            if i % 2 == 0
+            else wire_labels[0:1] + _shuffle(wire_labels[1:], (n + 1) % 2)
+        )
+        seq += [
+            (min(i), max(i)) for i in zip(wire_labels[::2], wire_labels_new[::2]) if i[0] != i[1]
+        ]
+        wire_labels = wire_labels_new
+
+    return seq
+
+
+def _swap_plus(instructions, seq):
+    """
+    Given CX instructions (c.f. Thm 7.1, [1]) and the labels of all boxes,
+    Return a list of labels of the boxes that is SWAP+ in descending order
+        * Assumes the instruction gives gates in the order from top to bottom,
+          from left to right
+        * SWAP+ is defined in section 3.A. of [2]. Note the northwest
+          diagonalization procedure of [1] consists exactly n layers of boxes,
+          each being either a SWAP or a SWAP+. That is, each northwest
+          diagonalization circuit can be uniquely represented by which of its
+          n(n-1)/2 boxes are SWAP+ and which are SWAP.
+    """
+    instr = deepcopy(instructions)
+    swap_plus = set()
+    for i, j in reversed(seq):
+        cnot_1 = instr.pop()
+        instr.pop()
+
+        if instr == [] or instr[-1] != cnot_1:
+            # Only two CNOTs on same set of controls -> this box is SWAP+
+            swap_plus.add((i, j))
+        else:
+            instr.pop()
+    return swap_plus
+
+
+def _update_phase_schedule(n, phase_schedule, swap_plus):
+    """
+    Given phase_schedule initialized to induce a CZ circuit in SWAP-only network and list of SWAP+ boxes
+    Update phase_schedule for each SWAP+ according to Algorithm 2, [2]
+    """
+    layer_order = list(range(n))[-3::-2] + list(range(n))[-2::-2][::-1]
+    order_comp = np.argsort(layer_order[::-1])
+
+    # Go through each box by descending layer order
+
+    for i in layer_order:
+        for j in range(i + 1, n):
+            if (i, j) not in swap_plus:
+                continue
+            # we need to correct for the effected linear functions:
+
+            # We first correct type 1 and type 2 by switching
+            # the phase applied to c_j and c_i+c_j
+            phase_schedule[j, j], phase_schedule[i, j] = phase_schedule[i, j], phase_schedule[j, j]
+
+            # Then, we go through all the boxes that permutes j BEFORE box(i,j) and update:
+
+            for k in range(n):  # all boxes that permutes j
+                if k in (i, j):
+                    continue
+                if (
+                    order_comp[min(k, j)] < order_comp[i]
+                    and phase_schedule[min(k, j), max(k, j)] % 4 != 0
+                ):
+                    phase = phase_schedule[min(k, j), max(k, j)]
+                    phase_schedule[min(k, j), max(k, j)] = 0
+
+                    # Step 1, apply phase to c_i, c_j, c_k
+                    for l_s in (i, j, k):
+                        phase_schedule[l_s, l_s] = (phase_schedule[l_s, l_s] + phase * 3) % 4
+
+                    # Step 2, apply phase to c_i+ c_j, c_i+c_k, c_j+c_k:
+                    for l1, l2 in [(i, j), (i, k), (j, k)]:
+                        ls = min(l1, l2)
+                        lb = max(l1, l2)
+                        phase_schedule[ls, lb] = (phase_schedule[ls, lb] + phase * 3) % 4
+    return phase_schedule
+
+
+def _apply_phase_to_nw_circuit(n, phase_schedule, seq, swap_plus):
+    """
+    Given
+        Width of the circuit (int n)
+        A CZ circuit, represented by the n*n phase schedule phase_schedule
+        A CX circuit, represented by box-labels (seq) and whether the box is SWAP+ (swap_plus)
+            *   This circuit corresponds to the CX tranformation that tranforms a matrix to
+                a NW matrix (c.f. Prop.7.4, [1])
+            *   SWAP+ is defined in section 3.A. of [2].
+            *   As previously noted, the northwest diagonalization procedure of [1] consists
+                of exactly n layers of boxes, each being either a SWAP or a SWAP+. That is,
+                each northwest diagonalization circuit can be uniquely represented by which
+                of its n(n-1)/2 boxes are SWAP+ and which are SWAP.
+    Return a QuantumCircuit that computes the phase scheudle S inside CX
+    """
+    cir = QuantumCircuit(n)
+
+    wires = list(zip(range(n), range(1, n)))
+    wires = wires[::2] + wires[1::2]
+
+    for i, (j, k) in zip(range(len(seq) - 1, -1, -1), reversed(seq)):
+        w1, w2 = wires[i % (n - 1)]
+
+        p = phase_schedule[j, k]
+
+        if (j, k) not in swap_plus:
+            cir.cx(w1, w2)
+
+        cir.cx(w2, w1)
+
+        if p % 4 == 0:
+            pass
+        elif p % 4 == 1:
+            cir.sdg(w2)
+        elif p % 4 == 2:
+            cir.z(w2)
+        else:
+            cir.s(w2)
+
+        cir.cx(w1, w2)
+
+    for i in range(n):
+        p = phase_schedule[n - 1 - i, n - 1 - i]
+        if p % 4 == 0:
+            continue
+        if p % 4 == 1:
+            cir.sdg(i)
+        elif p % 4 == 2:
+            cir.z(i)
+        else:
+            cir.s(i)
+
+    return cir
+
+
+def synth_cx_cz_depth_line_my(mat_x: np.ndarray, mat_z: np.ndarray):
+    """
+    Joint synthesis of a -CZ-CX- circuit for linear nearest neighbour (LNN) connectivity,
+    with 2-qubit depth at most 5n, based on Maslov and Yang.
+    This method computes the CZ circuit inside the CX circuit via phase gate insertions.
+
+    Args:
+        mat_z : a boolean symmetric matrix representing a CZ circuit.
+            Mz[i][j]=1 represents a CZ(i,j) gate
+
+        mat_x : a boolean invertible matrix representing a CX circuit.
+
+    Return:
+        QuantumCircuit : a circuit implementation of a CX circuit following a CZ circuit,
+        denoted as a -CZ-CX- circuit,in two-qubit depth at most 5n, for LNN connectivity.
+
+    Reference:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+        2. Dmitri Maslov, Willers Yang, *CNOT circuits need little help to implement arbitrary
+           Hadamard-free Clifford transformations they generate*,
+           `arXiv:2210.16195 <https://arxiv.org/abs/2210.16195>`_.
+    """
+
+    # First, find circuits implementing mat_x by Proposition 7.3 and Proposition 7.4 of [1]
+
+    n = len(mat_x)
+    mat_x = calc_inverse_matrix(mat_x)
+
+    cx_instructions_rows_m2nw, cx_instructions_rows_nw2id = _optimize_cx_circ_depth_5n_line(mat_x)
+
+    # Meanwhile, also build the -CZ- circuit via Phase gate insertions as per Algorithm 2 [2]
+    phase_schedule = _initialize_phase_schedule(mat_z)
+    seq = _make_seq(n)
+    swap_plus = _swap_plus(cx_instructions_rows_nw2id, seq)
+
+    _update_phase_schedule(n, phase_schedule, swap_plus)
+
+    qc = _apply_phase_to_nw_circuit(n, phase_schedule, seq, swap_plus)
+
+    for i, j in reversed(cx_instructions_rows_m2nw):
+        qc.cx(i, j)
+
+    return qc