qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/generalized_gates/uc_pauli_rot.py

@@ -0,0 +1,164 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+# The structure of the code is based on Emanuel Malvetti's semester thesis at ETH in 2018,
+# which was supervised by Raban Iten and Prof. Renato Renner.
+
+"""Uniformly controlled Pauli rotations."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+from qiskit.exceptions import QiskitError
+
+_EPS = 1e-10  # global variable used to chop very small numbers to zero
+
+
+class UCPauliRotGate(Gate):
+    r"""Uniformly controlled Pauli rotations.
+
+    Implements the :class:`.UCGate` for the special case that all unitaries are Pauli rotations,
+    :math:`U_i = R_P(a_i)` where :math:`P \in \{X, Y, Z\}` and :math:`a_i \in \mathbb{R}` is
+    the rotation angle.
+    """
+
+    def __init__(self, angle_list: list[float], rot_axis: str) -> None:
+        r"""
+        Args:
+            angle_list: List of rotation angles :math:`[a_0, ..., a_{2^{k-1}}]`.
+            rot_axis: Rotation axis. Must be either of ``"X"``, ``"Y"`` or ``"Z"``.
+        """
+        self.rot_axes = rot_axis
+        # Check if angle_list has type "list"
+        if not isinstance(angle_list, list):
+            raise QiskitError("The angles are not provided in a list.")
+        # Check if the angles in angle_list are real numbers
+        for angle in angle_list:
+            try:
+                float(angle)
+            except TypeError as ex:
+                raise QiskitError(
+                    "An angle cannot be converted to type float (real angles are expected)."
+                ) from ex
+        num_contr = math.log2(len(angle_list))
+        if num_contr < 0 or not num_contr.is_integer():
+            raise QiskitError(
+                "The number of controlled rotation gates is not a non-negative power of 2."
+            )
+        if rot_axis not in ("X", "Y", "Z"):
+            raise QiskitError("Rotation axis is not supported.")
+        # Create new gate.
+        num_qubits = int(num_contr) + 1
+        super().__init__("ucr" + rot_axis.lower(), num_qubits, angle_list)
+
+    def _define(self):
+        ucr_circuit = self._dec_ucrot()
+        gate = ucr_circuit.to_instruction()
+        q = QuantumRegister(self.num_qubits, "q")
+        ucr_circuit = QuantumCircuit(q)
+        ucr_circuit.append(gate, q[:])
+        self.definition = ucr_circuit
+
+    def _dec_ucrot(self):
+        """
+        Finds a decomposition of a UC rotation gate into elementary gates
+        (C-NOTs and single-qubit rotations).
+        """
+        q = QuantumRegister(self.num_qubits, "q")
+        circuit = QuantumCircuit(q)
+        q_target = q[0]
+        q_controls = q[1:]
+        if not q_controls:  # equivalent to: if len(q_controls) == 0
+            if self.rot_axes == "X":
+                if np.abs(self.params[0]) > _EPS:
+                    circuit.rx(self.params[0], q_target)
+            if self.rot_axes == "Y":
+                if np.abs(self.params[0]) > _EPS:
+                    circuit.ry(self.params[0], q_target)
+            if self.rot_axes == "Z":
+                if np.abs(self.params[0]) > _EPS:
+                    circuit.rz(self.params[0], q_target)
+        else:
+            # First, we find the rotation angles of the single-qubit rotations acting
+            #  on the target qubit
+            angles = self.params.copy()
+            UCPauliRotGate._dec_uc_rotations(angles, 0, len(angles), False)
+            # Now, it is easy to place the C-NOT gates to get back the full decomposition.
+            for i, angle in enumerate(angles):
+                if self.rot_axes == "X":
+                    if np.abs(angle) > _EPS:
+                        circuit.rx(angle, q_target)
+                if self.rot_axes == "Y":
+                    if np.abs(angle) > _EPS:
+                        circuit.ry(angle, q_target)
+                if self.rot_axes == "Z":
+                    if np.abs(angle) > _EPS:
+                        circuit.rz(angle, q_target)
+                # Determine the index of the qubit we want to control the C-NOT gate.
+                # Note that it corresponds
+                # to the number of trailing zeros in the binary representation of i+1
+                if not i == len(angles) - 1:
+                    binary_rep = np.binary_repr(i + 1)
+                    q_contr_index = len(binary_rep) - len(binary_rep.rstrip("0"))
+                else:
+                    # Handle special case:
+                    q_contr_index = len(q_controls) - 1
+                # For X rotations, we have to additionally place some Ry gates around the
+                # C-NOT gates. They change the basis of the NOT operation, such that the
+                # decomposition of for uniformly controlled X rotations works correctly by symmetry
+                # with the decomposition of uniformly controlled Z or Y rotations
+                if self.rot_axes == "X":
+                    circuit.ry(np.pi / 2, q_target)
+                circuit.cx(q_controls[q_contr_index], q_target)
+                if self.rot_axes == "X":
+                    circuit.ry(-np.pi / 2, q_target)
+        return circuit
+
+    @staticmethod
+    def _dec_uc_rotations(angles, start_index, end_index, reversed_dec):
+        """
+        Calculates rotation angles for a uniformly controlled R_t gate with a C-NOT gate at
+        the end of the circuit. The rotation angles of the gate R_t are stored in
+        angles[start_index:end_index]. If reversed_dec == True, it decomposes the gate such that
+        there is a C-NOT gate at the start of the circuit (in fact, the circuit topology for
+        the reversed decomposition is the reversed one of the original decomposition)
+        """
+        interval_len_half = (end_index - start_index) // 2
+        for i in range(start_index, start_index + interval_len_half):
+            if not reversed_dec:
+                angles[i], angles[i + interval_len_half] = UCPauliRotGate._update_angles(
+                    angles[i], angles[i + interval_len_half]
+                )
+            else:
+                angles[i + interval_len_half], angles[i] = UCPauliRotGate._update_angles(
+                    angles[i], angles[i + interval_len_half]
+                )
+        if interval_len_half <= 1:
+            return
+        else:
+            UCPauliRotGate._dec_uc_rotations(
+                angles, start_index, start_index + interval_len_half, False
+            )
+            UCPauliRotGate._dec_uc_rotations(
+                angles, start_index + interval_len_half, end_index, True
+            )
+
+    @staticmethod
+    def _update_angles(angle1, angle2):
+        """Calculate the new rotation angles according to Shende's decomposition."""
+        return (angle1 + angle2) / 2.0, (angle1 - angle2) / 2.0

qiskit/circuit/library/generalized_gates/ucrx.py

@@ -0,0 +1,32 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Uniformly controlled Pauli-X rotations."""
+
+from __future__ import annotations
+
+from .uc_pauli_rot import UCPauliRotGate
+
+
+class UCRXGate(UCPauliRotGate):
+    r"""Uniformly controlled Pauli-X rotations.
+
+    Implements the :class:`.UCGate` for the special case that all unitaries are Pauli-X rotations,
+    :math:`U_i = R_X(a_i)` where :math:`a_i \in \mathbb{R}` is the rotation angle.
+    """
+
+    def __init__(self, angle_list: list[float]) -> None:
+        r"""
+        Args:
+            angle_list: List of rotation angles :math:`[a_0, ..., a_{2^{k-1}}]`.
+        """
+        super().__init__(angle_list, "X")

qiskit/circuit/library/generalized_gates/ucry.py

@@ -0,0 +1,32 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Uniformly controlled Pauli-Y rotations."""
+
+from __future__ import annotations
+
+from .uc_pauli_rot import UCPauliRotGate
+
+
+class UCRYGate(UCPauliRotGate):
+    r"""Uniformly controlled Pauli-Y rotations.
+
+    Implements the :class:`.UCGate` for the special case that all unitaries are Pauli-Y rotations,
+    :math:`U_i = R_Y(a_i)` where :math:`a_i \in \mathbb{R}` is the rotation angle.
+    """
+
+    def __init__(self, angle_list: list[float]) -> None:
+        r"""
+        Args:
+            angle_list: List of rotation angles :math:`[a_0, ..., a_{2^{k-1}}]`.
+        """
+        super().__init__(angle_list, "Y")

qiskit/circuit/library/generalized_gates/ucrz.py

@@ -0,0 +1,32 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Uniformly controlled Pauli-Z rotations."""
+
+from __future__ import annotations
+
+from .uc_pauli_rot import UCPauliRotGate
+
+
+class UCRZGate(UCPauliRotGate):
+    r"""Uniformly controlled Pauli-Z rotations.
+
+    Implements the :class:`.UCGate` for the special case that all unitaries are Pauli-Z rotations,
+    :math:`U_i = R_Z(a_i)` where :math:`a_i \in \mathbb{R}` is the rotation angle.
+    """
+
+    def __init__(self, angle_list: list[float]):
+        r"""
+        Args:
+            angle_list: List of rotation angles :math:`[a_0, ..., a_{2^{k-1}}]`.
+        """
+        super().__init__(angle_list, "Z")

qiskit/circuit/library/generalized_gates/unitary.py

@@ -0,0 +1,236 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2024.
+#
+# 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.
+
+"""Arbitrary unitary circuit instruction."""
+
+from __future__ import annotations
+import math
+
+import typing
+import numpy
+
+from qiskit import _numpy_compat
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.controlledgate import ControlledGate
+from qiskit.circuit.annotated_operation import AnnotatedOperation, ControlModifier
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit._utils import _compute_control_matrix
+from qiskit.circuit.library.standard_gates.u import UGate
+from qiskit.quantum_info.operators.predicates import matrix_equal
+from qiskit.quantum_info.operators.predicates import is_unitary_matrix
+
+from .isometry import Isometry
+
+if typing.TYPE_CHECKING:
+    from qiskit.quantum_info.operators.base_operator import BaseOperator
+
+
+class UnitaryGate(Gate):
+    """Class quantum gates specified by a unitary matrix.
+
+    Example:
+
+        We can create a unitary gate from a unitary matrix then add it to a
+        quantum circuit. The matrix can also be directly applied to the quantum
+        circuit, see :meth:`.QuantumCircuit.unitary`.
+
+        .. plot::
+           :include-source:
+           :nofigs:
+
+            from qiskit import QuantumCircuit
+            from qiskit.circuit.library import UnitaryGate
+
+            matrix = [[0, 0, 0, 1],
+                      [0, 0, 1, 0],
+                      [1, 0, 0, 0],
+                      [0, 1, 0, 0]]
+            gate = UnitaryGate(matrix)
+
+            circuit = QuantumCircuit(2)
+            circuit.append(gate, [0, 1])
+    """
+
+    def __init__(
+        self,
+        data: numpy.ndarray | Gate | BaseOperator,
+        label: str | None = None,
+        check_input: bool = True,
+        *,
+        num_qubits: int | None = None,
+    ) -> None:
+        """Create a gate from a numeric unitary matrix.
+
+        Args:
+            data: Unitary operator.
+            label: Unitary name for backend [Default: ``None``].
+            check_input: If set to ``False`` this asserts the input
+                is known to be unitary and the checking to validate this will
+                be skipped. This should only ever be used if you know the
+                input is unitary, setting this to ``False`` and passing in
+                a non-unitary matrix will result unexpected behavior and errors.
+            num_qubits: If given, the number of qubits in the matrix.  If not given, it is inferred.
+
+        Raises:
+            ValueError: If input data is not an N-qubit unitary operator.
+        """
+        if hasattr(data, "to_matrix"):
+            # If input is Gate subclass or some other class object that has
+            # a to_matrix method this will call that method.
+            data = data.to_matrix()
+        elif hasattr(data, "to_operator"):
+            # If input is a BaseOperator subclass this attempts to convert
+            # the object to an Operator so that we can extract the underlying
+            # numpy matrix from `Operator.data`.
+            data = data.to_operator().data
+        # Convert to numpy array in case not already an array
+        data = numpy.asarray(data, dtype=complex)
+        input_dim, output_dim = data.shape
+        num_qubits = num_qubits if num_qubits is not None else int(math.log2(input_dim))
+        if check_input:
+            # Check input is unitary
+            if not is_unitary_matrix(data):
+                raise ValueError("Input matrix is not unitary.")
+            # Check input is N-qubit matrix
+            if input_dim != output_dim or 2**num_qubits != input_dim:
+                raise ValueError("Input matrix is not an N-qubit operator.")
+        # Store instruction params
+        super().__init__("unitary", num_qubits, [data], label=label)
+
+    def __eq__(self, other):
+        if not isinstance(other, UnitaryGate):
+            return False
+        if self.label != other.label:
+            return False
+        return matrix_equal(self.params[0], other.params[0])
+
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        """Return matrix for the unitary."""
+        dtype = self.params[0].dtype if dtype is None else dtype
+        return numpy.array(self.params[0], dtype=dtype, copy=copy)
+
+    def inverse(self, annotated: bool = False):
+        """Return the adjoint of the unitary."""
+        return self.adjoint()
+
+    def conjugate(self):
+        """Return the conjugate of the unitary."""
+        return UnitaryGate(numpy.conj(self.to_matrix()))
+
+    def adjoint(self):
+        """Return the adjoint of the unitary."""
+        return self.transpose().conjugate()
+
+    def transpose(self):
+        """Return the transpose of the unitary."""
+        return UnitaryGate(numpy.transpose(self.to_matrix()))
+
+    def _define(self):
+        """Calculate a subcircuit that implements this unitary."""
+        if self.num_qubits == 1:
+            from qiskit.synthesis.one_qubit.one_qubit_decompose import OneQubitEulerDecomposer
+
+            q = QuantumRegister(1, "q")
+            qc = QuantumCircuit(q, name=self.name)
+            theta, phi, lam, global_phase = OneQubitEulerDecomposer("U").angles_and_phase(
+                self.to_matrix()
+            )
+            qc._append(UGate(theta, phi, lam), [q[0]], [])
+            qc.global_phase = global_phase
+            self.definition = qc
+        elif self.num_qubits == 2:
+            from qiskit.synthesis.two_qubit.two_qubit_decompose import (  # pylint: disable=cyclic-import
+                two_qubit_cnot_decompose,
+            )
+
+            self.definition = two_qubit_cnot_decompose(self.to_matrix())
+        else:
+            from qiskit.synthesis.unitary.qsd import (  # pylint: disable=cyclic-import
+                qs_decomposition,
+            )
+
+            self.definition = qs_decomposition(self.to_matrix())
+            # Since iterative cosine-sine decomposition may provide imprecise matrices,
+            # we use the Isometry decomposition in this case
+            # pylint: disable=cyclic-import
+            from qiskit.quantum_info.operators import Operator
+
+            if not (
+                matrix_equal(Operator(self.definition).to_matrix(), self.to_matrix(), atol=1e-7)
+            ):
+                self.definition = Isometry(self.matrix, 0, 0).definition
+
+    def control(
+        self,
+        num_ctrl_qubits: int = 1,
+        label: str | None = None,
+        ctrl_state: int | str | None = None,
+        annotated: bool | None = None,
+    ) -> ControlledGate | AnnotatedOperation:
+        """Return controlled version of gate.
+
+        Args:
+            num_ctrl_qubits: Number of controls to add to gate (default is 1).
+            label: Optional gate label.
+            ctrl_state: The control state in decimal or as a bit string (e.g. ``"1011"``).
+                If ``None``, use ``2**num_ctrl_qubits - 1``.
+            annotated: indicates whether the controlled gate should be implemented
+                as an annotated gate. If ``None``, this is handled as ``False``.
+
+        Returns:
+            Controlled version of gate.
+        """
+        if not annotated:
+            mat = self.to_matrix()
+            cmat = _compute_control_matrix(mat, num_ctrl_qubits, ctrl_state=None)
+            from qiskit.synthesis.unitary.qsd import qs_decomposition
+
+            cmat_def = qs_decomposition(cmat, opt_a1=True, opt_a2=False)
+            # Since iterative cosine-sine decomposition may provide imprecise matrices,
+            # we use the Isometry decomposition in this case
+            # pylint: disable=cyclic-import
+            from qiskit.quantum_info.operators import Operator
+
+            if not matrix_equal(Operator(cmat_def).to_matrix(), cmat, atol=1e-7):
+                self.definition = Isometry(cmat, 0, 0).definition
+
+            gate = ControlledGate(
+                "c-unitary",
+                num_qubits=self.num_qubits + num_ctrl_qubits,
+                params=[mat],
+                label=label,
+                num_ctrl_qubits=num_ctrl_qubits,
+                definition=cmat_def,
+                ctrl_state=ctrl_state,
+                base_gate=self.copy(),
+            )
+        else:
+            gate = AnnotatedOperation(
+                self, ControlModifier(num_ctrl_qubits=num_ctrl_qubits, ctrl_state=ctrl_state)
+            )
+        return gate
+
+    def _qasm_decomposition(self):
+        """Return an unparameterized version of ourselves, so the OQ2 exporter doesn't choke on the
+        non-standard things in our `params` field."""
+        out = self.definition.to_gate()
+        out.name = self.name
+        return out
+
+    def validate_parameter(self, parameter):
+        """Unitary gate parameter has to be an ndarray."""
+        if isinstance(parameter, numpy.ndarray):
+            return parameter
+        else:
+            raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")

qiskit/circuit/library/graph_state.py

@@ -0,0 +1,172 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2024.
+#
+# 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.
+
+"""Graph State circuit and gate."""
+
+from __future__ import annotations
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils.deprecation import deprecate_func
+
+
+class GraphState(QuantumCircuit):
+    r"""Circuit to prepare a graph state.
+
+    Given a graph G = (V, E), with the set of vertices V and the set of edges E,
+    the corresponding graph state is defined as
+
+    .. math::
+
+        |G\rangle = \prod_{(a,b) \in E} CZ_{(a,b)} {|+\rangle}^{\otimes V}
+
+    Such a state can be prepared by first preparing all qubits in the :math:`+`
+    state, then applying a :math:`CZ` gate for each corresponding graph edge.
+
+    Graph state preparation circuits are Clifford circuits, and thus
+    easy to simulate classically. However, by adding a layer of measurements
+    in a product basis at the end, there is evidence that the circuit becomes
+    hard to simulate [2].
+
+    **Reference Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import GraphState
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       import rustworkx as rx
+       G = rx.generators.cycle_graph(5)
+       circuit = GraphState(rx.adjacency_matrix(G))
+       circuit.name = "Graph state"
+       _generate_circuit_library_visualization(circuit)
+
+    **References:**
+
+    [1] M. Hein, J. Eisert, H.J. Briegel, Multi-party Entanglement in Graph States,
+        `arXiv:0307130 <https://arxiv.org/pdf/quant-ph/0307130.pdf>`_
+    [2] D. Koh, Further Extensions of Clifford Circuits & their Classical Simulation Complexities.
+        `arXiv:1512.07892 <https://arxiv.org/pdf/1512.07892.pdf>`_
+    """
+
+    @deprecate_func(
+        since="2.1",
+        additional_msg="Use qiskit.circuit.library.GraphStateGate instead.",
+        removal_timeline="in Qiskit 3.0",
+    )
+    def __init__(self, adjacency_matrix: list | np.ndarray) -> None:
+        """Create graph state preparation circuit.
+
+        Args:
+            adjacency_matrix: input graph as n-by-n list of 0-1 lists
+
+        Raises:
+            CircuitError: If adjacency_matrix is not symmetric.
+
+        The circuit prepares a graph state with the given adjacency
+        matrix.
+        """
+
+        adjacency_matrix = np.asarray(adjacency_matrix)
+        if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
+            raise CircuitError("The adjacency matrix must be symmetric.")
+
+        graph_state_gate = GraphStateGate(adjacency_matrix)
+        super().__init__(graph_state_gate.num_qubits, name=f"graph: {adjacency_matrix}")
+        self.compose(graph_state_gate, qubits=self.qubits, inplace=True)
+
+
+class GraphStateGate(Gate):
+    r"""A gate representing a graph state.
+
+    Given a graph G = (V, E), with the set of vertices V and the set of edges E,
+    the corresponding graph state is defined as
+
+    .. math::
+
+        |G\rangle = \prod_{(a,b) \in E} CZ_{(a,b)} {|+\rangle}^{\otimes V}
+
+    Such a state can be prepared by first preparing all qubits in the :math:`+`
+    state, then applying a :math:`CZ` gate for each corresponding graph edge.
+
+    Graph state preparation circuits are Clifford circuits, and thus
+    easy to simulate classically. However, by adding a layer of measurements
+    in a product basis at the end, there is evidence that the circuit becomes
+    hard to simulate [2].
+
+    **Reference Circuit:**
+
+    .. plot::
+        :alt: Circuit diagram output by the previous code.
+        :include-source:
+
+        from qiskit.circuit import QuantumCircuit
+        from qiskit.circuit.library import GraphStateGate
+        import rustworkx as rx
+
+        G = rx.generators.cycle_graph(5)
+        circuit = QuantumCircuit(5)
+        circuit.append(GraphStateGate(rx.adjacency_matrix(G)), [0, 1, 2, 3, 4])
+        circuit.decompose().draw('mpl')
+
+    **References:**
+
+    [1] M. Hein, J. Eisert, H.J. Briegel, Multi-party Entanglement in Graph States,
+        `arXiv:0307130 <https://arxiv.org/pdf/quant-ph/0307130.pdf>`_
+    [2] D. Koh, Further Extensions of Clifford Circuits & their Classical Simulation Complexities.
+        `arXiv:1512.07892 <https://arxiv.org/pdf/1512.07892.pdf>`_
+    """
+
+    def __init__(self, adjacency_matrix: list | np.ndarray) -> None:
+        """
+        Args:
+            adjacency_matrix: input graph as n-by-n list of 0-1 lists
+
+        Raises:
+            CircuitError: If adjacency_matrix is not symmetric.
+
+        The gate represents a graph state with the given adjacency matrix.
+        """
+
+        adjacency_matrix = np.asarray(adjacency_matrix)
+        if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
+            raise CircuitError("The adjacency matrix must be symmetric.")
+        num_qubits = len(adjacency_matrix)
+
+        super().__init__(name="graph_state", num_qubits=num_qubits, params=[adjacency_matrix])
+
+    def _define(self):
+        adjacency_matrix = self.adjacency_matrix
+        circuit = QuantumCircuit(self.num_qubits, name=self.name)
+        circuit.h(range(self.num_qubits))
+        for i in range(self.num_qubits):
+            for j in range(i + 1, self.num_qubits):
+                if adjacency_matrix[i][j] == 1:
+                    circuit.cz(i, j)
+        self.definition = circuit
+
+    def validate_parameter(self, parameter):
+        """Parameter validation"""
+        return parameter
+
+    @property
+    def adjacency_matrix(self):
+        """Returns the adjacency matrix."""
+        return self.params[0]
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, GraphStateGate)
+            and self.num_qubits == other.num_qubits
+            and np.all(self.adjacency_matrix == other.adjacency_matrix)
+        )