qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/synthesis/linear_phase/cz_depth_lnn.py

@@ -0,0 +1,206 @@
+# 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.
+
+"""
+Synthesis of an n-qubit circuit containing only CZ gates for
+linear nearest neighbor (LNN) connectivity, using CX and phase (S, Sdg or Z) gates.
+The two-qubit depth of the circuit is bounded by 2*n+2.
+This algorithm reverts the order of qubits.
+
+References:
+    [1]: Dmitri Maslov, Martin Roetteler,
+         Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations,
+         `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+
+
+def _append_cx_stage1(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i, 2 * i + 1)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 2, 2 * i + 1)
+    return qc
+
+
+def _append_cx_stage2(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i + 1, 2 * i)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 1, 2 * i + 2)
+    return qc
+
+
+def _odd_pattern1(n):
+    """A pattern denoted by Pj in [1] for odd number of qubits:
+    [n-2, n-4, n-4, ..., 3, 3, 1, 1, 0, 0, 2, 2, ..., n-3, n-3]
+    """
+    pat = []
+    pat.append(n - 2)
+    for i in range((n - 3) // 2):
+        pat.append(n - 2 * i - 4)
+        pat.append(n - 2 * i - 4)
+    for i in range((n - 1) // 2):
+        pat.append(2 * i)
+        pat.append(2 * i)
+    return pat
+
+
+def _odd_pattern2(n):
+    """A pattern denoted by Pk in [1] for odd number of qubits:
+    [2, 2, 4, 4, ..., n-1, n-1, n-2, n-2, n-4, n-4, ..., 5, 5, 3, 3, 1]
+    """
+    pat = []
+    for i in range((n - 1) // 2):
+        pat.append(2 * i + 2)
+        pat.append(2 * i + 2)
+    for i in range((n - 3) // 2):
+        pat.append(n - 2 * i - 2)
+        pat.append(n - 2 * i - 2)
+    pat.append(1)
+    return pat
+
+
+def _even_pattern1(n):
+    """A pattern denoted by Pj in [1] for even number of qubits:
+    [n-1, n-3, n-3, n-5, n-5, ..., 1, 1, 0, 0, 2, 2, ..., n-4, n-4, n-2]
+    """
+    pat = []
+    pat.append(n - 1)
+    for i in range((n - 2) // 2):
+        pat.append(n - 2 * i - 3)
+        pat.append(n - 2 * i - 3)
+    for i in range((n - 2) // 2):
+        pat.append(2 * i)
+        pat.append(2 * i)
+    pat.append(n - 2)
+    return pat
+
+
+def _even_pattern2(n):
+    """A pattern denoted by Pk in [1] for even number of qubits:
+    [2, 2, 4, 4, ..., n-2, n-2, n-1, n-1, ..., 3, 3, 1, 1]
+    """
+    pat = []
+    for i in range((n - 2) // 2):
+        pat.append(2 * (i + 1))
+        pat.append(2 * (i + 1))
+    for i in range(n // 2):
+        pat.append(n - 2 * i - 1)
+        pat.append(n - 2 * i - 1)
+    return pat
+
+
+def _create_patterns(n):
+    """Creating the patterns for the phase layers."""
+    if (n % 2) == 0:
+        pat1 = _even_pattern1(n)
+        pat2 = _even_pattern2(n)
+    else:
+        pat1 = _odd_pattern1(n)
+        pat2 = _odd_pattern2(n)
+    pats = {}
+
+    layer = 0
+    for i in range(n):
+        pats[(0, i)] = (i, i)
+
+    if (n % 2) == 0:
+        ind1 = (2 * n - 4) // 2
+    else:
+        ind1 = (2 * n - 4) // 2 - 1
+    ind2 = 0
+    while layer < (n // 2):
+        for i in range(n):
+            pats[(layer + 1, i)] = (pat1[ind1 + i], pat2[ind2 + i])
+        layer += 1
+        ind1 -= 2
+        ind2 += 2
+    return pats
+
+
+def synth_cz_depth_line_mr(mat: np.ndarray):
+    """Synthesis of a CZ circuit for linear nearest neighbour (LNN) connectivity,
+    based on Maslov and Roetteler.
+
+    Note that this method *reverts* the order of qubits in the circuit,
+    and returns a circuit containing CX and phase (S, Sdg or Z) gates.
+
+    Args:
+        mat: an upper-diagonal matrix representing the CZ circuit.
+            mat[i][j]=1 for i<j represents a CZ(i,j) gate
+
+    Return:
+        QuantumCircuit: a circuit implementation of the CZ circuit of depth 2*n+2 for LNN connectivity.
+
+    Reference:
+        1. Dmitri Maslov, Martin Roetteler,
+           *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+           `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+    """
+    num_qubits = mat.shape[0]
+    pats = _create_patterns(num_qubits)
+    patlist = []
+    # s_gates[i] = 0, 1, 2 or 3 for a gate id, sdg, z or s on qubit i respectively
+    s_gates = np.zeros(num_qubits)
+
+    qc = QuantumCircuit(num_qubits)
+    for i in range(num_qubits):
+        for j in range(i + 1, num_qubits):
+            if mat[i][j]:  # CZ(i,j) gate
+                s_gates[i] += 2  # qc.z[i]
+                s_gates[j] += 2  # qc.z[j]
+                patlist.append((i, j - 1))
+                patlist.append((i, j))
+                patlist.append((i + 1, j - 1))
+                patlist.append((i + 1, j))
+
+    for i in range((num_qubits + 1) // 2):
+        for j in range(num_qubits):
+            if pats[(i, j)] in patlist:
+                patcnt = patlist.count(pats[(i, j)])
+                for _ in range(patcnt):
+                    s_gates[j] += 1  # qc.sdg[j]
+        # Add phase gates: s, sdg or z
+        for j in range(num_qubits):
+            if s_gates[j] % 4 == 1:
+                qc.sdg(j)
+            elif s_gates[j] % 4 == 2:
+                qc.z(j)
+            elif s_gates[j] % 4 == 3:
+                qc.s(j)
+        qc = _append_cx_stage1(qc, num_qubits)
+        qc = _append_cx_stage2(qc, num_qubits)
+        s_gates = np.zeros(num_qubits)
+
+    if (num_qubits % 2) == 0:
+        i = num_qubits // 2
+        for j in range(num_qubits):
+            if pats[(i, j)] in patlist and pats[(i, j)][0] != pats[(i, j)][1]:
+                patcnt = patlist.count(pats[(i, j)])
+                for _ in range(patcnt):
+                    s_gates[j] += 1  # qc.sdg[j]
+        # Add phase gates: s, sdg or z
+        for j in range(num_qubits):
+            if s_gates[j] % 4 == 1:
+                qc.sdg(j)
+            elif s_gates[j] % 4 == 2:
+                qc.z(j)
+            elif s_gates[j] % 4 == 3:
+                qc.s(j)
+        qc = _append_cx_stage1(qc, num_qubits)
+
+    return qc

qiskit/synthesis/permutation/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Module containing synthesis algorithms for Permutation gates."""
+
+
+from .permutation_lnn import synth_permutation_depth_lnn_kms
+from .permutation_full import synth_permutation_basic, synth_permutation_acg

qiskit/synthesis/permutation/permutation_full.py

@@ -0,0 +1,90 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Synthesis algorithm for Permutation gates for full-connectivity."""
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from .permutation_utils import (
+    _get_ordered_swap,
+    _inverse_pattern,
+    _pattern_to_cycles,
+    _decompose_cycles,
+)
+
+
+def synth_permutation_basic(pattern):
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using sorting.
+
+    More precisely, if the input permutation is a cycle of length ``m``,
+    then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+    if the input  permutation consists of several disjoint cycles, then each cycle
+    is essentially treated independently.
+
+    Args:
+        pattern (Union[list[int], np.ndarray]): permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        QuantumCircuit: the synthesized quantum circuit.
+    """
+    # This is the very original Qiskit algorithm for synthesizing permutations.
+
+    num_qubits = len(pattern)
+    qc = QuantumCircuit(num_qubits)
+
+    swaps = _get_ordered_swap(pattern)
+
+    for swap in swaps:
+        qc.swap(swap[0], swap[1])
+
+    return qc
+
+
+def synth_permutation_acg(pattern):
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using the Alon, Chung, Graham method.
+
+    This produces a quantum circuit of depth 2 (measured in the number of SWAPs).
+
+    This implementation is based on the Theorem 2 in the paper
+    "Routing Permutations on Graphs Via Matchings" (1993),
+    available at https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf.
+
+    Args:
+        pattern (Union[list[int], np.ndarray]): permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        QuantumCircuit: the synthesized quantum circuit.
+    """
+
+    num_qubits = len(pattern)
+    qc = QuantumCircuit(num_qubits)
+
+    # invert pattern (Qiskit notation is opposite)
+    cur_pattern = _inverse_pattern(pattern)
+    cycles = _pattern_to_cycles(cur_pattern)
+    swaps = _decompose_cycles(cycles)
+
+    for swap in swaps:
+        qc.swap(swap[0], swap[1])
+
+    return qc

qiskit/synthesis/permutation/permutation_lnn.py

@@ -0,0 +1,68 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Depth-efficient synthesis algorithm for Permutation gates."""
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from .permutation_utils import _inverse_pattern
+
+
+def synth_permutation_depth_lnn_kms(pattern):
+    """Synthesize a permutation circuit for a linear nearest-neighbor
+    architecture using the Kutin, Moulton, Smithline method.
+
+    This is the permutation synthesis algorithm from
+    https://arxiv.org/abs/quant-ph/0701194, Chapter 6.
+    It synthesizes any permutation of n qubits over linear nearest-neighbor
+    architecture using SWAP gates with depth at most n and size at most
+    n(n-1)/2 (where both depth and size are measured with respect to SWAPs).
+
+    Args:
+        pattern (Union[list[int], np.ndarray]): permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        QuantumCircuit: the synthesized quantum circuit.
+    """
+
+    # In Qiskit, the permutation pattern [2, 4, 3, 0, 1] means that
+    # the permutation that maps qubit 2 to position 0, 4 to 1, 3 to 2, 0 to 3, and 1 to 4.
+    # In the permutation synthesis code below the notation is opposite:
+    # [2, 4, 3, 0, 1] means that 0 maps to 2, 1 to 3, 2 to 3, 3 to 0, and 4 to 1.
+    # This is why we invert the pattern.
+    cur_pattern = _inverse_pattern(pattern)
+
+    num_qubits = len(cur_pattern)
+    qc = QuantumCircuit(num_qubits)
+
+    # add conditional odd-even swap layers
+    for i in range(num_qubits):
+        _create_swap_layer(qc, cur_pattern, i % 2)
+
+    return qc
+
+
+def _create_swap_layer(qc, pattern, starting_point):
+    """Implements a single swap layer, consisting of conditional swaps between each
+    neighboring couple. The starting_point is the first qubit to use (either 0 or 1
+    for even or odd layers respectively). Mutates both the quantum circuit ``qc``
+    and the permutation pattern ``pattern``.
+    """
+    num_qubits = len(pattern)
+    for j in range(starting_point, num_qubits - 1, 2):
+        if pattern[j] > pattern[j + 1]:
+            qc.swap(j, j + 1)
+            pattern[j], pattern[j + 1] = pattern[j + 1], pattern[j]

qiskit/synthesis/permutation/permutation_utils.py

@@ -0,0 +1,73 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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 permutations."""
+
+
+def _get_ordered_swap(permutation_in):
+    """Sorts the input permutation by iterating through the permutation list
+    and putting each element to its correct position via a SWAP (if it's not
+    at the correct position already). If ``n`` is the length of the input
+    permutation, this requires at most ``n`` SWAPs.
+
+    More precisely, if the input permutation is a cycle of length ``m``,
+    then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+    if the input  permutation consists of several disjoint cycles, then each cycle
+    is essentially treated independently.
+    """
+    permutation = list(permutation_in[:])
+    swap_list = []
+    index_map = _inverse_pattern(permutation_in)
+    for i, val in enumerate(permutation):
+        if val != i:
+            j = index_map[i]
+            swap_list.append((i, j))
+            permutation[i], permutation[j] = permutation[j], permutation[i]
+            index_map[val] = j
+            index_map[i] = i
+    swap_list.reverse()
+    return swap_list
+
+
+def _inverse_pattern(pattern):
+    """Finds inverse of a permutation pattern."""
+    b_map = {pos: idx for idx, pos in enumerate(pattern)}
+    return [b_map[pos] for pos in range(len(pattern))]
+
+
+def _pattern_to_cycles(pattern):
+    """Given a permutation pattern, creates its disjoint cycle decomposition."""
+    nq = len(pattern)
+    explored = [False] * nq
+    cycles = []
+    for i in pattern:
+        cycle = []
+        while not explored[i]:
+            cycle.append(i)
+            explored[i] = True
+            i = pattern[i]
+        if len(cycle) >= 2:
+            cycles.append(cycle)
+    return cycles
+
+
+def _decompose_cycles(cycles):
+    """Given a disjoint cycle decomposition, decomposes every cycle into a SWAP
+    circuit of depth 2."""
+    swap_list = []
+    for cycle in cycles:
+        m = len(cycle)
+        for i in range((m - 1) // 2):
+            swap_list.append((cycle[i - 1], cycle[m - 3 - i]))
+        for i in range(m // 2):
+            swap_list.append((cycle[i - 1], cycle[m - 2 - i]))
+    return swap_list

qiskit/synthesis/stabilizer/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+"""Module containing stabilizer state preparation circuit synthesis."""
+
+from .stabilizer_decompose import synth_stabilizer_layers, synth_stabilizer_depth_lnn

qiskit/synthesis/stabilizer/stabilizer_decompose.py

@@ -0,0 +1,188 @@
+# 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.
+"""
+Circuit synthesis for a stabilizer state preparation circuit.
+"""
+# pylint: disable=invalid-name
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.states import StabilizerState
+from qiskit.synthesis.linear.linear_matrix_utils import (
+    calc_inverse_matrix,
+)
+from qiskit.synthesis.linear_phase import synth_cz_depth_line_mr
+from qiskit.synthesis.clifford.clifford_decompose_layers import (
+    _default_cz_synth_func,
+    _reverse_clifford,
+    _create_graph_state,
+    _decompose_graph_state,
+)
+
+
+def synth_stabilizer_layers(
+    stab,
+    cz_synth_func=_default_cz_synth_func,
+    cz_func_reverse_qubits=False,
+    validate=False,
+):
+    """Synthesis of a stabilizer state into layers.
+
+    It provides a similar decomposition to the synthesis described in Lemma 8 of Bravyi and Maslov,
+    without the initial Hadamard-free sub-circuit which do not affect the stabilizer state.
+
+    For example, a 5-qubit stabilizer state is decomposed into the following layers:
+
+    .. parsed-literal::
+             ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
+        q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
+             │     ││     ││     ││     ││        │
+        q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
+             │     ││     ││     ││     ││        │
+        q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
+             │     ││     ││     ││     ││        │
+        q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
+             │     ││     ││     ││     ││        │
+        q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
+             └─────┘└─────┘└─────┘└─────┘└────────┘
+
+    Args:
+        stab (StabilizerState): a stabilizer state.
+        cz_synth_func (Callable): a function to decompose the CZ sub-circuit.
+            It gets as input a boolean symmetric matrix, and outputs a QuantumCircuit.
+        validate (Boolean): if True, validates the synthesis process.
+        cz_func_reverse_qubits (Boolean): True only if cz_synth_func is synth_cz_depth_line_mr,
+            since this function returns a circuit that reverts the order of qubits.
+
+    Return:
+        QuantumCircuit: a circuit implementation of the stabilizer state.
+
+    Raises:
+        QiskitError: if the input is not a StabilizerState.
+
+    Reference:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+    """
+
+    if not isinstance(stab, StabilizerState):
+        raise QiskitError("The input is not a StabilizerState.")
+
+    cliff = stab.clifford
+    num_qubits = cliff.num_qubits
+
+    if cz_func_reverse_qubits:
+        cliff0 = _reverse_clifford(cliff)
+    else:
+        cliff0 = cliff
+
+    H1_circ, cliff1 = _create_graph_state(cliff0, validate=validate)
+
+    H2_circ, CZ1_circ, S1_circ, _ = _decompose_graph_state(
+        cliff1, validate=validate, cz_synth_func=cz_synth_func
+    )
+
+    qubit_list = list(range(num_qubits))
+    layeredCircuit = QuantumCircuit(num_qubits)
+
+    layeredCircuit.append(H2_circ, qubit_list)
+    layeredCircuit.append(S1_circ, qubit_list)
+    layeredCircuit.append(CZ1_circ, qubit_list)
+
+    if cz_func_reverse_qubits:
+        H1_circ = H1_circ.reverse_bits()
+    layeredCircuit.append(H1_circ, qubit_list)
+
+    # Add Pauli layer to fix the Clifford phase signs
+    # pylint: disable=cyclic-import
+    from qiskit.quantum_info.operators.symplectic import Clifford
+
+    clifford_target = Clifford(layeredCircuit)
+    pauli_circ = _calc_pauli_diff_stabilizer(cliff, clifford_target)
+    layeredCircuit.append(pauli_circ, qubit_list)
+
+    return layeredCircuit
+
+
+def _calc_pauli_diff_stabilizer(cliff, cliff_target):
+    """Given two Cliffords whose stabilizers differ by a Pauli, we find this Pauli."""
+
+    # pylint: disable=cyclic-import
+    from qiskit.quantum_info.operators.symplectic import Pauli
+
+    num_qubits = cliff.num_qubits
+    if cliff.num_qubits != cliff_target.num_qubits:
+        raise QiskitError("num_qubits is not the same for the original clifford and the target.")
+
+    # stabilizer generators of the original clifford
+    stab_gen = StabilizerState(cliff).clifford.to_dict()["stabilizer"]
+
+    # stabilizer state of the target clifford
+    ts = StabilizerState(cliff_target)
+
+    phase_destab = [False] * num_qubits
+    phase_stab = [ts.expectation_value(Pauli(stab_gen[i])) == -1 for i in range(num_qubits)]
+
+    phase = []
+    phase.extend(phase_destab)
+    phase.extend(phase_stab)
+    phase = np.array(phase, dtype=int)
+
+    A = cliff.symplectic_matrix.astype(int)
+    Ainv = calc_inverse_matrix(A)
+
+    # By carefully writing how X, Y, Z gates affect each qubit, all we need to compute
+    # is A^{-1} * (phase)
+    C = np.matmul(Ainv, phase) % 2
+
+    # Create the Pauli
+    pauli_circ = QuantumCircuit(num_qubits, name="Pauli")
+    for k in range(num_qubits):
+        destab = C[k]
+        stab = C[k + num_qubits]
+        if stab and destab:
+            pauli_circ.y(k)
+        elif stab:
+            pauli_circ.x(k)
+        elif destab:
+            pauli_circ.z(k)
+
+    return pauli_circ
+
+
+def synth_stabilizer_depth_lnn(stab):
+    """Synthesis of an n-qubit stabilizer state for linear-nearest neighbour connectivity,
+    in 2-qubit depth 2*n+2 and two distinct CX layers, using CX and phase gates (S, Sdg or Z).
+
+    Args:
+        stab (StabilizerState): a stabilizer state.
+
+    Return:
+        QuantumCircuit: a circuit implementation of the stabilizer state.
+
+    Reference:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+        2. Dmitri Maslov, Martin Roetteler,
+           *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+           `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+    """
+
+    circ = synth_stabilizer_layers(
+        stab,
+        cz_synth_func=synth_cz_depth_line_mr,
+        cz_func_reverse_qubits=True,
+    )
+    return circ

qiskit/test/__init__.py

@@ -0,0 +1,18 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""Functionality and helpers for testing Qiskit."""
+
+from .base import QiskitTestCase
+from .decorators import requires_aer_provider, online_test, slow_test
+from .reference_circuits import ReferenceCircuits
+from .utils import Path