g-TRdZddlmZgdZddlZddlmZmZmZm Z m Z m Z m Z ddl mZmZdd lm Z ejrddlZd6dZd7dZd8d9dZd:dZd;dZd;dZdd"Zd>d#Zd>d$Zd=d%Zd>d&Zd>d'Z d=d(Z!d>d)Z"d>d*Z#d=d+Z$d>d,Z%d>d-Z&d>d.Z'd>d/Z(d?d0Z)d8d@d1Z*d8d@d2Z+dAd5Z,dS)BzvUser-space constructor functions for the expression tree, which do some of the inference and lifting boilerplate work.) annotations)liftbit_not logic_notbit_andbit_orbit_xor logic_andlogic_orequal not_equalless less_equalgreater greater_equallift_legacy_conditionN)ExprVarValueUnaryBinaryCastIndex)CastKind cast_kind)typesexprrtype types.Typereturnc@t|j|}|tjur|S|tjurt ||dS|tjurt ||dS|tjurtd|d|dtd|d|d) zCoerce ``expr`` to ``type`` by inserting a suitable :class:`Cast` node, if the cast is lossless. Otherwise, raise a ``TypeError``.TimplicitF cannot cast '' to 'z' without loss of precisionzno cast is defined to take '') rr rEQUALIMPLICITrLOSSLESS DANGEROUS TypeError)rr kinds `/granary/edev/quantum/lib/python3.11/site-packages/qiskit/circuit/classical/expr/constructors.py_coerce_losslessr00s TY % %D x~  x   D$.... x   D$//// x!!!UUUDUUUVVV F4FFtFFF G GG conditionCtuple[qiskit.circuit.Clbit | qiskit.circuit.ClassicalRegister, int]cdddlm}|\}}t||rStj}|rt ||n-t t jjt |||St |tj |j }| |j kr7t|tj | d}t||j}ttjj||tjS)aLift a legacy two-tuple equality condition into a new-style :class:`Expr`. Examples: Taking an old-style conditional instruction and getting an :class:`Expr` from its condition:: from qiskit.circuit import ClassicalRegister from qiskit.circuit.library import HGate from qiskit.circuit.classical import expr cr = ClassicalRegister(2) instr = HGate().c_if(cr, 3) lifted = expr.lift_legacy_condition(instr.condition) r)ClbitwidthTr$)qiskit.circuitr5 isinstancerBoolrrOp LOGIC_NOTUintsize bit_lengthrrr rr))r2r5targetvaluebool_leftrights r/rr?s$%$$$$$MFE&%  e %*ds65!!!eh6H#fV[J\J\^c0d0dd vuz 444 5 5D FK''D%*5+;+;+=+=>>>NNN % # #E &)/4 = ==r1types.Type | NonerA typing.Anyc t|tr|td|Sddlm}m}|dus|dust||r*t j}|dus|durtnt}nt||r"t j |j }t}nnt|trF|dkrtdt j | pd }t}ntd |d ||}t j||r |||Std |d |d|d )aVLift the given Python ``value`` to a :class:`~.expr.Value` or :class:`~.expr.Var`. If an explicit ``type`` is given, the typing in the output will reflect that. Examples: Lifting simple circuit objects to be :class:`~.expr.Var` instances:: >>> from qiskit.circuit import Clbit, ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.lift(Clbit()) Var(, Bool()) >>> expr.lift(ClassicalRegister(3, "c")) Var(ClassicalRegister(3, "c"), Uint(3)) The type of the return value can be influenced, if the given value could be interpreted losslessly as the given type (use :func:`cast` to perform a full set of casting operations, include lossy ones):: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr, types >>> expr.lift(ClassicalRegister(3, "c"), types.Uint(5)) Var(ClassicalRegister(3, "c"), Uint(5)) >>> expr.lift(5, types.Uint(4)) Value(5, Uint(4)) Nz3use 'cast' to cast existing expressions, not 'lift'r)r5ClassicalRegisterTFr6z!cannot represent a negative valuerzfailed to infer a type for 'r(zthe explicit type 'z$' is not suitable for representing 'z''; it must be non-strict supertype of ')r9r ValueErrorr8r5rHrr:rrr=r>intr?r- is_supertype)rAr r5rHinferred constructors r/rr^s4%  RSS S 77777777 }}*UE*B*B:<<$}}eeC E, - - A:EJ/// E3  A 199@AA A:E$4$4$6$6$;!<<< ?u???@@@ | $))({5$'''  >> from qiskit.circuit.classical import expr, types >>> value = expr.value(5, types.Uint(32)) >>> expr.cast(value, types.Uint(8)) Cast(Value(5, types.Uint(32)), types.Uint(8), implicit=False) r&r'r()rrr rNONEr-r)rNr s r/castrQsZ7mmGt$$ 55>>>t>>>???   r1ct|}|jjtjtjfvr*t dtjj d|jdttjj ||jS)aCreate a bitwise 'not' expression node from the given value, resolving any implicit casts and lifting the value into a :class:`Value` node if required. Examples: Bitwise negation of a :class:`.ClassicalRegister`:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.bit_not(ClassicalRegister(3, "c")) Unary(Unary.Op.BIT_NOT, Var(ClassicalRegister(3, 'c'), Uint(3)), Uint(3)) zcannot apply 'z ' to type 'r() rr r.rr:r=r-rr;BIT_NOTrNs r/rrsj7mmG|UZ 888U)9UUglUUUVVV !7GL 9 99r1ctt|tj}t tjj||jS)aCreate a logical 'not' expression node from the given value, resolving any implicit casts and lifting the value into a :class:`Value` node if required. Examples: Logical negation of a :class:`.ClassicalRegister`:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.logic_not(ClassicalRegister(3, "c")) Unary(Unary.Op.LOGIC_NOT, Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), Bool(), implicit=True), Bool()) )r0rrr:rr;r<r rTs r/rrs8tG}}ejll;;G #Wgl ; ;;r1rCrDtuple[Expr, Expr]ct|tot|t }t|tot|t }|s"|s t|}t|}nu|st|}|jjt jurN||jj krtd|d|dt||j}nt|}n|st|}|jjt jurN||jj krtd|d|dt||j}nwt|}ngt jt||d}t||}t||}||fS)zLift two binary operands simultaneously, inferring the widths of integer literals in either position to match the other operand.zinteger literal 'z#' is wider than the other operand 'r(r) r9rJboolrr r.rr=r?r7r-rmax)rCrDleft_int right_intuints r/_lift_binary_operandsr]s$$$CZd-C-C)CH5#&&Fz%/F/F+FI # #DzzU  #U  :?ej ( (  5:#333YYYQVYYYuz**DD::DD #Dzz 9>UZ ' '!!DIO33YYYRVYYY%++EEKKEEz#doo//1A1A1C1CQGGHHT4  eT"" ;r1op Binary.Opc t||\}}|jj|jjcxurtjurnntj}n|jjtjurZ|jjtjurB|j|jkr*t d|jjd|jjd|j}n#t d|d|jd|jdt||||S)Nz[binary bitwise operations are defined between unsigned integers of the same width, but got z and .invalid types for '': '' and 'r() r]r r.rr:r=r-r7rr^rCrDr s r/_binary_bitwiserfs'e44KD% y~6666EJ66666z|| 5: % %%*/UZ*G*G 9 " "F IOFF27*2BFFF yUbUUdiUU UUUVVV "dE4 ( ((r1cBttjj||S)aCreate a bitwise 'and' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Bitwise 'and' of a classical register and an integer literal:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.bit_and(ClassicalRegister(3, "c"), 0b111) Binary(Binary.Op.BIT_AND, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(7, Uint(3)), Uint(3)) )rfrr;BIT_ANDrCrDs r/rr 69,dE : ::r1cBttjj||S)aCreate a bitwise 'or' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Bitwise 'or' of a classical register and an integer literal:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.bit_or(ClassicalRegister(3, "c"), 0b101) Binary(Binary.Op.BIT_OR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3)) )rfrr;BIT_ORris r/rrs 69+T5 9 99r1cBttjj||S)a*Create a bitwise 'exclusive or' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Bitwise 'exclusive or' of a classical register and an integer literal:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.bit_xor(ClassicalRegister(3, "c"), 0b101) Binary(Binary.Op.BIT_XOR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3)) )rfrr;BIT_XORris r/r r (rjr1ctj}tt||}tt||}t ||||SN)rr:r0rr)r^rCrDrBs r/_binary_logicalrq;sK JLLE DJJ . .D T%[[% 0 0E "dE5 ) ))r1cBttjj||S)aCreate a logical 'and' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Logical 'and' of two classical bits:: >>> from qiskit.circuit import Clbit >>> from qiskit.circuit.classical import expr >>> expr.logical_and(Clbit(), Clbit()) Binary(Binary.Op.LOGIC_AND, Var(, Bool()), Var(, Bool()), Bool()) )rqrr; LOGIC_ANDris r/r r Bs 69.e < <>> from qiskit.circuit import Clbit >>> from qiskit.circuit.classical import expr >>> expr.logical_and(Clbit(), Clbit()) Binary(Binary.Op.LOGIC_OR, Var(, Bool()), Var(, Bool()), Bool()) )rqrr;LOGIC_ORris r/r r Qs 69-tU ; ;;r1c Zt||\}}|jj|jjur#td|d|jd|jdt j|j|j}t |t||t||t jSNrbrcrdr() r]r r.r-rrrr0r:res r/ _equal_likerx`s'e44KD% y~UZ_,,UbUUdiUU UUUVVV =EJ / /D "&tT224DUD4Q4QSXS]S_S_ ` ``r1cBttjj||S)aCreate an 'equal' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Equality between a classical register and an integer:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.equal(ClassicalRegister(3, "c"), 7) Binary(Binary.Op.EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3)) )rxrr;r)ris r/r r hs vye 4 44r1cBttjj||S)aCreate a 'not equal' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Inequality between a classical register and an integer:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.not_equal(ClassicalRegister(3, "c"), 7) Binary(Binary.Op.NOT_EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3)) )rxrr; NOT_EQUALris r/r r zs vy*D% 8 88r1c t||\}}|jj|jjus|jjtjur#t d|d|jd|jdtj|j|j}t|t||t||tjSrw) r]r r.rr:r-rrr0res r/_binary_relationr}s'e44KD% y~UZ_,, %*0L0LUbUUdiUU UUUVVV =EJ / /D "&tT224DUD4Q4QSXS]S_S_ ` ``r1cBttjj||S)aCreate a 'less than' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Query if a classical register is less than an integer:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.less(ClassicalRegister(3, "c"), 5) Binary(Binary.Op.LESS, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3)) )r}rr;LESSris r/rrs FIND% 8 88r1cBttjj||S)aNCreate a 'less than or equal to' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Query if a classical register is less than or equal to another:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.less(ClassicalRegister(3, "a"), ClassicalRegister(3, "b")) Binary(Binary.Op.LESS_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3)) )r}rr; LESS_EQUALris r/rrs FI0$ > >>r1cBttjj||S)aCreate a 'greater than' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Query if a classical register is greater than an integer:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.less(ClassicalRegister(3, "c"), 5) Binary(Binary.Op.GREATER, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3)) )r}rr;GREATERris r/rrs FI-tU ; ;;r1cBttjj||S)aWCreate a 'greater than or equal to' expression node from the given value, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Query if a classical register is greater than or equal to another:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.less(ClassicalRegister(3, "a"), ClassicalRegister(3, "b")) Binary(Binary.Op.GREATER_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3)) )r}rr; GREATER_EQUALris r/rrs FI3T5 A AAr1c |&|jtjurtd|dt |t r|t ||n|}nt||}t|}|jjtjks|jjtjkr#td|d|jd|jdt||||jS)Nztype 'z&' is not a valid bitshift operand typerbrcrdr() r.rr=r-r9rr0rr rres r/ _shift_likers DIUZ77MMMMNNN$ /3/?d+++TD$ KKE y~##uz%*'D'DUbUUdiUU UUUVVV "dE49 - --r1cDttjj|||S)aMCreate a 'bitshift left' expression node from the given two values, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. If ``type`` is given, the ``left`` operand will be coerced to it (if possible). Examples: Shift the value of a standalone variable left by some amount:: >>> from qiskit.circuit.classical import expr, types >>> a = expr.Var.new("a", types.Uint(8)) >>> expr.shift_left(a, 4) Binary(Binary.Op.SHIFT_LEFT, Var(, Uint(8), name='a'), Value(4, Uint(3)), Uint(8)) Shift an integer literal by a variable amount, coercing the type of the literal:: >>> expr.shift_left(3, a, types.Uint(16)) Binary(Binary.Op.SHIFT_LEFT, Value(3, Uint(16)), Var(, Uint(8), name='a'), Uint(16)) )rrr; SHIFT_LEFTrCrDr s r/ shift_leftrs2 vy+T5$ ? ??r1cDttjj|||S)auCreate a 'bitshift right' expression node from the given values, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. If ``type`` is given, the ``left`` operand will be coerced to it (if possible). Examples: Shift the value of a classical register right by some amount:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.shift_right(ClassicalRegister(8, "a"), 4) Binary(Binary.Op.SHIFT_RIGHT, Var(ClassicalRegister(8, "a"), Uint(8)), Value(4, Uint(3)), Uint(8)) )rrr; SHIFT_RIGHTrs r/ shift_rightrs" vy,dE4 @ @@r1r@indexc"t|t|}}|jjtjus|jjtjur t d|jd|jdt ||tjS)a.Index into the ``target`` with the given integer ``index``, lifting the values into :class:`Value` nodes if required. This can be used as the target of a :class:`.Store`, if the ``target`` is itself an lvalue. Examples: Index into a classical register with a literal:: >>> from qiskit.circuit import ClassicalRegister >>> from qiskit.circuit.classical import expr >>> expr.index(ClassicalRegister(8, "a"), 3) Index(Var(ClassicalRegister(8, "a"), Uint(8)), Value(3, Uint(2)), Bool()) zinvalid types for indexing: 'rdr()rr r.rr=r-rr:)r@rs r/rrsyLL$u++EF {uz))UZ_EJ-N-NY YYEJYYYZZZ  - --r1)rrr r!r"r)r2r3r"rrp)r rErArFr"r)rNrFr r!r"r)rNrFr"r)rCrFrDrFr"rV)r^r_rCrFrDrFr"r)rCrFrDrFr"r) r^r_rCrFrDrFr rEr"r)r rErCrFrDrFr"r)r@rFrrFr"r)-__doc__ __future__r__all__typingrrrrrrrrrrr TYPE_CHECKINGqiskitr0rrrQrrr]rfrrr rqr r rxr r r}rrrrrrrrr1r/rs #"""""   $ >>>>>>>>>>>>>>>>>>'''''''' MMM H H H H>>>>>55555p$::::$<<<<&!!!!H))))";;;;&::::&;;;;&**** = = = = < < < <aaaa5555$9999$aaaa9999$????$<<<<$BBBB$ . . . .@@@@@8AAAAA(......r1