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_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({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)')