def test_state_to_op():
assert state_to_operators(XKet) == XOp()
assert state_to_operators(PxKet) == PxOp()
assert state_to_operators(XBra) == XOp()
assert state_to_operators(PxBra) == PxOp()
assert state_to_operators(Ket) == Operator()
assert state_to_operators(Bra) == Operator()
assert state_to_operators(JxKet) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra) == set([J2Op(), JzOp()])
assert state_to_operators(JxKet()) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet()) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet()) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra()) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra()) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra()) == set([J2Op(), JzOp()])
assert operators_to_state(state_to_operators(XKet("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XBra("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XKet())) == XKet()
assert operators_to_state(state_to_operators(XBra())) == XKet()
raises(NotImplementedError, 'state_to_operators(XOp)')
def test_op_to_state():
assert operators_to_state(XOp) == XKet()
assert operators_to_state(PxOp) == PxKet()
assert operators_to_state(Operator) == Ket()
assert state_to_operators(operators_to_state(XOp("Q"))) == XOp("Q")
assert state_to_operators(operators_to_state(XOp())) == XOp()
raises(NotImplementedError, 'operators_to_state(XKet)')
def test_op_to_state():
assert operators_to_state(XOp) == XKet()
assert operators_to_state(PxOp) == PxKet()
assert operators_to_state(Operator) == Ket()
assert state_to_operators(operators_to_state(XOp("Q"))) == XOp("Q")
assert state_to_operators(operators_to_state(XOp())) == XOp()
raises(NotImplementedError, 'operators_to_state(XKet)')
def test_state_to_op():
assert state_to_operators(XKet) == XOp()
assert state_to_operators(PxKet) == PxOp()
assert state_to_operators(XBra) == XOp()
assert state_to_operators(PxBra) == PxOp()
assert state_to_operators(Ket) == Operator()
assert state_to_operators(Bra) == Operator()
assert operators_to_state(state_to_operators(XKet("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XBra("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XKet())) == XKet()
assert operators_to_state(state_to_operators(XBra())) == XKet()
raises(NotImplementedError, 'state_to_operators(XOp)')
def test_state_to_op():
assert state_to_operators(XKet) == XOp()
assert state_to_operators(PxKet) == PxOp()
assert state_to_operators(XBra) == XOp()
assert state_to_operators(PxBra) == PxOp()
assert state_to_operators(Ket) == Operator()
assert state_to_operators(Bra) == Operator()
assert operators_to_state(state_to_operators(XKet("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XBra("test"))) == XKet("test")
assert operators_to_state(state_to_operators(XKet())) == XKet()
assert operators_to_state(state_to_operators(XBra())) == XKet()
raises(NotImplementedError, lambda: state_to_operators(XOp))
def test_spin():
assert operators_to_state(set([J2Op, JxOp])) == JxKet
assert operators_to_state(set([J2Op, JyOp])) == JyKet
assert operators_to_state(set([J2Op, JzOp])) == JzKet
#FIXME ajgpitch 22 Sept 2019:
# JxKet() etc seems to require positional arguments: 'j' and 'm'
# So these tests cannot work
# Probably easy to work out what 'j' and 'm' should be from the physics
assert operators_to_state(set([J2Op(), JxOp()])) == JxKet()
assert operators_to_state(set([J2Op(), JyOp()])) == JyKet()
assert operators_to_state(set([J2Op(), JzOp()])) == JzKet()
assert state_to_operators(JxKet) == set([J2Op, JxOp])
assert state_to_operators(JyKet) == set([J2Op, JyOp])
assert state_to_operators(JzKet) == set([J2Op, JzOp])
assert state_to_operators(JxBra) == set([J2Op, JxOp])
assert state_to_operators(JyBra) == set([J2Op, JyOp])
assert state_to_operators(JzBra) == set([J2Op, JzOp])
#FIXME ajgpitch 22 Sept 2019:
# JxKet() etc seems to require positional arguments: 'j' and 'm'
# So these tests cannot work
# Probably easy to work out what 'j' and 'm' should be from the physics
assert state_to_operators(JxKet()) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet()) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet()) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra()) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra()) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra()) == set([J2Op(), JzOp()])
def test_spin():
assert operators_to_state(set([J2Op, JxOp])) == JxKet()
assert operators_to_state(set([J2Op, JyOp])) == JyKet()
assert operators_to_state(set([J2Op, JzOp])) == JzKet()
assert operators_to_state(set([J2Op(), JxOp()])) == JxKet()
assert operators_to_state(set([J2Op(), JyOp()])) == JyKet()
assert operators_to_state(set([J2Op(), JzOp()])) == JzKet()
assert state_to_operators(JxKet) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra) == set([J2Op(), JzOp()])
assert state_to_operators(JxKet()) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet()) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet()) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra()) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra()) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra()) == set([J2Op(), JzOp()])
def test_spin():
assert operators_to_state({J2Op, JxOp}) == JxKet
assert operators_to_state({J2Op, JyOp}) == JyKet
assert operators_to_state({J2Op, JzOp}) == JzKet
assert operators_to_state({J2Op(), JxOp()}) == JxKet
assert operators_to_state({J2Op(), JyOp()}) == JyKet
assert operators_to_state({J2Op(), JzOp()}) == JzKet
assert state_to_operators(JxKet) == {J2Op, JxOp}
assert state_to_operators(JyKet) == {J2Op, JyOp}
assert state_to_operators(JzKet) == {J2Op, JzOp}
assert state_to_operators(JxBra) == {J2Op, JxOp}
assert state_to_operators(JyBra) == {J2Op, JyOp}
assert state_to_operators(JzBra) == {J2Op, JzOp}
assert state_to_operators(JxKet(S.Half, S.Half)) == {J2Op(), JxOp()}
assert state_to_operators(JyKet(S.Half, S.Half)) == {J2Op(), JyOp()}
assert state_to_operators(JzKet(S.Half, S.Half)) == {J2Op(), JzOp()}
assert state_to_operators(JxBra(S.Half, S.Half)) == {J2Op(), JxOp()}
assert state_to_operators(JyBra(S.Half, S.Half)) == {J2Op(), JyOp()}
assert state_to_operators(JzBra(S.Half, S.Half)) == {J2Op(), JzOp()}
def test_spin():
assert operators_to_state(set([J2Op, JxOp])) == JxKet()
assert operators_to_state(set([J2Op, JyOp])) == JyKet()
assert operators_to_state(set([J2Op, JzOp])) == JzKet()
assert operators_to_state(set([J2Op(), JxOp()])) == JxKet()
assert operators_to_state(set([J2Op(), JyOp()])) == JyKet()
assert operators_to_state(set([J2Op(), JzOp()])) == JzKet()
assert state_to_operators(JxKet) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra) == set([J2Op(), JzOp()])
assert state_to_operators(JxKet()) == set([J2Op(), JxOp()])
assert state_to_operators(JyKet()) == set([J2Op(), JyOp()])
assert state_to_operators(JzKet()) == set([J2Op(), JzOp()])
assert state_to_operators(JxBra()) == set([J2Op(), JxOp()])
assert state_to_operators(JyBra()) == set([J2Op(), JyOp()])
assert state_to_operators(JzBra()) == set([J2Op(), JzOp()])
def test_spin():
assert operators_to_state({J2Op, JxOp}) == JxKet()
assert operators_to_state({J2Op, JyOp}) == JyKet()
assert operators_to_state({J2Op, JzOp}) == JzKet()
assert operators_to_state({J2Op(), JxOp()}) == JxKet()
assert operators_to_state({J2Op(), JyOp()}) == JyKet()
assert operators_to_state({J2Op(), JzOp()}) == JzKet()
assert state_to_operators(JxKet) == {J2Op(), JxOp()}
assert state_to_operators(JyKet) == {J2Op(), JyOp()}
assert state_to_operators(JzKet) == {J2Op(), JzOp()}
assert state_to_operators(JxBra) == {J2Op(), JxOp()}
assert state_to_operators(JyBra) == {J2Op(), JyOp()}
assert state_to_operators(JzBra) == {J2Op(), JzOp()}
assert state_to_operators(JxKet()) == {J2Op(), JxOp()}
assert state_to_operators(JyKet()) == {J2Op(), JyOp()}
assert state_to_operators(JzKet()) == {J2Op(), JzOp()}
assert state_to_operators(JxBra()) == {J2Op(), JxOp()}
assert state_to_operators(JyBra()) == {J2Op(), JyOp()}
assert state_to_operators(JzBra()) == {J2Op(), JzOp()}
def get_basis(expr, **options):
"""
Returns a basis state instance corresponding to the basis specified in
options=s. If no basis is specified, the function tries to form a default
basis state of the given expression.
There are three behaviors:
1. The basis specified in options is already an instance of StateBase. If
this is the case, it is simply returned. If the class is specified but
not an instance, a default instance is returned.
2. The basis specified is an operator or set of operators. If this
is the case, the operator_to_state mapping method is used.
3. No basis is specified. If expr is a state, then a default instance of
its class is returned. If expr is an operator, then it is mapped to the
corresponding state. If it is neither, then we cannot obtain the basis
state.
If the basis cannot be mapped, then it is not changed.
This will be called from within represent, and represent will
only pass QExpr's.
TODO (?): Support for Muls and other types of expressions?
Parameters
==========
expr : Operator or StateBase
Expression whose basis is sought
Examples
========
>>> from sympy.physics.quantum.represent import get_basis
>>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
>>> x = XKet()
>>> X = XOp()
>>> get_basis(x)
|x>
>>> get_basis(X)
|x>
>>> get_basis(x, basis=PxOp())
|px>
>>> get_basis(x, basis=PxKet)
|px>
"""
basis = options.pop("basis", None)
replace_none = options.pop("replace_none", True)
if basis is None and not replace_none:
return None
if basis is None:
if isinstance(expr, KetBase):
return _make_default(expr.__class__)
elif isinstance(expr, BraBase):
return _make_default((expr.dual_class()))
elif isinstance(expr, Operator):
state_inst = operators_to_state(expr)
return (state_inst if state_inst is not None else None)
else:
return None
elif (isinstance(basis, Operator) or
(not isinstance(basis, StateBase) and issubclass(basis, Operator))):
state = operators_to_state(basis)
if state is None:
return None
elif isinstance(state, StateBase):
return state
else:
return _make_default(state)
elif isinstance(basis, StateBase):
return basis
elif issubclass(basis, StateBase):
return _make_default(basis)
else:
return None
def get_basis(expr, **options):
"""
Returns a basis state instance corresponding to the basis
specified in options=s. If no basis is specified, the function
tries to form a default basis state of the given expression.
There are three behaviors:
1) The basis specified in options is already an instance of
StateBase. If this is the case, it is simply returned. If the
class is specified but not an instance, a default instance is returned.
2) The basis specified is an operator or set of operators. If this
is the case, the operator_to_state mapping method is used.
3) No basis is specified. If expr is a state, then a default
instance of its class is returned.
If expr is an operator, then it is mapped to the corresponding state.
If it is neither, then we cannot obtain the basis state.
If the basis cannot be mapped, then it is not changed.
This will be called from within represent, and represent will
only pass QExpr's.
TODO (?): Support for Muls and other types of expressions?
Parameters
==========
expr : Operator or StateBase
Expression whose basis is sought
Examples
========
>>> from sympy.physics.quantum.represent import get_basis
>>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
>>> x = XKet()
>>> X = XOp()
>>> get_basis(x)
|x>
>>> get_basis(X)
|x>
>>> get_basis(x, basis=PxOp())
|px>
>>> get_basis(x, basis=PxKet)
|px>
"""
basis = options.pop("basis", None)
replace_none = options.pop("replace_none", True)
if basis is None and not replace_none:
return None
if basis is None:
if isinstance(expr, KetBase):
return _make_default(expr.__class__)
elif isinstance(expr, BraBase):
return _make_default((expr.dual_class()))
elif isinstance(expr, Operator):
state_inst = operators_to_state(expr)
return (state_inst if state_inst is not None else None)
else:
return None
elif (isinstance(basis, Operator) or \
(not isinstance(basis, StateBase) and issubclass(basis, Operator))):
state = operators_to_state(basis)
if state is None:
return None
elif isinstance(state, StateBase):
return state
else:
return _make_default(state)
elif isinstance(basis, StateBase):
return basis
elif issubclass(basis, StateBase):
return _make_default(basis)
else:
return None
def test_operator_represent():
basis_kets = enumerate_states(operators_to_state(x_op), 1, 2)
assert rep_expectation(x_op) == qapply(basis_kets[1].dual * x_op *
basis_kets[0])
def test_operator_represent():
basis_kets = enumerate_states(operators_to_state(x_op), 1, 2)
assert rep_expectation(x_op) == qapply(basis_kets[1].dual*x_op*basis_kets[0])
from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet from sympy.physics.quantum.operatorset import operators_to_state from sympy.physics.quantum.represent import rep_expectation from sympy.physics.quantum.operator import Operator operators_to_state(XOp) #|x> operators_to_state(XOp()) #|x> operators_to_state(PxOp) #|px> operators_to_state(PxOp()) #|px> operators_to_state(Operator) #|psi> operators_to_state(Operator()) #|psi> rep_expectation(XOp()) #x_1*DiracDelta(x_1 - x_2) rep_expectation(XOp(), basis=PxOp()) #<px_2|*X*|px_1> rep_expectation(XOp(), basis=PxKet()) #<px_2|*X*|px_1>
def test_op_to_state():
assert operators_to_state(XOp) == XKet()
assert operators_to_state(PxOp) == PxKet()
assert operators_to_state(Operator) == Ket()
assert operators_to_state(set([J2Op, JxOp])) == JxKet()
assert operators_to_state(set([J2Op, JyOp])) == JyKet()
assert operators_to_state(set([J2Op, JzOp])) == JzKet()
assert operators_to_state(set([J2Op(), JxOp()])) == JxKet()
assert operators_to_state(set([J2Op(), JyOp()])) == JyKet()
assert operators_to_state(set([J2Op(), JzOp()])) == JzKet()
assert state_to_operators(operators_to_state(XOp("Q"))) == XOp("Q")
assert state_to_operators(operators_to_state(XOp())) == XOp()
raises(NotImplementedError, 'operators_to_state(XKet)')