z io SrSSKJr SSKrSSKJrJr SSKrSSK J r J r SSK J r SSKJr SSKJr SS KJrJrJrJr SS KJr SS KJr SS KJr SS KJrJr \(aSSK J!r! SSK"J#r# SSK$J%r% "SS\5r&\"\&5 g)z N-qubit Pauli Operator Class ) annotationsN)Literal TYPE_CHECKING) InstructionQuantumCircuit)Barrier)Delay) PauliGate)IGateXGateYGateZGate) QiskitError)generate_apidocs)ScalarOp) BasePauli_count_yClifford) PauliListTranspileLayoutc^\rSrSrSrSr\R"S5rSSSSS .r S5S6U4S jjjr \ S 5r \ S 5r S rSrS7Sjr\S8Sj5rSrS9Sjr\ S:Sj5r\ S5r\R.S5r\ S5r\R.S5r\ S5r\R.S5rSrSrSrS;SjrSS?S!jjr!S"r"S@SAU4S#jjjr#SBSCS$jjr$SDU4S%jjr%SDU4S&jjr&U4S'jr'U4S(jr(U4S)jr)U4S*jr*U4S+jr+S5SEU4S,jjjr,S5SFS-jjr-SGSHU4S.jjjr.\/S/5r0\S05r1\S15r2\S25r3S5SIS3jjr4S4r5U=r6$)JPauli'aN-qubit Pauli operator. This class represents an operator :math:`P` from the full :math:`n`-qubit *Pauli* group .. math:: P = (-i)^{q} P_{n-1} \otimes ... \otimes P_{0} where :math:`q\in \mathbb{Z}_4` and :math:`P_i \in \{I, X, Y, Z\}` are single-qubit Pauli matrices: .. math:: I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}, X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}, Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}, Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}. **Initialization** A Pauli object can be initialized in several ways: ``Pauli(obj)`` where ``obj`` is a Pauli string, ``Pauli`` or :class:`~qiskit.quantum_info.ScalarOp` operator, or a Pauli gate or :class:`~qiskit.QuantumCircuit` containing only Pauli gates. ``Pauli((z, x, phase))`` where ``z`` and ``x`` are boolean ``numpy.ndarrays`` and ``phase`` is an integer in ``[0, 1, 2, 3]``. ``Pauli((z, x))`` equivalent to ``Pauli((z, x, 0))`` with trivial phase. **String representation** An :math:`n`-qubit Pauli may be represented by a string consisting of :math:`n` characters from ``['I', 'X', 'Y', 'Z']``, and optionally phase coefficient in ``['', '-i', '-', 'i']``. For example: ``'XYZ'`` or ``'-iZIZ'``. In the string representation qubit-0 corresponds to the right-most Pauli character, and qubit-:math:`(n-1)` to the left-most Pauli character. For example ``'XYZ'`` represents :math:`X\otimes Y \otimes Z` with ``'Z'`` on qubit-0, ``'Y'`` on qubit-1, and ``'X'`` on qubit-2. The string representation can be converted to a ``Pauli`` using the class initialization (``Pauli('-iXYZ')``). A ``Pauli`` object can be converted back to the string representation using the :meth:`to_label` method or ``str(pauli)``. .. note:: Using ``str`` to convert a ``Pauli`` to a string will truncate the returned string for large numbers of qubits while :meth:`to_label` will return the full string with no truncation. The default truncation length is 50 characters. The default value can be changed by setting the class ``__truncate__`` attribute to an integer value. If set to ``0`` no truncation will be performed. **Array Representation** The internal data structure of an :math:`n`-qubit Pauli is two length-:math:`n` boolean vectors :math:`z \in \mathbb{Z}_2^N`, :math:`x \in \mathbb{Z}_2^N`, and an integer :math:`q \in \mathbb{Z}_4` defining the Pauli operator .. math:: P = (-i)^{q + z\cdot x} Z^z \cdot X^x. The :math:`k`-th qubit corresponds to the :math:`k`-th entry in the :math:`z` and :math:`x` arrays .. math:: \begin{aligned} P &= P_{n-1} \otimes ... \otimes P_{0} \\ P_k &= (-i)^{z[k] * x[k]} Z^{z[k]}\cdot X^{x[k]} \end{aligned} where ``z[k] = P.z[k]``, ``x[k] = P.x[k]`` respectively. The :math:`z` and :math:`x` arrays can be accessed and updated using the :attr:`z` and :attr:`x` properties respectively. The phase integer :math:`q` can be accessed and updated using the :attr:`phase` property. **Matrix Operator Representation** Pauli's can be converted to :math:`(2^n, 2^n)` :class:`~qiskit.quantum_info.Operator` using the :meth:`to_operator` method, or to a dense or sparse complex matrix using the :meth:`to_matrix` method. **Data Access** The individual qubit Paulis can be accessed and updated using the ``[]`` operator which accepts integer, lists, or slices for selecting subsets of Paulis. Note that selecting subsets of Pauli's will discard the phase of the current Pauli. For example .. plot:: :include-source: :nofigs: from qiskit.quantum_info import Pauli P = Pauli('-iXYZ') print('P[0] =', repr(P[0])) print('P[1] =', repr(P[1])) print('P[2] =', repr(P[2])) print('P[:] =', repr(P[:])) print('P[::-1] =', repr(P[::-1])) 2z)(?P[+-]?1?[ij]?)(?P[IXYZ]*)r)z-i-icv>[U[5(a$URURURpCnO[U[ 5(a-[ U5S;a [S5eUR"U6up#nO[U[5(aURU5up#nOe[U[5(aURU5up#nO;[U[[45(aURU5up#nO [S5eUR SS:wa [S5e["TU]IX#U5 g)aInitialize the Pauli. When using the symplectic array input data both z and x arguments must be provided, however the first (z) argument can be used alone for string label, Pauli operator, or :class:`.ScalarOp` input data. Args: data (str or tuple or Pauli or ScalarOp): input data for Pauli. If input is a tuple it must be of the form ``(z, x)`` or ``(z, x, phase)`` where ``z`` and ``x`` are boolean Numpy arrays, and phase is an integer from :math:`\mathbb{Z}_4`. If input is a string, it must be a concatenation of a phase and a Pauli string (e.g. ``'XYZ', '-iZIZ'``) where a phase string is a combination of at most three characters from ``['+', '-', '']``, ``['1', '']``, and ``['i', 'j', '']`` in this order, e.g. ``''``, ``'-1j'`` while a Pauli string is 1 or more characters of ``'I'``, ``'X'``, ``'Y'``, or ``'Z'``, e.g. ``'Z'``, ``'XIYY'``. Raises: QiskitError: if input array is invalid shape. )rrzNInvalid input tuple for Pauli, input tuple must be `(z, x, phase)` or `(z, x)`zInvalid input data for Pauli.rrzInput is not a single PauliN) isinstancer_z_x_phasetuplelenr _from_arraystr _from_labelr_from_scalar_oprr _from_circuitshapesuper__init__)selfdatabase_zbase_x base_phase __class__s h/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/quantum_info/operators/symplectic/pauli.pyr1Pauli.__init__s, dI & &)-$''4;;JFJ e $ $4y&!d*.)9)94)@ &FJ c " ")-)9)9$)? &FJ h ' ')-)=)=d)C &FJ ~{; < <)-););D)A &FJ=> > <<?a ;< < 4cg)z,Unique string identifier for operation type.paulir2s r8name Pauli.namesr:cg)zNumber of classical bits.rr=r>s r8 num_clbitsPauli.num_clbitssr:c*SUR5S3$)zDisplay representation.zPauli('z'))__str__r>s r8__repr__Pauli.__repr__s(++r:cUR(a<URUR:a"XR*SR5nUS-$UR5$)zPrint representation.Nz...) __truncate__ num_qubitsto_label)r2fronts r8rE Pauli.__str__sO   43D3D!D+++-.779E5= }}r:clUSLa [S5eUR5nUcU$URUSS9$)NFz9unable to avoid copy while creating an array as requested)copy) ValueError to_matrixastype)r2dtyperOarrs r8 __array__Pauli.__array__s= 5=XY YnnmsFE)FFr:c$[U5Ulg)zSet the max number of Pauli characters to display before truncation/ Args: val (int): the number of characters. .. note:: Truncation will be disabled if the truncation value is set to 0. N)intrI)clsvals r8set_truncationPauli.set_truncationss8r:cP[U[5(dgURU5$)zTest if two Paulis are equal.F)r$r_eqr2others r8__eq__ Pauli.__eq__s %++xxr:c&[U[5(d [U5n[R"UR UR :H5=(a- [R"UR UR :H5$![a gf=f)zReturn True if Pauli's are equivalent up to group phase. Args: other (Pauli): an operator object. Returns: bool: True if the Pauli's are equivalent up to group phase. F)r$rrnpallr%r&r_s r8equiv Pauli.equivsl%'' e vvdgg)*Jrvvdgg6I/JJ  s B BBc&SUR50$)zReturn settings.r3)rKr>s r8settingsPauli.settingss ((r:c[R"URURURRS9- S5S$)z.Return the group phase exponent for the Pauli.rSr)rdmodr'rrSr>s r8phase Pauli.phases8vvdkkDMM 8I8IM$JJANqQQr:c[R"XRURRS9-S5URSS&g)Nrlrm)rdrnrr'rS)r2values r8rorps5 DKKs r8xPauli.x#wwqzr:c(XRSSS24'gNrrtr2rZs r8rurv(1 r:c URS$)zThe z vector for the Pauli.rr%r>s r8zPauli.z,rwr:c(XRSSS24'gryr}rzs r8r~r1r{r:cUR$)z)Return the number of qubits in the Pauli.)rJr>s r8__len__ Pauli.__len__9s r:c[U[[R45(aU/n[ UR UUR U45$)z;Return the unsigned Pauli group Pauli for subset of qubits.)r$rXrdintegerrr~ru)r2qubitss r8 __getitem__Pauli.__getitem__=sA fsBJJ/ 0 0XFdffVndffVn566r:c[U[5(d [U5nURURSU4'URUR SU4'UR UR -Ulg)z(Update the Pauli for a subset of qubits.rN)r$rr~r%rur&r')r2rrrs r8 __setitem__Pauli.__setitem__DsX%''%LE"WW6 "WW6 kkELL0 r:cF[U[[R45(aU/n[ U5S:Xa,[ UR URUR45$[U5URS- :a([S[U5SURS- S35e[ U5UR:Xa [S5e[R"UR USS9n[R"URUSS9n[ X#UR45$)aReturn a Pauli with qubits deleted. Args: qubits (int or list): qubits to delete from Pauli. Returns: Pauli: the resulting Pauli with the specified qubits removed. Raises: QiskitError: if ind is out of bounds for the array size or number of qubits. rrz1Qubit index is larger than the number of qubits (>).z!Cannot delete all qubits of Pauli)axis) r$rXrdrr)rr%r&romaxrJrdelete)r2rr~rus r8r Pauli.deleteMs fsBJJ/ 0 0XF v;! $''477DJJ78 8 v;1, ,K=$//A"5!6b:  v;$// )AB B IIdggvA . IIdggvA .aDJJ'((r:c[U[5(d [U5nURUR-n[[R"U[ S9[R"U[ S945n[U[ [R45(a5URS:XaU/nO![[XUR-55n[U5UR:wa%[S[U5SURS35e[U5URS- :a([S[U5SURS- S35e[UR5Vs/sH oUU;dM UPM nnXU'X$U'U$s snf) a Insert a Pauli at specific qubit value. Args: qubits (int or list): qubits index to insert at. value (Pauli): value to insert. Returns: Pauli: the resulting Pauli with the entries inserted. Raises: QiskitError: if the insertion qubits are invalid. rlrzJNumber of indices does not match number of qubits for the inserted Pauli (z!=)z9Index is too larger for combined Pauli number of qubits (rr) r$rrJrdzerosboolrXrlistranger)rr)r2rrr ret_qubitsretr" self_qubitss r8insert Pauli.insertise%''%LE__u'7'77 RXXj5rxx RV7WXY fsBJJ/ 0 01$ eFU5E5E,EFG v;%** *''*6{m2e6F6F5GqJ  v;!+ +K=#..1"4!5R9  #("7K"7QF?q"7 KKF  Ls ( F5Fc4[UR55$)z-Make hashable based on string representation.)hashrKr>s r8__hash__Pauli.__hash__sDMMO$$r:cjURURURURS5$)zConvert a Pauli to a string label. .. note:: The difference between `to_label` and :meth:`__str__` is that the later will truncate the output for large numbers of qubits. Returns: str: the Pauli string label. r) _to_labelr~rur'r>s r8rKPauli.to_labels'~~dffdffdkk!n==r:chURURURURSUS9$)zConvert to a Numpy array or sparse CSR matrix. Args: sparse (bool): if True return sparse CSR matrices, otherwise return dense Numpy arrays (default: False). Returns: array: The Pauli matrix. r)sparse) _to_matrixr~rur')r2rs r8rQPauli.to_matrixs+tvvtvvt{{1~fMMr:cSSKJn URURURUR SSSS9up#[ U5S:Xa+[5[5[5[5S.UnO [U5nU(dU$[UR[U5S9nU*U-S - UlUR!U[#UR55 UR%5$) z%Convert to Pauli circuit instruction.r)piFT) full_group return_phaser)IXYZ)r?r)mathrrr~rur'r)r r r rr rrJr+ global_phaseappendrto_instruction)r2rr<rogatecircuits r8rPauli.to_instructions~~ FFDFFDKKNu4&  u:?uwUW57KERDU#DK s4yA %v{QtU4??34%%''r:c >Uc [USS5n[U[5(d [U5n[[TU]XX4S95$)a*Return the operator composition with another Pauli. Args: other (Pauli): a Pauli object. qargs (list or None): Optional, qubits to apply dot product on (default: None). front (bool): If True compose using right operator multiplication, instead of left multiplication [default: False]. inplace (bool): If True update in-place (default: False). Returns: Pauli: The composed Pauli. Raises: QiskitError: if other cannot be converted to an operator, or has incompatible dimensions for specified subsystems. .. note:: Composition (``&``) by default is defined as `left` matrix multiplication for matrix operators, while :meth:`dot` is defined as `right` matrix multiplication. That is that ``A & B == A.compose(B)`` is equivalent to ``B.dot(A)`` when ``A`` and ``B`` are of the same type. Setting the ``front=True`` kwarg changes this to `right` matrix multiplication and is equivalent to the :meth:`dot` method ``A.dot(B) == A.compose(B, front=True)``. NqargsrrLinplace)getattrr$rr0compose)r2r`rrLrr7s r8r Pauli.composesF< =E7D1E%''%LEUW_Uu_VWWr:c$URXSUS9$)a=Return the right multiplied operator self * other. Args: other (Pauli): an operator object. qargs (list or None): Optional, qubits to apply dot product on (default: None). inplace (bool): If True update in-place (default: False). Returns: Pauli: The operator self * other. Tr)r)r2r`rrs r8dot Pauli.dots||EdG|LLr:ct>[U[5(d [U5n[[TU] U55$N)r$rr0tensorr2r`r7s r8r Pauli.tensor-%''%LEUW^E*++r:ct>[U[5(d [U5n[[TU] U55$r)r$rr0expandrs r8r Pauli.expandrr:c4>[[TU] U55$r)rr0 _multiplyrs r8rPauli._multiplysUW&u-..r:c2>[[TU] 55$r)rr0 conjugater2r7s r8rPauli.conjugateUW&())r:c2>[[TU] 55$r)rr0 transposers r8rPauli.transpose rr:c2>[[TU] 55$rrr0adjointrs r8r Pauli.adjointsUW_&''r:c2>[[TU] 55$)z Return the inverse of the Pauli.rrs r8inverse Pauli.inversesUW_&''r:c>Uc [USS5n[U[5(d [U5n[TU]XS9n[ U5S:XaUS$U$)zReturn True if the Pauli commutes with other. Args: other (Pauli or PauliList): another Pauli operator. qargs (list): qubits to apply dot product on (default: None). Returns: bool: True if Pauli's commute, False if they anti-commute. Nrrrr)rr$rrr0commutesr))r2r`rrr7s r8rPauli.commutessY =E7D1E%++%LEgu2 s8q=q6M r:cH[R"URXS95$)zReturn True if other Pauli anticommutes with self. Args: other (Pauli): another Pauli operator. qargs (list): qubits to apply dot product on (default: None). Returns: bool: True if Pauli's anticommute, False if they commute. r)rd logical_notr)r2r`rs r8 anticommutesPauli.anticommutes,s~~dmmEm?@@r:c>Uc [USS5nSSKJn [U[[ [ U45(d [ U5n[ [TU]!XUS95$)ulPerforms either Heisenberg (default) or Schrödinger picture evolution of the Pauli by a Clifford and returns the evolved Pauli. Schrödinger picture evolution can be chosen by passing parameter ``frame='s'``. This option yields a faster calculation. Heisenberg picture evolves the Pauli as :math:`P^\prime = C^\dagger.P.C`. Schrödinger picture evolves the Pauli as :math:`P^\prime = C.P.C^\dagger`. Args: other (Pauli or Clifford or QuantumCircuit): The Clifford operator to evolve by. qargs (list): a list of qubits to apply the Clifford to. frame (string): ``'h'`` for Heisenberg (default) or ``'s'`` for Schrödinger framework. Returns: Pauli: the Pauli :math:`C^\dagger.P.C` (Heisenberg picture) or the Pauli :math:`C.P.C^\dagger` (Schrödinger picture). Raises: QiskitError: if the Clifford number of qubits and qargs don't match. Nrrr)rframe) r1qiskit.quantum_info.operators.symplectic.cliffordrr$rrrr0evolve)r2r`rrrr7s r8r Pauli.evolve8sU: =E7D1E O%%nh!OPP%LEUW^Ee^DEEr:c[RRU5nUc[SUS35e[RUS=(d SR SS5R SS5R SS 5n[ R"US RS 5[ RS 9SSS 2nU[S5:Hn[ R"U[S5:HU5RSS 5n[ R"U[S5:HU5RSS 5n[ R"U[ R"U5-S-/[S 9nXeU4$)zReturn the symplectic representation of Pauli string. Args: label (str): the Pauli string label. Returns: BasePauli: the BasePauli corresponding to the label. Raises: QiskitError: if Pauli string is not valid. NzPauli string label "z" is not valid.coeffr 1+jr"r<asciirlrrrrrm)r_VALID_LABEL_PATTERN fullmatchr_CANONICAL_PHASE_LABELreplacerd frombufferencodeuint8ord logical_orreshapearray count_nonzerorX)labelmatch_ro pauli_bytesysr5r4r6s r8r,Pauli._from_labeles6++55e< > 4UG?KL L,, G_ " + +C 4 < PM nnURAXFS9nM URBURDURF4$s snf)z*Convert a Pauli circuit to BasePauli data.zCannot apply Instruction: rrly?z.Cannot apply instruction with classical bits: r)$r$r r r r rr r definitionrr?rrrdrrJrrXrrexpfloatror3clbits operationrr r.rfind_bitindexrr%r&r')rYrrinner next_instrtuprs r8r.Pauli._from_circuits eiueD E E..u5 5 e[ ) )'!$>uzzl"KLL$$E !U--.d;!U--.d;#&     //rE%BTBTC vvsvvszz))Ps#$H?c$^SSKJn UcUcUR5$URm[ X5(a%[ UR 5mUR5nUbUT:a[SUSTS35eUmUc[[UR55nOQ[U4SjU55(a [S5e[ [U55[ U5:wa [S5e[U5"S T-5nURXS 9$) aApply a transpiler layout to this :class:`~.quantum_info.Pauli` Args: layout: Either a :class:`~.TranspileLayout`, a list of integers or None. If both layout and num_qubits are none, a copy of the operator is returned. num_qubits: The number of qubits to expand the operator to. If not provided then if ``layout`` is a :class:`~.TranspileLayout` the number of the transpiler output circuit qubits will be used by default. If ``layout`` is a list of integers the permutation specified will be applied without any expansion. If layout is None, the operator will be expanded to the given number of qubits. Returns: A new :class:`~.quantum_info.Pauli` with the provided layout applied rrz%The input num_qubits is too small, a z% qubit layout cannot be applied to a z qubit operatorc3D># UHoS:=(d UT:v M g7f)rNr=).0run_qubitss r8 %Pauli.apply_layout..s:6aq5)AM)6s z>Provided layout contains indices outside the number of qubits.z+Provided layout contains duplicate indices.rr)qiskit.transpiler.layoutrrOrJr$r)_output_qubit_listfinal_index_layoutrrranysettyper)r2layoutrJrnew_oprs @r8 apply_layoutPauli.apply_layouts& = >j099; ?? f . .6445H..0F  !H$!;J<H$$,:_>"H >%01F:6:::!"bcc3v;3v;.!"OPPdC(N+~~d~11r:)r'r)r3z6str | tuple | Pauli | ScalarOp | QuantumCircuit | None)NN)rZrX)r`rreturnr)r'dict)r int | listr'r)rr)rrrr'r)r'r+)F)rrr'z np.ndarray)NFF) r`rr list | NonerLrrrr'r)NF)r`rrr*rrr'r)r`rr'r)r`zPauli | PauliListrr*r'r)r`rrr*r'r)Nh)r`z!Pauli | Clifford | QuantumCircuitrr*rzLiteral['h', 's']r'r)r#z"TranspileLayout | list[int] | NonerJz int | Noner'r)7__name__ __module__ __qualname____firstlineno____doc__rIrecompilerrr1propertyr?rBrFrErU classmethodr[rarfrirosetterrur~rrrrrrrKrQrrrrrrrrrrrrr staticmethodr,r-r r.r%__static_attributes__ __classcell__)r7s@r8rr'svrL::&RS"#111=*5*5X,G  $ $ K ))RR  \\SSXXXX71)8&X% > N(0]b"X"X#."X>B"XUY"X "X"XH M, , /**((& A"#& 'F0'F'F! 'F  'F'FZ**6 * * 8 8%*%*PTX+28+2FP+2 +2+2r:r)'r0 __future__rr1typingrrnumpyrdqiskit.circuitrrqiskit.circuit.barrierrqiskit.circuit.delayr (qiskit.circuit.library.generalized_gatesr %qiskit.circuit.library.standard_gatesr r r rqiskit.exceptionsr$qiskit.quantum_info.operators.mixinsr'qiskit.quantum_info.operators.scalar_opr3qiskit.quantum_info.operators.symplectic.base_paulirrrr3qiskit.quantum_info.operators.symplectic.pauli_listrrrrr=r:r8rFs[# )6*&>LL)A<SJM8H 2IH 2Xr: