simplifiez l'expression quantique avec sympy.physique.quantique
Avec python sympy:
from sympy import sqrt
from sympy.physics.quantum import Bra,Ket,qapply
superpos = (Ket('Dead')+Ket('Alive'))/sqrt(2)
d = qapply(Bra('Dead')*superpos)
Ça donne:
sqrt(2)*<Dead|Alive>/2 + sqrt(2)*<Dead|Dead>/2
Comment puis-je définir 'Dead' et 'Alive' comme des États orthogonaux, de sorte que d.doit() donne:
sqrt(2)/2
(je n'ai pu faire:
d.subs(Bra('Dead')*Ket('Dead'),1).subs(Bra('Dead')*Ket('Alive'),0)
mais je suis sûr qu'il ya une meilleure façon)
4 réponses
le problème est que InnerProduct ne sait pas comment évaluer ces valeurs et laisse donc l'expression non simplifiée à la place. En regardant l' source, je vois qu'il essaie de l'appeler _eval_innerproduct() sur le Ket, qui dit ceci.
def _eval_innerproduct(self, bra, **hints):
"""Evaluate the inner product betweeen this ket and a bra.
This is called to compute <bra|ket>, where the ket is ``self``.
This method will dispatch to sub-methods having the format::
``def _eval_innerproduct_BraClass(self, **hints):``
Subclasses should define these methods (one for each BraClass) to
teach the ket how to take inner products with bras.
"""
vous devriez donc être en mesure de résoudre votre problème en créant 2 nouveaux Bra classes et un nouveau Ket classe qui implémente 2 méthodes - une évaluation interne des produits (utilisation de la dénomination convention mandatée ci-dessus).
pour être complet vous voulez probablement aussi implémenter l'autre Ket pour votre état orthogonal et pour s'assurer que dual_class renvoie la bonne classe dans chaque cas.
Ce n'est pas exactement ce que vous cherchez, mais vous pouvez utiliser Qubit pour créer des États orthogonaux.
from sympy import sqrt
from sympy.physics.quantum import Dagger, qapply
from sympy.physics.quantum.qubit import Qubit
dead = Qubit(0)
alive = Qubit(1)
ceux-ci créent Ket(0) et Ket(1). Pour rendre le soutien-gorge, vous pouvez utiliser le Dagger fonction.
print(Dagger(dead) * dead)
<0|0>
Lorsqu'il est appliqué à votre problème:
superpos = (dead + alive) / sqrt(2)
d = qapply(Dagger(dead) * superpos)
print(d)
sqrt(2)/2
Peut-être expression.xreplace() est ce que vous recherchez? Selon ce livrexreplace fonction peut prendre un dictionnaire où sympy-les symboles ou les expressions sont des clés hachables. Ce serait encore maladroit comme ceci:
from sympy import sqrt
from sympy.physics.quantum import Bra,Ket,qapply
superpos = (Ket('Dead')+Ket('Alive'))/sqrt(2)
d = qapply(Bra('Dead')*superpos)
mySubs = {Bra('Dead')*Ket('Dead'): 1, Bra('Dead')*Ket('Alive'): 0} ##plus other bindings
d.xreplace(mySubs)
(attention: Je ne l'ai pas encore testé...)
cela vous donne au moins la possibilité de définir toutes les substitutions souhaitées en un seul endroit et de les "réutiliser" où vous le souhaitez.
Une réponse en l'espace de Fock:
>>> from sympy import sqrt
>>> from sympy.physics.quantum import Dagger,qapply
>>> from sympy.physics.quantum.boson import BosonFockKet
>>> ket_Dead = BosonFockKet(0)
>>> ket_Alive = BosonFockKet(1)
>>> superpos = (ket_Dead+ket_Alive)/sqrt(2)
>>> bra_Dead = Dagger(ket_Dead)
>>> qapply(bra_Dead*superpos).doit()
sqrt(2)/2
la même chose est-elle possible dans L'espace de Hilbert ?