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, lambda: 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_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)')
def integrate_result(orig_expr, result, **options): """ Returns the result of integrating over any unities ``(|x><x|)`` in the given expression. Intended for integrating over the result of representations in continuous bases. This function integrates over any unities that may have been inserted into the quantum expression and returns the result. It uses the interval of the Hilbert space of the basis state passed to it in order to figure out the limits of integration. The unities option must be specified for this to work. Note: This is mostly used internally by represent(). Examples are given merely to show the use cases. Parameters ========== orig_expr : quantum expression The original expression which was to be represented result: Expr The resulting representation that we wish to integrate over Examples ======== >>> from sympy import symbols, DiracDelta >>> from sympy.physics.quantum.represent import integrate_result >>> from sympy.physics.quantum.cartesian import XOp, XKet >>> x_ket = XKet() >>> X_op = XOp() >>> x, x_1, x_2 = symbols('x, x_1, x_2') >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2)) x*DiracDelta(x - x_1)*DiracDelta(x_1 - x_2) >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2), ... unities=[1]) x*DiracDelta(x - x_2) """ if not isinstance(result, Expr): return result options['replace_none'] = True if not "basis" in options: arg = orig_expr.args[-1] options["basis"] = get_basis(arg, **options) elif not isinstance(options["basis"], StateBase): options["basis"] = get_basis(orig_expr, **options) basis = options.pop("basis", None) if basis is None: return result unities = options.pop("unities", []) if len(unities) == 0: return result kets = enumerate_states(basis, unities) coords = [k.label[0] for k in kets] for coord in coords: if coord in result.free_symbols: #TODO: Add support for sets of operators basis_op = state_to_operators(basis) start = basis_op.hilbert_space.interval.start end = basis_op.hilbert_space.interval.end result = integrate(result, (coord, start, end)) return result
def integrate_result(orig_expr, result, **options): """ Returns the result of integrating over any unities (|x><x|) in the given expression. Intended for integrating over the result of representations in continuous bases. This function integrates over any unities that may have been inserted into the quantum expression and returns the result. It uses the interval of the Hilbert space of the basis state passed to it in order to figure out the limits of integration. The unities option must be specified for this to work. Note: This is mostly used internally by represent(). Examples are given merely to show the use cases. Parameters ========== orig_expr : quantum expression The original expression which was to be represented result: Expr The resulting representation that we wish to integrate over Examples ======== >>> from sympy import symbols, DiracDelta >>> from sympy.physics.quantum.represent import integrate_result >>> from sympy.physics.quantum.cartesian import XOp, XKet >>> x_ket = XKet() >>> X_op = XOp() >>> x, x_1, x_2 = symbols('x, x_1, x_2') >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2)) x*DiracDelta(x - x_1)*DiracDelta(x_1 - x_2) >>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2), unities=[1]) x*DiracDelta(x - x_2) """ if not isinstance(result, Expr): return result options['replace_none'] = True if not "basis" in options: arg = orig_expr.args[-1] options["basis"] = get_basis(arg, **options) elif not isinstance(options["basis"], StateBase): options["basis"] = get_basis(orig_expr, **options) basis = options.pop("basis", None) if basis is None: return result unities = options.pop("unities", []) if len(unities) == 0: return result kets = enumerate_states(basis, unities) coords = [k.label[0] for k in kets] for coord in coords: if coord in result.free_symbols: #TODO: Add support for sets of operators basis_op = state_to_operators(basis) start = basis_op.hilbert_space.interval.start end = basis_op.hilbert_space.interval.end result = integrate(result, (coord, start, end)) return result
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 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_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)')