\heSrSSKrSSKJr SSKJr SSKJr SSKJ r SSK J r SSK J r SS KJr SS KJr SS KJr SS KJrJr SS KJr SSKJr SSKJrJrJr SSKJ r SSK!J"r" SSK#J$r$J%r% SSK&J'r' /SQr("SS\5r)"SS\)\5r*"SS\)\5r+"SS\)5r,"SS\,\*5r-"SS \,\+5r.S!r/S"r0S)S#jr1S*S$jr2S*S%jr3S)S&jr4S'r5S)S(jr6g)+zQubits for quantum computing. Todo: * Finish implementing measurement logic. This should include POVM. * Update docstrings. * Update tests. N)Add)Mul)Integer)Pow)S) conjugate)log_sympify) SYMPY_INTS)Matrixzeros) prettyForm) ComplexSpace)KetBraState) QuantumError represent) numpy_ndarrayscipy_sparse_matrix)bitcount) QubitQubitBraIntQubit IntQubitBraqubit_to_matrixmatrix_to_qubitmatrix_to_density measure_allmeasure_partialmeasure_partial_oneshotmeasure_all_oneshotcz\rSrSrSr\S5r\S5r\S5r \S5r \S5r Sr S r S rS rg ) QubitState5z"Base class for Qubit and QubitBra.c[U5S:Xa'[US[5(aUSR$[U5S:Xa.[US[5(a[ SUS55nO[ SU55n[ SU55nUH5nU[ R[ R4;dM)[SU-5e U$)Nrc3l# UH*oS:Xa[RO[Rv M, g7f)0NrZeroOne.0qbs S/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/quantum/qubit.py (QubitState._eval_args..Es!K7R#I!&&15587s24c3|# UH2oS:Xa[ROUS:Xa[ROUv M4 g7f)r+1Nr,r/s r2r3r4Gs,]X\RT#I!&&B#I1552MX\s:<c38# UHn[U5v M g7fNr )r0args r2r3r4Hs3dsXc]]dz$Qubit values must be 0 or 1, got: %r) len isinstancer& qubit_valuesstrtuplerr-r. ValueError)clsargselements r2 _eval_argsQubitState._eval_args<s t9>ja*==7'' ' t9>ja#66K47KKD]X\]]D3d33Gqvvquuo- :WDFF c0[S5[U5-$)N)rr;)rArBs r2_eval_hilbert_spaceQubitState._eval_hilbert_spaceQsAD ))rFc,[UR5$)z"The number of Qubits in the state.)r;r=selfs r2 dimensionQubitState.dimensionYs4$$%%rFcUR$r8rNrLs r2nqubitsQubitState.nqubits^s ~~rFcUR$)z,Returns the values of the qubits as a tuple.)labelrLs r2r=QubitState.qubit_valuesbszzrFcUR$r8rQrLs r2__len__QubitState.__len__ks ~~rFcRUR[URU- S- 5$)Nr))r=intrN)rMbits r2 __getitem__QubitState.__getitem__ns&  T^^c%9A%=!>??rFc[UR5nUH0n[URU- S- 5nX$S:XaSX$'M,SX$'M2 UR"[ U56$)zFlip the bit(s) given.r)r)listr=r[rN __class__r?)rMbitsnewargsir\s r2flipQubitState.flipusat(()Adnnq(1,-C|q      ~~uW~..rFN)__name__ __module__ __qualname____firstlineno____doc__ classmethodrDrIpropertyrNrRr=rXr]re__static_attributes__rgrFr2r&r&5sy, (**&&@ /rFr&cF\rSrSrSr\S5rSrSrSr Sr Sr S r g ) raA multi-qubit ket in the computational (z) basis. We use the normal convention that the least significant qubit is on the right, so ``|00001>`` has a 1 in the least significant qubit. Parameters ========== values : list, str The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011'). Examples ======== Create a qubit in a couple of different ways and look at their attributes: >>> from sympy.physics.quantum.qubit import Qubit >>> Qubit(0,0,0) |000> >>> q = Qubit('0101') >>> q |0101> >>> q.nqubits 4 >>> len(q) 4 >>> q.dimension 4 >>> q.qubit_values (0, 1, 0, 1) We can flip the value of an individual qubit: >>> q.flip(1) |0111> We can take the dagger of a Qubit to get a bra: >>> from sympy.physics.quantum.dagger import Dagger >>> Dagger(q) <0101| >>> type(Dagger(q)) Inner products work as expected: >>> ip = Dagger(q)*q >>> ip <0101|0101> >>> ip.doit() 1 c[$r8)rrLs r2 dual_classQubit.dual_classrFc vURUR:Xa[R$[R$r8)rUrr.r-rMbrahintss r2_eval_innerproduct_QubitBra!Qubit._eval_innerproduct_QubitBras$ :: "55L66MrFc &UR"S0UD6$)Nr8)_represent_ZGate)rMoptionss r2_represent_default_basisQubit._represent_default_basiss$$5W55rFc URSS5nSnSn[UR5HnXTU-- nUS-nM S/SUR--nSU[ U5'US:Xa [ U5$US:Xa"SSKnURUSS 9R5$US :Xa$SS K J n U RUSS 9R5$g) zBRepresent this qubits in the computational basis (ZGate). formatsympyr)rrHnumpyNcomplex)dtype scipy.sparse)sparse) getreversedr=rNr[r rarray transposescipyr csr_matrix) rMbasisr~_formatndefinite_stateitresultnprs r2r}Qubit._represent_ZGates++h0 4,,-B d "N!A.a'(&'s>"# g &> !   88F)84>>@ @  & $$$V9$=GGI I'rFc URS/5n[U5n[U5S:Xa[[SUR55nUR 5 X-n[[U5S- SS5H nUR U[XF55nM" [U5UR:XaUS$[U5$)Nindicesrr)) rr`r;rangerRsort_reduced_densityr[r )rMrxkwargsr sorted_idxnew_matrds r2 _eval_traceQubit._eval_traces**Y+'] z?a eAt||45J(s:*B3A++GS5GHG4  Ot|| +1: $W- -rFc ,Sn[U40UD6nURnUS-n[5RU5n[ U5HKn [ U5H9n [ S5H'n U"XU5n U"XU5n XU 4==X]U 4- ss'M) M; MM U$)zCompute the reduced density matrix by tracing out one qubit. The qubit argument should be of type Python int, since it is used in bit operations c:SU-S- nX- SU--X--X--$)NrHr)rg)jkqubitbit_masks r2find_index_that_is_projected.find_index_that_is_projecteds.%x!|HZQY/ALAQZP PrFrH)rcolsr rr)rMmatrixrr~r old_matrixold_sizenew_size new_matrixrdrrcolrows r2rQubit._reduced_densitys  Qv11 ??Q;X^^H- xA8_qA6qUCC6qUCC!t$ 8(<<$"%!rFrgN) rhrirjrkrlrmrsrzrr}rrrorgrFr2rrs64l 6J(.,rFrc(\rSrSrSr\S5rSrg)riaaA multi-qubit bra in the computational (z) basis. We use the normal convention that the least significant qubit is on the right, so ``|00001>`` has a 1 in the least significant qubit. Parameters ========== values : list, str The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011'). See also ======== Qubit: Examples using qubits c[$r8)rrLs r2rsQubitBra.dual_classs rFrgNrhrirjrkrlrmrsrorgrFr2rrs"rFrcV\rSrSrSr\S Sj5r\S5rSrSr Sr \ r \ r S r g) IntQubitStateiz>A base class for qubits that work with binary representations.Nc .[U5S:Xa-[US[5(a[RU5$[ SU55(d [ S[ SU55<S35eUbf[U[[45(d[ S[U5-5e[U5S:wa[ SU<S 35eURUSU5$[U5S:XaaUSS:aX[[[[US5555nUVs/sH oASU- S-PM nn[RU5$[U5S :Xa!USS:aURUSUS5$[RU5$s snf) Nr)rc3N# UHn[U[[45v M g7fr8)r<r[rr0as r2r3+IntQubitState._eval_args..(sADqZC>22Ds#%zvalues must be integers, got (c38# UHn[U5v M g7fr8)typers r2r3r)sI`[_VW$q''[_r:)z$nqubits must be an integer, got (%s)ztoo many positional arguments (z ). should be (number, nqubits=n)rH)r;r<r&rDallr@r?r[rr_eval_args_with_nqubitsrrrabs)rArBrRrvaluesrdr=s r2rDIntQubitState._eval_args"sj t9>ja*==((. .ADAAAEI`[_I`D`bc c  gW~66 !G$w-!WXX4yA~ [_acc..tAw@ @ t9>d1gkuXc$q'l%;<=G8?@1!W\Q.L@((6 6Y!^Q! ..tAwQ@ @((. .As"Fc[[U55nX#:a[SU<SU<S35e[[ U55Vs/sH oAU- S-PM nn[ R U5$s snf)Nzcannot represent z with z bitsr))rrr@rrr&rD)rAnumberrRneedrdr=s r2r%IntQubitState._eval_args_with_nqubits@siF $ >6r)rMprinterrBs r2 _print_labelIntQubitState._print_labelRs4;;=!!rFc>UR"U/UQ76n[U5$r8)rr)rMrrBrUs r2_print_label_pretty!IntQubitState._print_label_prettyUs"!!'1D1%  rFrgr8)rhrirjrkrlrmrDrrrr_print_label_repr_print_label_latexrorgrFr2rrsHH//:33"!%%rFrc.\rSrSrSr\S5rSrSrg)ri]aA qubit ket that store integers as binary numbers in qubit values. The differences between this class and ``Qubit`` are: * The form of the constructor. * The qubit values are printed as their corresponding integer, rather than the raw qubit values. The internal storage format of the qubit values in the same as ``Qubit``. Parameters ========== values : int, tuple If a single argument, the integer we want to represent in the qubit values. This integer will be represented using the fewest possible number of qubits. If a pair of integers and the second value is more than one, the first integer gives the integer to represent in binary form and the second integer gives the number of qubits to use. List of zeros and ones is also accepted to generate qubit by bit pattern. nqubits : int The integer that represents the number of qubits. This number should be passed with keyword ``nqubits=N``. You can use this in order to avoid ambiguity of Qubit-style tuple of bits. Please see the example below for more details. Examples ======== Create a qubit for the integer 5: >>> from sympy.physics.quantum.qubit import IntQubit >>> from sympy.physics.quantum.qubit import Qubit >>> q = IntQubit(5) >>> q |5> We can also create an ``IntQubit`` by passing a ``Qubit`` instance. >>> q = IntQubit(Qubit('101')) >>> q |5> >>> q.as_int() 5 >>> q.nqubits 3 >>> q.qubit_values (1, 0, 1) We can go back to the regular qubit form. >>> Qubit(q) |101> Please note that ``IntQubit`` also accepts a ``Qubit``-style list of bits. So, the code below yields qubits 3, not a single bit ``1``. >>> IntQubit(1, 1) |3> To avoid ambiguity, use ``nqubits`` parameter. Use of this keyword is recommended especially when you provide the values by variables. >>> IntQubit(1, nqubits=1) |1> >>> a = 1 >>> IntQubit(a, nqubits=1) |1> c[$r8)rrLs r2rsIntQubit.dual_classsrFc ,[RX5$r8)rrzrws r2_eval_innerproduct_IntQubitBra'IntQubit._eval_innerproduct_IntQubitBras00;;rFrgN) rhrirjrkrlrmrsrrorgrFr2rr]s"EL>> from sympy.physics.quantum.qubit import matrix_to_qubit, Qubit >>> from sympy.physics.quantum.represent import represent >>> q = Qubit('01') >>> matrix_to_qubit(represent(q)) |01> rrrrr)rHFTz*Matrix must be a row/column vector, got %rz>Matrix must be a row/column vector of size 2**nqubits, got: %r)rr)r<rrshaper rrrrrrr[reverserrrexpand) rrmlistlenrRketrArrdrCx qubit_arrays r2rrs*F&-((&-..||A!<<?h" aA <<?h" 86 A   gw ' '139:; ;F 8_ TlGQTlG . .g&G 7J>a3qAF|q01>KJ    !c;&777F&3S/** MKsF c SSKJn UR5nUVVs/sH3o3SH'oCSS:wdM [[ U/55US/PM) M5 nnn[ U5S:Xa[ R$U"U6$s snnf)z Works by finding the eigenvectors and eigenvalues of the matrix. We know we can decompose rho by doing: sum(EigenVal*|Eigenvect>>> from sympy.physics.quantum.qubit import Qubit, measure_all >>> from sympy.physics.quantum.gate import H >>> from sympy.physics.quantum.qapply import qapply >>> c = H(0)*H(1)*Qubit('00') >>> c H(0)*H(1)*|00> >>> q = qapply(c) >>> measure_all(q) [(|00>, 1/4), (|01>, 1/4), (|10>, 1/4), (|11>, 1/4)] rrHrR8This function cannot handle non-SymPy matrix formats yet) r normalizedmaxrr[mathr rappendrrrNotImplementedError)rr normalizemresultssizerRrds r2r!r!sD &A   A177|dhhtnTXXa[01tAtt8A78!$y:NO ! F  rFc[X5n[U[[45(a [ U54nUS:XaU(aUR 5n[ XA5n/nUH`nSnXRU-S- nUS:wdM!U(a[UR 55n O [U5n URU U45 Mb U$[S5e)a}Perform a partial ensemble measure on the specified qubits. Parameters ========== qubits : Qubit The qubit to measure. This can be any Qubit or a linear combination of them. bits : tuple The qubits to measure. format : str The format of the intermediate matrices to use. Possible values are ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is implemented. Returns ======= result : list A list that consists of primitive states and their probabilities. Examples ======== >>> from sympy.physics.quantum.qubit import Qubit, measure_partial >>> from sympy.physics.quantum.gate import H >>> from sympy.physics.quantum.qapply import qapply >>> c = H(0)*H(1)*Qubit('00') >>> c H(0)*H(1)*|00> >>> q = qapply(c) >>> measure_partial(q, (0,)) [(sqrt(2)*|00>/2 + sqrt(2)*|10>/2, 1/2), (sqrt(2)*|01>/2 + sqrt(2)*|11>/2, 1/2)] rrr) rr<r rr[r_get_possible_outcomesHrrr) rrbrrrpossible_outcomesoutputoutcomeprob_of_outcome next_matrixs r2r"r"TsH &A$W-..D |   A21;(G O  ' 115 5O!#"1'2D2D2F"GK"1'":K #)& ! F  rFcSSKn[X5nUS:XakUR5n[XA5nUR5nSnUH7nXxRU-S- nXv:dM[ UR55s $ g[ S5e)aIPerform a partial oneshot measurement on the specified qubits. A oneshot measurement is equivalent to performing a measurement on a quantum system. This type of measurement does not return the probabilities like an ensemble measurement does, but rather returns *one* of the possible resulting states. The exact state that is returned is determined by picking a state randomly according to the ensemble probabilities. Parameters ---------- qubits : Qubit The qubit to measure. This can be any Qubit or a linear combination of them. bits : tuple The qubits to measure. format : str The format of the intermediate matrices to use. Possible values are ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is implemented. Returns ------- result : Qubit The qubit that the system collapsed to upon measurement. rNrr)randomrrrrrr) rrbrrrr random_number total_probrs r2r#r#s4&A  LLN21;   (G 99W,a0 0J*&w'9'9';<< )" F  rFc[UR5n[[R"U5S-5n/n[ S[ U5-5H!nUR[SU-S55 M# /nUHnURSU-5 M [ SU-5H>nSn[ [ U55Hn XVU -(dMXS-- nM XXHU'M@ U$)aGet the possible states that can be produced in a measurement. Parameters ---------- m : Matrix The matrix representing the state of the system. bits : tuple, list Which bits will be measured. Returns ------- result : list The list of possible states which can occur given this measurement. These are un-normalized so we can derive the probability of finding this state by taking the inner product with itself 皙?r)rHr) rrr[rlog2rr;rr) rrbrrRoutput_matricesrd bit_masksr\truenessrs r2rrs( qww "uQZ34# Ic"1g: s9~&AQ<E!'()t!!$ rFc jSSKn[U5nUS:XaUR5nUR5nSnSnUH$nXWUR5-- nXT:a O US- nM& [ [ U[ [R"[UR55S-5S95$[S5e)aPerform a oneshot ensemble measurement on all qubits. A oneshot measurement is equivalent to performing a measurement on a quantum system. This type of measurement does not return the probabilities like an ensemble measurement does, but rather returns *one* of the possible resulting states. The exact state that is returned is determined by picking a state randomly according to the ensemble probabilities. Parameters ---------- qubits : Qubit The qubit to measure. This can be any Qubit or a linear combination of them. format : str The format of the intermediate matrices to use. Possible values are ('sympy','numpy','scipy.sparse'). Currently only 'sympy' is implemented. Returns ------- result : Qubit The qubit that the system collapsed to upon measurement. rNrr)rrr) rrrrrrr[rr rrr)rrrrrtotalrrds r2r$r$s0A  LLN  A q{{}_ $E$ aKF  Xfc$))CL2IB2N.OPQQ! F  rF)r)rT)7rlrsympy.core.addrsympy.core.mulrsympy.core.numbersrsympy.core.powerrsympy.core.singletonr$sympy.functions.elementary.complexesr&sympy.functions.elementary.exponentialr sympy.core.basicr sympy.external.gmpyr sympy.matricesr r sympy.printing.pretty.stringpictrsympy.physics.quantum.hilbertrsympy.physics.quantum.staterrrsympy.physics.quantum.qexprrsympy.physics.quantum.representr!sympy.physics.quantum.matrixutilsrrmpmath.libmp.libintmathr__all__r&rrrrrrr rr!r"r#rr$rgrFr2r!s & ":6%*(767745- &I/I/XDJDNz3.;&J;&|L<}eL<\-CL  +5 pH V- `0f) rF