z iM5 SrSSKJr /SQrSSKrSSKJr \R"SSS 9r"S S \R\5r "S S \ \R\R5r "SS\ \R\R\R\R45r\ "5r\"5rSSjrSSjr"SS\ \5rSSSjjr"SS\ \5r\"5rSSjrg)zExpression visitors.) annotations) ExprVisitor iter_varsiter_identifiersstructurally_equivalent is_lvalueN)expr_T_coT) covariantcl\rSrSrSrSrS SjrSSjrSSjrSSjr SSjr SS jr SS jr SS jr Srg )r zBase class for visitors to the :class:`Expr` tree. Subclasses should override whichever of the ``visit_*`` methods that they are able to handle, and should be organized such that non-existent methods will never be called.c$[SUSU35e)Nzexpression visitor z has no method to handle expr ) RuntimeErrorselfnodes `/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/circuit/classical/expr/visitors.py visit_genericExprVisitor.visit_generic*s06TUYTZ[\\c$URU5$Nrrs r visit_varExprVisitor.visit_var-!!$''rc$URU5$rrrs r visit_stretchExprVisitor.visit_stretch0rrc$URU5$rrrs r visit_valueExprVisitor.visit_value3rrc$URU5$rrrs r visit_unaryExprVisitor.visit_unary6rrc$URU5$rrrs r visit_binaryExprVisitor.visit_binary9rrc$URU5$rrrs r visit_castExprVisitor.visit_cast<rrc$URU5$rrrs r visit_indexExprVisitor.visit_index?rrN)r expr.Exprreturnr )rzexpr.Varr2r )rz expr.Stretchr2r )rz expr.Valuer2r )rz expr.Unaryr2r )rz expr.Binaryr2r )rz expr.Castr2r )rz expr.Indexr2r )__name__ __module__ __qualname____firstlineno____doc__ __slots__rrr r#r&r)r,r/__static_attributes__rrrrr s72I](((((((rrcB\rSrSrSrSrSrSrSrSr Sr S r Sr g ) _VarWalkerImplCrc## Uv g7frrrs rr_VarWalkerImpl.visit_varJ  c#$# SShvN gN7fNrrrs rr _VarWalkerImpl.visit_stretchM  c#$# SShvN gN7frBrrs rr#_VarWalkerImpl.visit_valueQrDrEc#V# URRU5ShvN gN7froperandacceptrs rr&_VarWalkerImpl.visit_unaryU<<&&t,,, )')c## URRU5ShvN URRU5ShvN gN(N7frleftrKrightrs rr)_VarWalkerImpl.visit_binaryX=99##D)))::$$T*** **!AA "AA A Ac#V# URRU5ShvN gN7frrIrs rr,_VarWalkerImpl.visit_cast\rMrNc## URRU5ShvN URRU5ShvN gN(N7frtargetrKindexrs rr/_VarWalkerImpl.visit_index_=;;%%d+++::$$T*** ,*rUN r3r4r5r6r8rr r#r&r)r,r/r9rrrr;r;Cs, I-+-+rr;cB\rSrSrSrSrSrSrSrSr Sr S r Sr g ) _IdentWalkerImpldrc## Uv g7frrrs rr_IdentWalkerImpl.visit_vargr?r@c## Uv g7frrrs rr _IdentWalkerImpl.visit_stretchjr?r@c#$# SShvN gN7frBrrs rr#_IdentWalkerImpl.visit_valuems  rEc#V# URRU5ShvN gN7frrIrs rr&_IdentWalkerImpl.visit_unaryprMrNc## URRU5ShvN URRU5ShvN gN(N7frrPrs rr)_IdentWalkerImpl.visit_binarysrTrUc#V# URRU5ShvN gN7frrIrs rr,_IdentWalkerImpl.visit_castwrMrNc## URRU5ShvN URRU5ShvN gN(N7frrYrs rr/_IdentWalkerImpl.visit_indexzr]rUNr^rrrr`r`ds*I-+-+rr`c#J# UR[5ShvN gN7f)aGet an iterator over the :class:`~.expr.Var` nodes referenced at any level in the given :class:`~.expr.Expr`. Examples: Print out the name of each :class:`.ClassicalRegister` encountered:: from qiskit.circuit import ClassicalRegister from qiskit.circuit.classical import expr cr1 = ClassicalRegister(3, "a") cr2 = ClassicalRegister(3, "b") for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)): if isinstance(node.var, ClassicalRegister): print(node.var.name) .. seealso:: :func:`iter_identifiers` Get an iterator over all identifier nodes in the expression, including both :class:`~.expr.Var` and :class:`~.expr.Stretch` nodes. N)rK _VAR_WALKERrs rrrs,{{;''' #!#c#J# UR[5ShvN gN7f)aGet an iterator over the :class:`~.expr.Var` and :class:`~.expr.Stretch` nodes referenced at any level in the given :class:`~.expr.Expr`. Examples: Print out the name of each :class:`.ClassicalRegister` encountered:: from qiskit.circuit import ClassicalRegister from qiskit.circuit.classical import expr cr1 = ClassicalRegister(3, "a") cr2 = ClassicalRegister(3, "b") for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)): if isinstance(node.var, ClassicalRegister): print(node.var.name) .. seealso:: :func:`iter_vars` Get an iterator over just the :class:`~.expr.Var` nodes in the expression. N)rK _IDENT_WALKERrrs rrrs*{{=)))rscL\rSrSrSrS SjrSrSrSrSr Sr S r S r S r g )_StructuralEquivalenceImplself_key other_keyotherc(X lX0lXlgrry)rr|rzr{s r__init__#_StructuralEquivalenceImpl.__init__s " rcURRURLd$URRUR:wagURbURUR5=nc URnUR b(UR URR5=ncURRnX#:H$NF)r| __class__typerzvarr{)rrself_var other_vars rr$_StructuralEquivalenceImpl.visit_vars ::  t~~ 5DII9U == txx1H%HX$QxxH >> !4>>$**..3Q&Qi%Z I$$rcURRURLagURURR:H$r)r|rrrs rr (_StructuralEquivalenceImpl.visit_stretchs2 ::  t~~ 5xx4::>>))rcURURRL=(aM URURR:H=(a# URURR:H$r)rr|rvaluers rr#&_StructuralEquivalenceImpl.visit_valuesQ NNdjj22 2 / TZZ__, / djj... rcDURRURLdGURRURLd$URRUR:wagURRUlURR U5$r)r|roprrJrKrs rr&&_StructuralEquivalenceImpl.visit_unarysi JJ  6zz}}DGG+zz$))+ZZ'' ||""4((rcURRURLdGURRURLd$URRUR:wagURnURUlURR U5(dgUR UlUR R U5$r)r|rrrrQrKrRrrr|s rr)'_StructuralEquivalenceImpl.visit_binarys JJ  6zz}}DGG+zz$))+ ZZ yy%%[[ zz  &&rcURRURLd$URRUR:wagURRUlURR U5$r)r|rrrJrKrs rr,%_StructuralEquivalenceImpl.visit_castsT ::  t~~ 5DII9UZZ'' ||""4((rcfURRURLd$URRUR:wagURnURUlURR U5(dgUR UlUR R U5$r)r|rrrZrKr[rs rr/&_StructuralEquivalenceImpl.visit_indexsz ::  t~~ 5DII9U \\ {{!!$''[[ zz  &&r)r|r{rzN)r|r1)r3r4r5r6r8r~rr r#r&r)r,r/r9rrrrwrws1I  %*  ) ') 'rrwc8UR[XU55$)aDo these two expressions have exactly the same tree structure, up to some key function for the :class:`~.expr.Var` objects? In other words, are these two expressions the exact same trees, except we compare the :attr:`.Var.var` fields by calling the appropriate ``*_var_key`` function on them, and comparing that output for equality. This function does not allow any semantic "equivalences" such as asserting that ``a == b`` is equivalent to ``b == a``; the evaluation order of the operands could, in general, cause such a statement to be false (consider hypothetical ``extern`` functions that access global state). There's no requirements on the key functions, except that their outputs should have general ``__eq__`` methods. If a key function returns ``None``, the variable will be used verbatim instead. Args: left: one of the :class:`~.expr.Expr` nodes. right: the other :class:`~.expr.Expr` node. left_var_key: a callable whose output should be used when comparing :attr:`.Var.var` attributes. If this argument is ``None`` or its output is ``None`` for a given variable in ``left``, the variable will be used verbatim. right_var_key: same as ``left_var_key``, but used on the variables in ``right`` instead. Examples: Comparing two expressions for structural equivalence, with no remapping of the variables. These are different because the different :class:`.Clbit` instances compare differently:: >>> from qiskit.circuit import Clbit >>> from qiskit.circuit.classical import expr >>> left_bits = [Clbit(), Clbit()] >>> right_bits = [Clbit(), Clbit()] >>> left = expr.logic_and(expr.logic_not(left_bits[0]), left_bits[1]) >>> right = expr.logic_and(expr.logic_not(right_bits[0]), right_bits[1]) >>> expr.structurally_equivalent(left, right) False Comparing the same two expressions, but this time using mapping functions that associate the bits with simple indices:: >>> left_key = {var: i for i, var in enumerate(left_bits)}.get >>> right_key = {var: i for i, var in enumerate(right_bits)}.get >>> expr.structurally_equivalent(left, right, left_key, right_key) True )rKrw)rQrR left_var_key right_var_keys rrrsb ;;1%}U VVrcB\rSrSrSrSrSrSrSrSr Sr S r Sr g ) _IsLValueImpli9rcg)NTrrs rr_IsLValueImpl.visit_var<srcgrrrs rr _IsLValueImpl.visit_stretch?rcgrrrs rr#_IsLValueImpl.visit_valueBrrcgrrrs rr&_IsLValueImpl.visit_unaryErrcgrrrs rr)_IsLValueImpl.visit_binaryHrrcgrrrs rr,_IsLValueImpl.visit_castKrrc8URRU5$r)rZrKrs rr/_IsLValueImpl.visit_indexNs{{!!$''rNr^rrrrr9s*I(rrc,UR[5$)aBReturn whether this expression can be used in l-value positions, that is, whether it has a well-defined location in memory, such as one that might be writeable. Being an l-value is a necessary but not sufficient for this location to be writeable; it is permissible that a larger object containing this memory location may not allow writing from the scope that attempts to write to it. This would be an access property of the containing program, however, and not an inherent property of the expression system. A constant expression is never an lvalue. Examples: Literal values are never l-values; there's no memory location associated with (for example) the constant ``1``:: >>> from qiskit.circuit.classical import expr >>> expr.is_lvalue(expr.lift(2)) False :class:`~.expr.Var` nodes are always l-values, because they always have some associated memory location:: >>> from qiskit.circuit.classical import types >>> from qiskit.circuit import Clbit >>> expr.is_lvalue(expr.Var.new("a", types.Bool())) True >>> expr.is_lvalue(expr.lift(Clbit())) True Currently there are no unary or binary operations on variables that can produce an l-value expression, but it is likely in the future that some sort of "indexing" operation will be added, which could produce l-values:: >>> a = expr.Var.new("a", types.Uint(8)) >>> b = expr.Var.new("b", types.Uint(8)) >>> expr.is_lvalue(a) and expr.is_lvalue(b) True >>> expr.is_lvalue(expr.bit_and(a, b)) False )rK _IS_LVALUErrs rrrUsP ;;z ""r)rr1r2ztyping.Iterator[expr.Var])rr1r2z5typing.Iterator[typing.Union[expr.Var, expr.Stretch]])NN) rQr1rRr1r0typing.Callable[[typing.Any], typing.Any] | Nonerrr2bool)rr1r2r)r7 __future__r__all__typingr TypeVarr GenericrIterableVarr;UnionStretchr`rqrurrrrwrrrrrrrrs&" w$/ (&..' (F+[!:;+B+{6??6<<$,,@V3W#XY+6  " (2*0N'T!2N'hFJFJ 1W 1W 1WC1WD 1W  1Wh(K%(2_ (#r