o 3Ih*@sNdZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z ddlmZdd lmZmZmZdd lmZmZmZdd lmZmZmZdd lmZe d Z eeeddZ ej!eefdde dej!eefdde dej!eefdde deeeddZ"eeeddZ#eeeddZ$eeeddZ%eeeddZ&eeedd Z'eeed!d"Z(eeed#d$Z)eeed%d&Z*eeed'd(Z+eeed)d*Z,eeed+d,Z-d-d.Z.d/d0Z/d1d2Z0e.ge/gd3ej1e<e.ge0gd3ej1e<d4e.giej1e<d5S)6a)Transforms that are always applied to quantum expressions. This module uses the kind and _constructor_postprocessor_mapping APIs to transform different combinations of Operators, Bras, and Kets into Inner/Outer/TensorProducts. These transformations are registered with the postprocessing API of core classes like `Mul` and `Pow` and are always applied to any expression involving Bras, Kets, and Operators. This API replaces the custom `__mul__` and `__pow__` methods of the quantum classes, which were found to be inconsistent. THIS IS EXPERIMENTAL. )Basic)Expr)Mul)S) Dispatcher#ambiguity_register_error_ignore_dup)debug InnerProduct)KetKindBraKind OperatorKind) OuterProductIdentityOperatorOperator)BraBaseKetBase StateBase) TensorProduct_transform_state_paircCsdS)z5Default transformer that does nothing for base types.Nabrr`/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sympy/physics/quantum/transforms.py_transform_expr7srcCs|fSNrxyrrr@r ) on_ambiguitycCs|fSrrrrrrr Er!cCstjSr)rOnerrrrr Jr!cC t||fS)z.Transform a bra*ket -> InnerProduct(bra, ket).r rrrr_transform_bra_ketN r%cCr$)z.Transform a keT*bra -> OuterProduct(ket, bra).)rrrrr_transform_ket_braSr&r'cCtd)zRaise a TypeError if a user tries to multiply two kets. Multiplication based on `*` is not a shorthand for tensor products. zEMultiplication of two kets is not allowed. Use TensorProduct instead. TypeErrorrrrr_transform_ket_ketXr+cCr()zRaise a TypeError if a user tries to multiply two bras. Multiplication based on `*` is not a shorthand for tensor products. zEMultiplication of two bras is not allowed. Use TensorProduct instead.r)rrrr_transform_bra_brabr,r-cCst|j||jfSr)r braketrrrr_transform_op_ketlr0cCst||j|jfSr)r r/r.rrrr_transform_bra_oppr1r2cC|jtkr tddS)zRaise a TypeError if a user tries to multiply TensorProduct(*kets)*ket. Multiplication based on `*` is not a shorthand for tensor products. z6Multiplication of TensorProduct(*kets)*ket is invalid.Nkindr r*rrrr_transform_tp_kett r6cC|jtkr tddS)zRaise a TypeError if a user tries to multiply ket*TensorProduct(*kets). Multiplication based on `*` is not a shorthand for tensor products. z6Multiplication of ket*TensorProduct(*kets) is invalid.Nr4rrrr_transform_ket_tpr7r9cCr3)zRaise a TypeError if a user tries to multiply TensorProduct(*bras)*bra. Multiplication based on `*` is not a shorthand for tensor products. z6Multiplication of TensorProduct(*bras)*bra is invalid.Nr5r r*rrrr_transform_tp_brar7r;cCr8)zRaise a TypeError if a user tries to multiply bra*TensorProduct(*bras). Multiplication based on `*` is not a shorthand for tensor products. z6Multiplication of bra*TensorProduct(*bras) is invalid.Nr:rrrr_transform_bra_tpr7r<cCsrtd||t|jt|jkr7|jtkr(|jtkr(tddt|j|jDStddt|j|jDfSdS)zECombine a product of tensor products if their number of args matches._transform_tp_tpcSsg|] \}}t||qSrr .0ijrrr sz$_transform_tp_tp..css|] \}}||VqdSrrr>rrr sz#_transform_tp_tp..N) rlenargsr5r r tupleziprrrrrr=s r=cCst|j|jt|j|jfS)z9Extract an inner produt from a product of outer products.)r r.r/rrrrr_transform_op_opsrHcCst|j}g}t|dkrA|d}|d}t||}|dur%||n|d|d|d||ddt|dks |rJ||dtj |ddS)aTransform a ``Mul`` of quantum expressions into canonical form. This function is registered ``_constructor_postprocessor_mapping`` as a transformer for ``Mul``. This means that every time a quantum expression is multiplied, this function will be called to transform it into canonical form as defined by the binary functions registered with ``_transform_state_pair``. The algorithm of this function is as follows. It walks the args of the input ``Mul`` from left to right and calls ``_transform_state_pair`` on every overlapping pair of args. Each time ``_transform_state_pair`` is called it can return a tuple of items or None. If None, the pair isn't transformed. If a tuple, then the last element of the tuple goes back into the args to be transformed again and the others are extended onto the result args list. The algorithm can be visualized in the following table: step result args ============================================================================ #0 [] [a, b, c, d, e, f] #1 [] [T(a,b), c, d, e, f] #2 [T(a,b)[:-1]] [T(a,b)[-1], c, d, e, f] #3 [T(a,b)[:-1]] [T(T(a,b)[-1], c), d, e, f] #4 [T(a,b)[:-1], T(T(a,b)[-1], c)[:-1]] [T(T(T(a,b)[-1], c)[-1], d), e, f] #5 ... One limitation of the current implementation is that we assume that only the last item of the transformed tuple goes back into the args to be transformed again. These seems to handle the cases needed for Mul. However, we may need to extend the algorithm to have the entire tuple go back into the args for further transformation. rNF)is_commutative) listrErDpoprappendinsertextendr _from_args)exprrEresultfirstsecond transformedrrr_postprocess_state_muls "      rWcCs,|\}}|jtks|jtkrtddS)zHandle bras and kets raised to powers. Under ``*`` multiplication this is invalid. Users should use a TensorProduct instead. z>A bra or ket to a power is invalid, use TensorProduct instead.N) as_base_expr5r r r*)rRbaseexprrr_postprocess_state_pows r[csh|\}td||jt|tr,jr.jr0|jtkr2fdd|jD}t|SdSdSdSdS)aHandle TensorProduct(*operators)**(positive integer). This handles a tensor product of operators, to an integer power. The power here is interpreted as regular multiplication, not tensor product exponentiation. The form of exponentiation performed here leaves the space and dimension of the object the same. This operation does not make sense for tensor product's of states. z_postprocess_tp_pow: csg|]}|qSrr)r?rrZrrrBsz'_postprocess_tp_pow..N) rXrrE isinstancer is_integer is_positiver5r )rRrYnew_argsrr\r_postprocess_tp_pows  ra)rPowrN)2__doc__sympy.core.basicrsympy.core.exprrsympy.core.mulrsympy.core.singletonr!sympy.multipledispatch.dispatcherrrsympy.utilities.miscr"sympy.physics.quantum.innerproductr sympy.physics.quantum.kindr r r sympy.physics.quantum.operatorrrrsympy.physics.quantum.staterrr#sympy.physics.quantum.tensorproductrrregisterraddr%r'r+r-r0r2r6r9r;r<r=rHrWr[ra"_constructor_postprocessor_mappingrrrrs                          ?