z ie5SrSSKJr SSKJr SSKrSSKrSSK J r SSK J r SSK Jr SSKJrJrJr SSKr\(aSS KJr "S S \ 5rSS jrS rSrg)z0A gate to implement time-evolution of operators.) annotations) TYPE_CHECKINGN)Gate)ParameterValueType)ParameterExpression)Pauli SparsePauliOpSparseObservable)EvolutionSynthesisc^\rSrSrSrSSU4Sjjjr\SSj5r\RSSj5rSSjr SSSjjr SSSjjr SS jr SSS jjr S rSU4S jjrS rU=r$)PauliEvolutionGateuTime-evolution of an operator consisting of Paulis. For an Hermitian operator :math:`H` consisting of Pauli terms and (real) evolution time :math:`t` this gate represents the unitary .. math:: U(t) = e^{-itH}. The evolution gates are related to the Pauli rotation gates by a factor of 2. For example the time evolution of the Pauli :math:`X` operator is connected to the Pauli :math:`X` rotation :math:`R_X` by .. math:: U(t) = e^{-itX} = R_X(2t). Compilation: This gate represents the exact evolution :math:`U(t)`. Implementing this operation exactly, however, generally requires an exponential number of gates. The compiler therefore typically implements an *approximation* of the unitary :math:`U(t)`, e.g. using a product formula such as defined by :class:`.LieTrotter`. By passing the ``synthesis`` argument, you can specify which method the compiler should use, see :mod:`qiskit.synthesis` for the available options. Note that the order in which the approximation and methods like :meth:`control` and :meth:`power` are called matters. Changing the order can lead to different unitaries. Examples: .. plot:: :include-source: :nofigs: from qiskit.circuit import QuantumCircuit from qiskit.circuit.library import PauliEvolutionGate from qiskit.quantum_info import SparsePauliOp X = SparsePauliOp("X") Z = SparsePauliOp("Z") I = SparsePauliOp("I") # build the evolution gate operator = (Z ^ Z) - 0.1 * (X ^ I) evo = PauliEvolutionGate(operator, time=0.2) # plug it into a circuit circuit = QuantumCircuit(2) circuit.append(evo, range(2)) print(circuit.draw()) The above will print (note that the ``-0.1`` coefficient is not printed!): .. code-block:: text ┌──────────────────────────┐ q_0: ┤0 ├ │ exp(-it (ZZ + XI))(0.2) │ q_1: ┤1 ├ └──────────────────────────┘ References: [1] G. Li et al. Paulihedral: A Generalized Block-Wise Compiler Optimization Framework For Quantum Simulation Kernels (2021). `arXiv:2109.03371 `__ c>[U[5(aUVs/sHn[U5PM nnO [U5nUc [U5n[U[5(aQ[ U5S:Xa [ S5eUSR nUSSHnUR U:wdM[ S5e O UR n[TU]!SXb/US9 Xl Uc SSK J n U"5nX@l gs snf) a Args: operator: The operator to evolve. Can also be provided as list of non-commuting operators where the elements are sums of commuting operators. For example: ``[XY + YX, ZZ + ZI + IZ, YY]``. time: The evolution time. label: A label for the gate to display in visualizations. Per default, the label is set to ``exp(-it )`` where ```` is the sum of the Paulis. Note that the label does not include any coefficients of the Paulis. See the class docstring for an example. synthesis: A synthesis strategy. If None, the default synthesis is the Lie-Trotter product formula with a single repetition. Nrz0The argument 'operator' cannot be an empty list.zdWhen represented as a list of operators, all of these operators must have the same number of qubits.PauliEvolution)name num_qubitsparamslabel) LieTrotter) isinstancelist _to_sparse_op_get_default_labellen ValueErrorrsuper__init__operatorqiskit.synthesis.evolutionr synthesis) selfrtimerr!oprr __class__s `/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/circuit/library/pauli_evolution.pyrPauliEvolutionGate.__init__es2 h % %4<=Hb b)HH=H$X.H =&x0E h % %8}! !STT!!//Jqrl==J.$?#",,J .:f\ab   =" I";>sC+c URS$)z^Return the evolution time as stored in the gate parameters. Returns: The evolution time. rrr"s r&r#PauliEvolutionGate.times{{1~cU/Ulg)z=Set the evolution time. Args: time: The evolution time. Nr))r"r#s r&r#r+s f r,cx[UR[5(aURR5nO URn[UR [5(a%[UR SSUR SS9nO UR n[U[5(a[R"U5nURSS9n[RRR!SU-U-5nUR#5$![an[ SUR35UeSnAff=f) zReturn the matrix :math:`e^{-it H}` as ``numpy.ndarray``. Returns: The matrix this gate represents. Raises: ValueError: If the ``time`` parameters is not numeric. z2Cannot compute matrix with non-numeric parameter: Nrr)startT)sparsey)rr#rnumeric TypeErrorrrrsumr r from_sparse_observable to_matrixscr0linalgexpmtoarray)r"r#excrspmatrixexps r&r5PauliEvolutionGate.to_matrixs  dii!4 5 5 yy((* 99D dmmT * *4==,DMM!4DEH}}H h 0 1 1$;;HEH%%T%2ii##C$J$9:{{}1  H T sD D9D44D9cV[URUR*URS9$)zQReturn the inverse, which is obtained by flipping the sign of the evolution time.r!r rr#r!)r" annotateds r&inversePauliEvolutionGate.inverses!$--$))t~~VVr,cZ[URURU-URS9$)a3Raise this gate to the power of ``exponent``. The outcome represents :math:`e^{-i tp H}` where :math:`p` equals ``exponent``. Args: exponent: The power to raise the gate to. annotated: Not applicable to this class. Usually, when this is ``True`` we return an :class:`.AnnotatedOperation` with a power modifier set instead of a concrete :class:`.Gate`. However, we can efficiently represent powers of Pauli evolutions as :class:`.PauliEvolutionGate`, which is used here. Returns: An operation implementing ``gate^exponent``. r?r@)r"exponentrAs r&powerPauliEvolutionGate.powers'"$--X1EQUQ_Q_``r,c$URU5$N)rF)r"rEs r&_return_repeat!PauliEvolutionGate._return_repeatszz(##r,c^UcSU-nO][U[5(a[U5SSRU5nO*[ U5U:wa[ S[ U5SUS35e[ U5mU4Sjn[UR[5(a"URVs/sH oe"U5PM nnOU"UR5n[XpRX RS9$s snf) aReturn the controlled version of itself. The outcome is the specified controlled version of :math:`e^{-itH}`. The returned gate represents :math:`e^{-it H_C}`, where :math:`H_C` is the original operator :math:`H`, tensored with :math:`|0\rangle\langle 0|` and :math:`|1\rangle\langle 1|` projectors (depending on the control state). Args: num_ctrl_qubits: Number of controls to add to gate (default: ``1``). label: Optional gate label. Ignored if implemented as an annotated operation. ctrl_state: The control state in decimal or as a bitstring (e.g. ``"111"``). If ``None``, use ``2**num_ctrl_qubits - 1``. annotated: Not applicable to this class. Usually, when this is ``True`` we return an :class:`.AnnotatedOperation` with a control modifier set instead of a concrete :class:`.Gate`. However, we can efficiently represent controlled Pauli evolutions as :class:`.PauliEvolutionGate`, which is used here. Returns: Controlled version of the given operation. N1zLength of ctrl_state (z) must match num_ctrl_qubits ()cd>[U[5(a[R"U5nUT- $rI)rr r from_sparse_pauli_op)r$ control_ops r& extend_op-PauliEvolutionGate.control..extend_op#s*"m,,%::2> ? "r,r?) rintbinzfillrrr rrr r#r!) r"num_ctrl_qubitsr ctrl_staterArSr$rrRs @r&controlPauliEvolutionGate.controls8  .J  C ( (Z,22?CJ:/1 ,S_,=>((7'8;&j1  # dmmT * *04 > " " H>H /H!(IIuWW ?s&C*cDURRU5Ulg)z4Unroll, where the default synthesis is matrix based.N)r! synthesize definitionr*s r&_definePauliEvolutionGate._define0s..33D9r,cb>[U[5(a [U5n[TU]U5$)z _to_sparse_op..Js M}e:e0 1 1}sz?Operator contains ParameterExpression, which are not supported.) rrr r rtypeanynp iscomplexcoeffs)rr0s r&rr<s (E""x( H/? @ @DT(^DTTUVWW 2<< &''[\\ Mv}} MMMZ[[ Mr,c[U[5(aF[U5S:XaUSR5SSS2$SSR SU55-S-$[UR 5S:XaUR R 5S$SSR UR R 55-S-$)Nrr(z + c3L# UHoR5SSS2v M g7f)Nr) bit_labels)rvterms r&rx"_operator_label..TsMHD 1$B$ 7Hs"$rO)rr rrjoinpaulis to_labels)rs r&_operator_labelrPs(,-- x=A A;))+DbD1 1UZZMHMMMPSSS 8??q ((*1-- HOO5578 83 >>r,c[U[5(a SUVs/sHn[U5PM snS3$S[U5S3$s snf)Nz exp(-it (z))zexp(-it rO)rrr)rr$s r&rr\sN(D!!(C(BOB/(CDBGG oh/0 22DsA)rz(Pauli | SparsePauliOp | SparseObservablergz SparsePauliOp | SparseObservable)rn __future__rtypingrnumpyr|scipyr6qiskit.circuit.gaterqiskit.circuit.quantumcircuitr"qiskit.circuit.parameterexpressionrqiskit.quantum_inforr r qiskitr r r rrrr,r&rs\7" $<BFF=Z5Z5z6%( ?3r,