supermarq.converters.qiskit
===========================

.. py:module:: supermarq.converters.qiskit


Attributes
----------

.. autoapisummary::

   supermarq.converters.qiskit.CIRCUIT_TYPE


Functions
---------

.. autoapisummary::

   supermarq.converters.qiskit.cirq_classical_control_to_qiskit
   supermarq.converters.qiskit.cirq_gate_to_qiskit_gate
   supermarq.converters.qiskit.cirq_qubits_to_qiskit
   supermarq.converters.qiskit.cirq_to_qiskit
   supermarq.converters.qiskit.decompose_measurement_inversions
   supermarq.converters.qiskit.qiskit_gate_to_cirq_gate
   supermarq.converters.qiskit.qiskit_to_cirq
   supermarq.converters.qiskit.swap_endianness


Module Contents
---------------

.. py:function:: cirq_classical_control_to_qiskit(op: cirq.Operation, measurement_key_to_indices: dict[str, list[int]], cr: qiskit.ClassicalRegister) -> qiskit.circuit.classical.expr.Expr | tuple[qiskit.circuit.Clbit, int]

   Converts cirq classical control to qiskit classical control. Cirq uses sympy for its
   classical logic, qiskit uses its own classical expressions.

   :param op: The cirq operation that is being classically controlled
   :param measurement_key_to_indices: Dictionary that maps cirq measurement keys to qiskit
   :param `Clbit` indices.:
   :param cr: The qiskit classical register that controls the operations

   :returns: A qiskit condition for classical control.


.. py:function:: cirq_gate_to_qiskit_gate(cirq_gate: cirq.Gate) -> qiskit.circuit.Gate

   Convert a single `cirq.Gate` to a qiskit Gate.


.. py:function:: cirq_qubits_to_qiskit(qubits: collections.abc.Sequence[cirq.Qid]) -> qiskit.QuantumCircuit

   Converts cirq qubits to qiskit qubits.

   :param qubits: A sequence of `cirq.Qid` s.

   :returns: A `qiskit.QuantumCircuit` object with the appropriate qubits.


.. py:function:: cirq_to_qiskit(cirq_circuit: cirq.Circuit, qubits: collections.abc.Sequence[cirq.Qid]) -> qiskit.QuantumCircuit

   Converts `cirq.Circuit` into a `qiskit.QuantumCircuit` with a single qubit register.

   Note: Qubits in the qiskit circuit are ordered according to the given qubits sequence
   (i.e. n-th qubit in `qiskit_circuit.qubits` = n-th qubit in sequence).

   :param cirq_circuit: The circuit to convert into `qiskit`.
   :param qubits: The qubits belonging to `cirq_circuit`.

   :returns: The `qiskit` equivalent of `cirq_circuit`.


.. py:function:: decompose_measurement_inversions(circuit: CIRCUIT_TYPE, context: cirq.TransformerContext | None = None) -> CIRCUIT_TYPE

   Decompose inverted measurements by replacing their `invert_mask` with explicit X gates.

   This is useful after running some cirq transformers (namely `cirq.eject_phased_paulis`), which
   will absorb Pauli gates into measurements by changing their `invert_mask`.

   :param circuit: The circuit to be transformed.
   :param context: An optional `cirq.TransformerContext` containing configuration and logging
                   information.

   :returns: An equivalent circuit with X gates in place of inversion masks.


.. py:function:: qiskit_gate_to_cirq_gate(inst: qiskit.circuit.Instruction) -> cirq.Gate | None

   Convert a single qiskit instruction to a single cirq.Gate, or return None.


.. py:function:: qiskit_to_cirq(qiskit_circuit: qiskit.QuantumCircuit, keep_global_phase: bool = False) -> cirq.Circuit

   Converts a `qiskit.QuantumCircuit` to a `cirq.Circuit`, preserving global phase.

   :param qiskit_circuit: The circuit to convert into `cirq`.
   :param keep_global_phase: Boolean flag to preserve the global phase of the circuit. Defaults to
                             `False`.

   :returns: The `cirq` equivalent circuit of `qiskit_circuit`.


.. py:function:: swap_endianness(matrix: numpy.typing.NDArray[numpy.complex128]) -> numpy.typing.NDArray[numpy.complex128]

   Change matrix from cirq-endian and qiskit-endian (and vice versa).


.. py:data:: CIRCUIT_TYPE