z i oSrSSKJr /SQrSSKrSSKJrJrJrJ r J r J r J r SSK JrJr SS KJ r \R"(aSSKrS)S jrS*S jrS+S,S jjrS-S jrS.SjrS.SjrS/SjrS0SjrS1SjrS1SjrS1SjrS0SjrS1SjrS1Sjr S0Sjr!S1Sjr"S1Sjr#S0Sjr$S1Sjr%S1Sjr&S1Sjr'S1Sjr(S2S jr)S+S3S!jjr*S+S3S"jjr+S4S#jr,S0S$jr-S1S%jr.S1S&jr/S1S'jr0S1S(jr1g)5zvUser-space constructor functions for the expression tree, which do some of the inference and lifting boilerplate work.) annotations)liftcastbit_not logic_notbit_andbit_orbit_xor logic_andlogic_orequal not_equalless less_equalgreater greater_equal shift_left shift_rightindexaddsubmuldivlift_legacy_conditionN)ExprVarValueUnaryBinaryCastIndex)CastKind cast_kind)typesc[URU5nU[RLaU$U[RLa [ XSS9$U[R La [ XSS9$g)z}Coerce ``expr`` to ``type`` by inserting a suitable :class:`Cast` node, if the cast is lossless. Otherwise, return ``None``.TimplicitFN)r%typer$EQUALIMPLICITr!LOSSLESS)exprr*kinds d/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/circuit/classical/expr/constructors.py_coerce_losslessr18s^ TYY %D x~~  x   D.. x   D// c\SSKJn Uup#[X!5(aU[R"5nU(a [ X$5$[ [ RR[ X$5U5$[ U[R"URS95nUR5UR:a+[U[R"UR5S9SS9n[X5R5n[[RR XV[R"55$)zJLift a legacy two-tuple equality condition into a new-style :class:`Expr`.r)ClbitwidthTr()qiskit.circuitr4 isinstancer&BoolrrOp LOGIC_NOTUintsize bit_lengthr!rr*r r+) conditionr4targetvaluebool_leftrights r0rrEs%MF&   %*s6!dehh6H6H#fJ\^c0dd vuzz 4 5D FKK'D%**5+;+;+=>N % #E &))//4 ==r2c X[U[5(aUb [S5eU$SSKJnJnJn USLdUSLd[X5(a,[R"5nUSLdUSLa[O[nO[X5(a%[R"URS9n[nO[U[5(aCUS:a [S5e[R"UR5=(d SS9n[nOl[U[5(a[R "5n[nO;[X5(a[R "5n[nO[#S US 35eUcUn[R$"X5(aU"X5$[#S US US US 35e)a Lift 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)) z3use 'cast' to cast existing expressions, not 'lift'r)r4ClassicalRegisterDurationTFr5z!cannot represent a negative valuerzfailed to infer a type for ''zthe explicit type 'z$' is not suitable for representing 'z''; it must be non-strict supertype of ')r8r ValueErrorr7r4rFrGr&r9rrr<r=intr>floatFloat TypeError is_supertype)rAr*r4rFrGinferred constructors r0rrVsi4%  RS S AA }*U*B*B::<$}eC E - -::EJJ/ E3   19@A A::E$4$4$6$;!< E5 ! !;;= E $ $>># 6ugQ?@@ | $))5''  dV#GwO008z < r2c[U5n[URU5[RLa[ SUSUS35e[ X5$)aCreate an explicit cast from the given value to the given type. Examples: Add an explicit cast node that explicitly casts a higher precision type to a lower precision one:: >>> 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) z cannot cast 'z' to 'rH)rr%r*r$NONErMr!)operandr*s r0rrsI7mGt$ 5-ytfA>??  r2cL[U5nURR[R[R 4;a4[ S[RRSURS35e[[RRXR5$)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)) cannot apply ' ' to type 'rH) rr*r/r&r9r<rMrr:BIT_NOT)rSs r0rrsq7mG||UZZ 88.)9)9(:+gll^STUVV !!7LL 99r2c [U5n[U[R"55nUc4[ S[ R RSURS35e[ [ R RXR5$)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()) rUrVrH) rr1r&r9rMrr:r;r*)rScoerced_operands r0rrsl 7mG&w =O.););(r6rMrmax)rCrDleft_int right_intuints r0_lift_binary_operandsr`s$$CZd-C)CH5#&Fz%/F+FI  DzU 4 ;3U  ::??ejj ( 5::#3#33'v-PQVPWWXYzz*D$ ;!:D ;Dz 99>>UZZ '!DIIOO3'w.QRVQWWXY%+E ; KE ;zz#doo/1A1A1CQGHT e" ;r2c [X5upURRURRs=La[RLaO O[R"5nOURR[R LaURR[R LaaURUR:wa:[ SURRSURRS35eURnO)[ SUSURSURS35e[XX#5$)Nz[binary bitwise operations are defined between unsigned integers of the same width, but got z and .invalid types for '': '' and 'rH) r`r*r/r&r9r<rMr6r oprCrDr*s r0_binary_bitwiserhs'4KD yy~~6EJJ6zz| 5:: %%**//UZZ*G 99 " IIOO,E%**2B2B1C1F yy-bTdii[ |STUVV "E ((r2cJ[[RRX5$)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)) )rhr r:BIT_ANDrCrDs r0rr 699,,d ::r2cJ[[RRX5$)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)) )rhr r:BIT_ORrks r0r r s 699++T 99r2cJ[[RRX5$)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)) )rhr r:BIT_XORrks r0r r *rlr2c [R"5n[U5n[U5n[X5n[X#5nUbUc)[ SUSUR SUR S35e[ XXS5$NrcrdrerH)r&r9rr1rMr*r )rgrCrDrB coerced_left coerced_rights r0_binary_logicalru=su JJLE :D KE#D0L$U2M}4-bTdii[ |STUVV "M 99r2cJ[[RRX5$)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()) )rur r: LOGIC_ANDrks r0r r Hs 699.. <>> 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()) )rur r:LOGIC_ORrks r0r r Ws 699--t ;;r2c [X5upURRURRLa)[SUSURSURS35e[R "URUR5n[ U[X5[X#5[R"55$rr) r`r*r/rMr&rr r1r9rfs r0 _equal_liker{fs'4KD yy~~UZZ__,-bTdii[ |STUVV ==EJJ /D "&t24DU4QSXS]S]S_ ``r2cJ[[RRX5$)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)) )r{r r:r+rks r0r r ps vyy 44r2cJ[[RRX5$)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)) )r{r r: NOT_EQUALrks r0rrs vyy**D 88r2c [X5upURRURRLd'URR[RLa)[ SUSURSURS35e[R "URUR5n[U[X5[X#5[R"55$rr) r`r*r/r&r9rMrr r1rfs r0_binary_relationrs'4KD yy~~UZZ__, %**0L-bTdii[ |STUVV ==EJJ /D "&t24DU4QSXS]S]S_ ``r2cJ[[RRX5$)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)) )rr r:LESSrks r0rrs FIINND 88r2cJ[[RRX5$)a.Create 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)) )rr r: LESS_EQUALrks r0rrs FII00$ >>r2cJ[[RRX5$)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)) )rr r:GREATERrks r0rrs FII--t ;;r2cJ[[RRX5$)a7Create 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)) )rr r: GREATER_EQUALrks r0rrs FII33T AAr2c 4Ub,UR[RLa[SUS35e[ U[ 5(a0Ub,[ X5nUc[SUSURS35eUnO [X5n[U5nURR[R:wd(URR[R:wa)[SUSURSURS35e[XX!R5$)Nztype 'z&' is not a valid bitshift operand typez' cannot losslessly represent 'rHrcrdre) r/r&r<rMr8rr1r*rr )rgrCrDr*rss r0 _shift_likers DIIUZZ7&&LMNN$  +D7L#&.Mdii[XY Z[[DD KE yy~~#uzz%**'D-bTdii[ |STUVV "E99 --r2cL[[RRXU5$)aCreate 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)) )rr r: SHIFT_LEFTrCrDr*s r0rrs2 vyy++T$ ??r2cL[[RRXU5$)aQCreate 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)) )rr r: SHIFT_RIGHTrs r0rrs" vyy,,d4 @@r2cR[U5[U5pURR[RLd'URR[RLa&[ SURSURS35e[ X[R"55$)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: 'rerH)rr*r/r&r<rMr"r9)r@rs r0rr)ssL$u+E {{uzz)UZZ__EJJ-N7 }GEJJ>> from qiskit.circuit.classical import expr >>> expr.add(5.0, 2.0) Binary(Binary.Op.ADD, Value(5.0, Float()), Value(2.0, Float()), Float()) Addition of two durations:: >>> from qiskit.circuit import Duration >>> from qiskit.circuit.classical import expr >>> expr.add(Duration.dt(1000), Duration.dt(1000)) Binary(Binary.Op.ADD, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration()) )rr r:ADDrks r0rrN4 vyy}}d 22r2cJ[[RRX5$)aCreate a subtraction expression node from the given values, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. Examples: Subtraction of two floating point numbers:: >>> from qiskit.circuit.classical import expr >>> expr.sub(5.0, 2.0) Binary(Binary.Op.SUB, Value(5.0, Float()), Value(2.0, Float()), Float()) Subtraction of two durations:: >>> from qiskit.circuit import Duration >>> from qiskit.circuit.classical import expr >>> expr.add(Duration.dt(1000), Duration.dt(1000)) Binary(Binary.Op.SUB, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration()) )rr r:SUBrks r0rrkrr2c [X5upURRURRs=La[RLaO O [ S5eURRURRLa{URR[R [R1;aC[R"URUR5n[X5n[X5nGOURR[RLaEURR[R [R1;a URnOURR[RLaEURR[R [R1;a URnOA[ S[RRSURSURS35e[[RRUUU5$)a%Create a multiplication expression node from the given values, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. This can be used to multiply numeric operands of the same type kind, or to multiply a duration operand by a numeric operand. Examples: Multiplication of two floating point numbers:: >>> from qiskit.circuit.classical import expr >>> expr.mul(5.0, 2.0) Binary(Binary.Op.MUL, Value(5.0, Float()), Value(2.0, Float()), Float()) Multiplication of a duration by a float:: >>> from qiskit.circuit import Duration >>> from qiskit.circuit.classical import expr >>> expr.mul(Duration.dt(1000), 0.5) Binary(Binary.Op.MUL, Value(Duration.dt(1000), Duration()), Value(0.5, Float()), Duration()) zcannot multiply two durationsrcrdrerH) r`r*r/r&rGrMr<rLrr1r r:MULrs r0rrsf:(4KD yy~~:ENN:788 yy~~(TYY^^ EKK?X-X}}TYY 3+ - 5>> )ejjoo%**ekkAZ.Zyy ENN *tyy~~%**ekkAZ/Zzz-fiimm_D 7SXS]S]R^^_`aa      r2c 8[X5upURRURRLGa URR[R[R [R 1;aURR[RLa[R "5nGO5[R"URUR5[RRLaA[R"URUR5n[X5n[X5nOURR[RLaEURR[R [R 1;a URnOA[S[RRSURSURS35e[[RRUUW5$)aCreate a division expression node from the given values, resolving any implicit casts and lifting the values into :class:`Value` nodes if required. This can be used to divide numeric operands of the same type kind, to divide a :class:`~.types.Duration` operand by a numeric operand, or to divide two :class:`~.types.Duration` operands which yields an expression of type :class:`~.types.Float`. Examples: Division of two floating point numbers:: >>> from qiskit.circuit.classical import expr >>> expr.div(5.0, 2.0) Binary(Binary.Op.DIV, Value(5.0, Float()), Value(2.0, Float()), Float()) Division of two durations:: >>> from qiskit.circuit import Duration >>> from qiskit.circuit.classical import expr >>> expr.div(Duration.dt(10000), Duration.dt(1000)) Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(Duration.dt(1000), Duration()), Float()) Division of a duration by a float:: >>> from qiskit.circuit import Duration >>> from qiskit.circuit.classical import expr >>> expr.div(Duration.dt(10000), 12.0) Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(12.0, types.Float()), Duration()) rcrdrerH)r`r*r/r&rGr<rLorderOrderingrRrr1rMr r:DIVrs r0rrsVV(4KD yy~~(TYY^^   @. 99>>U^^ +;;=D [[EJJ /u~~7J7J J==EJJ7D#D/D$U1E 5>> )ejjoo%**ekkAZ.Zyy-fiimm_D 7SXS]S]R^^_`aa      r2)r.rr* types.Typereturnz Expr | None)r?zCtuple[qiskit.circuit.Clbit | qiskit.circuit.ClassicalRegister, int]rr)N)r*types.Type | NonerA typing.Anyrr)rSrr*rrr)rSrrr)rCrrDrrztuple[Expr, Expr])rg Binary.OprCrrDrrr)rCrrDrrr) rgrrCrrDrr*rrr)r*rrCrrDrrr)r@rrrrr)2__doc__ __future__r__all__typingr.rrrrr r!r"r&r$r% TYPE_CHECKINGqiskitr1rrrrrr`rhrr r rur r r{r rrrrrrrrrrrrrrrr2r0rs # 4>>>'  >R> >";|$:$L.!H)";&:&;&: = <a5$9$a9$?$<$B$..#.,6.>O. .&@8A(.(S"3:3:0fAr2