g` dZddlmZddlZddlZddlZddlZ ddl Z ddlm Z m Z m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZddlZddlmZddlmZddl m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)dd l*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mZ>m?Z?ddl@mAZAmBZBddlCmDZDmEZEddlFmGZGmHZHddlImJZJmKZKddlLmMZMmNZNddlOmPZPmQZQddlRmSZSmTZTmUZUmVZVddlWmXZXmYZYddlZm[Z[dd l\m]Z]dd!l^m_Z_dd"l`maZadd#lbmcZcdd$ldmeZedd%lfmgZgmhZhdd&limjZjdd'lkmlZle jmrddlnZndd(lompZpdd)lqmrZrdd*lsmtZte d+d,Zued-Zved.ZweeTeSexeyeeeTexffZzeeYeXexeyeeeYexffZ{ed/eTeYZ|Gd0d1Z}Gd2d3e8Z~d>d9Zd?d;Zd<Zd=ZdS)@zQuantum circuit object.) annotationsN) OrderedDict defaultdict namedtuple) UnionOptionalTupleTypeTypeVarSequenceCallableMappingIterableAny DefaultDictLiteraloverload) CircuitData) StandardGate)compute_estimated_duration) QiskitError)is_main_process) Instruction)Gate) Parameter) CircuitError)deprecate_func)deprecate_pulse_dependency)_classical_resource_map) ControlFlowOp_builder_utils)CircuitScopeInterfaceControlFlowBuilderBlock) BreakLoopOpBreakLoopPlaceholder)ContinueLoopOpContinueLoopPlaceholder) ForLoopOpForLoopContext)IfElseOp IfContext) SwitchCaseOp SwitchContext) WhileLoopOpWhileLoopContext)exprtypes)ParameterExpressionParameterValueType)QuantumRegisterQubitAncillaRegister AncillaQubit)ClassicalRegisterClbit) ParameterView)ParameterVector)InstructionSet) Operation)Register)Bit)QuantumCircuitDataCircuitInstruction)Delay)Store)TranspileLayout) BaseOperator) Statevector BitLocations)index registersSTBitTypec<eZdZdZdZdZdddddddddZeeddddZ e j ddZ eeddddZ e j dZ e dސdd&Z edddddd'dd/Zedd1Zedd3Zej dd6Zedd8Zeed9dd;Zej ed9dd=Zedd>Zej dd?ZeddBZddCZeddDZej ddEZddGZddHZddIZe dJZe edKdLdMNddPZe ddQZe edKdLdMNddRZe ddSZ ddUZ!ddXZ"ddYZ#ddZZ$ddd\Z%dd]dd`Z& ddddZ' dddjZ( dddddkddxZ)dddyZ*edd{Z+edd}Z,eddZ-eddZ.eddZ/eddZ0eddZ1ddZ2ddZ3ddZ4ddZ5ddZ6ddZ7ddZ8ddZ9ddZ:e;j<ddZ=e;j<ddZ=dZ=eedKdLdMNddZ>eddZ?edKdLdMNddZ@ddZAedKdLdMNddZBddZC dddZD dddddZEe;j<d dZFe;j<d dZFd ddd dZFe;j<d dZGe;j<ddd„ZGdddĄZGddDŽZHe;j<ddɄZIe;j<ddd˄ZIddd̄ZIddτZJddфZKddӄZLddՄZMddքZNe;j<dd؄ZOe;j<dddلZO dddڄZOddۄZPddބZQddZRddZSddZT dd dZU dd!dZV d"d#dZW d$d%d ZXd fd&d ZYdfd'dZZddZ[eddZ\eddZ]eddZ^d(dZ_ddZ`d)dZadd*dZbddZcddZddd+dZe dddd,d"Zfdd#Zgd-d&Zhd.d'Zid/d)Zjd0d,Zkd1d.Zld2d3d/Zm d4d5d1Znd2d3d2Zoed6d4Zped7d6Zqed8d7Zrerj d9d9Zred:d;Zsedd<Ztd;d>Zue< dddd?d<dEZve< dddd?d=dGZv dddd?d>dHZvd?dKZwddLd@dMZx dAdBdSZyd/dTZz ddCdWZ{d/dXZ|dDdZZ}dEd[Z~ ddFd\Z ddGd_ZdHdaZdIdeZdJdhZdKdjZ ddLdkZ ddFdlZdMdoZ ddLdpZ ddFdqZdMdrZdNdsZ ddFdtZdMduZdMdvZdOdwZd/dxZd/dyZ ddCdzZ ddCd{ZdOd|ZdOd}Z ddPdZd/dZd/dZ ddCdZd/dZd/dZdQdZ ddRdZddSdZ ddCdZdOdZ ddTdZ dUdVdZd/dZ ddCdZd/dZ ddCdZ ddWdZdXdZ dYdZdZ d[d\dZ dd]dZd^dZ d_d`dZdadZdbdZdbdZe;j<dcdZe;j<dddZdeddLdZe;j<dfdZe;j<dgdZ dhddLdZe;j<didZe;j<ddLdjdZ deddLd„Z ddkdńZe;j<dldʄZe;j<dmd̄ZdeddLd̈́Zdnd΄ZdndτZe ddodԄZdpdքZdpdׄZdpd؄ZdqdrdۄZdS(sQuantumCircuita?Core Qiskit representation of a quantum circuit. .. note:: For more details setting the :class:`QuantumCircuit` in context of all of the data structures that go with it, how it fits into the rest of the :mod:`qiskit` package, and the different regimes of quantum-circuit descriptions in Qiskit, see the module-level documentation of :mod:`qiskit.circuit`. Circuit attributes ================== :class:`QuantumCircuit` has a small number of public attributes, which are mostly older functionality. Most of its functionality is accessed through methods. A small handful of the attributes are intentionally mutable, the rest are data attributes that should be considered immutable. ========================= ====================================================================== Mutable attribute Summary ========================= ====================================================================== :attr:`global_phase` The global phase of the circuit, measured in radians. :attr:`metadata` Arbitrary user mapping, which Qiskit will preserve through the transpiler, but otherwise completely ignore. :attr:`name` An optional string name for the circuit. ========================= ====================================================================== ========================= ====================================================================== Immutable data attribute Summary ========================= ====================================================================== :attr:`ancillas` List of :class:`AncillaQubit`\ s tracked by the circuit. :attr:`calibrations` Custom user-supplied pulse calibrations for individual instructions. :attr:`cregs` List of :class:`ClassicalRegister`\ s tracked by the circuit. :attr:`clbits` List of :class:`Clbit`\ s tracked by the circuit. :attr:`data` List of individual :class:`CircuitInstruction`\ s that make up the circuit. :attr:`duration` Total duration of the circuit, added by scheduling transpiler passes. This attribute is deprecated and :meth:`.estimate_duration` should be used instead. :attr:`layout` Hardware layout and routing information added by the transpiler. :attr:`num_ancillas` The number of ancilla qubits in the circuit. :attr:`num_clbits` The number of clbits in the circuit. :attr:`num_captured_vars` Number of captured real-time classical variables. :attr:`num_declared_vars` Number of locally declared real-time classical variables in the outer circuit scope. :attr:`num_input_vars` Number of input real-time classical variables. :attr:`num_parameters` Number of compile-time :class:`Parameter`\ s in the circuit. :attr:`num_qubits` Number of qubits in the circuit. :attr:`num_vars` Total number of real-time classical variables in the outer circuit scope. :attr:`op_start_times` Start times of scheduled operations, added by scheduling transpiler passes. :attr:`parameters` Ordered set-like view of the compile-time :class:`Parameter`\ s tracked by the circuit. :attr:`qregs` List of :class:`QuantumRegister`\ s tracked by the circuit. :attr:`qubits` List of :class:`Qubit`\ s tracked by the circuit. :attr:`unit` The unit of the :attr:`duration` field. ========================= ====================================================================== The core attribute is :attr:`data`. This is a sequence-like object that exposes the :class:`CircuitInstruction`\ s contained in an ordered form. You generally should not mutate this object directly; :class:`QuantumCircuit` is only designed for append-only operations (which should use :meth:`append`). Most operations that mutate circuits in place should be written as transpiler passes (:mod:`qiskit.transpiler`). .. autoattribute:: data Alongside the :attr:`data`, the :attr:`global_phase` of a circuit can have some impact on its output, if the circuit is used to describe a :class:`.Gate` that may be controlled. This is measured in radians and is directly settable. .. autoattribute:: global_phase The :attr:`name` of a circuit becomes the name of the :class:`~.circuit.Instruction` or :class:`.Gate` resulting from :meth:`to_instruction` and :meth:`to_gate` calls, which can be handy for visualizations. .. autoattribute:: name You can attach arbitrary :attr:`metadata` to a circuit. No part of core Qiskit will inspect this or change its behavior based on metadata, but it will be faithfully passed through the transpiler, so you can tag your circuits yourself. When serializing a circuit with QPY (see :mod:`qiskit.qpy`), the metadata will be JSON-serialized and you may need to pass a custom serializer to handle non-JSON-compatible objects within it (see :func:`.qpy.dump` for more detail). This field is ignored during export to OpenQASM 2 or 3. .. autoattribute:: metadata :class:`QuantumCircuit` exposes data attributes tracking its internal quantum and classical bits and registers. These appear as Python :class:`list`\ s, but you should treat them as immutable; changing them will *at best* have no effect, and more likely will simply corrupt the internal data of the :class:`QuantumCircuit`. .. autoattribute:: qregs .. autoattribute:: cregs .. autoattribute:: qubits .. autoattribute:: ancillas .. autoattribute:: clbits The :ref:`compile-time parameters ` present in instructions on the circuit are available in :attr:`parameters`. This has a canonical order (mostly lexical, except in the case of :class:`.ParameterVector`), which matches the order that parameters will be assigned when using the list forms of :meth:`assign_parameters`, but also supports :class:`set`-like constant-time membership testing. .. autoattribute:: parameters The storage of any :ref:`manual pulse-level calibrations ` for individual instructions on the circuit is in :attr:`calibrations`. This presents as a :class:`dict`, but should not be mutated directly; use the methods discussed in :ref:`circuit-calibrations`. .. autoattribute:: calibrations If you have transpiled your circuit, so you have a physical circuit, you can inspect the :attr:`layout` attribute for information stored by the transpiler about how the virtual qubits of the source circuit map to the hardware qubits of your physical circuit, both at the start and end of the circuit. .. autoattribute:: layout If your circuit was also *scheduled* as part of a transpilation, it will expose the individual timings of each instruction, along with the total :attr:`duration` of the circuit. .. autoattribute:: duration .. autoattribute:: unit .. autoattribute:: op_start_times Finally, :class:`QuantumCircuit` exposes several simple properties as dynamic read-only numeric attributes. .. autoattribute:: num_ancillas .. autoattribute:: num_clbits .. autoattribute:: num_captured_vars .. autoattribute:: num_declared_vars .. autoattribute:: num_input_vars .. autoattribute:: num_parameters .. autoattribute:: num_qubits .. autoattribute:: num_vars Creating new circuits ===================== ========================= ===================================================================== Method Summary ========================= ===================================================================== :meth:`__init__` Default constructor of no-instruction circuits. :meth:`copy` Make a complete copy of an existing circuit. :meth:`copy_empty_like` Copy data objects from one circuit into a new one without any instructions. :meth:`from_instructions` Infer data objects needed from a list of instructions. :meth:`from_qasm_file` Legacy interface to :func:`.qasm2.load`. :meth:`from_qasm_str` Legacy interface to :func:`.qasm2.loads`. ========================= ===================================================================== The default constructor (``QuantumCircuit(...)``) produces a circuit with no initial instructions. The arguments to the default constructor can be used to seed the circuit with quantum and classical data storage, and to provide a name, global phase and arbitrary metadata. All of these fields can be expanded later. .. automethod:: __init__ If you have an existing circuit, you can produce a copy of it using :meth:`copy`, including all its instructions. This is useful if you want to keep partial circuits while extending another, or to have a version you can mutate in-place while leaving the prior one intact. .. automethod:: copy Similarly, if you want a circuit that contains all the same data objects (bits, registers, variables, etc) but with none of the instructions, you can use :meth:`copy_empty_like`. This is quite common when you want to build up a new layer of a circuit to then use apply onto the back with :meth:`compose`, or to do a full rewrite of a circuit's instructions. .. automethod:: copy_empty_like In some cases, it is most convenient to generate a list of :class:`.CircuitInstruction`\ s separately to an entire circuit context, and then to build a circuit from this. The :meth:`from_instructions` constructor will automatically capture all :class:`.Qubit` and :class:`.Clbit` instances used in the instructions, and create a new :class:`QuantumCircuit` object that has the correct resources and all the instructions. .. automethod:: from_instructions :class:`QuantumCircuit` also still has two constructor methods that are legacy wrappers around the importers in :mod:`qiskit.qasm2`. These automatically apply :ref:`the legacy compatibility settings ` of :func:`~.qasm2.load` and :func:`~.qasm2.loads`. .. automethod:: from_qasm_file .. automethod:: from_qasm_str Data objects on circuits ======================== .. _circuit-adding-data-objects: Adding data objects ------------------- ============================= ================================================================= Method Adds this kind of data ============================= ================================================================= :meth:`add_bits` :class:`.Qubit`\ s and :class:`.Clbit`\ s. :meth:`add_register` :class:`.QuantumRegister` and :class:`.ClassicalRegister`. :meth:`add_var` :class:`~.expr.Var` nodes with local scope and initializers. :meth:`add_input` :class:`~.expr.Var` nodes that are treated as circuit inputs. :meth:`add_capture` :class:`~.expr.Var` nodes captured from containing scopes. :meth:`add_uninitialized_var` :class:`~.expr.Var` nodes with local scope and undefined state. ============================= ================================================================= Typically you add most of the data objects (:class:`.Qubit`, :class:`.Clbit`, :class:`.ClassicalRegister`, etc) to the circuit as part of using the :meth:`__init__` default constructor, or :meth:`copy_empty_like`. However, it is also possible to add these afterwards. Typed classical data, such as standalone :class:`~.expr.Var` nodes (see :ref:`circuit-repr-real-time-classical`), can be both constructed and added with separate methods. New registerless :class:`.Qubit` and :class:`.Clbit` objects are added using :meth:`add_bits`. These objects must not already be present in the circuit. You can check if a bit exists in the circuit already using :meth:`find_bit`. .. automethod:: add_bits Registers are added to the circuit with :meth:`add_register`. In this method, it is not an error if some of the bits are already present in the circuit. In this case, the register will be an "alias" over the bits. This is not generally well-supported by hardware backends; it is probably best to stay away from relying on it. The registers a given bit is in are part of the return of :meth:`find_bit`. .. automethod:: add_register :ref:`Real-time, typed classical data ` is represented on the circuit by :class:`~.expr.Var` nodes with a well-defined :class:`~.types.Type`. It is possible to instantiate these separately to a circuit (see :meth:`.Var.new`), but it is often more convenient to use circuit methods that will automatically manage the types and expression initialization for you. The two most common methods are :meth:`add_var` (locally scoped variables) and :meth:`add_input` (inputs to the circuit). .. automethod:: add_var .. automethod:: add_input In addition, there are two lower-level methods that can be useful for programmatic generation of circuits. When working interactively, you will most likely not need these; most uses of :meth:`add_uninitialized_var` are part of :meth:`copy_empty_like`, and most uses of :meth:`add_capture` would be better off using :ref:`the control-flow builder interface `. .. automethod:: add_uninitialized_var .. automethod:: add_capture Working with bits and registers ------------------------------- A :class:`.Bit` instance is, on its own, just a unique handle for circuits to use in their own contexts. If you have got a :class:`.Bit` instance and a circuit, just can find the contexts that the bit exists in using :meth:`find_bit`, such as its integer index in the circuit and any registers it is contained in. .. automethod:: find_bit Similarly, you can query a circuit to see if a register has already been added to it by using :meth:`has_register`. .. automethod:: has_register Working with compile-time parameters ------------------------------------ .. seealso:: :ref:`circuit-compile-time-parameters` A more complete discussion of what compile-time parametrization is, and how it fits into Qiskit's data model. Unlike bits, registers, and real-time typed classical data, compile-time symbolic parameters are not manually added to a circuit. Their presence is inferred by being contained in operations added to circuits and the global phase. An ordered list of all parameters currently in a circuit is at :attr:`QuantumCircuit.parameters`. The most common operation on :class:`.Parameter` instances is to replace them in symbolic operations with some numeric value, or another symbolic expression. This is done with :meth:`assign_parameters`. .. automethod:: assign_parameters The circuit tracks parameters by :class:`.Parameter` instances themselves, and forbids having multiple parameters of the same name to avoid some problems when interoperating with OpenQASM or other external formats. You can use :meth:`has_parameter` and :meth:`get_parameter` to query the circuit for a parameter with the given string name. .. automethod:: has_parameter .. automethod:: get_parameter .. _circuit-real-time-methods: Working with real-time typed classical data ------------------------------------------- .. seealso:: :mod:`qiskit.circuit.classical` Module-level documentation for how the variable-, expression- and type-systems work, the objects used to represent them, and the classical operations available. :ref:`circuit-repr-real-time-classical` A discussion of how real-time data fits into the entire :mod:`qiskit.circuit` data model as a whole. :ref:`circuit-adding-data-objects` The methods for adding new :class:`~.expr.Var` variables to a circuit after initialization. You can retrive a :class:`~.expr.Var` instance attached to a circuit by using its variable name using :meth:`get_var`, or check if a circuit contains a given variable with :meth:`has_var`. .. automethod:: get_var .. automethod:: has_var There are also several iterator methods that you can use to get the full set of variables tracked by a circuit. At least one of :meth:`iter_input_vars` and :meth:`iter_captured_vars` will be empty, as inputs and captures are mutually exclusive. All of the iterators have corresponding dynamic properties on :class:`QuantumCircuit` that contain their length: :attr:`num_vars`, :attr:`num_input_vars`, :attr:`num_captured_vars` and :attr:`num_declared_vars`. .. automethod:: iter_vars .. automethod:: iter_input_vars .. automethod:: iter_captured_vars .. automethod:: iter_declared_vars .. _circuit-adding-operations: Adding operations to circuits ============================= You can add anything that implements the :class:`.Operation` interface to a circuit as a single instruction, though most things you will want to add will be :class:`~.circuit.Instruction` or :class:`~.circuit.Gate` instances. .. seealso:: :ref:`circuit-operations-instructions` The :mod:`qiskit.circuit`-level documentation on the different interfaces that Qiskit uses to define circuit-level instructions. .. _circuit-append-compose: Methods to add general operations --------------------------------- These are the base methods that handle adding any object, including user-defined ones, onto circuits. =============== =============================================================================== Method When to use it =============== =============================================================================== :meth:`append` Add an instruction as a single object onto a circuit. :meth:`_append` Same as :meth:`append`, but a low-level interface that elides almost all error checking. :meth:`compose` Inline the instructions from one circuit onto another. :meth:`tensor` Like :meth:`compose`, but strictly for joining circuits that act on disjoint qubits. =============== =============================================================================== :class:`QuantumCircuit` has two main ways that you will add more operations onto a circuit. Which to use depends on whether you want to add your object as a single "instruction" (:meth:`append`), or whether you want to join the instructions from two circuits together (:meth:`compose`). A single instruction or operation appears as a single entry in the :attr:`data` of the circuit, and as a single box when drawn in the circuit visualizers (see :meth:`draw`). A single instruction is the "unit" that a hardware backend might be defined in terms of (see :class:`.Target`). An :class:`~.circuit.Instruction` can come with a :attr:`~.circuit.Instruction.definition`, which is one rule the transpiler (see :mod:`qiskit.transpiler`) will be able to fall back on to decompose it for hardware, if needed. An :class:`.Operation` that is not also an :class:`~.circuit.Instruction` can only be decomposed if it has some associated high-level synthesis method registered for it (see :mod:`qiskit.transpiler.passes.synthesis.plugin`). A :class:`QuantumCircuit` alone is not a single :class:`~.circuit.Instruction`; it is rather more complicated, since it can, in general, represent a complete program with typed classical memory inputs and outputs, and control flow. Qiskit's (and most hardware's) data model does not yet have the concept of re-usable callable subroutines with virtual quantum operands. You can convert simple circuits that act only on qubits with unitary operations into a :class:`.Gate` using :meth:`to_gate`, and simple circuits acting only on qubits and clbits into a :class:`~.circuit.Instruction` with :meth:`to_instruction`. When you have an :class:`.Operation`, :class:`~.circuit.Instruction`, or :class:`.Gate`, add it to the circuit, specifying the qubit and clbit arguments with :meth:`append`. .. automethod:: append :meth:`append` does quite substantial error checking to ensure that you cannot accidentally break the data model of :class:`QuantumCircuit`. If you are programmatically generating a circuit from known-good data, you can elide much of this error checking by using the fast-path appender :meth:`_append`, but at the risk that the caller is responsible for ensuring they are passing only valid data. .. automethod:: _append In other cases, you may want to join two circuits together, applying the instructions from one circuit onto specified qubits and clbits on another circuit. This "inlining" operation is called :meth:`compose` in Qiskit. :meth:`compose` is, in general, more powerful than a :meth:`to_instruction`-plus-:meth:`append` combination for joining two circuits, because it can also link typed classical data together, and allows for circuit control-flow operations to be joined onto another circuit. The downsides to :meth:`compose` are that it is a more complex operation that can involve more rewriting of the operand, and that it necessarily must move data from one circuit object to another. If you are building up a circuit for yourself and raw performance is a core goal, consider passing around your base circuit and having different parts of your algorithm write directly to the base circuit, rather than building a temporary layer circuit. .. automethod:: compose If you are trying to join two circuits that will apply to completely disjoint qubits and clbits, :meth:`tensor` is a convenient wrapper around manually adding bit objects and calling :meth:`compose`. .. automethod:: tensor As some rules of thumb: * If you have a single :class:`.Operation`, :class:`~.circuit.Instruction` or :class:`.Gate`, you should definitely use :meth:`append` or :meth:`_append`. * If you have a :class:`QuantumCircuit` that represents a single atomic instruction for a larger circuit that you want to re-use, you probably want to call :meth:`to_instruction` or :meth:`to_gate`, and then apply the result of that to the circuit using :meth:`append`. * If you have a :class:`QuantumCircuit` that represents a larger "layer" of another circuit, or contains typed classical variables or control flow, you should use :meth:`compose` to merge it onto another circuit. * :meth:`tensor` is wanted far more rarely than either :meth:`append` or :meth:`compose`. Internally, it is mostly a wrapper around :meth:`add_bits` and :meth:`compose`. Some potential pitfalls to beware of: * Even if you re-use a custom :class:`~.circuit.Instruction` during circuit construction, the transpiler will generally have to "unroll" each invocation of it to its inner decomposition before beginning work on it. This should not prevent you from using the :meth:`to_instruction`-plus-:meth:`append` pattern, as the transpiler will improve in this regard over time. * :meth:`compose` will, by default, produce a new circuit for backwards compatibility. This is more expensive, and not usually what you want, so you should set ``inplace=True``. * Both :meth:`append` and :meth:`compose` (but not :meth:`_append`) have a ``copy`` keyword argument that defaults to ``True``. In these cases, the incoming :class:`.Operation` instances will be copied if Qiskit detects that the objects have mutability about them (such as taking gate parameters). If you are sure that you will not re-use the objects again in other places, you should set ``copy=False`` to prevent this copying, which can be a substantial speed-up for large objects. Methods to add standard instructions ------------------------------------ The :class:`QuantumCircuit` class has helper methods to add many of the Qiskit standard-library instructions and gates onto a circuit. These are generally equivalent to manually constructing an instance of the relevent :mod:`qiskit.circuit.library` object, then passing that to :meth:`append` with the remaining arguments placed into the ``qargs`` and ``cargs`` fields as appropriate. The following methods apply special non-unitary :class:`~.circuit.Instruction` operations to the circuit: =============================== ==================================================== :class:`QuantumCircuit` method :mod:`qiskit.circuit` :class:`~.circuit.Instruction` =============================== ==================================================== :meth:`barrier` :class:`Barrier` :meth:`delay` :class:`Delay` :meth:`initialize` :class:`~library.Initialize` :meth:`measure` :class:`Measure` :meth:`reset` :class:`Reset` :meth:`store` :class:`Store` =============================== ==================================================== These methods apply uncontrolled unitary :class:`.Gate` instances to the circuit: =============================== ============================================ :class:`QuantumCircuit` method :mod:`qiskit.circuit.library` :class:`.Gate` =============================== ============================================ :meth:`dcx` :class:`~library.DCXGate` :meth:`ecr` :class:`~library.ECRGate` :meth:`h` :class:`~library.HGate` :meth:`id` :class:`~library.IGate` :meth:`iswap` :class:`~library.iSwapGate` :meth:`ms` :class:`~library.MSGate` :meth:`p` :class:`~library.PhaseGate` :meth:`pauli` :class:`~library.PauliGate` :meth:`prepare_state` :class:`~library.StatePreparation` :meth:`r` :class:`~library.RGate` :meth:`rcccx` :class:`~library.RC3XGate` :meth:`rccx` :class:`~library.RCCXGate` :meth:`rv` :class:`~library.RVGate` :meth:`rx` :class:`~library.RXGate` :meth:`rxx` :class:`~library.RXXGate` :meth:`ry` :class:`~library.RYGate` :meth:`ryy` :class:`~library.RYYGate` :meth:`rz` :class:`~library.RZGate` :meth:`rzx` :class:`~library.RZXGate` :meth:`rzz` :class:`~library.RZZGate` :meth:`s` :class:`~library.SGate` :meth:`sdg` :class:`~library.SdgGate` :meth:`swap` :class:`~library.SwapGate` :meth:`sx` :class:`~library.SXGate` :meth:`sxdg` :class:`~library.SXdgGate` :meth:`t` :class:`~library.TGate` :meth:`tdg` :class:`~library.TdgGate` :meth:`u` :class:`~library.UGate` :meth:`unitary` :class:`~library.UnitaryGate` :meth:`x` :class:`~library.XGate` :meth:`y` :class:`~library.YGate` :meth:`z` :class:`~library.ZGate` =============================== ============================================ The following methods apply :class:`Gate` instances that are also controlled gates, so are direct subclasses of :class:`ControlledGate`: =============================== ====================================================== :class:`QuantumCircuit` method :mod:`qiskit.circuit.library` :class:`.ControlledGate` =============================== ====================================================== :meth:`ccx` :class:`~library.CCXGate` :meth:`ccz` :class:`~library.CCZGate` :meth:`ch` :class:`~library.CHGate` :meth:`cp` :class:`~library.CPhaseGate` :meth:`crx` :class:`~library.CRXGate` :meth:`cry` :class:`~library.CRYGate` :meth:`crz` :class:`~library.CRZGate` :meth:`cs` :class:`~library.CSGate` :meth:`csdg` :class:`~library.CSdgGate` :meth:`cswap` :class:`~library.CSwapGate` :meth:`csx` :class:`~library.CSXGate` :meth:`cu` :class:`~library.CUGate` :meth:`cx` :class:`~library.CXGate` :meth:`cy` :class:`~library.CYGate` :meth:`cz` :class:`~library.CZGate` =============================== ====================================================== Finally, these methods apply particular generalized multiply controlled gates to the circuit, often with eager syntheses. They are listed in terms of the *base* gate they are controlling, since their exact output is often a synthesized version of a gate. =============================== ================================================= :class:`QuantumCircuit` method Base :mod:`qiskit.circuit.library` :class:`.Gate` =============================== ================================================= :meth:`mcp` :class:`~library.PhaseGate` :meth:`mcrx` :class:`~library.RXGate` :meth:`mcry` :class:`~library.RYGate` :meth:`mcrz` :class:`~library.RZGate` :meth:`mcx` :class:`~library.XGate` =============================== ================================================= The rest of this section is the API listing of all the individual methods; the tables above are summaries whose links will jump you to the correct place. .. automethod:: barrier .. automethod:: ccx .. automethod:: ccz .. automethod:: ch .. automethod:: cp .. automethod:: crx .. automethod:: cry .. automethod:: crz .. automethod:: cs .. automethod:: csdg .. automethod:: cswap .. automethod:: csx .. automethod:: cu .. automethod:: cx .. automethod:: cy .. automethod:: cz .. automethod:: dcx .. automethod:: delay .. automethod:: ecr .. automethod:: h .. automethod:: id .. automethod:: initialize .. automethod:: iswap .. automethod:: mcp .. automethod:: mcrx .. automethod:: mcry .. automethod:: mcrz .. automethod:: mcx .. automethod:: measure .. automethod:: ms .. automethod:: p .. automethod:: pauli .. automethod:: prepare_state .. automethod:: r .. automethod:: rcccx .. automethod:: rccx .. automethod:: reset .. automethod:: rv .. automethod:: rx .. automethod:: rxx .. automethod:: ry .. automethod:: ryy .. automethod:: rz .. automethod:: rzx .. automethod:: rzz .. automethod:: s .. automethod:: sdg .. automethod:: store .. automethod:: swap .. automethod:: sx .. automethod:: sxdg .. automethod:: t .. automethod:: tdg .. automethod:: u .. automethod:: unitary .. automethod:: x .. automethod:: y .. automethod:: z .. _circuit-control-flow-methods: Adding control flow to circuits ------------------------------- .. seealso:: :ref:`circuit-control-flow-repr` Discussion of how control-flow operations are represented in the whole :mod:`qiskit.circuit` context. ============================== ================================================================ :class:`QuantumCircuit` method Control-flow instruction ============================== ================================================================ :meth:`if_test` :class:`.IfElseOp` with only a ``True`` body. :meth:`if_else` :class:`.IfElseOp` with both ``True`` and ``False`` bodies. :meth:`while_loop` :class:`.WhileLoopOp`. :meth:`switch` :class:`.SwitchCaseOp`. :meth:`for_loop` :class:`.ForLoopOp`. :meth:`break_loop` :class:`.BreakLoopOp`. :meth:`continue_loop` :class:`.ContinueLoopOp`. ============================== ================================================================ :class:`QuantumCircuit` has corresponding methods for all of the control-flow operations that are supported by Qiskit. These have two forms for calling them. The first is a very straightfowards convenience wrapper that takes in the block bodies of the instructions as :class:`QuantumCircuit` arguments, and simply constructs and appends the corresponding :class:`.ControlFlowOp`. The second form, which we strongly recommend you use for constructing control flow, is called *the builder interface*. Here, the methods take only the real-time discriminant of the operation, and return `context managers `__ that you enter using ``with``. You can then use regular :class:`QuantumCircuit` methods within those blocks to build up the control-flow bodies, and Qiskit will automatically track which of the data resources are needed for the inner blocks, building the complete :class:`.ControlFlowOp` as you leave the ``with`` statement. It is far simpler and less error-prone to build control flow programmatically this way. .. TODO: expand the examples of the builder interface. .. automethod:: break_loop .. automethod:: continue_loop .. automethod:: for_loop .. automethod:: if_else .. automethod:: if_test .. automethod:: switch .. automethod:: while_loop Converting circuits to single objects ------------------------------------- As discussed in :ref:`circuit-append-compose`, you can convert a circuit to either an :class:`~.circuit.Instruction` or a :class:`.Gate` using two helper methods. .. automethod:: to_instruction .. automethod:: to_gate Helper mutation methods ----------------------- There are two higher-level methods on :class:`QuantumCircuit` for appending measurements to the end of a circuit. Note that by default, these also add an extra register. .. automethod:: measure_active .. automethod:: measure_all There are two "subtractive" methods on :class:`QuantumCircuit` as well. This is not a use-case that :class:`QuantumCircuit` is designed for; typically you should just look to use :meth:`copy_empty_like` in place of :meth:`clear`, and run :meth:`remove_final_measurements` as its transpiler-pass form :class:`.RemoveFinalMeasurements`. .. automethod:: clear .. automethod:: remove_final_measurements .. _circuit-calibrations: Manual calibration of instructions ---------------------------------- :class:`QuantumCircuit` can store :attr:`calibrations` of instructions that define the pulses used to run them on one particular hardware backend. You can .. automethod:: add_calibration .. automethod:: has_calibration_for Circuit properties ================== Simple circuit metrics ---------------------- When constructing quantum circuits, there are several properties that help quantify the "size" of the circuits, and their ability to be run on a noisy quantum device. Some of these, like number of qubits, are straightforward to understand, while others like depth and number of tensor components require a bit more explanation. Here we will explain all of these properties, and, in preparation for understanding how circuits change when run on actual devices, highlight the conditions under which they change. Consider the following circuit: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit import QuantumCircuit qc = QuantumCircuit(12) for idx in range(5): qc.h(idx) qc.cx(idx, idx+5) qc.cx(1, 7) qc.x(8) qc.cx(1, 9) qc.x(7) qc.cx(1, 11) qc.swap(6, 11) qc.swap(6, 9) qc.swap(6, 10) qc.x(6) qc.draw('mpl') From the plot, it is easy to see that this circuit has 12 qubits, and a collection of Hadamard, CNOT, X, and SWAP gates. But how to quantify this programmatically? Because we can do single-qubit gates on all the qubits simultaneously, the number of qubits in this circuit is equal to the :meth:`width` of the circuit:: assert qc.width() == 12 We can also just get the number of qubits directly using :attr:`num_qubits`:: assert qc.num_qubits == 12 .. important:: For a quantum circuit composed from just qubits, the circuit width is equal to the number of qubits. This is the definition used in quantum computing. However, for more complicated circuits with classical registers, and classically controlled gates, this equivalence breaks down. As such, from now on we will not refer to the number of qubits in a quantum circuit as the width. It is also straightforward to get the number and type of the gates in a circuit using :meth:`count_ops`:: qc.count_ops() .. code-block:: text OrderedDict([('cx', 8), ('h', 5), ('x', 3), ('swap', 3)]) We can also get just the raw count of operations by computing the circuits :meth:`size`:: assert qc.size() == 19 .. automethod:: count_ops .. automethod:: depth .. automethod:: get_instructions .. automethod:: num_connected_components .. automethod:: num_nonlocal_gates .. automethod:: num_tensor_factors .. automethod:: num_unitary_factors .. automethod:: size .. automethod:: width Accessing scheduling information -------------------------------- If a :class:`QuantumCircuit` has been scheduled as part of a transpilation pipeline, the timing information for individual qubits can be accessed. The whole-circuit timing information is available through the :meth:`estimate_duration` method and :attr:`op_start_times` attribute. .. automethod:: estimate_duration .. automethod:: qubit_duration .. automethod:: qubit_start_time .. automethod:: qubit_stop_time Instruction-like methods ======================== .. These methods really shouldn't be on `QuantumCircuit` at all. They're generally more appropriate as `Instruction` or `Gate` methods. `reverse_ops` shouldn't be a method _full stop_---it was copying a `DAGCircuit` method from an implementation detail of the original `SabreLayout` pass in Qiskit. :class:`QuantumCircuit` also contains a small number of methods that are very :class:`~.circuit.Instruction`-like in detail. You may well find better integration and more API support if you first convert your circuit to an :class:`~.circuit.Instruction` (:meth:`to_instruction`) or :class:`.Gate` (:meth:`to_gate`) as appropriate, then call the corresponding method. .. automethod:: control .. automethod:: inverse .. automethod:: power .. automethod:: repeat .. automethod:: reverse_ops Visualization ============= Qiskit includes some drawing tools to give you a quick feel for what your circuit looks like. This tooling is primarily targeted at producing either a `Matplotlib `__- or text-based drawing. There is also a lesser-featured LaTeX backend for drawing, but this is only for simple circuits, and is not as actively maintained. .. seealso:: :mod:`qiskit.visualization` The primary documentation for all of Qiskit's visualization tooling. .. automethod:: draw In addition to the core :meth:`draw` driver, there are two visualization-related helper methods, which are mostly useful for quickly unwrapping some inner instructions or reversing the :ref:`qubit-labelling conventions ` in the drawing. For more general mutation, including basis-gate rewriting, you should use the transpiler (:mod:`qiskit.transpiler`). .. automethod:: decompose .. automethod:: reverse_bits Internal utilities ================== These functions are not intended for public use, but were accidentally left documented in the public API during the 1.0 release. They will be removed in Qiskit 2.0, but will be supported until then. .. automethod:: cast .. automethod:: cbit_argument_conversion .. automethod:: cls_instances .. automethod:: cls_prefix .. automethod:: qbit_argument_conversion rcircuitN)name global_phasemetadatainputscaptures declarationsregsRegister | int | Sequence[Bit]rR str | NonerSr4rT dict | NonerUIterable[expr.Var]rVrWCMapping[expr.Var, expr.Expr] | Iterable[Tuple[expr.Var, expr.Expr]]c~td|Dro td|D}n#ttf$rd}YnwxYw|s t dd|Dd|dt d|D}d |_| |.||_|n2t|tst d ||_||_ | t||_d |_g|_g|_ g|_ i|_i|_t+|_g|_t1t2|_|j|d |_||_i|_i|_i|_ |D]} |!| |D]} |"| t|tFr|$}|D]\} } |%| | d |_&d |_'|in||_(d S) az Default constructor of :class:`QuantumCircuit`. .. `QuantumCirucit` documents its `__init__` method explicitly, unlike most classes where it's implicitly appended to the class-level documentation, just because the class is so huge and has a lot of introductory material to its class docstring. Args: regs: The registers to be included in the circuit. * If a list of :class:`~.Register` objects, represents the :class:`.QuantumRegister` and/or :class:`.ClassicalRegister` objects to include in the circuit. For example: * ``QuantumCircuit(QuantumRegister(4))`` * ``QuantumCircuit(QuantumRegister(4), ClassicalRegister(3))`` * ``QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))`` * If a list of ``int``, the amount of qubits and/or classical bits to include in the circuit. It can either be a single int for just the number of quantum bits, or 2 ints for the number of quantum bits and classical bits, respectively. For example: * ``QuantumCircuit(4) # A QuantumCircuit with 4 qubits`` * ``QuantumCircuit(4, 3) # A QuantumCircuit with 4 qubits and 3 classical bits`` * If a list of python lists containing :class:`.Bit` objects, a collection of :class:`.Bit` s to be added to the circuit. name: the name of the quantum circuit. If not set, an automatically generated string will be assigned. global_phase: The global phase of the circuit in radians. metadata: Arbitrary key value metadata to associate with the circuit. This gets stored as free-form data in a dict in the :attr:`~qiskit.circuit.QuantumCircuit.metadata` attribute. It will not be directly used in the circuit. inputs: any variables to declare as ``input`` runtime variables for this circuit. These should already be existing :class:`.expr.Var` nodes that you build from somewhere else; if you need to create the inputs as well, use :meth:`QuantumCircuit.add_input`. The variables given in this argument will be passed directly to :meth:`add_input`. A circuit cannot have both ``inputs`` and ``captures``. captures: any variables that that this circuit scope should capture from a containing scope. The variables given here will be passed directly to :meth:`add_capture`. A circuit cannot have both ``inputs`` and ``captures``. declarations: any variables that this circuit should declare and initialize immediately. You can order this input so that later declarations depend on earlier ones (including inputs or captures). If you need to depend on values that will be computed later at runtime, use :meth:`add_var` at an appropriate point in the circuit execution. This argument is intended for convenient circuit initialization when you already have a set of created variables. The variables used here will be directly passed to :meth:`add_var`, which you can use directly if this is the first time you are creating the variable. Raises: CircuitError: if the circuit name, if given, is not valid. CircuitError: if both ``inputs`` and ``captures`` are given. c3\K|]'}t|tttf V(dSN) isinstancelistr5r9.0regs S/granary/edev/quantum/lib/python3.11/site-packages/qiskit/circuit/quantumcircuit.py z*QuantumCircuit.__init__..s8__SV:cD/;L#MNNN______c3<K|]}|t|kVdSr`intrcs rfrgz*QuantumCircuit.__init__..s,$E$ESCHH_$E$E$E$E$E$ErhFz-Circuit args must be Registers or integers. (c6g|]}t|jSrQ)type__name__rcs rf z+QuantumCircuit.__init__..%s!;;;sS *;;;rhz 'z' was provided)c34K|]}t|VdSr`rjrcs rfrgz*QuantumCircuit.__init__..)s(22cS222222rhNzFThe circuit name should be a string (or None to auto-generate a name).dt))anyall ValueError TypeErrorrtuple _base_name _cls_prefix _name_updaterastrrR_increment_instances_OuterCircuitScopeInterface _builder_api_op_start_times_control_flow_scopesqregscregs_qubit_indices_clbit_indicesr_data _ancillasrdict _calibrations add_register_layoutrS _vars_input _vars_capture _vars_local add_input add_captureritemsadd_var _duration_unitrT) selfrRrSrTrUrVrWrXvalid_reg_sizeinput_capturevarinitials rf__init__zQuantumCircuit.__init__sR __Z^___ _ _ 3 '!$$E$E$E$E$E!E!E * ' ' '!& '" " ;;d;;;  ?C    22T22222D 4 <"..00DO       D#&& X #DODI !!###8==#  !-/  .0  :<9;#.-- -/ALTARAR4   (132402 # #F NN6 " " " " & &G   W % % % % lG , , 0'--//L( ' 'LC LLg & & & & &.H  Y Ys5A  A z1.3.0zin Qiskit 2.0.0T)sinceremoval_timeline is_propertyc|jS)zwThe total duration of the circuit, set by a scheduling transpiler pass. Its unit is specified by :attr:`unit`.rrs rfdurationzQuantumCircuit.durationxs ~rhvalueint | float | Nonec||_dSr`rrrs rfrzQuantumCircuit.durations rhc|jS)z/The unit that :attr:`duration` is specified in.rrs rfunitzQuantumCircuit.units zrhc||_dSr`rrs rfrzQuantumCircuit.units  rhFdataradd_regsboolreturn typing.Selfct|}|jdkri|rDtd|jg|_fdt |jD|_n#dt |jD|_|jdkri|rDtd|j g|_ fdt |j D|_ n#d t |j D|_ ||_ |S) z3A private constructor from rust space circuit data.rRrq)rRbitsc>i|]\}}|t||fgSrQrH)rdrIbitqrs rf z5QuantumCircuit._from_circuit_data..<&&&@JsCer5k];;&&&rhc6i|]\}}|t|gSrQrrdrIrs rfrz5QuantumCircuit._from_circuit_data..5&&&5?UCCeR00&&&rhcc>i|]\}}|t||fgSrQr)rdrIrcrs rfrz5QuantumCircuit._from_circuit_data..rrhc6i|]\}}|t|gSrQrrs rfrz5QuantumCircuit._from_circuit_data..rrh) rO num_qubitsr5qubitsr enumerater num_clbitsr9clbitsrrr)clsrrrRoutrrs @@rf_from_circuit_dataz!QuantumCircuit._from_circuit_datasT $''' ?Q   $#DK@@@D &&&&NWX\XcNdNd&&&""&&CLT[CYCY&&&" ?Q   &CdkBBBD &&&&NWX\XcNdNd&&&""&&CLT[CYCY&&&"  rh)rrrRrSrT instructionsIterable[CircuitInstruction | tuple[qiskit.circuit.Instruction] | tuple[qiskit.circuit.Instruction, Iterable[Qubit]] | tuple[qiskit.circuit.Instruction, Iterable[Qubit], Iterable[Clbit]]]rIterable[Qubit]rIterable[Clbit]'QuantumCircuit'c t|||}t t|r9t|}|| ||r9t|}||||D]}t |t s t |} fd|jD}fd|jD}|||| ||| ||S)aConstruct a circuit from an iterable of :class:`.CircuitInstruction`\ s. Args: instructions: The instructions to add to the circuit. qubits: Any qubits to add to the circuit. This argument can be used, for example, to enforce a particular ordering of qubits. clbits: Any classical bits to add to the circuit. This argument can be used, for example, to enforce a particular ordering of classical bits. name: The name of the circuit. global_phase: The global phase of the circuit in radians. metadata: Arbitrary key value metadata to associate with the circuit. Returns: The quantum circuit. )rRrSrTcg|]}|v| SrQrQ)rdqubit added_qubitss rfroz4QuantumCircuit.from_instructions..#YYYuL?X?Xe?X?X?Xrhcg|]}|v| SrQrQ)rdclbit added_clbitss rfroz4QuantumCircuit.from_instructions..rrh) rOsetrbadd_bitsupdaterarBrr_append) rrrrRrSrTrP instructionrrs @@rffrom_instructionsz QuantumCircuit.from_instructionssq<!dPXYYYuu uu  (&\\F   V $ $ $    ' ' '  (&\\F   V $ $ $    ' ' '' ) )Kk+=>> ?0+> YYYY);YYYFYYYY);YYYF   V $ $ $   V $ $ $    ' ' '    ' ' ' OOK ( ( ( (rhOptional[TranspileLayout]c|jS)aReturn any associated layout information about the circuit This attribute contains an optional :class:`~.TranspileLayout` object. This is typically set on the output from :func:`~.transpile` or :meth:`.PassManager.run` to retain information about the permutations caused on the input circuit by transpilation. There are two types of permutations caused by the :func:`~.transpile` function, an initial layout which permutes the qubits based on the selected physical qubits on the :class:`~.Target`, and a final layout which is an output permutation caused by :class:`~.SwapGate`\s inserted during routing. )rrs rflayoutzQuantumCircuit.layouts |rhrAc t|S)zThe circuit data (instructions and context). Returns: QuantumCircuitData: a list-like object containing the :class:`.CircuitInstruction`\ s for each instruction. )rArs rfrzQuantumCircuit.datas"$'''rh data_inputrct|tr|}nt|}|j|j|_|sdSt|dtr|D]}||ddS|D]\}}}||||d dS)aSets the circuit data from a list of instructions and context. Args: data_input (Iterable): A sequence of instructions with their execution contexts. The elements must either be instances of :class:`.CircuitInstruction` (preferred), or a 3-tuple of ``(instruction, qargs, cargs)`` (legacy). In the legacy format, ``instruction`` must be an :class:`~.circuit.Instruction`, while ``qargs`` and ``cargs`` must be iterables of :class:`~.circuit.Qubit` or :class:`.Clbit` specifiers (similar to the allowed forms in calls to :meth:`append`). NrFcopy) rarrrbrclearrSrBappend)rrrqargscargss rfrzQuantumCircuit.datas j+ . . *#**JJj))J  -  F jm%7 8 8 C) 5 5  Ke 4444 5 5.8 C C) UE KE BBBB C Crh list[int]c<|jtd|jS)aReturn a list of operation start times. This attribute is enabled once one of scheduling analysis passes runs on the quantum circuit. Returns: List of integers representing instruction start times. The index corresponds to the index of instruction in :attr:`QuantumCircuit.data`. Raises: AttributeError: When circuit is not scheduled. NznThis circuit is not scheduled. To schedule it run the circuit through one of the transpiler scheduling passes.)r~AttributeErrorrs rfop_start_timeszQuantumCircuit.op_start_timess0   ' b ##rh)rrc|jS)zReturn calibration dictionary. The custom pulse definition of a given gate is of the form ``{'gate_name': {(qubits, params): schedule}}`` _calibrations_proprs rf calibrationszQuantumCircuit.calibrations3s &&rhrc||_dS)zSet the circuit calibration data from a dictionary of calibration definition. Args: calibrations (dict): A dictionary of input in the format ``{'gate_name': {(qubits, gate_params): schedule}}`` Nrrrs rfrzQuantumCircuit.calibrations=s#/rhc*t|jS)eAn alternative private path to the `calibrations` property for avoiding deprecation warnings.)rrrs rfrz!QuantumCircuit._calibrations_propHsD&'''rhc:tt||_dS)rN)rrrrs rfrz!QuantumCircuit._calibrations_propNs)|<<rhrCircuitInstruction | tuplec,||S)zReturn True if the circuit has a calibration defined for the instruction context. In this case, the operation does not need to be translated to the device basis. )_has_calibration_forrrs rfhas_calibration_forz"QuantumCircuit.has_calibration_forTs ((555rhct|tr|j}|j}n|\}}}jr|jjvrdSt fd|D}g}|jD]V}t|tr*|j s#| t|A| |Wt |}||fj|jvS)zjAn alternative private path to the `has_calibration_for` method for avoiding deprecation warnings.Fc3LK|]}j|VdSr`)rrI)rdrrs rfrgz6QuantumCircuit._has_calibration_for..fs3DDEt{((//DDDDDDrh) rarB operationrrrRrvparamsr3 parametersrfloat)rrrr_rps` rfrz#QuantumCircuit._has_calibration_for\s k#5 6 6 /#-I 'FF#. Ivq& ).@W*W*W5DDDDVDDDDD! ! !A!011 !!, ! eAhh'''' a    v4#:9>#JJJrhc|jS)aThe user provided metadata associated with the circuit. The metadata for the circuit is a user provided ``dict`` of metadata for the circuit. It will not be used to influence the execution or operation of the circuit, but it is expected to be passed between all transforms of the circuit (ie transpilation) and that providers will associate any circuit metadata with the results it returns from execution of that circuit. ) _metadatars rfrTzQuantumCircuit.metadataps ~rhc\t|tstd||_dS)zUpdate the circuit metadataz2Only a dictionary is accepted for circuit metadataN)rarrur)rrTs rfrTzQuantumCircuit.metadata}s1(D)) RPQQ Q!rhrzcHt|dS)Ntext)output)rzdrawrs rf__str__zQuantumCircuit.__str__s499F9++,,,rhctt|tsdSddlm}||d||dkS)NFrcircuit_to_dagcopy_operations)rarOqiskit.convertersr )rotherr s rf__eq__zQuantumCircuit.__eq__sa%00 5 544444~dE:::nn 5? ? ?   rhc |j}||}|jddhz D]1}t ||t j|j||2t||_|j d|_ |j t j|j j |t j|j j ||S)Nrr}T)deepcopyrr) __class____new____dict__keyssetattr_copyrr|r}rr replace_bitsrr)rmemorresultks rf __deepcopy__zQuantumCircuit.__deepcopy__snS!!##%%.(AA G GA FAu~dmA.>EE F F F F9&AAz55  !!>$*"3T::>$*"3T:: "    rhc&|xjdz c_dSNr instancesrs rfr{z#QuantumCircuit._increment_instancess  rhg333333?zin the 2.0 releasezWThis method is only used as an internal helper and will be removed with no replacement.)rradditional_msgrkc|jSzUReturn the current number of instances of this class, useful for auto naming.r r"s rf cls_instanceszQuantumCircuit.cls_instancess }rhc|jSr%r r"s rf_cls_instanceszQuantumCircuit._cls_instancess }rhc|jSz)Return the prefix to use for auto naming.prefixr"s rf cls_prefixzQuantumCircuit.cls_prefixs zrhc|jSr*r+r"s rfrxzQuantumCircuit._cls_prefixs zrhNonectsdtjj}nd}|jd|||_dS)z-update name of instance using instance number-N)rmpcurrent_processpidrwr(rR)rpid_names rfryzQuantumCircuit._name_updates\   52-//355HHHJJ)<)<)>)>JJJ rhregisterr?cd}t|tr ||jvrd}n t|tr ||jvrd}|S)z Test if this circuit has the register r. Args: register (Register): a quantum or classical register. Returns: bool: True if the register is contained in this circuit. FT)rar5rr9r)rr7has_regs rf has_registerzQuantumCircuit.has_registersW h 0 0 X5K5KGG "3 4 4 TZ9O9OGrhc||jdz}t|jD]B}|||jC|j|_|j |_ |S)uReverse the circuit by reversing the order of instructions. This is done by recursively reversing all instructions. It does not invert (adjoint) any gate. Returns: QuantumCircuit: the reversed circuit. Examples: input: .. code-block:: text ┌───┐ q_0: ┤ H ├─────■────── └───┘┌────┴─────┐ q_1: ─────┤ RX(1.57) ├ └──────────┘ output: .. code-block:: text ┌───┐ q_0: ─────■──────┤ H ├ ┌────┴─────┐└───┘ q_1: ┤ RX(1.57) ├───── └──────────┘ _reverser) copy_empty_likerRreversedrrreplacer reverse_opsrr)r reverse_circrs rfrAzQuantumCircuit.reverse_opss>++DI ,BCC #DI.. e eK  !4!4{?T?`?`?b?b!4!c!c d d d d $  I rhc*tttjttjjj}|jddd|jdddtjD]G}fdt|D}|t||jHtj D]G}fdt|D}|t||jHj D]T}fd|jD}fd|jD}| ||| U|S) uReturn a circuit with the opposite order of wires. The circuit is "vertically" flipped. If a circuit is defined over multiple registers, the resulting circuit will have the same registers but with their order flipped. This method is useful for converting a circuit written in little-endian convention to the big-endian equivalent, and vice versa. Returns: QuantumCircuit: the circuit with reversed bit order. Examples: input: .. code-block:: text ┌───┐ a_0: ┤ H ├──■───────────────── └───┘┌─┴─┐ a_1: ─────┤ X ├──■──────────── └───┘┌─┴─┐ a_2: ──────────┤ X ├──■─────── └───┘┌─┴─┐ b_0: ───────────────┤ X ├──■── └───┘┌─┴─┐ b_1: ────────────────────┤ X ├ └───┘ output: .. code-block:: text ┌───┐ b_0: ────────────────────┤ X ├ ┌───┐└─┬─┘ b_1: ───────────────┤ X ├──■── ┌───┐└─┬─┘ a_0: ──────────┤ X ├──■─────── ┌───┐└─┬─┘ a_1: ─────┤ X ├──■──────────── ┌───┐└─┬─┘ a_2: ┤ H ├──■───────────────── └───┘ rRrSNcPg|]"}|j#SrQfind_bitrIrdr new_qubit_maprs rfroz/QuantumCircuit.reverse_bits..I-YYY%M$--"6"6"<=YYYrh)rrRcPg|]"}|j#SrQrGrdr new_clbit_maprs rfroz/QuantumCircuit.reverse_bits..LrKrhcPg|]"}|j#SrQrGrIs rfroz/QuantumCircuit.reverse_bits..P-```EmDMM%$8$8$>?```rhcPg|]"}|j#SrQrGrMs rfroz/QuantumCircuit.reverse_bits..QrPrhr)rOrbr?rrrRrSrrr5rr9rrr@) rcircrerrrrrNrJs ` @@rf reverse_bitszQuantumCircuit.reverse_bitss^ $+&& ' ' $+&& ' '*      DDbD)  DDbD) DJ'' I ICYYYYY8TW==YYYD   o4chGGG H H H HDJ'' K KCYYYYY8TW==YYYD   /TIII J J J J9 L LK`````[M_```F`````[M_```F LL,,F6,JJ K K K K rh annotatedc$t|j|jg|j|jR|jdz|j d}t|jD]D}| | |j |E|S)uZInvert (take adjoint of) this circuit. This is done by recursively inverting all gates. Args: annotated: indicates whether the inverse gate can be implemented as an annotated gate. Returns: QuantumCircuit: the inverted circuit Raises: CircuitError: if the circuit cannot be inverted. Examples: input: .. code-block:: text ┌───┐ q_0: ┤ H ├─────■────── └───┘┌────┴─────┐ q_1: ─────┤ RX(1.57) ├ └──────────┘ output: .. code-block:: text ┌───┐ q_0: ──────■──────┤ H ├ ┌─────┴─────┐└───┘ q_1: ┤ RX(-1.57) ├───── └───────────┘ _dgrDrTr=) rOrrrrrRrSr?rrr@rinverse)rrT inverse_circrs rfrXzQuantumCircuit.inverseUsJ& K K Z Z   U"++    $DJ//  K  ##k.C.K.KV_.K.`.`#aa    rh)insert_barriersrepsrZct|j|jg|j|jRd|jd|zi}|dkr |}n$#t$r|}YnwxYwt|D]B}| ||j|j|r||dz kr| C|S)aDRepeat this circuit ``reps`` times. Args: reps (int): How often this circuit should be repeated. insert_barriers (bool): Whether to include barriers between circuit repetitions. Returns: QuantumCircuit: A circuit containing ``reps`` repetitions of this circuit. rRz**rr) rOrrrrrRto_gaterto_instructionrangerbarrier)rr[rZ repeated_circinstis rfrepeatzQuantumCircuit.repeats' K '+z 48J   EIYQ\VZQ\Q\E\  !88 -$(LLNN - - -**,, -4[[ , ,%%dDKEEE",qD1H}}!))+++sAA0/A0powerr matrix_powerc|dkr:t|ttjfr|s|s||S|jdkrt d|j |}n"#t$r}t d|d}~wwxYwt|j |j g|j |jR}||||t#t%|j|S)ahRaise this circuit to the power of ``power``. If ``power`` is a positive integer and both ``matrix_power`` and ``annotated`` are ``False``, this implementation defaults to calling ``repeat``. Otherwise, the circuit is converted into a gate, and a new circuit, containing this gate raised to the given power, is returned. The gate raised to the given power is implemented either as a unitary gate if ``annotated`` is ``False`` or as an annotated operation if ``annotated`` is ``True``. Args: power (float): The power to raise this circuit to. matrix_power (bool): indicates whether the inner power gate can be implemented as a unitary gate. annotated (bool): indicates whether the inner power gate can be implemented as an annotated operation. Raises: CircuitError: If the circuit needs to be converted to a unitary gate, but is not unitary. Returns: QuantumCircuit: A circuit implementing this circuit raised to the power of ``power``. rzoCannot raise a parameterized circuit to a non-positive power or matrix-power, please bind the free parameters: zThe circuit contains non-unitary operations and cannot be raised to a power. Note that no qiskit.circuit.Instruction objects may be in the circuit for this operation.NrW)rarknpintegerrdnum_parametersrrr]rrOrrrrrrerbr_r)rrerfrTgateex power_circuits rfrezQuantumCircuit.powers86 QJJ53 "344     ;;u%% %   " "%?%%   <<>>DD   D   't{DKZ$*ZtzZZZ TZZZCCT%PTP_J`J`EaEabbbs$A99 BBBrnum_ctrl_qubitslabel ctrl_statestr | int | Nonec@ |}n"#t$r}td|d}~wwxYw|||||}t |}t ||jg|jRdd|ji} | || j| S)aControl this circuit on ``num_ctrl_qubits`` qubits. Args: num_ctrl_qubits (int): The number of control qubits. label (str): An optional label to give the controlled operation for visualization. ctrl_state (str or int): The control state in decimal or as a bitstring (e.g. '111'). If None, use ``2**num_ctrl_qubits - 1``. annotated: indicates whether the controlled gate should be implemented as an annotated gate. Returns: QuantumCircuit: The controlled version of this circuit. Raises: CircuitError: If the circuit contains a non-unitary operation and cannot be controlled. zThe circuit contains non-unitary operations and cannot be controlled. Note that no qiskit.circuit.Instruction objects may be in the circuit for this operation.NrRc_) r]rrcontrolr5rOrrrRr) rrnrorprTrkrlcontrolled_gate control_qregcontrolled_circs rfrtzQuantumCircuit.controls. <<>>DD   8   ,,z9UU&77 ( $+ (,    9Idi9I9I   0FGGGs 616)r var_remapinline_capturesr$Union['QuantumCircuit', Instruction]0QubitSpecifier | Sequence[QubitSpecifier] | None0ClbitSpecifier | Sequence[ClbitSpecifier] | Nonefrontinplacewraprrx.Mapping[str | expr.Var, str | expr.Var] | NoneryOptional['QuantumCircuit']c  |r|r|jrtd|s|jrtd|r|n|} indfd t|tr]|jsV|jrO| jrtd | |j|jD]} | | |r[t|trFtd |j Dr| n| }t|ts||j d|j}||jd|j}|rc| j } | | ||| | D]} | | n| ||||rdn| S|j| jks|j| jkrtdi}|5| j }|t+|j | j n| |}t/||jkr(tdt/|d|jdt/t1|t/|krtd|d|t+|j ||5| j}|t+|j| jn| |}t/||jkr(tdt/|d|jdt/t1|t/|krtd|d|t+|j| ||jD]%\}}| j||&d| _d| _| xj|jz c_|j } dfd d}|r/| j }| || |i| |||r'| !||rdn| S)u`Apply the instructions from one circuit onto specified qubits and/or clbits on another. .. note:: By default, this creates a new circuit object, leaving ``self`` untouched. For most uses of this function, it is far more efficient to set ``inplace=True`` and modify the base circuit in-place. When dealing with realtime variables (:class:`.expr.Var` instances), there are two principal strategies for using :meth:`compose`: 1. The ``other`` circuit is treated as entirely additive, including its variables. The variables in ``other`` must be entirely distinct from those in ``self`` (use ``var_remap`` to help with this), and all variables in ``other`` will be declared anew in the output with matching input/capture/local scoping to how they are in ``other``. This is generally what you want if you're joining two unrelated circuits. 2. The ``other`` circuit was created as an exact extension to ``self`` to be inlined onto it, including acting on the existing variables in their states at the end of ``self``. In this case, ``other`` should be created with all these variables to be inlined declared as "captures", and then you can use ``inline_captures=True`` in this method to link them. This is generally what you want if you're building up a circuit by defining layers on-the-fly, or rebuilding a circuit using layers taken from itself. You might find the ``vars_mode="captures"`` argument to :meth:`copy_empty_like` useful to create each layer's base, in this case. Args: other (qiskit.circuit.Instruction or QuantumCircuit): (sub)circuit or instruction to compose onto self. If not a :obj:`.QuantumCircuit`, this can be anything that :obj:`.append` will accept. qubits (list[Qubit|int]): qubits of self to compose onto. clbits (list[Clbit|int]): clbits of self to compose onto. front (bool): If ``True``, front composition will be performed. This is not possible within control-flow builder context managers. inplace (bool): If ``True``, modify the object. Otherwise, return composed circuit. copy (bool): If ``True`` (the default), then the input is treated as shared, and any contained instructions will be copied, if they might need to be mutated in the future. You can set this to ``False`` if the input should be considered owned by the base circuit, in order to avoid unnecessary copies; in this case, it is not valid to use ``other`` afterward, and some instructions may have been mutated in place. var_remap (Mapping): mapping to use to rewrite :class:`.expr.Var` nodes in ``other`` as they are inlined into ``self``. This can be used to avoid naming conflicts. Both keys and values can be given as strings or direct :class:`.expr.Var` instances. If a key is a string, it matches any :class:`~.expr.Var` with the same name. If a value is a string, whenever a new key matches a it, a new :class:`~.expr.Var` is created with the correct type. If a value is a :class:`~.expr.Var`, its :class:`~.expr.Expr.type` must exactly match that of the variable it is replacing. inline_captures (bool): if ``True``, then all "captured" :class:`~.expr.Var` nodes in the ``other`` :class:`.QuantumCircuit` are assumed to refer to variables already declared in ``self`` (as any input/capture/local type), and the uses in ``other`` will apply to the existing variables. If you want to build up a layer for an existing circuit to use with :meth:`compose`, you might find the ``vars_mode="captures"`` argument to :meth:`copy_empty_like` useful. Any remapping in ``vars_remap`` occurs before evaluating this variable inlining. If this is ``False`` (the default), then all variables in ``other`` will be required to be distinct from those in ``self``, and new declarations will be made for them. wrap (bool): If True, wraps the other circuit into a gate (or instruction, depending on whether it contains only unitary instructions) before composing it onto self. Rather than using this option, it is almost always better to manually control this yourself by using :meth:`to_instruction` or :meth:`to_gate`, and then call :meth:`append`. Returns: QuantumCircuit: the composed circuit (returns None if inplace==True). Raises: CircuitError: if no correct wire mapping can be made between the two circuits, such as if ``other`` is wider than ``self``. CircuitError: if trying to emit a new circuit while ``self`` has a partially built control-flow context active, such as the context-manager forms of :meth:`if_test`, :meth:`for_loop` and :meth:`while_loop`. CircuitError: if trying to compose to the front of a circuit when a control-flow builder block is active; there is no clear meaning to this action. Examples: .. code-block:: python >>> lhs.compose(rhs, qubits=[3, 2], inplace=True) .. code-block:: text ┌───┐ ┌─────┐ ┌───┐ lqr_1_0: ───┤ H ├─── rqr_0: ──■──┤ Tdg ├ lqr_1_0: ───┤ H ├─────────────── ├───┤ ┌─┴─┐└─────┘ ├───┤ lqr_1_1: ───┤ X ├─── rqr_1: ┤ X ├─────── lqr_1_1: ───┤ X ├─────────────── ┌──┴───┴──┐ └───┘ ┌──┴───┴──┐┌───┐ lqr_1_2: ┤ U1(0.1) ├ + = lqr_1_2: ┤ U1(0.1) ├┤ X ├─────── └─────────┘ └─────────┘└─┬─┘┌─────┐ lqr_2_0: ─────■───── lqr_2_0: ─────■───────■──┤ Tdg ├ ┌─┴─┐ ┌─┴─┐ └─────┘ lqr_2_1: ───┤ X ├─── lqr_2_1: ───┤ X ├─────────────── └───┘ └───┘ lcr_0: 0 ═══════════ lcr_0: 0 ═══════════════════════ lcr_1: 0 ═══════════ lcr_1: 0 ═══════════════════════ zPCannot compose to the front of a circuit while a control-flow context is active.zJCannot emit a new composed circuit while a control-flow context is active.Nrexpr.VarcacheMapping[expr.Var, expr.Var]rc ||x}r|S|x}s|jx}rst|tr%tj||j}|j|jkr(td|jd|jd|jdn|}|||<|S)Nz%mismatched types in replacement for 'z': 'z' cannot become '') getrRrarzr1Varnewrmr)rrr replacementrxs rf replace_varz+QuantumCircuit.compose..replace_varsiinn$s  (}}S111 "immTWT\F]F]7]{ "k3//F"&(,,{CH"E"EK#sx//&LLL XLL8C8HLLL0 " $E#J rhz>cannot implicitly add clbits while within a control-flow scopec3JK|]}t|jtVdSr`)rarr)rdinss rfrgz)QuantumCircuit.compose..s.MM3z#-66MMMMMMrhcopy_instructionsr)rrrzHTrying to compose with another QuantumCircuit which has more 'in' edges.z%Number of items in qubits parameter (z2) does not match number of qubits in the circuit (z).z4Duplicate qubits referenced in 'qubits' parameter: 'rz%Number of items in clbits parameter (z2) does not match number of clbits in the circuit (z4Duplicate clbits referenced in 'clbits' parameter: 'rqct |D]!}||"|rp|D]Z}|}||s-||urt d|dt d|d|d[n6|D]!}||"|D]!}||"fd tj |j |j  fd} |j } | || | | || dS) Nz Variable 'zt' to be inlined is not in the base circuit. If you wanted it to be automatically added, use `inline_captures=False`.z Replacement 'z' for variable 'z:' is not in the base circuit. Is the replacement correct?cz|}i|_i|_i|_||d|S)NF)ry)r>rrr)block new_blockbit_mapcopy_with_remappingvar_maps rf recurse_blockzJQuantumCircuit.compose..copy_with_remapping..recurse_blocksS "1133 (* %*, '(* %$#E9gwX]^^^^  rh)rc|}t|t}|sJt|ddx}7||urr|n|}||_n|r|fd|jD}t|ttfr |j |_nt|tr |j |_ nUt|tr@t|j|j}||urr|n|S)N _conditionc3.K|]}|VdSr`rQ)rdrrs rfrgzXQuantumCircuit.compose..copy_with_remapping..map_vars..2s-.].]}}U/C/C.].].].].].]rh)rar!getattrr map_condition conditionreplace_blocksblocksr+r/rr- map_targettargetrDmap_exprlvaluervalue)opn_opis_control_flowrrrvariable_mappers rfmap_varszEQuantumCircuit.compose..copy_with_remapping..map_vars(sb",T="A"A'&-dL$&G&GGT*."***499;;;4D%4%B%B9%M%MDNN$ ...].].].]QUQ\.].].]]]D!$;(?@@N)8)F)Ft)W)W#D,77N&5&@&@&M&M e,, '00==?W?WX\Xc?d?dD'+bjjTjtyy{{{tCrhrr)iter_input_varsriter_captured_varshas_varrriter_declared_varsadd_uninitialized_varr VariableMapperrrrrrmap_nonstandard_ops_current_scopeextend)sourcedestrrry new_qubits new_clbitsrrrrrrrrrs `` @@rfrz3QuantumCircuit.compose..copy_with_remappingsv --// : :{{3889999 @!4466  C"-+c7";";K<< C(A(ABB +--".!%>????0022 F F**;;sG+D+DEEEE ! ! ! ! ! ! !6D GW4;LO D D D D D D D*"<,,t,DDL  % %Z % K K K  , ,X 6 6 6    ! ! ( ( 6 6 6 6 6rh)rrryrr)rrrrrrNN)"rrrrarOrrrrrsrr]r^rrrrrrrrzip_qbit_argument_conversionlenr_cbit_argument_conversionrrrrrrSrr)rrrrr}r~rrrxryrreold_dataredge_map mapped_qubits mapped_clbitsrkcalsrappend_existingrrs `` @@rfcomposezQuantumCircuit.composesd  u !: b  44 \ /ttDIIKK#+BB       * e^ , , +; +5< +,&X el+++ ;++C%%c****  Jun55 MM%*MMMMM, ))++  %00 -~%7u'7%78~%7u'7%78 J:??T?BB  E66 ===#+..KLL----. EvD III",44 ,  do - -1ADO1S1SZ 8: > KM OOC dk:: ; ; ; ; ::6BBM=!!U%555"TC  KM OOC dk:: ; ; ; ; ::6BBM=!!U%555"TC t |j|j|j |j g|j|j|j|jR}| |t|jt|jd| |t|j|t|j|d|r!|j |j dS|S)uTensor ``self`` with ``other``. Remember that in the little-endian convention the leftmost operation will be at the bottom of the circuit. See also `the docs `__ for more information. .. code-block:: text ┌────────┐ ┌─────┐ ┌─────┐ q_0: ┤ bottom ├ ⊗ q_0: ┤ top ├ = q_0: ─┤ top ├── └────────┘ └─────┘ ┌┴─────┴─┐ q_1: ┤ bottom ├ └────────┘ Args: other (QuantumCircuit): The other circuit to tensor this circuit with. inplace (bool): If ``True``, modify the object. Otherwise return composed circuit. Examples: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit import QuantumCircuit top = QuantumCircuit(1) top.x(0); bottom = QuantumCircuit(2) bottom.cry(0.2, 0, 1); tensored = bottom.tensor(top) tensored.draw('mpl') Returns: QuantumCircuit: The tensored circuit (returns ``None`` if ``inplace=True``). rrrmeasTr~N)rrrrrRrOrr9rrrr_rr)rrr~rrrrs rftensorzQuantumCircuit.tensorWsXJ_u'77 _u'77   OOs5;// 4 4 4 41 4 4 4 4 4 1 "ek!n&9@@@@S@@@@@A~~%j*==%j11  OOs5;// 4 4 4 41 4 4 4 4 4 1 "ek!n&9CCCCVCCCCC"4?U5E#EvNNB!@5;@@R@@@DD"            D UE%"233U5;K5L5LVZ [[[  %"J / / %"J / /       M  / / /4 rh list[Qubit]c|jjS)zcA list of :class:`Qubit`\ s in the order that they were added. You should not mutate this.)rrrs rfrzQuantumCircuit.qubitsz  rh list[Clbit]c|jjS)zcA list of :class:`Clbit`\ s in the order that they were added. You should not mutate this.)rrrs rfrzQuantumCircuit.clbitsrrhlist[AncillaQubit]c|jS)zjA list of :class:`AncillaQubit`\ s in the order that they were added. You should not mutate this.)rrs rfancillaszQuantumCircuit.ancillass ~rhc0|j|jz|jzS)zzThe number of real-time classical variables in the circuit. This is the length of the :meth:`iter_vars` iterable.)num_input_varsnum_captured_varsnum_declared_varsrs rfnum_varszQuantumCircuit.num_varss "T%;;d>TTTrhc*t|jS)zThe number of real-time classical variables in the circuit marked as circuit inputs. This is the length of the :meth:`iter_input_vars` iterable. If this is non-zero, :attr:`num_captured_vars` must be zero.)rrrs rfrzQuantumCircuit.num_input_vars 4#$$$rhc*t|jS)zThe number of real-time classical variables in the circuit marked as captured from an enclosing scope. This is the length of the :meth:`iter_captured_vars` iterable. If this is non-zero, :attr:`num_input_vars` must be zero.)rrrs rfrz QuantumCircuit.num_captured_varss4%&&&rhc*t|jS)zThe number of real-time classical variables in the circuit that are declared by this circuit scope, excluding inputs or captures. This is the length of the :meth:`iter_declared_vars` iterable.)rrrs rfrz QuantumCircuit.num_declared_varsrrhtyping.Iterable[expr.Var]cR|jrF|jd}tj||Stj|j|j|jS)aGet an iterable over all real-time classical variables in scope within this circuit. This method will iterate over all variables in scope. For more fine-grained iterators, see :meth:`iter_declared_vars`, :meth:`iter_input_vars` and :meth:`iter_captured_vars`.rE) r itertoolschainriter_local_varsrvaluesrr)rbuilders rf iter_varszQuantumCircuit.iter_varss  $ \/3G?7#=#=#?#?AXAXAZAZ[[ [   # # % %t'9'@'@'B'BDDTD[D[D]D]   rhc|jr|jdS|jS)zGet an iterable over all real-time classical variables that are declared with automatic storage duration in this scope. This excludes input variables (see :meth:`iter_input_vars`) and captured variables (see :meth:`iter_captured_vars`).rE)rrrrrs rfrz!QuantumCircuit.iter_declared_varss?  $ C,R0@@BB B&&(((rhcF|jrdS|jS)zGet an iterable over all real-time classical variables that are declared as inputs to this circuit scope. This excludes locally declared variables (see :meth:`iter_declared_vars`) and captured variables (see :meth:`iter_captured_vars`).rQ)rrrrs rfrzQuantumCircuit.iter_input_varss)  $ 2&&(((rhc|jr|jdS|jS)aGet an iterable over all real-time classical variables that are captured by this circuit scope from a containing scope. This excludes input variables (see :meth:`iter_input_vars`) and locally declared variables (see :meth:`iter_declared_vars`).rE)rrrrrs rfrz!QuantumCircuit.iter_captured_vars s?  $ F,R0CCEE E!((***rhrhsc,||S)z%Overload & to implement self.compose.rrrs rf__and__zQuantumCircuit.__and__ s||C   rhc4||d|S)z/Overload &= to implement self.compose in place.Trrrs rf__iand__zQuantumCircuit.__iand__ s S$ ''' rhtopc,||S)z$Overload ^ to implement self.tensor.rrrs rf__xor__zQuantumCircuit.__xor__ s{{3rhc4||d|S)z.Overload ^= to implement self.tensor in place.Trrrs rf__ixor__zQuantumCircuit.__ixor__ s C &&& rhc*t|jS)z'Return number of operations in circuit.)rrrs rf__len__zQuantumCircuit.__len__ s4:rhitemrBcdSr`rQrrs rf __getitem__zQuantumCircuit.__getitem__ s 5<< I&   LLL  ##cL ||S#ttf$r|cYSwxYwrrrs rf_castzQuantumCircuit._cast6 s> 5<< I&   LLL rqubit_representationQubitSpecifierc,||Sa Converts several qubit representations (such as indexes, range, etc.) into a list of qubits. Args: qubit_representation: Representation to expand. Returns: The resolved instances of the qubits. rrr s rfqbit_argument_conversionz'QuantumCircuit.qbit_argument_conversion> s$--.BCCCrhcDt||j|jtSr )_bit_argument_conversionrrr6rs rfrz(QuantumCircuit._qbit_argument_conversionR $( $+t/BE   rhclbit_representationClbitSpecifierc,||S)a& Converts several classical bit representations (such as indexes, range, etc.) into a list of classical bits. Args: clbit_representation : Representation to expand. Returns: A list of tuples where each tuple is a classical bit. rrrs rfcbit_argument_conversionz'QuantumCircuit.cbit_argument_conversiona s"--.BCCCrhcDt||j|jtS)a% Converts several classical bit representations (such as indexes, range, etc.) into a list of classical bits. Args: clbit_representation: Representation to expand. Returns: A list of tuples where each tuple is a classical bit. )rrrr:rs rfrz(QuantumCircuit._cbit_argument_conversiont rrhrrrSequence[QubitSpecifier]rSequence[ParameterValueType]r=c}|g}fd|pgD}|D]}tj||t|j}tj||gD]y\} } | tj|| ||} | | d| |j t|j dz z|S)zSAn internal method to bypass some checking when directly appending a standard gate.Nc:g|]}|SrQr rdqargrs rfroz8QuantumCircuit._append_standard_gate.. 'WWW4$88>>WWWrhresource_requesterroT_standard_gater) rrvalidate_parameterr=resolve_classical_resourcebroadcast_arguments _check_dupsrB from_standardr_add_refrr) rrrrro circuit_scopeexpanded_qargsparamrrrrs ` rf_append_standard_gatez$QuantumCircuit._append_standard_gate s++-- >FWWWW5;TVWWW / /E  #B . . . .%9abbb /NBGG c cGD!   T " " ",:2tVSXYYYK  T B B B  ! !-"]>]`a>a b b b brhrOperation | CircuitInstructionSequence[QubitSpecifier] | NonerSequence[ClbitSpecifier] | NonecZt|tr|j}|j}|j}n|}t|t s|t |dr9|}t|t stdn3t|t rtdtd }t|ddx}r`d}|D]C} |pt| t}t| tjrt|| } D|r|rt!j|}t|t$rOfdt&jd |jDDx} rtd | d fd |pgD} fd |pgD} t/|j} t|t2r|| | nt3j|| | }t|dd}|D]v\}}||||}||| |jtA|jdz w| S)aAppend one or more instructions to the end of the circuit, modifying the circuit in place. The ``qargs`` and ``cargs`` will be expanded and broadcast according to the rules of the given :class:`~.circuit.Instruction`, and any non-:class:`.Bit` specifiers (such as integer indices) will be resolved into the relevant instances. If a :class:`.CircuitInstruction` is given, it will be unwrapped, verified in the context of this circuit, and a new object will be appended to the circuit. In this case, you may not pass ``qargs`` or ``cargs`` separately. Args: instruction: :class:`~.circuit.Instruction` instance to append, or a :class:`.CircuitInstruction` with all its context. qargs: specifiers of the :class:`~.circuit.Qubit`\ s to attach instruction to. cargs: specifiers of the :class:`.Clbit`\ s to attach instruction to. copy: if ``True`` (the default), then the incoming ``instruction`` is copied before adding it to the circuit if it contains symbolic parameters, so it can be safely mutated without affecting other circuits the same instruction might be in. If you are sure this instruction will not be in other circuits, you can set this ``False`` for a small speedup. Returns: qiskit.circuit.InstructionSet: a handle to the :class:`.CircuitInstruction`\ s that were actually added to the circuit. Raises: CircuitError: if the operation passed is not an instance of :class:`~.circuit.Instruction` . r^z/operation.to_instruction() is not an Operation.zTObject is a subclass of Operation, please add () to pass an instance of this object.zHObject to append must be an Operation or have a to_instruction() method.rrQFc>h|]}||SrQ)r)rdrrs rf z(QuantumCircuit.append.. s=   ||C((     rhc3>K|]}|VdSr`)r)rdrs rfrgz(QuantumCircuit.append.. s?9938E,,..999999rhz%Control-flow op attempts to capture 'z' which are not in this circuitc:g|]}|SrQr rs rfroz)QuantumCircuit.append.. r rhc:g|]}|SrQr)rdcargrs rfroz)QuantumCircuit.append.. r rhr!rr)!rarBrrrr>hasattrr^r issubclassrrr3r1Expr_validate_exprrrr!rr from_iterablerr=r'rr(r)r@rr+rr)rrrrrrr,r is_parameterr. bad_capturesr-expanded_cargsrbroadcast_iterbase_instructionrr9s` rfrzQuantumCircuit.append sDJ k#5 6 6 $#-I&E&EE#I)Y// y"233 %4466 !)Y77Z&'XYYYZi33&; #^++-- Y"55 56 6 L A A+Uz%AT/U/U eTY//A*=%@@E 6  6!N955 i / /     $?8899]>]`a>a b b b brhr%cdSr`rQrrr%s rfrzQuantumCircuit._append s !Srhr>Sequence[Qubit]Sequence[Clbit]cdSr`rQ)rrrrs rfrzQuantumCircuit._append s Crhr$c|r*|j|d|_d|_|St |t  }|rt |||} |j|nN#t $rAdt|jj D}|j ||YnwxYwd|_d|_|r|jn|S)aiAppend an instruction to the end of the circuit, modifying the circuit in place. .. warning:: This is an internal fast-path function, and it is the responsibility of the caller to ensure that all the arguments are valid; there is no error checking here. In particular: * all the qubits and clbits must already exist in the circuit and there can be no duplicates in the list. * any control-flow operations or classically conditioned instructions must act only on variables present in the circuit. * the circuit must not be within a control-flow builder context. .. note:: This function may be used by callers other than :obj:`.QuantumCircuit` when the caller is sure that all error-checking, broadcasting and scoping has already been performed, and the only reference to the circuit the instructions are being appended to is within that same function. In particular, it is not safe to call :meth:`QuantumCircuit._append` on a circuit that is received by a function argument. This is because :meth:`.QuantumCircuit._append` will not recognize the scoping constructs of the control-flow builder interface. Args: instruction: A complete well-formed :class:`.CircuitInstruction` of the operation and its context to be added. In the legacy compatibility form, this can be a bare :class:`.Operation`, in which case ``qargs`` and ``cargs`` must be explicitly given. qargs: Legacy argument for qubits to attach the bare :class:`.Operation` to. Ignored if the first argument is in the preferential :class:`.CircuitInstruction` form. cargs: Legacy argument for clbits to attach the bare :class:`.Operation` to. Ignored if the first argument is in the preferential :class:`.CircuitInstruction` form. Returns: CircuitInstruction: a handle to the instruction that was just added. :meta public: Nrqc^g|]*\}}t|ttf!||jf+SrQ)rar3rOr)rdidxr.s rfroz*QuantumCircuit._append..N sJCe&9>%JKKe&'rh) rrrrrarB RuntimeErrorrrrappend_manual_params)rrrrr% old_stylers rfrzQuantumCircuit._append sR   J  k * * * DMDI ";0BCCC  H,[%GGK  A J  k * * * * A A A"+K,A,H"I"IF J + +K @ @ @ @ @  A  (1B{$${BsA22AB=<B=defaultrLUnion[Parameter, T]cdSr`rQrrRrOs rf get_parameterzQuantumCircuit.get_parameterZ sKN3rh. type(...)rcdSr`rQrRs rfrSzQuantumCircuit.get_parameter^ sORsrh typing.Anycz|j|x}|turtd|d|S|S)aRetrieve a compile-time parameter that is accessible in this circuit scope by name. Args: name: the name of the parameter to retrieve. default: if given, this value will be returned if the parameter is not present. If it is not given, a :exc:`KeyError` is raised instead. Returns: The corresponding parameter. Raises: KeyError: if no default is given, but the parameter does not exist in the circuit. Examples: Retrieve a parameter by name from a circuit:: from qiskit.circuit import QuantumCircuit, Parameter my_param = Parameter("my_param") # Create a parametrized circuit. qc = QuantumCircuit(1) qc.rx(my_param, 0) # We can use 'my_param' as a parameter, but let's say we've lost the Python object # and need to retrieve it. my_param_again = qc.get_parameter("my_param") assert my_param is my_param_again Get a variable from a circuit by name, returning some default if it is not present:: assert qc.get_parameter("my_param", None) is my_param assert qc.get_parameter("unknown_param", None) is None See also: :meth:`get_var` A similar method, but for :class:`.expr.Var` run-time variables instead of :class:`.Parameter` compile-time parameters. Nzno parameter named ' ' is present)rget_parameter_by_nameEllipsisKeyError)rrRrO parameters rfrSzQuantumCircuit.get_parameterb sPR99$?? ?I H(""HdHHHIIINrh name_or_paramstr | Parameterct|tr||dduSt|to||jd|kS)aCheck whether a parameter object exists in this circuit. Args: name_or_param: the parameter, or name of a parameter to check. If this is a :class:`.Parameter` node, the parameter must be exactly the given one for this function to return ``True``. Returns: whether a matching parameter is assignable in this circuit. See also: :meth:`QuantumCircuit.get_parameter` Retrieve the :class:`.Parameter` instance from this circuit by name. :meth:`QuantumCircuit.has_var` A similar method to this, but for run-time :class:`.expr.Var` variables instead of compile-time :class:`.Parameter`\ s. N)rarzrSrrR)rr]s rf has_parameterzQuantumCircuit.has_parameter se$ mS ) ) G%%mT::$F F }i 0 0 N""=#5t<< M rhUnion[expr.Var, T]cdSr`rQrRs rfget_varzQuantumCircuit.get_var rrhrcdSr`rQrRs rfrczQuantumCircuit.get_var sHKrhc||x}|S|turtd|d|S)aRetrieve a variable that is accessible in this circuit scope by name. Args: name: the name of the variable to retrieve. default: if given, this value will be returned if the variable is not present. If it is not given, a :exc:`KeyError` is raised instead. Returns: The corresponding variable. Raises: KeyError: if no default is given, but the variable does not exist. Examples: Retrieve a variable by name from a circuit:: from qiskit.circuit import QuantumCircuit # Create a circuit and create a variable in it. qc = QuantumCircuit() my_var = qc.add_var("my_var", False) # We can use 'my_var' as a variable, but let's say we've lost the Python object and # need to retrieve it. my_var_again = qc.get_var("my_var") assert my_var is my_var_again Get a variable from a circuit by name, returning some default if it is not present:: assert qc.get_var("my_var", None) is my_var assert qc.get_var("unknown_variable", None) is None See also: :meth:`get_parameter` A similar method, but for :class:`.Parameter` compile-time parameters instead of :class:`.expr.Var` run-time variables. Nzno variable named 'rX)rrcrZr[)rrRrOrs rfrczQuantumCircuit.get_var sYN&&((0066 6C CJ h  CCCCDD Drh name_or_varstr | expr.Varct|tr||dduS||jd|kS)aCheck whether a variable is accessible in this scope. Args: name_or_var: the variable, or name of a variable to check. If this is a :class:`.expr.Var` node, the variable must be exactly the given one for this function to return ``True``. Returns: whether a matching variable is accessible. See also: :meth:`QuantumCircuit.get_var` Retrieve the :class:`.expr.Var` instance from this circuit by name. :meth:`QuantumCircuit.has_parameter` A similar method to this, but for compile-time :class:`.Parameter`\ s instead of run-time :class:`.expr.Var` variables. N)rarzrcrR)rrfs rfrzQuantumCircuit.has_var sK$ k3 ' ' ?<< T22$> >||K,d33{BBrhtypes.Type | Nonec^t|tr2|tdtj||}n|}|jstd||jdx}/||krtd|dtd|d|d|S) aThe common logic for preparing and validating a new :class:`~.expr.Var` for the circuit. The given ``type_`` can be ``None`` if the variable specifier is already a :class:`.Var`, and must be a :class:`~.types.Type` if it is a string. The argument is ignored if the given first argument is a :class:`.Var` already. Returns the validated variable, which is guaranteed to be safe to add to the circuit.Nz:the type must be known when creating a 'Var' from a stringzycannot add variables that wrap `Clbit` or `ClassicalRegister` instances. Use `add_bits` or `add_register` as appropriate.rOrz#' is already present in the circuitz cannot add 'z$' as its name shadows the existing ') rarzrr1rr standalonercrR)rrfrrpreviouss rf_prepare_new_varzQuantumCircuit._prepare_new_var s k3 ' ' }"#_```(,,{E22CCC> "H SXt << >??? s D!D9rc|jrtd|jstd|j|dS)aAdd a variable with no initializer. In most cases, you should use :meth:`add_var` to initialize the variable. To use this function, you must already hold a :class:`~.expr.Var` instance, as the use of the function typically only makes sense in copying contexts. .. warning:: Qiskit makes no assertions about what an uninitialized variable will evaluate to at runtime, and some hardware may reject this as an error. You should treat this function with caution, and as a low-level primitive that is useful only in special cases of programmatically rebuilding two like circuits. Args: var: the variable to add. z. s,44z#s##444444rhrrrQrc3@K|]}t|tVdSr`rrcs rfrgz.QuantumCircuit.add_register.. s,'M'M 3(<(<'M'M'M'M'M'MrhrzwQuantumCircuit parameters can be Registers or Integers. If Integers, up to 2 arguments. QuantumCircuit was called with .c38K|]}j|jkVdSr`r)rdrer7s rfrgz.QuantumCircuit.add_register.. s=66.1 )666666rhzregister name "z" already existszexpected a register)rrrrarkr5rsr9rr?rrrRr7rrr _add_qregrrrJr add_clbitrHrrbr)rrXrrrrKr7s @rfrzQuantumCircuit.add_register s%  F 44t444 4 4 4yyA~~*T!Wc":":~7a<<DD+DGS99;DDTaC'M'M'M'M'M$M$M7a<<9;EE,T!Wc::Eu}"("W(((  : :H(H-- V#666659Z$*5L66633 V##TX]#T#T#TUUU(O44 3#33C$"555--c222(O44 :x((((H&788 : !!(+++ )( 3 3HCd111+C0:AA8S/RRRR ,,S1113? J1A537H44+C00 Hd++ : h''''"#8999; : :rhqregr5cJ|j|t|D]x\}}||jvr(|j|j||f6|j|t|jjdz ||fg|j|<ydSr) rrrrrJr add_qubitrHr)rrrKrs rfrzQuantumCircuit._add_qreg s $!$ b bHCd)))#C(2994+FFFF $$S)))+7 8MPQ8QUY[^T_S`+a+a#C((  b brhr Iterable[Bit]c*fd|D}|rtd||D]}t|trj|t|t r@j|tjj dz gj |<t|tr@j |tjj dz gj|<td|dS)zAdd Bits to the circuit.c8h|]}|jvs |jv|SrQ)rr)rdrrs rfr5z*QuantumCircuit.add_bits.. s:   3$*=#=#=H[A[A[CA[A[A[rhz0Attempted to add bits found already in circuit: rzFExpected an instance of Qubit, Clbit, or AncillaQubit, but was passed N)rrar8rrr6rrrHrrr:rrr)rrduplicate_bitsrs` rfrzQuantumCircuit.add_bits sO         dbR`bbcc c  C#|,, +%%c***#u%%  $$S)))+7 8MPQ8QSU+V+V#C((C''  $$S)))+7 8MPQ8QSU+V+V#C((":47::  rhrr@rHc t|tr |j|St|tr |j|St dt |#t$r}t d|d|d}~wwxYw)agFind locations in the circuit which can be used to reference a given :obj:`~Bit`. In particular, this function can find the integer index of a qubit, which corresponds to its hardware index for a transpiled circuit. .. note:: The circuit index of a :class:`.AncillaQubit` will be its index in :attr:`qubits`, not :attr:`ancillas`. Args: bit (Bit): The bit to locate. Returns: namedtuple(int, List[Tuple(Register, int)]): A 2-tuple. The first element (``index``) contains the index at which the ``Bit`` can be found (in either :obj:`~QuantumCircuit.qubits`, :obj:`~QuantumCircuit.clbits`, depending on its type). The second element (``registers``) is a list of ``(register, index)`` pairs with an entry for each :obj:`~Register` in the circuit which contains the :obj:`~Bit` (and the index in the :obj:`~Register` at which it can be found). Raises: CircuitError: If the supplied :obj:`~Bit` was of an unknown type. CircuitError: If the supplied :obj:`~Bit` could not be found on the circuit. Examples: Loop through a circuit, getting the qubit and clbit indices of each operation:: from qiskit.circuit import QuantumCircuit, Qubit qc = QuantumCircuit(3, 3) qc.h(0) qc.cx(0, 1) qc.cx(1, 2) qc.measure([0, 1, 2], [0, 1, 2]) # The `.qubits` and `.clbits` fields are not integers. assert isinstance(qc.data[0].qubits[0], Qubit) # ... but we can use `find_bit` to retrieve them. assert qc.find_bit(qc.data[0].qubits[0]).index == 0 simple = [ ( instruction.operation.name, [qc.find_bit(bit).index for bit in instruction.qubits], [qc.find_bit(bit).index for bit in instruction.clbits], ) for instruction in qc.data ] z&Could not locate bit of unknown type: zCould not locate provided bit: z*. Has it been added to the QuantumCircuit?N)rar6rr:rrrmr[)rrerrs rfrHzQuantumCircuit.find_bit5 sf #u%% Y*3//C'' Y*3//"#WDQTII#W#WXXX   a#aaa  s"!A%!A%A%% B/BBct|}t|t|krtddS)z6Raise exception if list of qubits contains duplicates.zduplicate qubit argumentsN)rrr)rrsqubitss rfr)zQuantumCircuit._check_dupst s;f++ w<<3v;; & &:;; ; ' &rh parameter_map*dict[Parameter, ParameterValueType] | Nonerc*ddlm}||||S)aCreate an :class:`~.circuit.Instruction` out of this circuit. .. seealso:: :func:`circuit_to_instruction` The underlying driver of this method. Args: parameter_map: For parameterized circuits, a mapping from parameters in the circuit to parameters to be used in the instruction. If None, existing circuit parameters will also parameterize the instruction. label: Optional gate label. Returns: qiskit.circuit.Instruction: a composite instruction encapsulating this circuit (can be decomposed back). r)circuit_to_instructionr#)(qiskit.converters.circuit_to_instructionr)rrrors rfr^zQuantumCircuit.to_instructionz s/, TSSSSS%%dMGGGGrhrc*ddlm}||||S)aCreate a :class:`.Gate` out of this circuit. The circuit must act only qubits and contain only unitary operations. .. seealso:: :func:`circuit_to_gate` The underlying driver of this method. Args: parameter_map: For parameterized circuits, a mapping from parameters in the circuit to parameters to be used in the gate. If ``None``, existing circuit parameters will also parameterize the gate. label : Optional gate label. Returns: Gate: a composite gate encapsulating this circuit (can be decomposed back). r)circuit_to_gater#)!qiskit.converters.circuit_to_gater)rrrors rfr]zQuantumCircuit.to_gate s.* FEEEEEt]%@@@@rhgates_to_decomposeBstr | Type[Instruction] | Sequence[str | Type[Instruction]] | Nonecddlm}ddlm}ddlm}||d}||d}t |D]}||}||dS) aCall a decomposition pass on this circuit, to decompose one level (shallow decompose). Args: gates_to_decompose: Optional subset of gates to decompose. Can be a gate type, such as ``HGate``, or a gate name, such as "h", or a gate label, such as "My H Gate", or a list of any combination of these. If a gate name is entered, it will decompose all gates with that name, whether the gates have labels or not. Defaults to all gates in the circuit. reps: Optional number of times the circuit should be decomposed. For instance, ``reps=2`` equals calling ``circuit.decompose().decompose()``. Returns: QuantumCircuit: a circuit one level decomposed r) Decomposer )dag_to_circuitTr )apply_synthesisF)(qiskit.transpiler.passes.basis.decomposer qiskit.converters.circuit_to_dagr  qiskit.converters.dag_to_circuitrr_run) rrr[rr rdagpass_rs rf decomposezQuantumCircuit.decompose s, GFFFFFCCCCCCCCCCCCnT4888 ,dCCCt ! !A))C..CC~c59999rhmediumrscale float | Nonefilenamestyledict | str | None interactive plot_barriersrS bool | Nonejustifyvertical_compression idle_wires with_layoutfold int | Noneax Any | None initial_state cregbundle wire_orderlist[int] | Noneexpr_lencddlm}||fid|d|d|d|d|d|d |d |d | d | d | d| d| d|d|d|d|S)aDraw the quantum circuit. Use the output parameter to choose the drawing format: **text**: ASCII art TextDrawing that can be printed in the console. **mpl**: images with color rendered purely in Python using matplotlib. **latex**: high-quality images compiled via latex. **latex_source**: raw uncompiled latex output. .. warning:: Support for :class:`~.expr.Expr` nodes in conditions and :attr:`.SwitchCaseOp.target` fields is preliminary and incomplete. The ``text`` and ``mpl`` drawers will make a best-effort attempt to show data dependencies, but the LaTeX-based drawers will skip these completely. Args: output: Select the output method to use for drawing the circuit. Valid choices are ``text``, ``mpl``, ``latex``, ``latex_source``. By default, the ``text`` drawer is used unless the user config file (usually ``~/.qiskit/settings.conf``) has an alternative backend set as the default. For example, ``circuit_drawer = latex``. If the output kwarg is set, that backend will always be used over the default in the user config file. scale: Scale of image to draw (shrink if ``< 1.0``). Only used by the ``mpl``, ``latex`` and ``latex_source`` outputs. Defaults to ``1.0``. filename: File path to save image to. Defaults to ``None`` (result not saved in a file). style: Style name, file name of style JSON file, or a dictionary specifying the style. * The supported style names are ``"iqp"`` (default), ``"iqp-dark"``, ``"clifford"``, ``"textbook"`` and ``"bw"``. * If given a JSON file, e.g. ``my_style.json`` or ``my_style`` (the ``.json`` extension may be omitted), this function attempts to load the style dictionary from that location. Note, that the JSON file must completely specify the visualization specifications. The file is searched for in ``qiskit/visualization/circuit/styles``, the current working directory, and the location specified in ``~/.qiskit/settings.conf``. * If a dictionary, every entry overrides the default configuration. If the ``"name"`` key is given, the default configuration is given by that style. For example, ``{"name": "textbook", "subfontsize": 5}`` loads the ``"texbook"`` style and sets the subfontsize (e.g. the gate angles) to ``5``. * If ``None`` the default style ``"iqp"`` is used or, if given, the default style specified in ``~/.qiskit/settings.conf``. interactive: When set to ``True``, show the circuit in a new window (for ``mpl`` this depends on the matplotlib backend being used supporting this). Note when used with either the `text` or the ``latex_source`` output type this has no effect and will be silently ignored. Defaults to ``False``. reverse_bits: When set to ``True``, reverse the bit order inside registers for the output visualization. Defaults to ``False`` unless the user config file (usually ``~/.qiskit/settings.conf``) has an alternative value set. For example, ``circuit_reverse_bits = True``. plot_barriers: Enable/disable drawing barriers in the output circuit. Defaults to ``True``. justify: Options are ``"left"``, ``"right"`` or ``"none"`` (str). If anything else is supplied, left justified will be used instead. It refers to where gates should be placed in the output circuit if there is an option. ``none`` results in each gate being placed in its own column. Defaults to ``left``. vertical_compression: ``high``, ``medium`` or ``low``. It merges the lines generated by the `text` output so the drawing will take less vertical room. Default is ``medium``. Only used by the ``text`` output, will be silently ignored otherwise. idle_wires: Include idle wires (wires with no circuit elements) in output visualization. Default is ``True`` unless the user config file (usually ``~/.qiskit/settings.conf``) has an alternative value set. For example, ``circuit_idle_wires = False``. with_layout: Include layout information, with labels on the physical layout. Default is ``True``. fold: Sets pagination. It can be disabled using -1. In ``text``, sets the length of the lines. This is useful when the drawing does not fit in the console. If None (default), it will try to guess the console width using ``shutil.get_terminal_size()``. However, if running in jupyter, the default line length is set to 80 characters. In ``mpl``, it is the number of (visual) layers before folding. Default is 25. ax: Only used by the `mpl` backend. An optional ``matplotlib.axes.Axes`` object to be used for the visualization output. If none is specified, a new matplotlib Figure will be created and used. Additionally, if specified there will be no returned Figure since it is redundant. initial_state: Adds :math:`|0\rangle` in the beginning of the qubit wires and :math:`0` to classical wires. Default is ``False``. cregbundle: If set to ``True``, bundle classical registers. Default is ``True``, except for when ``output`` is set to ``"text"``. wire_order: A list of integers used to reorder the display of the bits. The list must have an entry for every bit with the bits in the range 0 to (``num_qubits`` + ``num_clbits``). expr_len: The number of characters to display if an :class:`~.expr.Expr` is used for the condition in a :class:`.ControlFlowOp`. If this number is exceeded, the string will be truncated at that number and '...' added to the end. Returns: :class:`.TextDrawing` or :class:`matplotlib.figure` or :class:`PIL.Image` or :class:`str`: * ``TextDrawing`` (if ``output='text'``) A drawing that can be printed as ascii art. * ``matplotlib.figure.Figure`` (if ``output='mpl'``) A matplotlib figure object for the circuit diagram. * ``PIL.Image`` (if ``output='latex``') An in-memory representation of the image of the circuit diagram. * ``str`` (if ``output='latex_source'``) The LaTeX source code for visualizing the circuit diagram. Raises: VisualizationError: when an invalid output method is selected ImportError: when the output methods requires non-installed libraries. Example: .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit qc = QuantumCircuit(1, 1) qc.h(0) qc.measure(0, 0) qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'}) r)circuit_drawerrrrrrrrSrrrrrrrrrr)qiskit.visualizationr)rrrrrrrrSrrrrrrrrrrrs rfrzQuantumCircuit.draw sd 877777~    % X %  6  $  (- & G "6!5 "z $   r (- "z! ""z# $X%  rhc0t|jdd SN _directiveFrrxs rfzQuantumCircuit.{ sG Ku= = 9 rhfilter_functionCallable[..., int]cFtt||jS)aReturns total number of instructions in circuit. Args: filter_function (callable): a function to filter out some instructions. Should take as input a tuple of (Instruction, list(Qubit), list(Clbit)). By default, filters out "directives", such as barrier or snapshot. Returns: int: Total number of gate operations. )summapr)rrs rfsizezQuantumCircuit.sizey s 3 33444rhc0t|jdd Srrrs rfrzQuantumCircuit. s!g KuO O K rh$Callable[[CircuitInstruction], bool]cd|j|j|fDd}|jD]}t t j|j|j}t|jddx}| tj |jt|tjr |||n| tj |jnt|jtr)||tj|jjnFt|jt$r,|||jj|||jjt+fd|Dd}||r|dz }|D]}||<t+dS) aReturn circuit depth (i.e., length of critical path). The depth of a quantum circuit is a measure of how many "layers" of quantum gates, executed in parallel, it takes to complete the computation defined by the circuit. Because quantum gates take time to implement, the depth of a circuit roughly corresponds to the amount of time it takes the quantum computer to execute the circuit. .. warning:: This operation is not well defined if the circuit contains control-flow operations. Args: filter_function: A function to decide which instructions count to increase depth. Should take as a single positional input a :class:`CircuitInstruction`. Instructions for which the function returns ``False`` are ignored in the computation of the circuit depth. By default, filters out "directives", such as :class:`.Barrier`. Returns: int: Depth of circuit. Examples: Simple calculation of total circuit depth:: from qiskit.circuit import QuantumCircuit qc = QuantumCircuit(4) qc.h(0) qc.cx(0, 1) qc.h(2) qc.cx(2, 3) assert qc.depth() == 2 Modifying the previous example to only calculate the depth of multi-qubit gates:: assert qc.depth(lambda instr: len(instr.qubits) > 1) == 1 ci|] }|D]}|d SrrQ)rdobjectsobjs rfrz(QuantumCircuit.depth.. s<   Za  SVC    rhctj|D]K}|jr|||t j|jLdSr`)r1rrladdrr"node_resourcesr)rnoders rfupdate_from_exprz.QuantumCircuit.depth..update_from_expr sl~d++ N N>NKK$$$$NN>#@#E#E#LMMMM  N NrhrNc3(K|] }|V dSr`rQ)rdr obj_depthss rfrgz'QuantumCircuit.depth.. s'@@Z_@@@@@@rhrrkr)rrrrrrrrrrr"condition_resourcesrar1r<r-rrrrDrrmaxr) rrrrrr new_depthrrs @rfdepthzQuantumCircuit.depth s X  #'; T^^=M=M"N    N N N : , ,K)/+*PQQRRG$[%:L$OOO \~A)LLSTTTi33Y$$Wi8888NN>#Ei#P#P#WXXXXK1<@@ H  $)K4I4P*Q*QRRRRK1599 H  +*?*FGGG  +*?*FGGG @@@@@@@!LLLI{++ Q  , ,"+ 3 ,:$$&&2222rhc4|jS)znReturn number of qubits plus clbits in circuit. Returns: int: Width of circuit. )rwidthrs rfrzQuantumCircuit.width sz!!!rhc|jjS)zReturn number of qubits.)rrrs rfrzQuantumCircuit.num_qubits z$$rhc*t|jS)z$Return the number of ancilla qubits.)rrrs rf num_ancillaszQuantumCircuit.num_ancillas s4=!!!rhc|jjS)z Return number of classical bits.)rrrs rfrzQuantumCircuit.num_clbits rrh'OrderedDict[Instruction, int]'cR|j}t|S)zCount each operation kind in the circuit. Returns: OrderedDict: a breakdown of how many operations of each kind, sorted by amount. )r count_opsr)rops_dicts rfrzQuantumCircuit.count_ops s% :''))8$$$rhc4|jS)z|Return number of non-local gates (i.e. involving 2+ qubits). Conditional nonlocal gates are also included. )rnum_nonlocal_gatesrs rfrz!QuantumCircuit.num_nonlocal_gates s z,,...rhc*fd|jDS)zGet instructions matching name. Args: name (str): The name of instruction to. Returns: list(tuple): list of (instruction, qargs, cargs). c4g|]}|jjk|SrQ)rrR)rdmatchrRs rfroz3QuantumCircuit.get_instructions..s(NNN%1E1M1M1M1M1Mrhr)rrRs `rfget_instructionszQuantumCircuit.get_instructionss"ONNN4:NNNNrh unitary_onlycL|r|jn|j|jz}dt|D}dtt |D}t |}|jD]}|r|j}t |}n9|j|jz}t |t |jddrdndz}|dkrPt |jdd s9g} d} |sJ|jjD]=} || } t|D]#} | || vr| | n$>|D]A}||}t|D]'} ||| vr| | vr| | n(Btt| } t | } | dkrtg}| D]} | || g}t|D]!} | | vr| || "| ||}|| dz z}|dkrn|S) zHow many non-entangled subcircuits can the circuit be factored to. Args: unitary_only (bool): Compute only unitary part of graph. Returns: int: Number of connected components in circuit. ci|]\}}|| SrQrQ)rdrKrs rfrz;QuantumCircuit.num_connected_components..s0Z0Z0Zhc3c0Z0Z0Zrhcg|]}|gSrQrQ)rdrs rfroz;QuantumCircuit.num_connected_components..s???se???rhrNrrrrF) rrrr_rrrrcondition_bitsrrbrr)rrr bit_indices sub_graphsnum_sub_graphsrargs num_qargsgraphs_touched num_touchedrrKrrreg_int connections _sub_graphss rfnum_connected_componentsz'QuantumCircuit.num_connected_componentss+Kt{{t{1J0Z0Z)TX//0Z0Z0Z @?uS-=-='>'>??? Z :2 2 K ")II ")K,>>II !6 dKKRAAQR A~~gk.C\SX&Y&Y~!# $&*4C&&)#.!&~!6!6&&A"jm33 . 5 5a 8 8 8 % 4!&&D)$/G">22&&"jm33 66 . 5 5a 8 8 8 %!%c.&9&9!:!:!.11 ??"$K-<<#**:c?;;;;"$K$^44@@n44'..z#???&&{333!,J"kAo5N""#rhc.|dS)ziComputes the number of tensor factors in the unitary (quantum) part of the circuit only. T)r)rrs rfnum_unitary_factorsz"QuantumCircuit.num_unitary_factorsYs,,$,???rhc*|S)a)Computes the number of tensor factors in the unitary (quantum) part of the circuit only. Notes: This is here for backwards compatibility, and will be removed in a future release of Qiskit. You should call `num_unitary_factors` instead. )rrs rfnum_tensor_factorsz!QuantumCircuit.num_tensor_factors_s'')))rhcl||}|j|_|S)zCopy the circuit. Args: name (str): name to be given to the copied circuit. If None, then the name stays the same. Returns: QuantumCircuit: a deepcopy of the current circuit, with the specified name )r>rr)rrRcpys rfrzQuantumCircuit.copyjs/""4((JOO%%  rhalike) vars_moder $Literal['alike', 'captures', 'drop']c |(t|tstd|dtj|}t |||t |jj|jj |jj |_|r||_ |S)aReturn a copy of self with the same structure but empty. That structure includes: * name, calibrations and other metadata * global phase * all the qubits and clbits, including the registers * the realtime variables defined in the circuit, handled according to the ``vars`` keyword argument. .. warning:: If the circuit contains any local variable declarations (those added by the ``declarations`` argument to the circuit constructor, or using :meth:`add_var`), they may be **uninitialized** in the output circuit. You will need to manually add store instructions for them (see :class:`.Store` and :meth:`.QuantumCircuit.store`) to initialize them. Args: name: Name for the copied circuit. If None, then the name stays the same. vars_mode: The mode to handle realtime variables in. alike The variables in the output circuit will have the same declaration semantics as in the original circuit. For example, ``input`` variables in the source will be ``input`` variables in the output circuit. captures All variables will be converted to captured variables. This is useful when you are building a new layer for an existing circuit that you will want to :meth:`compose` onto the base, since :meth:`compose` can inline captures onto the base circuit (but not other variables). drop The output circuit will have no variables defined. Returns: QuantumCircuit: An empty copy of self. Nzinvalid name for a circuit: 'z''. The name must be a string or 'None'.)rS) rarzrurr_copy_metadatarrrrrSrR)rrRr rs rfr>zQuantumCircuit.copy_empty_likewsZ 4 5 5 ]]]] jtS),,, J tz0tz?V      CH rhcP|j|j|_dS)akClear all instructions in self. Clearing the circuits will keep the metadata and calibrations. .. seealso:: :meth:`copy_empty_like` A method to produce a new circuit with no instructions and all the same tracking of quantum and classical typed data, but without mutating the original circuit. N)rrrSrs rfrzQuantumCircuit.clears)  -rhlengthr9c|d|jDvr4tj}|t_t|}|t_nt||}|S)zCCreates a creg, checking if ClassicalRegister with same name existscg|] }|j SrQr)rdcregs rfroz/QuantumCircuit._create_creg..555$DI555rh)rr9r,)rrrR save_prefixnew_cregs rf _create_cregzQuantumCircuit._create_cregs\ 55$*555 5 5+2K'+  $(00H'2  $ $(66Hrhc|d|jDvr4tj}|t_t|}|t_nt||}|S)zACreates a qreg, checking if QuantumRegister with same name existscg|] }|j SrQr)rdrs rfroz/QuantumCircuit._create_qreg..rrh)rr5r,)rrrRrnew_qregs rf _create_qregzQuantumCircuit._create_qregsZ 55$*555 5 5)0K%)O "&v..H%0O " "&vt44HrhrcRddlm}|||ggdS)zReset the quantum bit(s) to their default state. Args: qubit: qubit(s) to reset. Returns: qiskit.circuit.InstructionSet: handle to the added instruction. r)ResetFr)resetrr)rrrs rfrzQuantumCircuit.resets8 !     {{5577UGRe{<<.ds-]]]uuCNNL\L\?\?\U?\?\?\rhr"N) rr rrrrrr`r")rr~r rRqubits_to_measurerrs @rfmeasure_activezQuantumCircuit.measure_activeQs DCCCCC  DD99;;DnT""]]]] ]]]$$S):%;%;YGG (###  &111 K4rhrc|r|}n|}|r`||jd}|||||j|n`|j|jkrtd|||j|j d|j|s|SdS)aAdds measurement to all qubits. By default, adds new classical bits in a :obj:`.ClassicalRegister` to store these measurements. If ``add_bits=False``, the results of the measurements will instead be stored in the already existing classical bits, with qubit ``n`` being measured into classical bit ``n``. Returns a new circuit with measurements if ``inplace=False``. Args: inplace (bool): All measurements inplace or return new circuit. add_bits (bool): Whether to add new bits to store the results. Returns: QuantumCircuit: Returns circuit with measurements when ``inplace=False``. Raises: CircuitError: if ``add_bits=False`` but there are not enough classical bits. rzPThe number of classical bits must be equal or greater than the number of qubits.rN) rrrrr`r"rrrr)rr~rrRrs rf measure_allzQuantumCircuit.measure_allos,  DD99;;D  H((&AAH   h ' ' ' LLNNN LLh / / / /00", LLNNN LLdk!do2E&F G G G K4rhc ddlm}ddlm}|r|}n|}||}|}||}t |jt |j  fd|jD} fd|j j D} g|_i|_ t|j j t|j |j|_ || |D]} || |D]<} | j} || | j| j=|s|SdS)aRemoves final measurements and barriers on all qubits if they are present. Deletes the classical registers that were used to store the values from these measurements that become idle as a result of this operation, and deletes classical bits that are referenced only by removed registers, or that aren't referenced at all but have become idle as a result of this operation. Measurements and barriers are considered final if they are followed by no other operations (aside from other measurements or barriers.) .. note:: This method has rather complex behavior, particularly around the removal of newly idle classical bits and registers. It is much more efficient to avoid adding unnecessary classical data in the first place, rather than trying to remove it later. .. seealso:: :class:`.RemoveFinalMeasurements` A transpiler pass that removes final measurements and barriers. This does not remove the classical data. If this is your goal, you can call that with:: from qiskit.circuit import QuantumCircuit from qiskit.transpiler.passes import RemoveFinalMeasurements qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.barrier() qc.measure([0, 1], [0, 1]) pass_ = RemoveFinalMeasurements() just_bell = pass_(qc) Args: inplace (bool): All measurements removed inplace or return new circuit. Returns: QuantumCircuit: Returns the resulting circuit when ``inplace=False``, else None. r)RemoveFinalMeasurementsr cg|]}|v| SrQrQ)rdr kept_cregss rfroz.s#JJJtz7I7I7I7I7Irhcg|]}|v| SrQrQ)rdr kept_clbitss rfroz.s#VVV5+AUAUAUAUAUrh)rreserverSN)qiskit.transpiler.passesr*r r rrrrrrrrrrrrSrrtopological_op_nodesrrrr)rr~r*r rRrremove_final_measnew_dag cregs_to_add clbits_to_addrrrbr.r,s @@rfremove_final_measurementsz(QuantumCircuit.remove_final_measurementssN EDDDDD444444  DD99;;DnT""3355#'',,--//00 '.)) KJJJJJJ VVVVDJ,=VVV   !:$c$*ooDL]     m$$$  $ $D   d # # # #0022 6 6D7<<>>D KKdj$* 5 5 5 5 K4rhpathc`ddlm}|||j|j|jdS)aRead an OpenQASM 2.0 program from a file and convert to an instance of :class:`.QuantumCircuit`. Args: path (str): Path to the file for an OpenQASM 2 program Return: QuantumCircuit: The QuantumCircuit object for the input OpenQASM 2. See also: :func:`.qasm2.load`: the complete interface to the OpenQASM 2 importer. rqasm2F include_pathcustom_instructionscustom_classicalstrict)qiskitr:loadLEGACY_INCLUDE_PATHLEGACY_CUSTOM_INSTRUCTIONSLEGACY_CUSTOM_CLASSICAL)r7r:s rffrom_qasm_filezQuantumCircuit.from_qasm_filesI !     zz 2 % @":    rhqasm_strc`ddlm}|||j|j|jdS)avConvert a string containing an OpenQASM 2.0 program to a :class:`.QuantumCircuit`. Args: qasm_str (str): A string containing an OpenQASM 2.0 program. Return: QuantumCircuit: The QuantumCircuit object for the input OpenQASM 2 See also: :func:`.qasm2.loads`: the complete interface to the OpenQASM 2 importer. rr9Fr;)r@r:loadsrBrCrD)rFr:s rf from_qasm_strzQuantumCircuit.from_qasm_str sI !     {{ 2 % @":    rhcL|jr|jdjS|jjS)z9The global phase of the current circuit scope in radians.rErrSrrs rfrSzQuantumCircuit.global_phase s+  $ >,R0= =z&&rhanglecT|jr||jd_dS||j_dS)z{Set the phase of the current circuit scope. Args: angle (float, ParameterExpression): radians rENrK)rrLs rfrSzQuantumCircuit.global_phase's5  $ ,9>D %b ) 6 6 6&+DJ # # #rhr;c4t|jjS)u The parameters defined in the circuit. This attribute returns the :class:`.Parameter` objects in the circuit sorted alphabetically. Note that parameters instantiated with a :class:`.ParameterVector` are still sorted numerically. Examples: The snippet below shows that insertion order of parameters does not matter. .. code-block:: python >>> from qiskit.circuit import QuantumCircuit, Parameter >>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant") >>> circuit = QuantumCircuit(1) >>> circuit.rx(b, 0) >>> circuit.rz(elephant, 0) >>> circuit.ry(a, 0) >>> circuit.parameters # sorted alphabetically! ParameterView([Parameter(a), Parameter(b), Parameter(elephant)]) Bear in mind that alphabetical sorting might be unintuitive when it comes to numbers. The literal "10" comes before "2" in strict alphabetical sorting. .. code-block:: python >>> from qiskit.circuit import QuantumCircuit, Parameter >>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")] >>> circuit = QuantumCircuit(1) >>> circuit.u(*angles, 0) >>> circuit.draw() ┌─────────────────────────────┐ q: ┤ U(angle_1,angle_2,angle_10) ├ └─────────────────────────────┘ >>> circuit.parameters ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)]) To respect numerical sorting, a :class:`.ParameterVector` can be used. .. code-block:: python >>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector >>> x = ParameterVector("x", 12) >>> circuit = QuantumCircuit(1) >>> for x_i in x: ... circuit.rx(x_i, 0) >>> circuit.parameters ParameterView([ ParameterVectorElement(x[0]), ParameterVectorElement(x[1]), ParameterVectorElement(x[2]), ParameterVectorElement(x[3]), ..., ParameterVectorElement(x[11]) ]) Returns: The sorted :class:`.Parameter` objects in the circuit. )r;rrrs rfrzQuantumCircuit.parameters3sxTZ2333rhc4|jS)z/The number of parameter objects in the circuit.)rrjrs rfrjzQuantumCircuit.num_parametersqsz((***rhset[Parameter]c4|jS)a^Efficiently get all parameters in the circuit, without any sorting overhead. .. warning:: The returned object may directly view onto the ``ParameterTable`` internals, and so should not be mutated. This is an internal performance detail. Code outside of this package should not use this method. )runsorted_parametersrs rf_unsorted_parametersz#QuantumCircuit._unsorted_parametersvsz--///rh) flat_inputr?rKUnion[Mapping[Parameter, ParameterValueType], Iterable[ParameterValueType]]Literal[False]rTr?cdSr`rQrrr~rTr?s rfassign_parametersz QuantumCircuit.assign_parameterss 3rh Literal[True]cdSr`rQrXs rfrYz QuantumCircuit.assign_parameterss srhc |r}n]tts jj}}||ttjj r{|rn  |r@fd Dx}r0tdd d|Dd fd|j n,|jj fd|jd  fd  tt fd |jD|_|rdn|S) a7Assign parameters to new parameters or values. If ``parameters`` is passed as a dictionary, the keys should be :class:`.Parameter` instances in the current circuit. The values of the dictionary can either be numeric values or new parameter objects. If ``parameters`` is passed as a list or array, the elements are assigned to the current parameters in the order of :attr:`parameters` which is sorted alphabetically (while respecting the ordering in :class:`.ParameterVector` objects). The values can be assigned to the current circuit object or to a copy of it. .. note:: When ``parameters`` is given as a mapping, it is permissible to have keys that are strings of the parameter names; these will be looked up using :meth:`get_parameter`. You can also have keys that are :class:`.ParameterVector` instances, and in this case, the dictionary value should be a sequence of values of the same length as the vector. If you use either of these cases, you must leave the setting ``flat_input=False``; changing this to ``True`` enables the fast path, where all keys must be :class:`.Parameter` instances. Args: parameters: Either a dictionary or iterable specifying the new parameter values. inplace: If False, a copy of the circuit with the bound parameters is returned. If True the circuit instance itself is modified. flat_input: If ``True`` and ``parameters`` is a mapping type, it is assumed to be exactly a mapping of ``{parameter: value}``. By default (``False``), the mapping may also contain :class:`.ParameterVector` keys that point to a corresponding sequence of values, and these will be unrolled during the mapping, or string keys, which will be converted to :class:`.Parameter` instances using :meth:`get_parameter`. strict: If ``False``, any parameters given in the mapping that are not used in the circuit will be ignored. If ``True`` (the default), an error will be raised indicating a logic error. Raises: CircuitError: If parameters is a dict and contains parameters not present in the circuit. ValueError: If parameters is a list/array and the length mismatches the number of free parameters in the circuit. Returns: A copy of the circuit with bound parameters if ``inplace`` is False, otherwise None. Examples: Create a parameterized circuit and assign the parameters in-place. .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit.circuit import QuantumCircuit, Parameter circuit = QuantumCircuit(2) params = [Parameter('A'), Parameter('B'), Parameter('C')] circuit.ry(params[0], 0) circuit.crx(params[1], 0, 1) circuit.draw('mpl') circuit.assign_parameters({params[0]: params[2]}, inplace=True) circuit.draw('mpl') Bind the values out-of-place by list and get a copy of the original circuit. .. plot:: :alt: Circuit diagram output by the previous code. :include-source: from qiskit.circuit import QuantumCircuit, ParameterVector circuit = QuantumCircuit(2) params = ParameterVector('P', 2) circuit.ry(params[0], 0) circuit.crx(params[1], 0, 1) bound_circuit = circuit.assign_parameters([1, 2]) bound_circuit.draw('mpl') circuit.draw('mpl') c>g|]}||SrQ)r`)rdr\rs rfroz4QuantumCircuit.assign_parameters..s="+$BTBTU^B_B_rhzCannot bind parameters (z, c34K|]}t|VdSr`)rz)rdrs rfrgz3QuantumCircuit.assign_parameters..s(8P8PAQ8P8P8P8P8P8Prhz) not present in the circuit.cSr`rQ) raw_mappingsrfcreate_mapping_viewz=QuantumCircuit.assign_parameters..create_mapping_view s ""rhc>ttSr`)rr)initial_parametersrsrfraz=QuantumCircuit.assign_parameters..create_mapping_viewsC 2J??@@@rhNc  d}t|}t|D]\}}t|ts|j zx}s:|D]}|| |}|js<|}t|trtd|d|||<d}|r| |t|f|fS)NFz(Calibration cannot use complex number: 'rT) rbrrar3rrassignnumericcomplexrurYrv) rrschedulemodifiednew_parametersrcr\ containedto_bindra mapping_views rfmap_calibrationz9QuantumCircuit.assign_parameters..map_calibration"s=#2244 H!*--N ). 9 9 9!)-@AA%.%9LK|]\\}}}|||VdSr`rQ)rdrrrhrns rfrgz=QuantumCircuit.assign_parameters...AsN:0VZ(( HEErhN)rr)rdrkrrns rfrgz3QuantumCircuit.assign_parameters..>s  'D, >J>P>P>R>R      rh)rarrrrr{ry collectionsabcr_unroll_param_dictrjoinassign_parameters_mappingassign_parameters_iterablerrr) rrr~rTr?rrextrasrarcrnrmr`s `` @@@@@rfrYz QuantumCircuit.assign_parametersst  "FFj$// *J)YY[[F  ' ' ) ) )    ! ! ! j+/"9 : : @(2[**8O8OPZ8[8[K /:  #$tyy8P8P8P8P8P/P/P$$$  # # # # # L 2 2; ? ? ? ?"(!8  A A A A A A L 3 3J ? ? ?  = = = = = =4 +     +1*>*D*D*F*F    *ttF*rhparameter_binds&Mapping[Parameter, ParameterValueType]c i}|D]\}}t|tr|t|t|kr8t d|jdt|dt|d|t||t|tr||| |<|||<|S)NzParameter vector 'z ' has length z, but was assigned to z values.) rrar<rrrRrrrzrS)rrxrr\rs rfrsz!QuantumCircuit._unroll_param_dictKs / 5 5 7 7 ' ' Iu)_55 'y>>SZZ//&EY^EE#i..EE03E EEE 3y%001111Is++ '5:D&&y1122!&I rhr#c ddlm}|rYtfd|D}t |t |||ddSj}t |t |||dS)ajApply :class:`~.library.Barrier`. If ``qargs`` is empty, applies to all qubits in the circuit. Args: qargs (QubitSpecifier): Specification for one or more qubit arguments. label (str): The string label of the barrier. Returns: qiskit.circuit.InstructionSet: handle to the added instructions. r)BarriercFi|]}|D]}|dSr`r )rdrrrs rfrz*QuantumCircuit.barrier..ms7YYYTD4R4RSW4X4XYYqDYYYYrhr#rQFr) r`r|rvrrBrrrr)rrorr|rs` rfr`zQuantumCircuit.barrier]s %$$$$$  YYYYUYYYF;;"773v;;e#D#D#DfbQQX] [%%''F&&((//"773v;;e#D#D#DfbQQ rhrqrrQubitSpecifier | Nonercf||j}|t|||ggdS)aApply :class:`~.circuit.Delay`. If qarg is ``None``, applies to all qubits. When applying to multiple qubits, delays with the same duration will be created. Args: duration (int or float or ParameterExpression): duration of the delay. qarg (Object): qubit argument to apply this delay. unit (str): unit of the duration. Supported units: ``'s'``, ``'ms'``, ``'us'``, ``'ns'``, ``'ps'``, and ``'dt'``. Default is ``'dt'``, i.e. integer time unit depending on the target backend. Returns: qiskit.circuit.InstructionSet: handle to the added instructions. Raises: CircuitError: if arguments have bad format. N)rFr)rrrC)rrrrs rfdelayzQuantumCircuit.delayxs9, <;D{{5555vr{NNNrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.HGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rHGaterrs rfhzQuantumCircuit.h!)),* > > L )     rhqubit1qubit2cJ|tj||g|gS)a~Apply :class:`~qiskit.circuit.library.RXXGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The angle of the rotation. qubit1: The qubit(s) to apply the gate to. qubit2: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rRXXGaterrrrs rfrxxzQuantumCircuit.rxx()),*>@PSXRYZZZrhcL|tj|g|g|S)aApply :class:`~qiskit.circuit.library.RYGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The rotation angle of the gate. qubit: The qubit(s) to apply the gate to. label: The string label of the gate in the circuit. Returns: A handle to the instructions created. r#)r/rRYGaters rfryzQuantumCircuit.ryrrhc||dvr&|tj||g|g|Sddlm}|||||||ggdS) aiApply :class:`~qiskit.circuit.library.CRYGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The angle of the rotation. control_qubit: The qubit(s) used as the control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. Nrr#r)CRYGaterFr)r/rrlibrary.standard_gates.ryr)rrrrrorprs rfcryzQuantumCircuit.cryrrhcJ|tj||g|gS)aApply :class:`~qiskit.circuit.library.RYYGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The rotation angle of the gate. qubit1: The qubit(s) to apply the gate to. qubit2: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rRYYGaters rfryyzQuantumCircuit.ryyrrhcH|tj|g|gS)aHApply :class:`~qiskit.circuit.library.RZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: phi: The rotation angle of the gate. qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rRZGate)rrrs rfrzzQuantumCircuit.rz%s#)),*=wNNNrhc||dvr&|tj||g|g|Sddlm}|||||||ggdS) aiApply :class:`~qiskit.circuit.library.CRZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The angle of the rotation. control_qubit: The qubit(s) used as the control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. Nrr#r)CRZGaterFr)r/rrlibrary.standard_gates.rzr)rrrrrorprs rfcrzzQuantumCircuit.crz3rrhcJ|tj||g|gS)aApply :class:`~qiskit.circuit.library.RZXGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The rotation angle of the gate. qubit1: The qubit(s) to apply the gate to. qubit2: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rRZXGaters rfrzxzQuantumCircuit.rzxZrrhcJ|tj||g|gS)aApply :class:`~qiskit.circuit.library.RZZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The rotation angle of the gate. qubit1: The qubit(s) to apply the gate to. qubit2: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rRZZGaters rfrzzzQuantumCircuit.rzzkrrhcH|tj||gdS)aApply :class:`~qiskit.circuit.library.ECRGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit1, qubit2: The qubits to apply the gate to. Returns: A handle to the instructions created. rQ)r/rECRGaterrrs rfecrzQuantumCircuit.ecr|s%)),*>@PRTUUUrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.SGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rSGaters rfszQuantumCircuit.srrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.SdgGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rSdgGaters rfsdgzQuantumCircuit.sdg!)),*>LLLrhc||dvr%|tj||gd|Sddlm}||||||ggd S) a:Apply :class:`~qiskit.circuit.library.CSGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. NrrQr#r)CSGaterFr)r/rrlibrary.standard_gates.sr)rrrrorprs rfcszQuantumCircuit.csrrhc||dvr%|tj||gd|Sddlm}||||||ggd S) a<Apply :class:`~qiskit.circuit.library.CSdgGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. NrrQr#r)CSdgGaterFr)r/rrrr)rrrrorprs rfcsdgzQuantumCircuit.csdgs.  x!7!7--% |'DbPU.  766666{{ H5Z 8 8 8 L )     rhcH|tj||gdS)a Apply :class:`~qiskit.circuit.library.SwapGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit1, qubit2: The qubits to apply the gate to. Returns: A handle to the instructions created. rQ)r/rSwapGaters rfswapzQuantumCircuit.swaps-))  ! V     rhcH|tj||gdS)a!Apply :class:`~qiskit.circuit.library.iSwapGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit1, qubit2: The qubits to apply the gate to. Returns: A handle to the instructions created. rQ)r/r ISwapGaters rfiswapzQuantumCircuit.iswaps%)),*@66BRTVWWWrh target_qubit1 target_qubit2c||dvr&|tj|||gd|Sddlm}|||||||ggd S) aApply :class:`~qiskit.circuit.library.CSwapGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the control. target_qubit1: The qubit(s) targeted by the gate. target_qubit2: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. ``'1'``). Defaults to controlling on the ``'1'`` state. Returns: A handle to the instructions created. NrrQr#r) CSwapGaterFr)r/rrlibrary.standard_gates.swapr)rrrrrorprs rfcswapzQuantumCircuit.cswap s2  x!7!7--& }= .  ;:::::{{ IEj 9 9 9 M= 9     rhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.SXGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rSXGaters rfsxzQuantumCircuit.sx5s!)),*=wKKKrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.SXdgGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rSXdgGaters rfsxdgzQuantumCircuit.sxdgBs!)),*?%"MMMrhc||dvr%|tj||gd|Sddlm}||||||ggd S) a;Apply :class:`~qiskit.circuit.library.CSXGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. NrrQr#r)CSXGaterFr)r/rrlibrary.standard_gates.sxr)rrrrorprs rfcsxzQuantumCircuit.csxOs.  x!7!7--$}l&CRu.  766666{{ G%J 7 7 7 L )     rhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.TGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rTGaters rftzQuantumCircuit.ttrrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.TdgGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rTdgGaters rftdgzQuantumCircuit.tdgrrhcL|tj|g|||gS)aApply :class:`~qiskit.circuit.library.UGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: theta: The :math:`\theta` rotation angle of the gate. phi: The :math:`\phi` rotation angle of the gate. lam: The :math:`\lambda` rotation angle of the gate. qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. )r/rUGate)rrrrrs rfuzQuantumCircuit.us)()),*  x!7!7--# -S%( .  544444{{ F5#sE: N N N L )     rhcJ|tj|gd|S)aVApply :class:`~qiskit.circuit.library.XGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. label: The string label of the gate in the circuit. Returns: A handle to the instructions created. rQr#)r/rXGate)rrros rfrzQuantumCircuit.xs')),*@PRTUUUrhc||dvr$|tj|||gdSddlm}||||||ggdS) aGApply :class:`~qiskit.circuit.library.CCXGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit1: The qubit(s) used as the first control. control_qubit2: The qubit(s) used as the second control. target_qubit: The qubit(s) targeted by the gate. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. N11rQr)CCXGaterFr)r/rr$rr)rrrrrpr$s rfccxzQuantumCircuit.ccxs.  y!8!8--$>  655555{{ Gz * * * ^\ :     rh noancillaancilla_qubitsmodec 8ddlm}m}m}t |} || ||| ||| d||| d||| ||| d||| d|d} |r||} | |} nI#t $r<} t| }td|d || d } ~ wwxYwt| d r}| j d krr| j }|td |dt|ds|g}t ||kr%t |}td|d|d|d |}ng}| | |d d |gz|d d zgS)aVApply :class:`~qiskit.circuit.library.MCXGate`. The multi-cX gate can be implemented using different techniques, which use different numbers of ancilla qubits and have varying circuit depth. These modes are: - ``'noancilla'``: Requires 0 ancilla qubits. - ``'recursion'``: Requires 1 ancilla qubit if more than 4 controls are used, otherwise 0. - ``'v-chain'``: Requires 2 less ancillas than the number of control qubits. - ``'v-chain-dirty'``: Same as for the clean ancillas (but the circuit will be longer). For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubits: The qubits used as the controls. target_qubit: The qubit(s) targeted by the gate. ancilla_qubits: The qubits used as the ancillae, if the mode requires them. mode: The choice of mode, explained further above. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. Raises: ValueError: if the given mode is not known, or if too few ancilla qubits are passed. AttributeError: if no ancilla qubits are passed, but some are needed. r)MCXGate MCXRecursive MCXVChainrFT)dirty_ancillasrp)r& recursionzv-chainz v-chain-dirtyadvancedbasiczbasic-dirty-ancillazUnsupported mode (z) selected, choose one of Nnum_ancilla_qubitsrzNo ancillas provided, but z are needed!rz At least z ancillas required, but z given.)rr*r+r,rrr[rbrrtr:r1rr)rrrr'r(rpr*r+r,rnavailable_implementationsrrkrl all_modesrequiredactuallys rfmcxzQuantumCircuit.mcx?sSH ONNNNNNNNNn--!ZHHH%o*MMM y%JOOO&YtXbccc$ _LLLYuQ[\\\#,9$$$ % % !  ?..~>>A ,T2DD   6;;==>>IPTPPYPP   4- . . 43JQ3N3N.H%$%X(%X%X%XYYY>955 2"0!1>""X--~.. !`X!`!`x!`!`!`aaa+IXI6NNN{{4!2l^!CnUVUVUVFW!WY[\\\s B C 7CCcF|tj|gdS)aApply :class:`~qiskit.circuit.library.YGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rYGaters rfyzQuantumCircuit.yrrhc||dvr%|tj||gd|Sddlm}||||||ggd S) a;Apply :class:`~qiskit.circuit.library.CYGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the controls. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. NrrQr#r)CYGaterFr)r/rr;library.standard_gates.yr)rrrrorpr;s rfcyzQuantumCircuit.cyrrhcF|tj|gdS)aApply :class:`~qiskit.circuit.library.ZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: qubit: The qubit(s) to apply the gate to. Returns: A handle to the instructions created. rQ)r/rZGaters rfzzQuantumCircuit.zrrhc||dvr%|tj||gd|Sddlm}||||||ggd S) a;Apply :class:`~qiskit.circuit.library.CZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit: The qubit(s) used as the controls. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '1'). Defaults to controlling on the '1' state. Returns: A handle to the instructions created. NrrQr#r)CZGaterFr)r/rrBlibrary.standard_gates.zr)rrrrorprBs rfczzQuantumCircuit.czrrhc||dvr&|tj|||gd|Sddlm}|||||||ggd S) aApply :class:`~qiskit.circuit.library.CCZGate`. For the full matrix form of this gate, see the underlying gate documentation. Args: control_qubit1: The qubit(s) used as the first control. control_qubit2: The qubit(s) used as the second control. target_qubit: The qubit(s) targeted by the gate. label: The string label of the gate in the circuit. ctrl_state: The control state in decimal, or as a bitstring (e.g. '10'). Defaults to controlling on the '11' state. Returns: A handle to the instructions created. Nr!rQr#r)CCZGaterFr)r/rrFrCr)rrrrrorprFs rfcczzQuantumCircuit.cczs2  y!8!8--$> .  655555{{ G%J 7 7 7 ^\ :     rh pauli_stringcRddlm}||||gdS)aApply :class:`~qiskit.circuit.library.PauliGate`. Args: pauli_string: A string representing the Pauli operator to apply, e.g. 'XX'. qubits: The qubits to apply this gate to. Returns: A handle to the instructions created. r) PauliGateFr).qiskit.circuit.library.generalized_gates.paulirJr)rrHrrJs rfpaulizQuantumCircuit.pauli$s; MLLLLL{{99\22FBU{KKKrhstate+Statevector | Sequence[complex] | str | int normalizecddlm}||j}n0t|tt jttfr|g}t|trt|nd}| ||||||dS)uPrepare qubits in a specific state. This class implements a state preparing unitary. Unlike :meth:`.initialize` it does not reset the qubits first. Args: state: The state to initialize to, can be either of the following. * Statevector or vector of complex amplitudes to initialize to. * Labels of basis states of the Pauli eigenstates Z, X, Y. See :meth:`.Statevector.from_label`. Notice the order of the labels is reversed with respect to the qubit index to be applied to. Example label '01' initializes the qubit zero to :math:`|1\rangle` and the qubit one to :math:`|0\rangle`. * An integer that is used as a bitmap indicating which qubits to initialize to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2 to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`. qubits: Qubits to initialize. If ``None`` the initialization is applied to all qubits in the circuit. label: An optional label for the gate normalize: Whether to normalize an input array to a unit vector. Returns: A handle to the instruction that was just initialized Examples: Prepare a qubit in the state :math:`(|0\rangle - |1\rangle) / \sqrt{2}`. .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(1) circuit.prepare_state([1/np.sqrt(2), -1/np.sqrt(2)], 0) circuit.draw() output: .. code-block:: text ┌─────────────────────────────────────┐ q_0: ┤ State Preparation(0.70711,-0.70711) ├ └─────────────────────────────────────┘ Prepare from a string two qubits in the state :math:`|10\rangle`. The order of the labels is reversed with respect to qubit index. More information about labels for basis states are in :meth:`.Statevector.from_label`. .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(2) circuit.prepare_state('01', circuit.qubits) circuit.draw() output: .. code-block:: text ┌─────────────────────────┐ q_0: ┤0 ├ │ State Preparation(0,1) │ q_1: ┤1 ├ └─────────────────────────┘ Initialize two qubits from an array of complex amplitudes .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(2) circuit.prepare_state([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits) circuit.draw() output: .. code-block:: text ┌───────────────────────────────────────────┐ q_0: ┤0 ├ │ State Preparation(0,0.70711,-0.70711j,0) │ q_1: ┤1 ├ └───────────────────────────────────────────┘ r)StatePreparationN)rorOFr) 'qiskit.circuit.library.data_preparationrQrrarkrhrirr6rr)rrMrrorOrQrs rf prepare_statezQuantumCircuit.prepare_state6sF MLLLLL >[FF bj% ? @ @ XF$.uc$:$:DS[[[ {{  UJey Q Q Q    rhcddlm}||j}n0t|tt jttfr|g}t|trt|nd}| |||||dS)ucInitialize qubits in a specific state. Qubit initialization is done by first resetting the qubits to :math:`|0\rangle` followed by calling :class:`~qiskit.circuit.library.StatePreparation` class to prepare the qubits in a specified state. Both these steps are included in the :class:`~qiskit.circuit.library.Initialize` instruction. Args: params: The state to initialize to, can be either of the following. * Statevector or vector of complex amplitudes to initialize to. * Labels of basis states of the Pauli eigenstates Z, X, Y. See :meth:`.Statevector.from_label`. Notice the order of the labels is reversed with respect to the qubit index to be applied to. Example label ``'01'`` initializes the qubit zero to :math:`|1\rangle` and the qubit one to :math:`|0\rangle`. * An integer that is used as a bitmap indicating which qubits to initialize to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2 to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`. qubits: Qubits to initialize. If ``None`` the initialization is applied to all qubits in the circuit. normalize: Whether to normalize an input array to a unit vector. Returns: A handle to the instructions created. Examples: Prepare a qubit in the state :math:`(|0\rangle - |1\rangle) / \sqrt{2}`. .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(1) circuit.initialize([1/np.sqrt(2), -1/np.sqrt(2)], 0) circuit.draw() output: .. code-block:: text ┌──────────────────────────────┐ q_0: ┤ Initialize(0.70711,-0.70711) ├ └──────────────────────────────┘ Initialize from a string two qubits in the state :math:`|10\rangle`. The order of the labels is reversed with respect to qubit index. More information about labels for basis states are in :meth:`.Statevector.from_label`. .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(2) circuit.initialize('01', circuit.qubits) circuit.draw() output: .. code-block:: text ┌──────────────────┐ q_0: ┤0 ├ │ Initialize(0,1) │ q_1: ┤1 ├ └──────────────────┘ Initialize two qubits from an array of complex amplitudes. .. code-block:: import numpy as np from qiskit import QuantumCircuit circuit = QuantumCircuit(2) circuit.initialize([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits) circuit.draw() output: .. code-block:: text ┌────────────────────────────────────┐ q_0: ┤0 ├ │ Initialize(0,0.70711,-0.70711j,0) │ q_1: ┤1 ├ └────────────────────────────────────┘ r) InitializeNFr) $library.data_preparation.initializerrUrrarkrhrirr6rr)rrrrOrUrs rf initializezQuantumCircuit.initializesH EDDDDD >[FF bj% ? @ @ XF$.vs$;$;ES[[[ {{::fj)DDfSX{YYYrhr np.ndarray | Gate | BaseOperatorcddlm}|||}|jdkr2t|tt fst |dkr|g}|||gdS)aApply unitary gate specified by ``obj`` to ``qubits``. Args: obj: Unitary operator. qubits: The circuit qubits to apply the transformation to. label: Unitary name for backend [Default: None]. Returns: QuantumCircuit: The quantum circuit. Example: Apply a gate specified by a unitary matrix to a quantum circuit .. code-block:: python from qiskit import QuantumCircuit matrix = [[0, 0, 0, 1], [0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0]] circuit = QuantumCircuit(2) circuit.unitary(matrix, [0, 1]) r) UnitaryGater#Fr)!library.generalized_gates.unitaryrZrrarkr6rr)rrrrorZrks rfunitaryzQuantumCircuit.unitarys> CBBBBB{3e,,, ?a  &3,// "3v;;?? {{4%{888rhr#c8|jr |jdS|jS)NrE)rr}rs rfrzQuantumCircuit._current_scopeBs$  $ 1,R0 0  rhrJIterable[Register] allow_jumpsforbidden_message Optional[str]c |jt||||||dS)acAdd a scope for collecting instructions into this circuit. This should only be done by the control-flow context managers, which will handle cleaning up after themselves at the end as well. Args: qubits: Any qubits that this scope should automatically use. clbits: Any clbits that this scope should automatically use. allow_jumps: Whether this scope allows jumps to be used within it. forbidden_message: If given, all attempts to add instructions to this scope will raise a :exc:`.CircuitError` with this message. )parentrJr_r`N)rrr$r)rrrrJr_r`s rf _push_scopezQuantumCircuit._push_scopeGsY( !(( #**,,#'"3     rhr$c4|jS)zFinish a scope used in the control-flow builder interface, and return it to the caller. This should only be done by the control-flow context managers, since they naturally synchronize the creation and deletion of stack elements.)rpoprs rf _pop_scopezQuantumCircuit._pop_scopefs (,,...rhc|jr|jdS|jstd|jdS)a'Return the instruction 3-tuple of the most recent instruction in the current scope, even if that scope is currently under construction. This function is only intended for use by the control-flow ``if``-statement builders, which may need to modify a previous instruction.rE&This circuit contains no instructions.)rpeekrrrs rf#_peek_previous_instruction_in_scopez2QuantumCircuit._peek_previous_instruction_in_scopemsO  $ 8,R05577 7z IGHH Hz"~rhc|jr|jdS|jstd|j}|S)a]Return the instruction 3-tuple of the most recent instruction in the current scope, even if that scope is currently under construction, and remove it from that scope. This function is only intended for use by the control-flow ``if``-statement builders, which may need to replace a previous instruction with another. rEri)rrfrrrs rf"_pop_previous_instruction_in_scopez1QuantumCircuit._pop_previous_instruction_in_scopeysZ  $ 7,R04466 6z IGHH Hjnn&& rhr1tuple[ClassicalRegister | Clbit, int] | expr.Exprbodyr0cdSr`rQrrrorrros rf while_loopzQuantumCircuit.while_loops 3rhSequence[ClbitSpecifier]cdSr`rQrqs rfrrzQuantumCircuit.while_loop rhc|}t|tjrt ||}n#||d|df}|%||t dt|||S||t d|t|||||dS) aCreate a ``while`` loop on this circuit. There are two forms for calling this function. If called with all its arguments (with the possible exception of ``label``), it will create a :obj:`~qiskit.circuit.controlflow.WhileLoopOp` with the given ``body``. If ``body`` (and ``qubits`` and ``clbits``) are *not* passed, then this acts as a context manager, which will automatically build a :obj:`~qiskit.circuit.controlflow.WhileLoopOp` when the scope finishes. In this form, you do not need to keep track of the qubits or clbits you are using, because the scope will handle it for you. Example usage:: from qiskit.circuit import QuantumCircuit, Clbit, Qubit bits = [Qubit(), Qubit(), Clbit()] qc = QuantumCircuit(bits) with qc.while_loop((bits[2], 0)): qc.h(0) qc.cx(0, 1) qc.measure(0, 0) Args: condition (Tuple[Union[ClassicalRegister, Clbit], int]): An equality condition to be checked prior to executing ``body``. The left-hand side of the condition must be a :obj:`~ClassicalRegister` or a :obj:`~Clbit`, and the right-hand side must be an integer or boolean. body (Optional[QuantumCircuit]): The loop body to be repeatedly executed. Omit this to use the context-manager mode. qubits (Optional[Sequence[Qubit]]): The circuit qubits over which the loop body should be run. Omit this to use the context-manager mode. clbits (Optional[Sequence[Clbit]]): The circuit clbits over which the loop body should be run. Omit this to use the context-manager mode. label (Optional[str]): The string label of the instruction in the circuit. Returns: InstructionSet or WhileLoopContext: If used in context-manager mode, then this should be used as a ``with`` resource, which will infer the block content and operands on exit. If the full form is used, then this returns a handle to the instructions created. Raises: CircuitError: if an incorrect calling convention is used. rrNzOWhen using 'while_loop' as a context manager, you cannot pass qubits or clbits.r#zEWhen using 'while_loop' with a body, you must pass qubits and clbits.Fr) rrar1r<r=r'rr0rr/)rrrorrror,s rfrrzQuantumCircuit.while_loopsV++-- i + + _&}i@@II&AA)A,OOQZ[\Q]^I <!V%7"9$D)5AAA A ^v~W {{;y$>>UZ{[[[rhindexset Iterable[int]loop_parameterParameter | Noner*cdSr`rQrrwryrorrros rffor_loopzQuantumCircuit.for_loop rhUnion[Parameter, None]cdSr`rQr|s rfr}zQuantumCircuit.for_loopr~rhc|&||tdt||||S||td|t||||||dS)a Create a ``for`` loop on this circuit. There are two forms for calling this function. If called with all its arguments (with the possible exception of ``label``), it will create a :class:`~qiskit.circuit.ForLoopOp` with the given ``body``. If ``body`` (and ``qubits`` and ``clbits``) are *not* passed, then this acts as a context manager, which, when entered, provides a loop variable (unless one is given, in which case it will be reused) and will automatically build a :class:`~qiskit.circuit.ForLoopOp` when the scope finishes. In this form, you do not need to keep track of the qubits or clbits you are using, because the scope will handle it for you. For example:: from qiskit import QuantumCircuit qc = QuantumCircuit(2, 1) with qc.for_loop(range(5)) as i: qc.h(0) qc.cx(0, 1) qc.measure(0, 0) qc.break_loop().c_if(0, True) Args: indexset (Iterable[int]): A collection of integers to loop over. Always necessary. loop_parameter (Optional[Parameter]): The parameter used within ``body`` to which the values from ``indexset`` will be assigned. In the context-manager form, if this argument is not supplied, then a loop parameter will be allocated for you and returned as the value of the ``with`` statement. This will only be bound into the circuit if it is used within the body. If this argument is ``None`` in the manual form of this method, ``body`` will be repeated once for each of the items in ``indexset`` but their values will be ignored. body (Optional[QuantumCircuit]): The loop body to be repeatedly executed. Omit this to use the context-manager mode. qubits (Optional[Sequence[QubitSpecifier]]): The circuit qubits over which the loop body should be run. Omit this to use the context-manager mode. clbits (Optional[Sequence[ClbitSpecifier]]): The circuit clbits over which the loop body should be run. Omit this to use the context-manager mode. label (Optional[str]): The string label of the instruction in the circuit. Returns: InstructionSet or ForLoopContext: depending on the call signature, either a context manager for creating the for loop (it will automatically be added to the circuit at the end of the block), or an :obj:`~InstructionSet` handle to the appended loop operation. Raises: CircuitError: if an incorrect calling convention is used. NzMWhen using 'for_loop' as a context manager, you cannot pass qubits or clbits.r#zCWhen using 'for_loop' with a body, you must pass qubits and clbits.Fr)rr*rr)r|s rfr}zQuantumCircuit.for_loopsh <!V%7"c"$.NNN N ^v~U {{ he < V^abb b{{<UCCCVVZ_{```rhc|jrEt}|}|||j|jdS|t |j|j|j|jdS)aApply :class:`~qiskit.circuit.BreakLoopOp`. .. warning:: If you are using the context-manager "builder" forms of :meth:`.if_test`, :meth:`.for_loop` or :meth:`.while_loop`, you can only call this method if you are within a loop context, because otherwise the "resource width" of the operation cannot be determined. This would quickly lead to invalid circuits, and so if you are trying to construct a reusable loop body (without the context managers), you must also use the non-context-manager form of :meth:`.if_test` and :meth:`.if_else`. Take care that the :obj:`.BreakLoopOp` instruction must span all the resources of its containing loop, not just the immediate scope. Returns: A handle to the instruction created. Raises: CircuitError: if this method was called within a builder context, but not contained within a loop. Fr) rr&placeholder_resourcesrrrr%rrrr resourcess rf break_loopzQuantumCircuit.break_loop1s*  $ Z,..I!7799I;;y)*:I._formats  $G,, 9Y''3 %in 5 5I ++--3$' NN       sAA A-,A-NrQ)rarrrRrvrr)rrkrrhrrs rfadd_calibrationzQuantumCircuit.add_calibrationksz0   " dD ! ! [F9D  3w//00FFF.2NNN!Jq#$6$6=$+a..ANNNrhci|]}|dSrrQrdrs rfrz3QuantumCircuit.qubit_start_time..s'''1!Q'''rhci|]}|dSFrQrs rfrz3QuantumCircuit.qubit_start_time..***aE***rhTcg|]}||SrQrQrddones rfroz3QuantumCircuit.qubit_start_time.."K"K"KDd"K4"K"K"Krhc3K|]}|VdSr`rQ)rdstarts rfrgz2QuantumCircuit.qubit_start_time..s">>U5>>>>>>rh) rrrarrCrrrrmin)rrrstartsdonesrs` rfrzQuantumCircuit.qubit_start_timesr = #z   !+"7??&V1NNNNvNNN'''''**6***: ? ?K ( ( ***!+"7??($QxH"1III)>)GGIII#'a6{{c"K"KELLNN"K"K"KLLLL>>fmmoo>>>>>>>>Mqrhcj5jD]+}t|jtst d,dSfd|D}fd|D}d|D}t jD]}|D]M}||jvrBt|jtr#||s||xx|jjzcc<Hd||<Nt|td| Dkr-td | DcSt|dkr!t| SdS) a%Return the stop time of the last instruction, excluding delays, over the supplied qubits. Its time unit is ``self.unit``. Return 0 if there are no instructions over qubits Args: *qubits: Qubits within ``self`` to include. Integers are allowed for qubits, indicating indices of ``self.qubits``. Returns: Return the stop time of the last instruction, excluding delays, over the qubits Raises: CircuitError: if ``self`` is a not-yet scheduled circuit. Nz;qubit_stop_time undefined. Circuit must be scheduled first.rcXg|]&}t|tr j|n|'SrQrrs rfroz2QuantumCircuit.qubit_stop_time..rrhc i|] }|j SrQ)rrs rfrz2QuantumCircuit.qubit_stop_time..s222aDM222rhci|]}|dSrrQrs rfrz2QuantumCircuit.qubit_stop_time..rrhTcg|]}||SrQrQrs rfroz2QuantumCircuit.qubit_stop_time..rrhc3K|]}|VdSr`rQ)rdstops rfrgz1QuantumCircuit.qubit_stop_time..s";;D4;;;;;;rh) rrrarrCrr?rrrr)rrrstopsrrs` rfrzQuantumCircuit.qubit_stop_times = #z   !+"7??&U1NNNNvNNN22226222**6***#DJ// < >u||~~&& &1rhr int | floatc ddlm}t|||}|dkr|S|dkrddlm}|||jSdddd d d d d d ddd }||vrt d|d|||z S)u^Estimate the duration of a scheduled circuit This method computes the estimate of the circuit duration by finding the longest duration path in the circuit based on the durations provided by a given target. This method only works for simple circuits that have no control flow or other classical feed-forward operations. Args: target (Target): The :class:`.Target` instance that contains durations for the instructions if the target is missing duration data for any of the instructions in the circuit an :class:`.QiskitError` will be raised. This should be the same target object used as the target for transpilation. unit: The unit to return the duration in. This defaults to "s" for seconds but this can be a supported SI prefix for seconds returns. For example setting this to "n" will return in unit of nanoseconds. Supported values of this type are "f", "p", "n", "u", "µ", "m", "k", "M", "G", "T", and "P". Additionally, a value of "dt" is also accepted to output an integer in units of "dt". For this to function "dt" must be specified in the ``target``. Returns: The estimated duration for the execution of a single shot of the circuit in the specified unit. Raises: QiskitError: If the circuit is not scheduled or contains other details that prevent computing an estimated duration from (such as parameterized delay). rr rrq)duration_in_dtgV瞯gư>gMbP?g@@g.AgeAgmBg4&k C) frnrµmrMGrLPzSpecified unit: z1 is not a valid/supported SI prefix, 's', or 'dt')r r rqiskit.circuit.durationrrqr)rrrr durr prefix_dicts rfestimate_durationz QuantumCircuit.estimate_durations< 544444()=)=vFF 3;;J 4<< > > > > > >!>#vy11 1    { " "Z4ZZZ [&&&rh)rXrYrRrZrSr4rTr[rUr\rVr\rWr])rr)FN)rrrrrRrZrr)rrrrrrrRrZrSr4rTr[rr)rr)rrA)rr)rr)rr)rr)rr)rTr)rrz)rrr`)rrk)rr/)r7r?rr)rrr)rTrrr)r[rkrZrrr)FF)rerrfrrTrrr)rNNF) rnrkrorZrprqrTrrr)NNFFF)rrzrr{rr|r}rr~rrrrrrxrryrrr)rrr~rrr)rr)rr)rr)rr)rrrr)rrrr)rrkrrB)rrrr)rrKrrrr)r r rr)rrrr)rQrQN) rrrrrrrorZrr=r) rr0rr1rr2rrrr=)rrBr%rrrB)rr>rrFrrGrr>)rQrQr%r)rRrzrOrLrrP).)rRrzrOrTrr)rRrzrOrVrr)r]r^rr)rRrzrOrLrra)rRrzrOrTrr)rRrzrOrV)rfrgrr)rfrgrrirr)rrVrfrgrr)rr)rfrzrrzrr)rfrrr/rr)rXrYrr/)rr5rr/)rrrr/)rr@rrH)rrFrr/)rrrorZrr)rrrorZrrr)rrr[rkrr)NNNNFTNNrNTNNFNNr)"rrZrrrrZrrrrrrrSrrrZrrZrrrrrrrrrrrrrrrrk)rrrrk)rrrrk)rr)rRrzrr)rrrrk)rRrZrr)rRrZr r rr)rrkrRrzrr9)rrkrRrzrr5)rr rr=)rrVrrVrr=)rr rrrr=)T)r~rrr)TT)r~rrrrr)r7rzrr)rFrzrr)rr4)rLr4)rr;)rrP) rrUr~rVrTrr?rrr) rrUr~rZrTrr?rrr/) rrUr~rrTrr?rrr)rxryrry)rr rr=Nrq)rr4rr~rrzrr=) rr rr rorZrprqrr=)rr4rrrr=)rr4rr rr=) rr4rr rr rorZrprqrr=) rr4rrrr rprqrr=)rr4rr4rr rr=) rr4rr4rr4rr rr=)rr rr rr rr=) rr rr rr rr rr=)rr4rr rorZrr=)rr4rr rr rr=)rr4rr rr=)rr rr rr=) rr rr rr rorZrprqrr=) rr4rr4rr4rr rr=)rr4rr4rr4rr4rr rr rorZrprqrr=)rr rorZrr=) rr rr rr rprqrr=)Nr&N) rrrr r'r{r(rzrprqrr=) rr rr rr rorZrprqrr=)rHrzrrrr=)NNF) rMrNrr1rorZrOrrr=)NF)rrNrr1rOr)rrXrrrorZ)rr#)rQrQrQTN) rrrrrJr^r_rr`ra)rr$)rrB) rrnror/rr/rr/rorZrr0) rrnrorrrrrsrorZrr=)NNN)rwrxryrzror/rr/rr/rorZrr*)rwrxryrrorrrrrsrorZrr=)NNNN)rrrr,) rrrrrrrrsrorZrr=)rrrrrrrrrrsrorZrr=) rrrr/rr/rr/rorarr.) rrrrrrrrsrorarr=)rr=)rkrrrrrrr/)rrrr)r)rrzrr)rn __module__ __qualname____doc__r!r,rpropertyrrsetterr classmethodr staticmethodrrrrrrrrrrTrrrr{r&r(r-rxryr:rArSrXrdrertrrrrrrrrrrrrrrrrrrtypingrrrrrrrrr/rrrSr`rcrrnrrrrrrrrHr)r^r]rrrrrrrrrrrrrrrr>rrrrrur"r&r(r6rErIrSrrjrSrYrsr`rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrr%r6r9r=r@rDrGrLrSrWr\rrdrgrkrmrrr}rrrrrrrrrrrQrhrfrOrOzsBQ Q fI F  +, $%'')\^eYeYeYeYeYeYN^'4ESWXXXYXX __^'4ESWXXXYXX [[KO    [ D#%"$+, $22222\2hX (((X( [CCC[C:$$$X$(D111'''21X'D111///21/(((X( ====  666 6KKKK(   X _"""_" ----     .[^-3  [ [ ^-3  [[KKKK"&&&&PBBBBH22222hKCKCKCKCZ>6:+++++ZRRRRRh   \ 0   \ ,'''X'  , , , ,;4;4;4X;4z+++X+ 0 0 0 0#&  X"%  Xr+ ! r+r+r+r+r+r+h$59<'+ OOOOO4 K K K K"!'+ # # # # # J K K K KKKKK" U U U U&!'+ % % % % % X(,      @UUUU"HHHH6    ,    6UY^^^^^,!'+ % % % % % N[[[[$UY^^^^^,!'+ % % % % % N[[[[" O O O O&!'+ % % % % % N[[[["[[[[" V V V V K K K K M M M M"!'+ # # # # # R!'+ # # # # # J    " X X X X$!'+ ( ( ( ( ( T L L L L N N N N"!'+ # # # # # J K K K K M M M MZZZZ<!'+. . . . . ` X X X X X$!'+ & & & & & P V V V V&(, % % % % % VLP'+ R]R]R]R]R]h K K K K"!'+ & & & & & P K K K K"!'+ # # # # # T!'+ ( ( ( ( ( TLLLL*37  p p p p p j37 mZmZmZmZmZf! )9)9)9)9)9V!!!!#%"$(* +/      >////         __ __=\RV=\=\=\=\=\~ _   _  _   _ MQA [_A A A A A F _YYY_Y _!_ VdVdVdVdVdVd~!7 7 7 7 7 r __ __CaDCaCaCaCaCaJ    :    : 7;0E0E0E0E 0Ef N N N N((((T++++Z9'9'9'9'9'9'9'rhrOcdeZdZdZddZedZdddd Zdd ZdZ dZ dZ dZ dZ dS)r|rPrPrOc||_dSr`r)rrPs rfrz$_OuterCircuitScopeInterface.__init__Ds  rhc|jjSr`)rPrrs rfrz(_OuterCircuitScopeInterface.instructionsGs |!!rhFr$r%rc:|j||S)Nr$)rPrrEs rfrz"_OuterCircuitScopeInterface.appendKs|##K#OOOrhrrct|jj|d|j_d|j_dSr)rPrrrr)rrs rfrz"_OuterCircuitScopeInterface.extendOs5 !!$''' $   rhct|tr#||jjvrt d|d|St|t r#||jjvrt d|d|St|tr: |jjj |S#t$rt d|ddwxYwt d|d)NzClbit z is not present in this circuit.z Register zClassical bit index z is out-of-range.z'Unknown classical resource specifier: 'z'.) rar:rPrrr9rrkrr IndexError)r specifiers rfr'z6_OuterCircuitScopeInterface.resolve_classical_resourceTs  i ' '  ;;;"#WI#W#W#WXXX  i!2 3 3   222"#Zy#Z#Z#Z[[[  i % % b b|)0;; b b b"#V)#V#V#VWW]aa bRYRRRSSSs BB=cd|j|d}||jj|j<dSr`)rPrnrrRrws rfrz1_OuterCircuitScopeInterface.add_uninitialized_varls0l++C66-0  ***rhcN|jj|jdSr`)rPrrfrRrws rfrsz&_OuterCircuitScopeInterface.remove_varps#  $$SX.....rhc|jj|x}|S|jj|x}|S|jj|Sr`)rPrrrr)rrRrs rfrcz#_OuterCircuitScopeInterface.get_varssa<+//55 5C BJ<-11$77 7C DJ|'++D111rhch||j|krtd|ddS)Nrz ' is not present in this circuit)rcrRrrws rfryz#_OuterCircuitScopeInterface.use_varzs= << ! !S ( (H3HHHII I ) (rhN)rPrOr)rr)rnrr __slots__rrrrrr'rrsrcryrQrhrfr|r|>sI""X"=BPPPPPP!!!! TTT0111///222JJJJJrhr|r,r#r expr.Exprrcttj|D]9}|jr||||j:|Sr`)rr1rrlryr'r)r,rrs rfr=r=sd4>$''((>> > >  ! !# & & & &  4 4SW = = = = Krh list[Bit]c Tt|r|vr|gStd|dt|ttjfr@ |gS#t $r)}td|dt d|d}~wwxYwt|tr|S fd|DS#t$r`}t|tr dj d t|j d nd |d t|d }t||d}~wwxYw) aGet the list of bits referred to by the specifier ``specifier``. Valid types for ``specifier`` are integers, bits of the correct type (as given in ``type_``), or iterables of one of those two scalar types. Integers are interpreted as indices into the sequence ``bit_sequence``. All allowed bits must be in ``bit_set`` (which should implement fast lookup), which is assumed to contain the same bits as ``bit_sequence``. Returns: List[Bit]: a list of the specified bits from ``bits``. Raises: CircuitError: if an incorrect type or index is encountered, if the same bit is specified more than once, or if the specifier is to a bit not in the ``bit_set``. Bit '' is not in the circuit.Index  out of range for size rNc4g|]}t|SrQ)_bit_argument_conversion_scalar)rdrI bit_sequencebit_setrs rfroz,_bit_argument_conversion..s7    ,E<% P P   rhIncorrect bit type: expected ' ' but got 'rInvalid bit index: ' ' of type ') rarrkrhrirrrrur@rnrmrrrrrlmessages ``` rfrrs$)U##H   ; F9FFFGGG)c2:.//  +, ,   OOO3|;L;LOOO   )U##'I&& ,      "     ,,,)S)) Q cU^ c cYH` c c c cP PPd9ooPPP  7##+ ,s1A B #$BB -B== D'AD""D'c t||r||vr|Std|dt|ttjfr? ||S#t $r)}td|dt |d|d}~wwxYwt|tr d|jdt|jdnd |d t|d}t|) Nrrrrrrrrrr) rarrkrhrirrr@rnrmrs rfrrs%)U##H    F9FFFGGG)c2:.//  * *   OOO3|;L;LOOO   i % % M___DOOD\____ LI L L$y// L L L w  s A B$BBcb|j|_|j|_t||_|j|_|j|_|j|_|dkr[|j|_|j |_ |j |_ ng|dkr2i|_i|_ d| D|_ n/|dkri|_i|_ i|_ ntd|dtj|j|_tj|j|_dS)NrrVci|] }|j| SrQr)rdrs rfrz"_copy_metadata..sKKKsSXsKKKrhdropzunknown vars_mode: 'r)rrrr|r}rrrrrrrrtrrrr)originalrr s rfr r s|##%%CI##%%CI2377C&++--CM!05577C!05577CG#.3355".3355$27799 j KKh6H6H6J6JKKK f  < <<<===x'=>>CN8#566CMMMrh)r,r#rrrr)rr)r __future__rcollections.abcrqrrrmultiprocessingr3rrrrrrr r r r r rrrrrrnumpyrhqiskit._accelerate.circuitrr#qiskit._accelerate.circuit_durationrqiskit.exceptionsrqiskit.utils.multiprocessingrqiskit.circuit.instructionrqiskit.circuit.gaterqiskit.circuit.parameterrqiskit.circuit.exceptionsr qiskit.utilsrqiskit.utils.deprecate_pulserr2r controlflowr!r"controlflow.builderr#r$controlflow.break_loopr%r&controlflow.continue_loopr'r(controlflow.for_loopr)r*controlflow.if_elser+r,controlflow.switch_caser-r.controlflow.while_loopr/r0 classicalr1r2parameterexpressionr3r4quantumregisterr5r6r7r8classicalregisterr9r:parametertabler;parametervectorr<instructionsetr=rr>r7r?rr@quantumcircuitdatarArBrrCrurD TYPE_CHECKINGr@qiskit.transpiler.layoutrE+qiskit.quantum_info.operators.base_operatorrF&qiskit.quantum_info.states.statevectorrGrHrKrLrkrr rrMrOr|r=rrr rQrhrfr(sq"""""" <<<<<<<<<<222222333333JJJJJJ))))))888888222222$$$$$$......222222''''''CCCCCC%%%%%%66666666OOOOOOOOEEEEEEEENNNNNNNN;;;;;;;;44444444@@@@@@@@AAAAAAAA""""""""HHHHHHHHRRRRRRRRRRRR77777777)))))),,,,,,****** FFFFFFFF CMMM888888HHHHHHBBBBBBz.*@AA  GCLL GCLL   U5#:  !   U5#:  ! ')UE * *Ag'Ag'Ag'Ag'Ag'Ag'Ag'Ag'HN>J>J>J>J>J"7>J>J>JB    +,+,+,+,\   (77777rh