\hkNSSKJr SSKJr SSKJr SSKJr SSKJ r SSK J r J r SSK Jr SSKJr SS KJr SS KJr /S Qr\"S 5r\"S SS/0S9rS!SjrS"Sjr\(a \(a\rO\rSrSrSrSrSrS#Sjr S#Sjr!"SS\5r"Sr#Sr$S$Sjr%S r&g)%)deque)randint) import_module)BasicMul)Number equal_valued)Pow)S) represent)Dagger) generate_gate_rulesgenerate_equivalent_ids GateIdentitybfs_identity_searchrandom_identity_searchis_scalar_sparse_matrixis_scalar_nonsparse_matrix is_degenerate is_reduciblenumpyscipyfromlistsparse) import_kwargsc[(a [(d[[U6USS9n[ U[ 5(aU(aUS:H$S$UR 5R5n[RURU*:URU:5n[RURU*:URU:5n[RUSUR5n[RUSUR5n U [S5-n X-n U R5Sn U R5Sn X:Hn U R5nU SSnUS:Xag X- R5n[!S U5nUU:Hn[#URS - 5U:n[#UR5U:nU=(a UnU(aUOSn[%U=(a U=(a U5$) axChecks if a given scipy.sparse matrix is a scalar matrix. A scalar matrix is such that B = bI, where B is the scalar matrix, b is some scalar multiple, and I is the identity matrix. A scalar matrix would have only the element b along it's main diagonal and zeroes elsewhere. Parameters ========== circuit : Gate tuple Sequence of quantum gates representing a quantum circuit nqubits : int Number of qubits in the circuit identity_only : bool Check for only identity matrices eps : number The tolerance value for zeroing out elements in the matrix. Values in the range [-eps, +eps] will be changed to a zero. z scipy.sparse)nqubitsformatTgy?ryFg?)nprr r isinstanceinttodensegetA logical_andrealimagwherecomplexnonzeroalltracepowabsbool)circuitr identity_onlyepsmatrix dense_matrix bool_real bool_imagcorrected_realcorrected_imagcorrected_dense row_indices col_indices bool_indices is_diagonal first_elementtrace_of_correctedexpected_tracehas_correct_trace real_is_one imag_is_zerois_one is_identitys \/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/quantum/identitysearch.pyrr s, 2UU sG}g,.F 63+v{55~~',,. NN<#4#4t#;#/#4#4s#:< NN<#4#4t#;#/#4#4s#:< )S,2C2CD)S,2C2CD''"+5(9&--/2 %--/2 #1 "&&( '*1-  Z ' .;BBDQ..@-,,s23c9 =--.4 - -f4 KE$5E+FFNcL[[U6US9n[U[5(aU(aUS:H$S$UR 5nU(dXTS- OUnU(a[ USS5OSnU[ SU5:Hn[UR5=(a U=(a U5$)aChecks if a given circuit, in matrix form, is equivalent to a scalar value. Parameters ========== circuit : Gate tuple Sequence of quantum gates representing a quantum circuit nqubits : int Number of qubits in the circuit identity_only : bool Check for only identity matrices eps : number This argument is ignored. It is just for signature compatibility with is_scalar_sparse_matrix. Note: Used in situations when is_scalar_sparse_matrix has bugs )rr Trr!) r rr#r r.r r/r1r?) r2rr3r4r5 matrix_traceadjusted_matrix_tracerGrCs rHrrxs(sG}g 6F 66""+v{55 ||~ )6".Qi!7&2 5Bl6!9a0t 1SG_D    F%6 F;H HrIcp[U[5(aURR$UR$N)r#r base min_qubits)a_gates rH_get_min_qubitsrRs+&#{{%%%   rIc[U5S:a&USn[[U5U4[U5S5n[U5S:a'W(a US[U5n[W54U-nXE4$g)a_Perform a LL operation. A LL operation multiplies both left and right circuits with the dagger of the left circuit's leftmost gate, and the dagger is multiplied on the left side of both circuits. If a LL is possible, it returns the new gate rule as a 2-tuple (LHS, RHS), where LHS is the left circuit and and RHS is the right circuit of the new rule. If a LL is not possible, None is returned. Parameters ========== left : Gate tuple The left circuit of a gate rule expression. right : Gate tuple The right circuit of a gate rule expression. Examples ======== Generate a new gate rule using a LL operation: >>> from sympy.physics.quantum.identitysearch import ll_op >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> ll_op((x, y, z), ()) ((Y(0), Z(0)), (X(0),)) >>> ll_op((y, z), (x,)) ((Z(0),), (Y(0), X(0))) rTr Nlenis_scalar_matrixrrR)leftrightll_gatell_gate_is_unitarynew_left new_rights rHll_opr]swF D A q'- G_g &(@$H D A ,#d)$G_&. $$ rIc[U5S:a2U[U5S- n[[U5U4[U5S5n[U5S:a*W(a#US[U5S- nU[W54-nXE4$g)aaPerform a LR operation. A LR operation multiplies both left and right circuits with the dagger of the left circuit's rightmost gate, and the dagger is multiplied on the right side of both circuits. If a LR is possible, it returns the new gate rule as a 2-tuple (LHS, RHS), where LHS is the left circuit and and RHS is the right circuit of the new rule. If a LR is not possible, None is returned. Parameters ========== left : Gate tuple The left circuit of a gate rule expression. right : Gate tuple The right circuit of a gate rule expression. Examples ======== Generate a new gate rule using a LR operation: >>> from sympy.physics.quantum.identitysearch import lr_op >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> lr_op((x, y, z), ()) ((X(0), Y(0)), (Z(0),)) >>> lr_op((x, y), (z,)) ((X(0),), (Z(0), Y(0))) rr TNrT)rWrXlr_gatelr_gate_is_unitaryr[r\s rHlr_oprasF D A s4y1}%- G_g &(@$H D A ,#d)a-(VG_.. $$ rIc[U5S:a&USn[[U5U4[U5S5n[U5S:a'W(a US[U5n[W54U-nXT4$g)a`Perform a RL operation. A RL operation multiplies both left and right circuits with the dagger of the right circuit's leftmost gate, and the dagger is multiplied on the left side of both circuits. If a RL is possible, it returns the new gate rule as a 2-tuple (LHS, RHS), where LHS is the left circuit and and RHS is the right circuit of the new rule. If a RL is not possible, None is returned. Parameters ========== left : Gate tuple The left circuit of a gate rule expression. right : Gate tuple The right circuit of a gate rule expression. Examples ======== Generate a new gate rule using a RL operation: >>> from sympy.physics.quantum.identitysearch import rl_op >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> rl_op((x,), (y, z)) ((Y(0), X(0)), (Z(0),)) >>> rl_op((x, y), (z,)) ((Z(0), X(0), Y(0)), ()) rTr NrT)rWrXrl_gaterl_gate_is_unitaryr\r[s rHrl_opreswF E Q(- G_g &(@$H E Q-!CJ' 7O%,$$ rIc[U5S:a2U[U5S- n[[U5U4[U5S5n[U5S:a*W(a#US[U5S- nU[W54-nXT4$g)abPerform a RR operation. A RR operation multiplies both left and right circuits with the dagger of the right circuit's rightmost gate, and the dagger is multiplied on the right side of both circuits. If a RR is possible, it returns the new gate rule as a 2-tuple (LHS, RHS), where LHS is the left circuit and and RHS is the right circuit of the new rule. If a RR is not possible, None is returned. Parameters ========== left : Gate tuple The left circuit of a gate rule expression. right : Gate tuple The right circuit of a gate rule expression. Examples ======== Generate a new gate rule using a RR operation: >>> from sympy.physics.quantum.identitysearch import rr_op >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> rr_op((x, y), (z,)) ((X(0), Y(0), Z(0)), ()) >>> rr_op((x,), (y, z)) ((X(0), Z(0)), (Y(0),)) rr TNrT)rWrXrr_gaterr_gate_is_unitaryr\r[s rHrr_opriMsF E QE Q'- G_g &(@$H E Q-!CJN+ 6'?,,$$ rIc^ ^ ^ [U[5(a+U(a![R[R41$S1$[U[5(a UR n[ 5m [5m [U5m U U U 4SjnT RUSS45 T RUS45 [T 5S:apT R5up4n[X45nU"Xe5 [X45nU"Xe5 [X45nU"Xe5 [X45nU"Xe5 [T 5S:aMpU(a8[5nT H&nUup4UR[ U6[ U645 M( Um T $)am Returns a set of gate rules. Each gate rules is represented as a 2-tuple of tuples or Muls. An empty tuple represents an arbitrary scalar value. This function uses the four operations (LL, LR, RL, RR) to generate the gate rules. A gate rule is an expression such as ABC = D or AB = CD, where A, B, C, and D are gates. Each value on either side of the equal sign represents a circuit. The four operations allow one to find a set of equivalent circuits from a gate identity. The letters denoting the operation tell the user what activities to perform on each expression. The first letter indicates which side of the equal sign to focus on. The second letter indicates which gate to focus on given the side. Once this information is determined, the inverse of the gate is multiplied on both circuits to create a new gate rule. For example, given the identity, ABCD = 1, a LL operation means look at the left value and multiply both left sides by the inverse of the leftmost gate A. If A is Hermitian, the inverse of A is still A. The resulting new rule is BCD = A. The following is a summary of the four operations. Assume that in the examples, all gates are Hermitian. LL : left circuit, left multiply ABCD = E -> AABCD = AE -> BCD = AE LR : left circuit, right multiply ABCD = E -> ABCDD = ED -> ABC = ED RL : right circuit, left multiply ABC = ED -> EABC = EED -> EABC = D RR : right circuit, right multiply AB = CD -> ABD = CDD -> ABD = C The number of gate rules generated is n*(n+1), where n is the number of gates in the sequence (unproven). Parameters ========== gate_seq : Gate tuple, Mul, or Number A variable length tuple or Mul of Gates whose product is equal to a scalar matrix return_as_muls : bool True to return a set of Muls; False to return a set of tuples Examples ======== Find the gate rules of the current circuit using tuples: >>> from sympy.physics.quantum.identitysearch import generate_gate_rules >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> generate_gate_rules((x, x)) {((X(0),), (X(0),)), ((X(0), X(0)), ())} >>> generate_gate_rules((x, y, z)) {((), (X(0), Z(0), Y(0))), ((), (Y(0), X(0), Z(0))), ((), (Z(0), Y(0), X(0))), ((X(0),), (Z(0), Y(0))), ((Y(0),), (X(0), Z(0))), ((Z(0),), (Y(0), X(0))), ((X(0), Y(0)), (Z(0),)), ((Y(0), Z(0)), (X(0),)), ((Z(0), X(0)), (Y(0),)), ((X(0), Y(0), Z(0)), ()), ((Y(0), Z(0), X(0)), ()), ((Z(0), X(0), Y(0)), ())} Find the gate rules of the current circuit using Muls: >>> generate_gate_rules(x*x, return_as_muls=True) {(1, 1)} >>> generate_gate_rules(x*y*z, return_as_muls=True) {(1, X(0)*Z(0)*Y(0)), (1, Y(0)*X(0)*Z(0)), (1, Z(0)*Y(0)*X(0)), (X(0)*Y(0), Z(0)), (Y(0)*Z(0), X(0)), (Z(0)*X(0), Y(0)), (X(0)*Y(0)*Z(0), 1), (Y(0)*Z(0)*X(0), 1), (Z(0)*X(0)*Y(0), 1), (X(0), Z(0)*Y(0)), (Y(0), X(0)*Z(0)), (Z(0), Y(0)*X(0))} )rkc>UbDUup#UT;aX24T;aTRU5 US-T:aTRXS-4-5 ggg)Nr )addappend)new_ruleopsr[r\max_opsqueueruless rHprocess_new_rule-generate_gate_rules..process_new_rulesZ  "* Hu$))>e)K (#Qw  Xq 23! rIrkr)r#r r OnerargsrsetrUrnrmpopleftr]rareri) gate_seqreturn_as_mulsrtrWrXrpro mul_rulesrulerqrrrss @@@rHrrs@d(F## UUAEEN# #:  Hc " "== GE EE(mG4 LL(B"# IIxn e*q. ==?S%'%'%'%' e*q. E DKD MM3:sE{3 4 LrIcx[U[5(a[R1$[U[5(a UR n[ 5n[U5nUH9nUupVUS:XaURU5 M US:XdM(URU5 M; U(aSn[ [Xr55nU$)alReturns a set of equivalent gate identities. A gate identity is a quantum circuit such that the product of the gates in the circuit is equal to a scalar value. For example, XYZ = i, where X, Y, Z are the Pauli gates and i is the imaginary value, is considered a gate identity. This function uses the four operations (LL, LR, RL, RR) to generate the gate rules and, subsequently, to locate equivalent gate identities. Note that all equivalent identities are reachable in n operations from the starting gate identity, where n is the number of gates in the sequence. The max number of gate identities is 2n, where n is the number of gates in the sequence (unproven). Parameters ========== gate_seq : Gate tuple, Mul, or Number A variable length tuple or Mul of Gates whose product is equal to a scalar matrix. return_as_muls: bool True to return as Muls; False to return as tuples Examples ======== Find equivalent gate identities from the current circuit with tuples: >>> from sympy.physics.quantum.identitysearch import generate_equivalent_ids >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> generate_equivalent_ids((x, x)) {(X(0), X(0))} >>> generate_equivalent_ids((x, y, z)) {(X(0), Y(0), Z(0)), (X(0), Z(0), Y(0)), (Y(0), X(0), Z(0)), (Y(0), Z(0), X(0)), (Z(0), X(0), Y(0)), (Z(0), Y(0), X(0))} Find equivalent gate identities from the current circuit with Muls: >>> generate_equivalent_ids(x*x, return_as_muls=True) {1} >>> generate_equivalent_ids(x*y*z, return_as_muls=True) {X(0)*Y(0)*Z(0), X(0)*Z(0)*Y(0), Y(0)*X(0)*Z(0), Y(0)*Z(0)*X(0), Z(0)*X(0)*Y(0), Z(0)*Y(0)*X(0)} rkc[U6$rNr)id_seqs rH)generate_equivalent_ids..ZsV rI) r#r r rvrrwrxrrmmap)rzr{eq_ids gate_rulesr}lrconvert_to_muls rHrrsj(F##w Hc " "== UF$X.J 7 JJqM "W JJqM 4S01 MrIcd\rSrSrSrSr\S5r\S5r\S5r \S5r Sr S r g ) ri`aOWrapper class for circuits that reduce to a scalar value. A gate identity is a quantum circuit such that the product of the gates in the circuit is equal to a scalar value. For example, XYZ = i, where X, Y, Z are the Pauli gates and i is the imaginary value, is considered a gate identity. Parameters ========== args : Gate tuple A variable length tuple of Gates that form an identity. Examples ======== Create a GateIdentity and look at its attributes: >>> from sympy.physics.quantum.identitysearch import GateIdentity >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> an_identity = GateIdentity(x, y, z) >>> an_identity.circuit X(0)*Y(0)*Z(0) >>> an_identity.equivalent_ids {(X(0), Y(0), Z(0)), (X(0), Z(0), Y(0)), (Y(0), X(0), Z(0)), (Y(0), Z(0), X(0)), (Z(0), X(0), Y(0)), (Z(0), Y(0), X(0))} c[R"U/UQ76n[U6Ul[ U5Ul[ U5UlU$rN)r__new__r_circuitr_rulesr_eq_ids)clsrwobjs rHrGateIdentity.__new__s=mmC'$'Dz (. -d3  rIcUR$rN)rselfs rHr2GateIdentity.circuits }}rIcUR$rN)rrs rHrGateIdentity.gate_ruless {{rIcUR$rN)rrs rHequivalent_idsGateIdentity.equivalent_idss ||rIcUR$rN)rwrs rHsequenceGateIdentity.sequences yyrIc,[UR5$)z'Returns the string of gates in a tuple.)strr2rs rH__str__GateIdentity.__str__s4<<  rIrkN) __name__ __module__ __qualname____firstlineno____doc__rpropertyr2rrrr__static_attributes__rkrIrHrr`sa<!rIrc8UHnXR;dM g g)aChecks if a gate identity is a permutation of another identity. Parameters ========== identity_set : set A Python set with GateIdentity objects. gate_identity : GateIdentity The GateIdentity to check for existence in the set. Examples ======== Check if the identity is a permutation of another identity: >>> from sympy.physics.quantum.identitysearch import ( ... GateIdentity, is_degenerate) >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> an_identity = GateIdentity(x, y, z) >>> id_set = {an_identity} >>> another_id = (y, z, x) >>> is_degenerate(id_set, another_id) True >>> another_id = (x, x) >>> is_degenerate(id_set, another_id) False TF)r) identity_set gate_identityan_ids rHrrs#B 11 1 rIcxSn[[X#55H nXnU4U-n[XAS5(dM g g)a[Determines if a circuit is reducible by checking if its subcircuits are scalar values. Parameters ========== circuit : Gate tuple A tuple of Gates representing a circuit. The circuit to check if a gate identity is contained in a subcircuit. nqubits : int The number of qubits the circuit operates on. begin : int The leftmost gate in the circuit to include in a subcircuit. end : int The rightmost gate in the circuit to include in a subcircuit. Examples ======== Check if the circuit can be reduced: >>> from sympy.physics.quantum.identitysearch import is_reducible >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> is_reducible((x, y, z), 1, 0, 3) True Check if an interval in the circuit can be reduced: >>> is_reducible((x, y, z), 1, 1, 3) False >>> is_reducible((x, y, y), 1, 1, 3) True rkFT)reversedrangerV)r2rbeginendcurrent_circuitndx next_gates rHrrsHJOe)*L $,8 _u = = + rIc UbUS::a [U5nUn[S/5n[5n[U5S:aUR5nUHnXx4-n [ XS[U 55n [ XU5(a0[ Xi5(d U (dUR[U 65 M_[U 5U:dMpU (aMyURU 5 M [U5S:aMU$)aConstructs a set of gate identities from the list of possible gates. Performs a breadth first search over the space of gate identities. This allows the finding of the shortest gate identities first. Parameters ========== gate_list : list, Gate A list of Gates from which to search for gate identities. nqubits : int The number of qubits the quantum circuit operates on. max_depth : int The longest quantum circuit to construct from gate_list. identity_only : bool True to search for gate identities that reduce to identity; False to search for gate identities that reduce to a scalar. Examples ======== Find a list of gate identities: >>> from sympy.physics.quantum.identitysearch import bfs_identity_search >>> from sympy.physics.quantum.gate import X, Y, Z >>> x = X(0); y = Y(0); z = Z(0) >>> bfs_identity_search([x], 1, max_depth=2) {GateIdentity(X(0), X(0))} >>> bfs_identity_search([x, y, z], 1) {GateIdentity(X(0), X(0)), GateIdentity(Y(0), Y(0)), GateIdentity(Z(0), Z(0)), GateIdentity(X(0), Y(0), Z(0))} Find a list of identities that only equal to 1: >>> bfs_identity_search([x, y, z], 1, identity_only=True) {GateIdentity(X(0), X(0)), GateIdentity(Y(0), Y(0)), GateIdentity(Z(0), Z(0))} rrkr ) rUrrxryrrVrrmrrn) gate_listr max_depthr3id_onlyrridsrr new_circuitcircuit_reducibles rHrrsTIN N G 2$KE %C u:>--/"I)L8K!-[-.K0@!B  !w??!#33) k23k"Y.'' [)!# u:>* JrIc[U5nSn[U5HnU[SUS- 5nXF4-nM [XBS5nU(aU$S$)zRandomly selects numgates from gate_list and checks if it is a gate identity. If the circuit is a gate identity, the circuit is returned; Otherwise, None is returned. rkrr FN)rUrrrV)rnumgatesr gate_sizer2ir is_scalars rHrrDsZIIG 8_gaQ78 L(!59I7)T)rI)gdy=rN)F)NF)' collectionsrsympy.core.randomrsympy.externalrsympy.core.basicrsympy.core.mulrsympy.core.numbersr r sympy.core.powerr sympy.core.singletonr sympy.physics.quantum.representr sympy.physics.quantum.daggerr__all__r"rrrrVrRr]rarerirrrrrrrrkrIrHrs%("3 "5/ 7gj8*-EFUGp-H^%.1!0f0f0f0fNbL^:!5:!z$N/d7;K\*rI