g3dZddlmZgdZddlZddlZddlZddlZddlm Z ej rddl Z ej dd Z Gd d ejZejGd d eZejGddeZejGddeZejGddeZejGddeZejGddeZdS)zExpression-tree nodes.) annotations)ExprVarValueCastUnaryBinaryN)types_T_coT) covariantcJeZdZUdZdZded<ejdZd d Z d S) raRoot base class of all nodes in the expression tree. The base case should never be instantiated directly. This must not be subclassed by users; subclasses form the internal data of the representation of expressions, and it does not make sense to add more outside of Qiskit library code. All subclasses are responsible for setting their ``type`` attribute in their ``__init__``, and should not call the parent initializer.)type types.TypercdSNselfs X/granary/edev/quantum/lib/python3.11/site-packages/qiskit/circuit/classical/expr/expr.py__init__z Expr.__init__?s visitor0qiskit.circuit.classical.expr.ExprVisitor[_T_co]returnr c,||S)aCall the relevant ``visit_*`` method on the given :class:`ExprVisitor`. The usual entry point for a simple visitor is to construct it, and then call :meth:`accept` on the root object to be visited. For example:: expr = ... visitor = MyVisitor() visitor.accept(expr) Subclasses of :class:`Expr` should override this to call the correct virtual method on the visitor. This implements double dispatch with the visitor.) visit_genericrrs racceptz Expr.acceptCs$$T***rN)rrrr ) __name__ __module__ __qualname____doc__ __slots____annotations__abcabstractmethodrrrrrrr0sf//I     + + + + + +rrc2eZdZdZdZddd Zd Zd Zd ZdS)rz`A cast from one type to another, implied by the use of an expression in a different context.)operandimplicitFr)rrrr*boolc0||_||_||_dSr)rr)r*)rr)rr*s rrz Cast.__init__Zs    rc,||Sr) visit_castrs rrz Cast.accept_s!!$'''rct|to/|j|jko|j|jko|j|jkSr) isinstancerrr)r*rothers r__eq__z Cast.__eq__bsI ud # # 0 UZ' 0  - 0 /  rc8d|jd|jd|jdS)NzCast(, z , implicit=))r)rr*rs r__repr__z Cast.__repr__js)Mt|MMtyMMT]MMMMrN)F)r)rrrr*r+ r r!r"r#r$rrr3r7rrrrrSsp(I!!!!! (((   NNNNNrrceZdZUdZdZded< ded< dddfd ZeddZe ddZ dZ dZ dZ dZdZdZfdZdZdZxZS)raA classical variable. These variables take two forms: a new-style variable that owns its storage location and has an associated name; and an old-style variable that wraps a :class:`.Clbit` or :class:`.ClassicalRegister` instance that is owned by some containing circuit. In general, construction of variables for use in programs should use :meth:`Var.new` or :meth:`.QuantumCircuit.add_var`. Variables are immutable after construction, so they can be used as dictionary keys.)varnameCqiskit.circuit.Clbit | qiskit.circuit.ClassicalRegister | uuid.UUIDr: str | Noner;Nr;rrctd|td|td|dSNrr:r;super __setattr__)rr:rr; __class__s rrz Var.__init__sY FD))) E3''' FD)))))rstrr typing.Selfc@|tj||S)z@Generate a new named variable that owns its own backing storage.r>)uuiduuid4)clsr;rs rnewzVar.news!s4:<<D1111rr+c@t|jtjS)zWhether this :class:`Var` is a standalone variable that owns its storage location. If false, this is a wrapper :class:`Var` around a pre-existing circuit object.)r0r:rHUUIDrs r standalonezVar.standalones$(DI...rc,||Sr) visit_varrs rrz Var.accepts  &&&rcnt||rtd|dtd|d)Nz'Var' object attribute 'z' is read-onlyz'Var' object has no attribute '')hasattrAttributeError)rkeyvalues rrCzVar.__setattr__sI 4   Q !OC!O!O!OPP PEsEEEFFFrcDt|j|j|jfSr)hashrr:r;rs r__hash__z Var.__hash__sTY$)4555rct|to/|j|jko|j|jko|j|jkSr)r0rrr:r;r1s rr3z Var.__eq__sI uc " " ( UZ' (EI% ( UZ'  rcl|jd|jd|jdSd|jd|jd|jdS)NzVar(r5r6z, name='z'))r;r:rrs rr7z Var.__repr__sN 9 2$(22di222 2BdhBB$)BBTYBBBBrc*|j|j|jfSr)r:rr;rs r __getstate__zVar.__getstate__s$)TY//rc|\}}}td|td|td|dSr@rA)rstater:rr;rDs r __setstate__zVar.__setstate__sbT4 FD))) E3''' FD)))))rc|Srrrs r__copy__z Var.__copy__ rc|Srr)rmemos r __deepcopy__zVar.__deepcopy__rcr)r:r<rrr;r=)r;rErrrrF)rr+)r r!r"r#r$r%r classmethodrKpropertyrNrrCrYr3r7r]r`rbrf __classcell__rDs@rrrns\[[ ILLLL  * * * * * * * *222[2///X/ '''GGG 666   CCC 000***** rrc0eZdZdZdZd dZdZd Zd Zd S) rzA single scalar value.)rVrV typing.Anyrrc"||_||_dSr)rrV)rrVrs rrzValue.__init__s  rc,||Sr) visit_valuers rrz Value.accept""4(((rclt|to|j|jko|j|jkSr)r0rrrVr1s rr3z Value.__eq__s0%''aDI,Ca V[VaHaarc(d|jd|jdS)NzValue(r5r6)rVrrs rr7zValue.__repr__s2 22di2222rN)rVrlrrr8rrrrrsc  I)))bbb33333rrcVeZdZdZdZGddejZdd Zd Z d Z dZ dS)rzA unary expression. Args: op: The opcode describing which operation is being done. operand: The operand of the operation. type: The resolved type of the result. )opr)c8eZdZdZdZ dZ fdZfdZxZS)Unary.OpaVEnumeration of the opcodes for unary operations. The bitwise negation :data:`BIT_NOT` takes a single bit or an unsigned integer of known width, and returns a value of the same type. The logical negation :data:`LOGIC_NOT` takes an input that is implicitly coerced to a Boolean, and returns a Boolean. r cJdtSNzUnary.rB__str__rrDs rr{zUnary.Op.__str__s/EGGOO--// /rcJdtSryrBr7r|s rr7zUnary.Op.__repr__s!0EGG,,..00 0r) r r!r"r#BIT_NOT LOGIC_NOTr{r7rirjs@rOprvsm  - - 0 0 0 0 0 1 1 1 1 1 1 1 1 1rrrtrvr)rrrc0||_||_||_dSrrtr)r)rrtr)rs rrzUnary.__init__s  rc,||Sr) visit_unaryrs rrz Unary.acceptrprct|to-|j|jko|j|juo|j|jkSr)r0rrrtr)r1s rr3z Unary.__eq__sI ue $ $ . UZ' .58# .  -  rc8d|jd|jd|jdS)NzUnary(r5r6rrs rr7zUnary.__repr__s)???4<??49????rN)rtrvr)rrr r r!r"r#r$enumEnumrrrr3r7rrrrrs"I11111TY1110 )))   @@@@@rrcVeZdZdZdZGddejZdd Zd Z dZ dZ dS)r zA binary expression. Args: op: The opcode describing which operation is being done. left: The left-hand operand. right: The right-hand operand. type: The resolved type of the result. )rtleftrightczeZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z dZ fdZfdZxZS) Binary.OpamEnumeration of the opcodes for binary operations. The bitwise operations :data:`BIT_AND`, :data:`BIT_OR` and :data:`BIT_XOR` apply to two operands of the same type, which must be a single bit or an unsigned integer of fixed width. The resultant type is the same as the two input types. The logical operations :data:`LOGIC_AND` and :data:`LOGIC_OR` first implicitly coerce their arguments to Booleans, and then apply the logical operation. The resultant type is always Boolean. The binary mathematical relations :data:`EQUAL`, :data:`NOT_EQUAL`, :data:`LESS`, :data:`LESS_EQUAL`, :data:`GREATER` and :data:`GREATER_EQUAL` take unsigned integers (with an implicit cast to make them the same width), and return a Boolean. The bitshift operations :data:`SHIFT_LEFT` and :data:`SHIFT_RIGHT` can take bit-like container types (e.g. unsigned integers) as the left operand, and any integer type as the right-hand operand. In all cases, the output bit width is the same as the input, and zeros fill in the "exposed" spaces. rwr  cJdtSNzBinary.rzr|s rr{zBinary.Op.__str__Ts0UWW__..00 0rcJdtSrr~r|s rr7zBinary.Op.__repr__Ws!1UWW--//11 1r)r r!r"r#BIT_ANDBIT_ORBIT_XOR LOGIC_ANDLOGIC_OREQUAL NOT_EQUALLESS LESS_EQUALGREATER GREATER_EQUAL SHIFT_LEFT SHIFT_RIGHTr{r7rirjs@rrr!s  .+*4 ,+/ 1/ ;2 ? A B 1 1 1 1 1 2 2 2 2 2 2 2 2 2rrrtrrrrrrc>||_||_||_||_dSrrtrrr)rrtrrrs rrzBinary.__init__Zs"   rc,||Sr) visit_binaryrs rrz Binary.accept`s##D)))rct|to=|j|jko-|j|juo|j|jko|j|jkSr)r0r rrtrrr1s rr3z Binary.__eq__cs\ uf % % * UZ' *58# * UZ' * ek)  rc Hd|jd|jd|jd|jd S)NzBinary(r5r6rrs rr7zBinary.__repr__ls3KKKDIKKKKtyKKKKrN)rtrrrrrrrrrrrr r s(I7272727272TY727272r ***   LLLLLrr c0eZdZdZdZd dZd Zd Zd Zd S)IndexzAn indexing expression. Args: target: The object being indexed. index: The expression doing the indexing. type: The resolved type of the result. )targetindexrrrrrc0||_||_||_dSrrrr)rrrrs rrzIndex.__init__|s   rc,||Sr) visit_indexrs rrz Index.acceptrprct|to/|j|jko|j|jko|j|jkSr)r0rrrrr1s rr3z Index.__eq__sI ue $ $ * UZ' * u|+ * ek)  rc8d|jd|jd|jdS)NzIndex(r5r6rrs rr7zIndex.__repr__s)A AAtzAATYAAAArN)rrrrrrr8rrrrrpsk$I )))   BBBBBrr)r# __future__r__all__r&rtypingrHr TYPE_CHECKINGqiskitTypeVarr ABCrfinalrrrrr rrrrrsR#"""""     MMM w$/// + + + + +37 + + +FNNNNN4NNN4VVVVV$VVVr33333D333&4@4@4@4@4@D4@4@4@nXLXLXLXLXLTXLXLXLvBBBBBDBBBBBr