def test_j2(): j, m = symbols('j m') assert Commutator(J2, Jz).doit() == 0 assert qapply(J2 * JzKet(1, 1)) == 2 * hbar**2 * JzKet(1, 1) assert qapply(J2 * JzKet( j, m)) == j**2 * hbar**2 * JzKet(j, m) + j * hbar**2 * JzKet(j, m) assert J2.matrix_element(1, 1, 1, 1) == 2 * hbar**2
def test_entropy(): up = JzKet(S(1) / 2, S(1) / 2) down = JzKet(S(1) / 2, -S(1) / 2) d = Density((up, S(1) / 2), (down, S(1) / 2)) # test for density object ent = entropy(d) assert entropy(d) == log(2) / 2 assert d.entropy() == log(2) / 2 np = import_module('numpy', min_module_version='1.4.0') if np: #do this test only if 'numpy' is available on test machine np_mat = represent(d, format='numpy') ent = entropy(np_mat) assert isinstance(np_mat, np.matrixlib.defmatrix.matrix) assert ent.real == 0.69314718055994529 assert ent.imag == 0 scipy = import_module('scipy', __import__kwargs={'fromlist': ['sparse']}) if scipy and np: #do this test only if numpy and scipy are available mat = represent(d, format="scipy.sparse") assert isinstance(mat, scipy_sparse_matrix) assert ent.real == 0.69314718055994529 assert ent.imag == 0
def test_jx(): assert Commutator(Jx, Jz).doit() == -I * hbar * Jy assert qapply(Jx * JzKet(1, 1)) == sqrt(2) * hbar * JzKet(1, 0) / 2 assert Jx.rewrite('plusminus') == (Jminus + Jplus) / 2 assert represent(Jx, basis=Jz, j=1) == (represent(Jplus, basis=Jz, j=1) + represent(Jminus, basis=Jz, j=1)) / 2
def test_entropy(): up = JzKet(S.Half, S.Half) down = JzKet(S.Half, Rational(-1, 2)) d = Density((up, S.Half), (down, S.Half)) # test for density object ent = entropy(d) assert entropy(d) == log(2) / 2 assert d.entropy() == log(2) / 2 np = import_module("numpy", min_module_version="1.4.0") if np: # do this test only if 'numpy' is available on test machine np_mat = represent(d, format="numpy") ent = entropy(np_mat) assert isinstance(np_mat, np.matrixlib.defmatrix.matrix) assert ent.real == 0.69314718055994529 assert ent.imag == 0 scipy = import_module("scipy", import_kwargs={"fromlist": ["sparse"]}) if scipy and np: # do this test only if numpy and scipy are available mat = represent(d, format="scipy.sparse") assert isinstance(mat, scipy_sparse_matrix) assert ent.real == 0.69314718055994529 assert ent.imag == 0
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_issue3044(): expr1 = TensorProduct(Jz * JzKet(S(2), S(-1)) / sqrt(2), Jz * JzKet(S(1) / 2, S(1) / 2)) result = Mul(S(-1), S(1) / 4, (2**(S(1) / 2)), hbar**2) result *= TensorProduct(JzKet(2, -1), JzKet(S(1) / 2, S(1) / 2)) assert qapply(expr1) == result
def test_tensorproduct(): tp = TensorProduct(JzKet(1, 1), JzKet(1, 0)) assert str(tp) == '|1,1>x|1,0>' assert pretty(tp) == '|1,1>x |1,0>' assert upretty(tp) == '❘1,1⟩⨂ ❘1,0⟩' assert latex(tp) == \ r'{{\left|1,1\right\rangle }}\otimes {{\left|1,0\right\rangle }}' sT(tp, "TensorProduct(JzKet(Integer(1),Integer(1)), JzKet(Integer(1),Integer(0)))")
def test_tensorproduct(): tp = TensorProduct(JzKet(1, 1), JzKet(1, 0)) assert str(tp) == "|1,1>x|1,0>" assert pretty(tp) == "|1,1>x |1,0>" assert upretty(tp) == u"❘1,1⟩⨂ ❘1,0⟩" assert (latex(tp) == r"{{\left|1,1\right\rangle }}\otimes {{\left|1,0\right\rangle }}") sT( tp, "TensorProduct(JzKet(Integer(1),Integer(1)), JzKet(Integer(1),Integer(0)))" )
def test_innerproduct(): j, m = symbols("j m") assert InnerProduct(JzBra(1, 1), JzKet(1, 1)).doit() == 1 assert InnerProduct(JzBra(S(1) / 2, S(1) / 2), JzKet(S(1) / 2, -S(1) / 2)).doit() == 0 assert InnerProduct(JzBra(j, m), JzKet(j, m)).doit() == 1 assert InnerProduct(JzBra(1, 0), JyKet(1, 1)).doit() == I / sqrt(2) assert InnerProduct(JxBra(S(1) / 2, S(1) / 2), JzKet(S(1) / 2, S(1) / 2)).doit() == -sqrt(2) / 2 assert InnerProduct(JyBra(1, 1), JzKet(1, 1)).doit() == S(1) / 2 assert InnerProduct(JxBra(1, -1), JyKet(1, 1)).doit() == 0
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 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_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_outer_product(): k = Ket('k') b = Bra('b') op = OuterProduct(k, b) assert isinstance(op, OuterProduct) assert isinstance(op, Operator) assert op.ket == k assert op.bra == b assert op.label == (k, b) assert op.is_commutative is False op = k*b assert isinstance(op, OuterProduct) assert isinstance(op, Operator) assert op.ket == k assert op.bra == b assert op.label == (k, b) assert op.is_commutative is False op = 2*k*b assert op == Mul(Integer(2), k, b) op = 2*(k*b) assert op == Mul(Integer(2), OuterProduct(k, b)) assert Dagger(k*b) == OuterProduct(Dagger(b), Dagger(k)) assert Dagger(k*b).is_commutative is False #test the _eval_trace assert Tr(OuterProduct(JzKet(1, 1), JzBra(1, 1))).doit() == 1 # test scaled kets and bras assert OuterProduct(2 * k, b) == 2 * OuterProduct(k, b) assert OuterProduct(k, 2 * b) == 2 * OuterProduct(k, b) # test sums of kets and bras k1, k2 = Ket('k1'), Ket('k2') b1, b2 = Bra('b1'), Bra('b2') assert (OuterProduct(k1 + k2, b1) == OuterProduct(k1, b1) + OuterProduct(k2, b1)) assert (OuterProduct(k1, b1 + b2) == OuterProduct(k1, b1) + OuterProduct(k1, b2)) assert (OuterProduct(1 * k1 + 2 * k2, 3 * b1 + 4 * b2) == 3 * OuterProduct(k1, b1) + 4 * OuterProduct(k1, b2) + 6 * OuterProduct(k2, b1) + 8 * OuterProduct(k2, b2))
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_eval_trace(): up = JzKet(S(1) / 2, S(1) / 2) down = JzKet(S(1) / 2, -S(1) / 2) d = Density((up, 0.5), (down, 0.5)) t = Tr(d) assert t.doit() == 1 #test dummy time dependent states class TestTimeDepKet(TimeDepKet): def _eval_trace(self, bra, **options): return 1 x, t = symbols('x t') k1 = TestTimeDepKet(0, 0.5) k2 = TestTimeDepKet(0, 1) d = Density([k1, 0.5], [k2, 0.5]) assert d.doit() == (0.5 * OuterProduct(k1, k1.dual) + 0.5 * OuterProduct(k2, k2.dual)) t = Tr(d) assert t.doit() == 1
def test_outer_product(): k = Ket('k') b = Bra('b') op = OuterProduct(k, b) assert isinstance(op, OuterProduct) assert isinstance(op, Operator) assert op.ket == k assert op.bra == b assert op.label == (k, b) assert op.is_commutative is False op = k * b assert isinstance(op, OuterProduct) assert isinstance(op, Operator) assert op.ket == k assert op.bra == b assert op.label == (k, b) assert op.is_commutative is False op = 2 * k * b assert op == Mul(Integer(2), k, b) op = 2 * (k * b) assert op == Mul(Integer(2), OuterProduct(k, b)) assert Dagger(k * b) == OuterProduct(Dagger(b), Dagger(k)) assert Dagger(k * b).is_commutative is False #test the _eval_trace assert Tr(OuterProduct(JzKet(1, 1), JzBra(1, 1))).doit() == 1
def test_rewrite(): # Rewrite to same basis assert JxBra(1, 1).rewrite('Jx') == JxBra(1, 1) assert JxKet(1, 1).rewrite('Jx') == JxKet(1, 1) # Rewriting to different basis assert JxKet(1, 1).rewrite('Jy') == I * JyKet(1, 1) assert JxKet(1, 0).rewrite('Jy') == JyKet(1, 0) assert JxKet(1, -1).rewrite('Jy') == -I * JyKet(1, -1) assert JxKet(1, 1).rewrite( 'Jz') == JzKet(1, 1) / 2 + JzKet(1, 0) / sqrt(2) + JzKet(1, -1) / 2 assert JxKet(1, 0).rewrite( 'Jz') == -sqrt(2) * JzKet(1, 1) / 2 + sqrt(2) * JzKet(1, -1) / 2 assert JxKet(1, -1).rewrite( 'Jz') == JzKet(1, 1) / 2 - JzKet(1, 0) / sqrt(2) + JzKet(1, -1) / 2 assert JyKet(1, 1).rewrite('Jx') == -I * JxKet(1, 1) assert JyKet(1, 0).rewrite('Jx') == JxKet(1, 0) assert JyKet(1, -1).rewrite('Jx') == I * JxKet(1, -1) assert JyKet(1, 1).rewrite('Jz') == JzKet(1, 1) / 2 + sqrt(2) * I * JzKet( 1, 0) / 2 - JzKet(1, -1) / 2 assert JyKet(1, 0).rewrite( 'Jz') == sqrt(2) * I * JzKet(1, 1) / 2 + sqrt(2) * I * JzKet(1, -1) / 2 assert JyKet(1, -1).rewrite('Jz') == -JzKet(1, 1) / 2 + sqrt(2) * I * JzKet( 1, 0) / 2 + JzKet(1, -1) / 2 assert JzKet(1, 1).rewrite( 'Jx') == JxKet(1, 1) / 2 - sqrt(2) * JxKet(1, 0) / 2 + JxKet(1, -1) / 2 assert JzKet(1, 0).rewrite( 'Jx') == sqrt(2) * JxKet(1, 1) / 2 - sqrt(2) * JxKet(1, -1) / 2 assert JzKet(1, -1).rewrite( 'Jx') == JxKet(1, 1) / 2 + sqrt(2) * JxKet(1, 0) / 2 + JxKet(1, -1) / 2 assert JzKet(1, 1).rewrite('Jy') == JyKet(1, 1) / 2 - sqrt(2) * I * JyKet( 1, 0) / 2 - JyKet(1, -1) / 2 assert JzKet(1, 0).rewrite('Jy') == -sqrt(2) * I * JyKet( 1, 1) / 2 - sqrt(2) * I * JyKet(1, -1) / 2 assert JzKet(1, -1).rewrite('Jy') == -JyKet(1, 1) / 2 - sqrt(2) * I * JyKet( 1, 0) / 2 + JyKet(1, -1) / 2 # Innerproducts of rewritten states assert qapply(JxBra(1, 1) * JxKet(1, 1).rewrite('Jy')).doit() == 1 assert qapply(JxBra(1, 0) * JxKet(1, 0).rewrite('Jy')).doit() == 1 assert qapply(JxBra(1, -1) * JxKet(1, -1).rewrite('Jy')).doit() == 1 assert qapply(JxBra(1, 1) * JxKet(1, 1).rewrite('Jz')).doit() == 1 assert qapply(JxBra(1, 0) * JxKet(1, 0).rewrite('Jz')).doit() == 1 assert qapply(JxBra(1, -1) * JxKet(1, -1).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, 1) * JyKet(1, 1).rewrite('Jx')).doit() == 1 assert qapply(JyBra(1, 0) * JyKet(1, 0).rewrite('Jx')).doit() == 1 assert qapply(JyBra(1, -1) * JyKet(1, -1).rewrite('Jx')).doit() == 1 assert qapply(JyBra(1, 1) * JyKet(1, 1).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, 0) * JyKet(1, 0).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, -1) * JyKet(1, -1).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, 1) * JyKet(1, 1).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, 0) * JyKet(1, 0).rewrite('Jz')).doit() == 1 assert qapply(JyBra(1, -1) * JyKet(1, -1).rewrite('Jz')).doit() == 1 assert qapply(JzBra(1, 1) * JzKet(1, 1).rewrite('Jy')).doit() == 1 assert qapply(JzBra(1, 0) * JzKet(1, 0).rewrite('Jy')).doit() == 1 assert qapply(JzBra(1, -1) * JzKet(1, -1).rewrite('Jy')).doit() == 1 assert qapply(JxBra(1, 1) * JxKet(1, 0).rewrite('Jy')).doit() == 0 assert qapply(JxBra(1, 1) * JxKet(1, -1).rewrite('Jy')) == 0 assert qapply(JxBra(1, 1) * JxKet(1, 0).rewrite('Jz')).doit() == 0 assert qapply(JxBra(1, 1) * JxKet(1, -1).rewrite('Jz')) == 0 assert qapply(JyBra(1, 1) * JyKet(1, 0).rewrite('Jx')).doit() == 0 assert qapply(JyBra(1, 1) * JyKet(1, -1).rewrite('Jx')) == 0 assert qapply(JyBra(1, 1) * JyKet(1, 0).rewrite('Jz')).doit() == 0 assert qapply(JyBra(1, 1) * JyKet(1, -1).rewrite('Jz')) == 0 assert qapply(JzBra(1, 1) * JzKet(1, 0).rewrite('Jx')).doit() == 0 assert qapply(JzBra(1, 1) * JzKet(1, -1).rewrite('Jx')) == 0 assert qapply(JzBra(1, 1) * JzKet(1, 0).rewrite('Jy')).doit() == 0 assert qapply(JzBra(1, 1) * JzKet(1, -1).rewrite('Jy')) == 0 assert qapply(JxBra(1, 0) * JxKet(1, 1).rewrite('Jy')) == 0 assert qapply(JxBra(1, 0) * JxKet(1, -1).rewrite('Jy')) == 0 assert qapply(JxBra(1, 0) * JxKet(1, 1).rewrite('Jz')) == 0 assert qapply(JxBra(1, 0) * JxKet(1, -1).rewrite('Jz')) == 0 assert qapply(JyBra(1, 0) * JyKet(1, 1).rewrite('Jx')) == 0 assert qapply(JyBra(1, 0) * JyKet(1, -1).rewrite('Jx')) == 0 assert qapply(JyBra(1, 0) * JyKet(1, 1).rewrite('Jz')) == 0 assert qapply(JyBra(1, 0) * JyKet(1, -1).rewrite('Jz')) == 0 assert qapply(JzBra(1, 0) * JzKet(1, 1).rewrite('Jx')) == 0 assert qapply(JzBra(1, 0) * JzKet(1, -1).rewrite('Jx')) == 0 assert qapply(JzBra(1, 0) * JzKet(1, 1).rewrite('Jy')) == 0 assert qapply(JzBra(1, 0) * JzKet(1, -1).rewrite('Jy')) == 0 assert qapply(JxBra(1, -1) * JxKet(1, 1).rewrite('Jy')) == 0 assert qapply(JxBra(1, -1) * JxKet(1, 0).rewrite('Jy')).doit() == 0 assert qapply(JxBra(1, -1) * JxKet(1, 1).rewrite('Jz')) == 0 assert qapply(JxBra(1, -1) * JxKet(1, 0).rewrite('Jz')).doit() == 0 assert qapply(JyBra(1, -1) * JyKet(1, 1).rewrite('Jx')) == 0 assert qapply(JyBra(1, -1) * JyKet(1, 0).rewrite('Jx')).doit() == 0 assert qapply(JyBra(1, -1) * JyKet(1, 1).rewrite('Jz')) == 0 assert qapply(JyBra(1, -1) * JyKet(1, 0).rewrite('Jz')).doit() == 0 assert qapply(JzBra(1, -1) * JzKet(1, 1).rewrite('Jx')) == 0 assert qapply(JzBra(1, -1) * JzKet(1, 0).rewrite('Jx')).doit() == 0 assert qapply(JzBra(1, -1) * JzKet(1, 1).rewrite('Jy')) == 0 assert qapply(JzBra(1, -1) * JzKet(1, 0).rewrite('Jy')).doit() == 0
def test_jz(): assert Commutator(Jz, Jminus).doit() == -hbar * Jminus assert qapply(Jz * JzKet(2, 1)) == hbar * JzKet(2, 1) assert Jz.rewrite('plusminus')
def test_jy(): assert Commutator(Jy, Jz).doit() == I * hbar * Jx assert qapply(Jy * JzKet(1, 1)) == I * sqrt(2) * hbar * JzKet(1, 0) / 2 assert Jy.rewrite('plusminus') == (Jplus - Jminus) / (2 * I) assert represent(Jy, basis=Jz) == (represent(Jplus, basis=Jz) - represent(Jminus, basis=Jz)) / (2 * I)
def test_spin(): lz = JzOp('L') ket = JzKet(1, 0) bra = JzBra(1, 0) cket = JzKetCoupled(1, 0, (1, 2)) cbra = JzBraCoupled(1, 0, (1, 2)) cket_big = JzKetCoupled(1, 0, (1, 2, 3)) cbra_big = JzBraCoupled(1, 0, (1, 2, 3)) rot = Rotation(1, 2, 3) bigd = WignerD(1, 2, 3, 4, 5, 6) smalld = WignerD(1, 2, 3, 0, 4, 0) assert str(lz) == 'Lz' ascii_str = \ """\ L \n\ z\ """ ucode_str = \ u"""\ L \n\ z\ """ assert pretty(lz) == ascii_str assert upretty(lz) == ucode_str assert latex(lz) == 'L_z' sT(lz, "JzOp(Symbol('L'))") assert str(J2) == 'J2' ascii_str = \ """\ 2\n\ J \ """ ucode_str = \ u"""\ 2\n\ J \ """ assert pretty(J2) == ascii_str assert upretty(J2) == ucode_str assert latex(J2) == r'J^2' sT(J2, "J2Op(Symbol('J'))") assert str(Jz) == 'Jz' ascii_str = \ """\ J \n\ z\ """ ucode_str = \ u"""\ J \n\ z\ """ assert pretty(Jz) == ascii_str assert upretty(Jz) == ucode_str assert latex(Jz) == 'J_z' sT(Jz, "JzOp(Symbol('J'))") assert str(ket) == '|1,0>' assert pretty(ket) == '|1,0>' assert upretty(ket) == u'❘1,0⟩' assert latex(ket) == r'{\left|1,0\right\rangle }' sT(ket, "JzKet(Integer(1),Integer(0))") assert str(bra) == '<1,0|' assert pretty(bra) == '<1,0|' assert upretty(bra) == u'⟨1,0❘' assert latex(bra) == r'{\left\langle 1,0\right|}' sT(bra, "JzBra(Integer(1),Integer(0))") assert str(cket) == '|1,0,j1=1,j2=2>' assert pretty(cket) == '|1,0,j1=1,j2=2>' assert upretty(cket) == u'❘1,0,j₁=1,j₂=2⟩' assert latex(cket) == r'{\left|1,0,j_{1}=1,j_{2}=2\right\rangle }' sT( cket, "JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))" ) assert str(cbra) == '<1,0,j1=1,j2=2|' assert pretty(cbra) == '<1,0,j1=1,j2=2|' assert upretty(cbra) == u'⟨1,0,j₁=1,j₂=2❘' assert latex(cbra) == r'{\left\langle 1,0,j_{1}=1,j_{2}=2\right|}' sT( cbra, "JzBraCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))" ) assert str(cket_big) == '|1,0,j1=1,j2=2,j3=3,j(1,2)=3>' # TODO: Fix non-unicode pretty printing # i.e. j1,2 -> j(1,2) assert pretty(cket_big) == '|1,0,j1=1,j2=2,j3=3,j1,2=3>' assert upretty(cket_big) == u'❘1,0,j₁=1,j₂=2,j₃=3,j₁,₂=3⟩' assert latex(cket_big) == \ r'{\left|1,0,j_{1}=1,j_{2}=2,j_{3}=3,j_{1,2}=3\right\rangle }' sT( cket_big, "JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2), Integer(3)),Tuple(Tuple(Integer(1), Integer(2), Integer(3)), Tuple(Integer(1), Integer(3), Integer(1))))" ) assert str(cbra_big) == '<1,0,j1=1,j2=2,j3=3,j(1,2)=3|' assert pretty(cbra_big) == u'<1,0,j1=1,j2=2,j3=3,j1,2=3|' assert upretty(cbra_big) == u'⟨1,0,j₁=1,j₂=2,j₃=3,j₁,₂=3❘' assert latex(cbra_big) == \ r'{\left\langle 1,0,j_{1}=1,j_{2}=2,j_{3}=3,j_{1,2}=3\right|}' sT( cbra_big, "JzBraCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(2), Integer(3)),Tuple(Tuple(Integer(1), Integer(2), Integer(3)), Tuple(Integer(1), Integer(3), Integer(1))))" ) assert str(rot) == 'R(1,2,3)' assert pretty(rot) == 'R (1,2,3)' assert upretty(rot) == u'ℛ (1,2,3)' assert latex(rot) == r'\mathcal{R}\left(1,2,3\right)' sT(rot, "Rotation(Integer(1),Integer(2),Integer(3))") assert str(bigd) == 'WignerD(1, 2, 3, 4, 5, 6)' ascii_str = \ """\ 1 \n\ D (4,5,6)\n\ 2,3 \ """ ucode_str = \ u"""\ 1 \n\ D (4,5,6)\n\ 2,3 \ """ assert pretty(bigd) == ascii_str assert upretty(bigd) == ucode_str assert latex(bigd) == r'D^{1}_{2,3}\left(4,5,6\right)' sT( bigd, "WignerD(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6))" ) assert str(smalld) == 'WignerD(1, 2, 3, 0, 4, 0)' ascii_str = \ """\ 1 \n\ d (4)\n\ 2,3 \ """ ucode_str = \ u"""\ 1 \n\ d (4)\n\ 2,3 \ """ assert pretty(smalld) == ascii_str assert upretty(smalld) == ucode_str assert latex(smalld) == r'd^{1}_{2,3}\left(4\right)' sT( smalld, "WignerD(Integer(1), Integer(2), Integer(3), Integer(0), Integer(4), Integer(0))" )
from sympy.physics.quantum.constants import hbar from sympy.physics.quantum.dagger import Dagger from sympy.physics.quantum.gate import H from sympy.physics.quantum.operator import Operator from sympy.physics.quantum.qapply import qapply from sympy.physics.quantum.spin import Jx, Jy, Jz, Jplus, Jminus, J2, JzKet from sympy.physics.quantum.tensorproduct import TensorProduct from sympy.physics.quantum.state import Ket from sympy.physics.quantum.density import Density from sympy.physics.quantum.qubit import Qubit from sympy.physics.quantum.boson import BosonOp, BosonFockKet, BosonFockBra from sympy.physics.quantum.tensorproduct import TensorProduct j, jp, m, mp = symbols("j j' m m'") z = JzKet(1, 0) po = JzKet(1, 1) mo = JzKet(1, -1) A = Operator('A') class Foo(Operator): def _apply_operator_JzKet(self, ket, **options): return ket def test_basic(): assert qapply(Jz * po) == hbar * po assert qapply(Jx * z) == hbar * po / sqrt(2) + hbar * mo / sqrt(2) assert qapply((Jplus + Jminus) * z / sqrt(2)) == hbar * po + hbar * mo
def test_jminus(): assert qapply(Jminus * JzKet(1, -1)) == 0 assert Jminus.matrix_element(1, 0, 1, 1) == sqrt(2) * hbar assert Jminus.rewrite('xyz') == Jx - I * Jy
def test_jplus(): assert Commutator(Jplus, Jminus).doit() == 2 * hbar * Jz assert qapply(Jplus * JzKet(1, 1)) == 0 assert Jplus.matrix_element(1, 1, 1, 1) == 0 assert Jplus.rewrite('xyz') == Jx + I * Jy
def test_sympy__physics__quantum__spin__JzKet(): from sympy.physics.quantum.spin import JzKet assert _test_args(JzKet(1, 0))
def test_big_expr(): f = Function('f') x = symbols('x') e1 = Dagger( AntiCommutator( Operator('A') + Operator('B'), Pow(DifferentialOperator(Derivative(f(x), x), f(x)), 3)) * TensorProduct(Jz**2, Operator('A') + Operator('B'))) * (JzBra(1, 0) + JzBra( 1, 1)) * (JzKet(0, 0) + JzKet(1, -1)) e2 = Commutator(Jz**2, Operator('A') + Operator('B')) * AntiCommutator( Dagger(Operator('C') * Operator('D')), Operator('E').inv()**2) * Dagger(Commutator(Jz, J2)) e3 = Wigner3j(1, 2, 3, 4, 5, 6) * TensorProduct( Commutator( Operator('A') + Dagger(Operator('B')), Operator('C') + Operator('D')), Jz - J2) * Dagger( OuterProduct(Dagger(JzBra(1, 1)), JzBra( 1, 0))) * TensorProduct( JzKetCoupled(1, 1, (1, 1)) + JzKetCoupled(1, 0, (1, 1)), JzKetCoupled(1, -1, (1, 1))) e4 = (ComplexSpace(1) * ComplexSpace(2) + FockSpace()**2) * (L2(Interval(0, oo)) + HilbertSpace()) assert str( e1 ) == '(Jz**2)x(Dagger(A) + Dagger(B))*{Dagger(DifferentialOperator(Derivative(f(x), x),f(x)))**3,Dagger(A) + Dagger(B)}*(<1,0| + <1,1|)*(|0,0> + |1,-1>)' ascii_str = \ """\ / 3 \\ \n\ |/ +\\ | \n\ 2 / + +\\ <| /d \\ | + +> \n\ /J \\ x \\A + B /*||DifferentialOperator|--(f(x)),f(x)| | ,A + B |*(<1,0| + <1,1|)*(|0,0> + |1,-1>)\n\ \\ z/ \\\\ \dx / / / \ """ ucode_str = \ u"""\ ⎧ 3 ⎫ \n\ ⎪⎛ †⎞ ⎪ \n\ 2 ⎛ † †⎞ ⎨⎜ ⎛d ⎞ ⎟ † †⎬ \n\ ⎛J ⎞ ⨂ ⎝A + B ⎠⋅⎪⎜DifferentialOperator⎜──(f(x)),f(x)⎟ ⎟ ,A + B ⎪⋅(⟨1,0❘ + ⟨1,1❘)⋅(❘0,0⟩ + ❘1,-1⟩)\n\ ⎝ z⎠ ⎩⎝ ⎝dx ⎠ ⎠ ⎭ \ """ assert pretty(e1) == ascii_str assert upretty(e1) == ucode_str assert latex(e1) == \ r'{\left(J_z\right)^{2}}\otimes \left({A^{\dag} + B^{\dag}}\right) \left\{\left(DifferentialOperator\left(\frac{\partial}{\partial x} \operatorname{f}{\left (x \right )},\operatorname{f}{\left (x \right )}\right)^{\dag}\right)^{3},A^{\dag} + B^{\dag}\right\} \left({\left\langle 1,0\right|} + {\left\langle 1,1\right|}\right) \left({\left|0,0\right\rangle } + {\left|1,-1\right\rangle }\right)' sT( e1, "Mul(TensorProduct(Pow(JzOp(Symbol('J')), Integer(2)), Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), AntiCommutator(Pow(Dagger(DifferentialOperator(Derivative(Function('f')(Symbol('x')), Symbol('x')),Function('f')(Symbol('x')))), Integer(3)),Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), Add(JzBra(Integer(1),Integer(0)), JzBra(Integer(1),Integer(1))), Add(JzKet(Integer(0),Integer(0)), JzKet(Integer(1),Integer(-1))))" ) assert str(e2) == '[Jz**2,A + B]*{E**(-2),Dagger(D)*Dagger(C)}*[J2,Jz]' ascii_str = \ """\ [ 2 ] / -2 + +\\ [ 2 ]\n\ [/J \\ ,A + B]*<E ,D *C >*[J ,J ]\n\ [\\ z/ ] \\ / [ z]\ """ ucode_str = \ u"""\ ⎡ 2 ⎤ ⎧ -2 † †⎫ ⎡ 2 ⎤\n\ ⎢⎛J ⎞ ,A + B⎥⋅⎨E ,D ⋅C ⎬⋅⎢J ,J ⎥\n\ ⎣⎝ z⎠ ⎦ ⎩ ⎭ ⎣ z⎦\ """ assert pretty(e2) == ascii_str assert upretty(e2) == ucode_str assert latex(e2) == \ r'\left[\left(J_z\right)^{2},A + B\right] \left\{\left(E\right)^{-2},D^{\dag} C^{\dag}\right\} \left[J^2,J_z\right]' sT( e2, "Mul(Commutator(Pow(JzOp(Symbol('J')), Integer(2)),Add(Operator(Symbol('A')), Operator(Symbol('B')))), AntiCommutator(Pow(Operator(Symbol('E')), Integer(-2)),Mul(Dagger(Operator(Symbol('D'))), Dagger(Operator(Symbol('C'))))), Commutator(J2Op(Symbol('J')),JzOp(Symbol('J'))))" ) assert str(e3) == \ "Wigner3j(1, 2, 3, 4, 5, 6)*[Dagger(B) + A,C + D]x(-J2 + Jz)*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x|1,-1,j1=1,j2=1>" ascii_str = \ """\ [ + ] / 2 \\ \n\ /1 3 5\\*[B + A,C + D]x |- J + J |*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x |1,-1,j1=1,j2=1>\n\ | | \\ z/ \n\ \\2 4 6/ \ """ ucode_str = \ u"""\ ⎡ † ⎤ ⎛ 2 ⎞ \n\ ⎛1 3 5⎞⋅⎣B + A,C + D⎦⨂ ⎜- J + J ⎟⋅❘1,0⟩⟨1,1❘⋅(❘1,0,j₁=1,j₂=1⟩ + ❘1,1,j₁=1,j₂=1⟩)⨂ ❘1,-1,j₁=1,j₂=1⟩\n\ ⎜ ⎟ ⎝ z⎠ \n\ ⎝2 4 6⎠ \ """ assert pretty(e3) == ascii_str assert upretty(e3) == ucode_str assert latex(e3) == \ r'\left(\begin{array}{ccc} 1 & 3 & 5 \\ 2 & 4 & 6 \end{array}\right) {\left[B^{\dag} + A,C + D\right]}\otimes \left({- J^2 + J_z}\right) {\left|1,0\right\rangle }{\left\langle 1,1\right|} \left({{\left|1,0,j_{1}=1,j_{2}=1\right\rangle } + {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }}\right)\otimes {{\left|1,-1,j_{1}=1,j_{2}=1\right\rangle }}' sT( e3, "Mul(Wigner3j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)), TensorProduct(Commutator(Add(Dagger(Operator(Symbol('B'))), Operator(Symbol('A'))),Add(Operator(Symbol('C')), Operator(Symbol('D')))), Add(Mul(Integer(-1), J2Op(Symbol('J'))), JzOp(Symbol('J')))), OuterProduct(JzKet(Integer(1),Integer(0)),JzBra(Integer(1),Integer(1))), TensorProduct(Add(JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))), JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))), JzKetCoupled(Integer(1),Integer(-1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))))" ) assert str(e4) == '(C(1)*C(2)+F**2)*(L2([0, oo))+H)' ascii_str = \ """\ // 1 2\\ x2\\ / 2 \\\n\ \\\\C x C / + F / x \L + H/\ """ ucode_str = \ u"""\ ⎛⎛ 1 2⎞ ⨂2⎞ ⎛ 2 ⎞\n\ ⎝⎝C ⨂ C ⎠ ⊕ F ⎠ ⨂ ⎝L ⊕ H⎠\ """ assert pretty(e4) == ascii_str assert upretty(e4) == ucode_str assert latex(e4) == \ r'\left(\left(\mathcal{C}^{1}\otimes \mathcal{C}^{2}\right)\oplus {\mathcal{F}}^{\otimes 2}\right)\otimes \left({\mathcal{L}^2}\left( \left[0, \infty\right) \right)\oplus \mathcal{H}\right)' sT( e4, "TensorProductHilbertSpace((DirectSumHilbertSpace(TensorProductHilbertSpace(ComplexSpace(Integer(1)),ComplexSpace(Integer(2))),TensorPowerHilbertSpace(FockSpace(),Integer(2)))),(DirectSumHilbertSpace(L2(Interval(Integer(0), oo, False, True)),HilbertSpace())))" )
def test_fidelity(): #test with kets up = JzKet(S(1) / 2, S(1) / 2) down = JzKet(S(1) / 2, -S(1) / 2) updown = (S(1) / sqrt(2)) * up + (S(1) / sqrt(2)) * down #check with matrices up_dm = represent(up * Dagger(up)) down_dm = represent(down * Dagger(down)) updown_dm = represent(updown * Dagger(updown)) assert abs(fidelity(up_dm, up_dm) - 1) < 1e-3 assert fidelity(up_dm, down_dm) < 1e-3 assert abs(fidelity(up_dm, updown_dm) - (S(1) / sqrt(2))) < 1e-3 assert abs(fidelity(updown_dm, down_dm) - (S(1) / sqrt(2))) < 1e-3 #check with density up_dm = Density([up, 1.0]) down_dm = Density([down, 1.0]) updown_dm = Density([updown, 1.0]) assert abs(fidelity(up_dm, up_dm) - 1) < 1e-3 assert abs(fidelity(up_dm, down_dm)) < 1e-3 assert abs(fidelity(up_dm, updown_dm) - (S(1) / sqrt(2))) < 1e-3 assert abs(fidelity(updown_dm, down_dm) - (S(1) / sqrt(2))) < 1e-3 #check mixed states with density updown2 = (sqrt(3) / 2) * up + (S(1) / 2) * down d1 = Density([updown, 0.25], [updown2, 0.75]) d2 = Density([updown, 0.75], [updown2, 0.25]) assert abs(fidelity(d1, d2) - 0.991) < 1e-3 assert abs(fidelity(d2, d1) - fidelity(d1, d2)) < 1e-3 #using qubits/density(pure states) state1 = Qubit('0') state2 = Qubit('1') state3 = (S(1) / sqrt(2)) * state1 + (S(1) / sqrt(2)) * state2 state4 = (sqrt(S(2) / 3)) * state1 + (S(1) / sqrt(3)) * state2 state1_dm = Density([state1, 1]) state2_dm = Density([state2, 1]) state3_dm = Density([state3, 1]) assert fidelity(state1_dm, state1_dm) == 1 assert fidelity(state1_dm, state2_dm) == 0 assert abs(fidelity(state1_dm, state3_dm) - 1 / sqrt(2)) < 1e-3 assert abs(fidelity(state3_dm, state2_dm) - 1 / sqrt(2)) < 1e-3 #using qubits/density(mixed states) d1 = Density([state3, 0.70], [state4, 0.30]) d2 = Density([state3, 0.20], [state4, 0.80]) assert abs(fidelity(d1, d1) - 1) < 1e-3 assert abs(fidelity(d1, d2) - 0.996) < 1e-3 assert abs(fidelity(d1, d2) - fidelity(d2, d1)) < 1e-3 #TODO: test for invalid arguments # non-square matrix mat1 = [[0, 0], [0, 0], [0, 0]] mat2 = [[0, 0], [0, 0]] raises(ValueError, lambda: fidelity(mat1, mat2)) # unequal dimensions mat1 = [[0, 0], [0, 0]] mat2 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] raises(ValueError, lambda: fidelity(mat1, mat2)) # unsupported data-type x, y = 1, 2 # random values that is not a matrix raises(ValueError, lambda: fidelity(x, y))
def test_doit(): x, y = symbols('x y') A, B, C, D, E, F = symbols('A B C D E F', commutative=False) d = Density([XKet(), 0.5], [PxKet(), 0.5]) assert (0.5 * (PxKet() * Dagger(PxKet())) + 0.5 * (XKet() * Dagger(XKet()))) == d.doit() # check for kets with expr in them d_with_sym = Density([XKet(x * y), 0.5], [PxKet(x * y), 0.5]) assert (0.5 * (PxKet(x * y) * Dagger(PxKet(x * y))) + 0.5 * (XKet(x * y) * Dagger(XKet(x * y)))) == d_with_sym.doit() d = Density([(A + B) * C, 1.0]) assert d.doit() == (1.0 * A * C * Dagger(C) * Dagger(A) + 1.0 * A * C * Dagger(C) * Dagger(B) + 1.0 * B * C * Dagger(C) * Dagger(A) + 1.0 * B * C * Dagger(C) * Dagger(B)) # With TensorProducts as args # Density with simple tensor products as args t = TensorProduct(A, B, C) d = Density([t, 1.0]) assert d.doit() == \ 1.0 * TensorProduct(A*Dagger(A), B*Dagger(B), C*Dagger(C)) # Density with multiple Tensorproducts as states t2 = TensorProduct(A, B) t3 = TensorProduct(C, D) d = Density([t2, 0.5], [t3, 0.5]) assert d.doit() == (0.5 * TensorProduct(A * Dagger(A), B * Dagger(B)) + 0.5 * TensorProduct(C * Dagger(C), D * Dagger(D))) #Density with mixed states d = Density([t2 + t3, 1.0]) assert d.doit() == (1.0 * TensorProduct(A * Dagger(A), B * Dagger(B)) + 1.0 * TensorProduct(A * Dagger(C), B * Dagger(D)) + 1.0 * TensorProduct(C * Dagger(A), D * Dagger(B)) + 1.0 * TensorProduct(C * Dagger(C), D * Dagger(D))) #Density operators with spin states tp1 = TensorProduct(JzKet(1, 1), JzKet(1, -1)) d = Density([tp1, 1]) # full trace t = Tr(d) assert t.doit() == 1 #Partial trace on density operators with spin states t = Tr(d, [0]) assert t.doit() == JzKet(1, -1) * Dagger(JzKet(1, -1)) t = Tr(d, [1]) assert t.doit() == JzKet(1, 1) * Dagger(JzKet(1, 1)) # with another spin state tp2 = TensorProduct(JzKet(S(1) / 2, S(1) / 2), JzKet(S(1) / 2, -S(1) / 2)) d = Density([tp2, 1]) #full trace t = Tr(d) assert t.doit() == 1 #Partial trace on density operators with spin states t = Tr(d, [0]) assert t.doit() == JzKet(S(1) / 2, -S(1) / 2) * Dagger( JzKet(S(1) / 2, -S(1) / 2)) t = Tr(d, [1]) assert t.doit() == JzKet(S(1) / 2, S(1) / 2) * Dagger(JzKet(S(1) / 2, S(1) / 2))
def test_issue3044(): expr1 = TensorProduct(Jz * JzKet(S(2), S.NegativeOne) / sqrt(2), Jz * JzKet(S.Half, S.Half)) result = Mul(S.NegativeOne, Rational(1, 4), 2**S.Half, hbar**2) result *= TensorProduct(JzKet(2, -1), JzKet(S.Half, S.Half)) assert qapply(expr1) == result
def test_represent(): # Spin operators assert represent(Jx) == hbar * Matrix([[0, 1], [1, 0]]) / 2 assert represent( Jx, j=1) == hbar * sqrt(2) * Matrix([[0, 1, 0], [1, 0, 1], [0, 1, 0]]) / 2 assert represent(Jy) == hbar * I * Matrix([[0, -1], [1, 0]]) / 2 assert represent(Jy, j=1) == hbar * I * sqrt(2) * Matrix( [[0, -1, 0], [1, 0, -1], [0, 1, 0]]) / 2 assert represent(Jz) == hbar * Matrix([[1, 0], [0, -1]]) / 2 assert represent(Jz, j=1) == hbar * Matrix([[1, 0, 0], [0, 0, 0], [0, 0, -1]]) # Spin states # Jx basis assert represent(JxKet(S(1) / 2, S(1) / 2), basis=Jx) == Matrix([1, 0]) assert represent(JxKet(S(1) / 2, -S(1) / 2), basis=Jx) == Matrix([0, 1]) assert represent(JxKet(1, 1), basis=Jx) == Matrix([1, 0, 0]) assert represent(JxKet(1, 0), basis=Jx) == Matrix([0, 1, 0]) assert represent(JxKet(1, -1), basis=Jx) == Matrix([0, 0, 1]) assert represent(JyKet(S(1) / 2, S(1) / 2), basis=Jx) == Matrix([exp(-I * pi / 4), 0]) assert represent(JyKet(S(1) / 2, -S(1) / 2), basis=Jx) == Matrix([0, exp(I * pi / 4)]) assert represent(JyKet(1, 1), basis=Jx) == Matrix([-I, 0, 0]) assert represent(JyKet(1, 0), basis=Jx) == Matrix([0, 1, 0]) assert represent(JyKet(1, -1), basis=Jx) == Matrix([0, 0, I]) assert represent(JzKet(S(1) / 2, S(1) / 2), basis=Jx) == sqrt(2) * Matrix([-1, 1]) / 2 assert represent(JzKet(S(1) / 2, -S(1) / 2), basis=Jx) == sqrt(2) * Matrix([-1, -1]) / 2 assert represent(JzKet(1, 1), basis=Jx) == Matrix([1, -sqrt(2), 1]) / 2 assert represent(JzKet(1, 0), basis=Jx) == sqrt(2) * Matrix([1, 0, -1]) / 2 assert represent(JzKet(1, -1), basis=Jx) == Matrix([1, sqrt(2), 1]) / 2 # Jy basis assert represent(JxKet(S(1) / 2, S(1) / 2), basis=Jy) == Matrix([exp(-3 * I * pi / 4), 0]) assert represent(JxKet(S(1) / 2, -S(1) / 2), basis=Jy) == Matrix([0, exp(3 * I * pi / 4)]) assert represent(JxKet(1, 1), basis=Jy) == Matrix([I, 0, 0]) assert represent(JxKet(1, 0), basis=Jy) == Matrix([0, 1, 0]) assert represent(JxKet(1, -1), basis=Jy) == Matrix([0, 0, -I]) assert represent(JyKet(S(1) / 2, S(1) / 2), basis=Jy) == Matrix([1, 0]) assert represent(JyKet(S(1) / 2, -S(1) / 2), basis=Jy) == Matrix([0, 1]) assert represent(JyKet(1, 1), basis=Jy) == Matrix([1, 0, 0]) assert represent(JyKet(1, 0), basis=Jy) == Matrix([0, 1, 0]) assert represent(JyKet(1, -1), basis=Jy) == Matrix([0, 0, 1]) assert represent(JzKet(S(1) / 2, S(1) / 2), basis=Jy) == sqrt(2) * Matrix([-1, I]) / 2 assert represent(JzKet(S(1) / 2, -S(1) / 2), basis=Jy) == sqrt(2) * Matrix([I, -1]) / 2 assert represent(JzKet(1, 1), basis=Jy) == Matrix([1, -I * sqrt(2), -1]) / 2 assert represent(JzKet(1, 0), basis=Jy) == Matrix([-sqrt(2) * I, 0, -sqrt(2) * I]) / 2 assert represent(JzKet(1, -1), basis=Jy) == Matrix([-1, -sqrt(2) * I, 1]) / 2 # Jz basis assert represent(JxKet(S(1) / 2, S(1) / 2)) == sqrt(2) * Matrix([1, 1]) / 2 assert represent(JxKet(S(1) / 2, -S(1) / 2)) == sqrt(2) * Matrix([-1, 1]) / 2 assert represent(JxKet(1, 1)) == Matrix([1, sqrt(2), 1]) / 2 assert represent(JxKet(1, 0)) == sqrt(2) * Matrix([-1, 0, 1]) / 2 assert represent(JxKet(1, -1)) == Matrix([1, -sqrt(2), 1]) / 2 assert represent(JyKet(S(1) / 2, S(1) / 2)) == sqrt(2) * Matrix([-1, -I]) / 2 assert represent(JyKet(S(1) / 2, -S(1) / 2)) == sqrt(2) * Matrix([-I, -1]) / 2 assert represent(JyKet(1, 1)) == Matrix([1, sqrt(2) * I, -1]) / 2 assert represent(JyKet(1, 0)) == sqrt(2) * Matrix([I, 0, I]) / 2 assert represent(JyKet(1, -1)) == Matrix([-1, sqrt(2) * I, 1]) / 2 assert represent(JzKet(S(1) / 2, S(1) / 2)) == Matrix([1, 0]) assert represent(JzKet(S(1) / 2, -S(1) / 2)) == Matrix([0, 1]) assert represent(JzKet(1, 1)) == Matrix([1, 0, 0]) assert represent(JzKet(1, 0)) == Matrix([0, 1, 0]) assert represent(JzKet(1, -1)) == Matrix([0, 0, 1])
def test_innerproduct(): x = symbols('x') ip1 = InnerProduct(Bra(), Ket()) ip2 = InnerProduct(TimeDepBra(), TimeDepKet()) ip3 = InnerProduct(JzBra(1, 1), JzKet(1, 1)) ip4 = InnerProduct(JzBraCoupled(1, 1, (1, 1)), JzKetCoupled(1, 1, (1, 1))) ip_tall1 = InnerProduct(Bra(x / 2), Ket(x / 2)) ip_tall2 = InnerProduct(Bra(x), Ket(x / 2)) ip_tall3 = InnerProduct(Bra(x / 2), Ket(x)) assert str(ip1) == '<psi|psi>' assert pretty(ip1) == '<psi|psi>' assert upretty(ip1) == u'⟨ψ❘ψ⟩' assert latex( ip1) == r'\left\langle \psi \right. {\left|\psi\right\rangle }' sT(ip1, "InnerProduct(Bra(Symbol('psi')),Ket(Symbol('psi')))") assert str(ip2) == '<psi;t|psi;t>' assert pretty(ip2) == '<psi;t|psi;t>' assert upretty(ip2) == u'⟨ψ;t❘ψ;t⟩' assert latex(ip2) == \ r'\left\langle \psi;t \right. {\left|\psi;t\right\rangle }' sT( ip2, "InnerProduct(TimeDepBra(Symbol('psi'),Symbol('t')),TimeDepKet(Symbol('psi'),Symbol('t')))" ) assert str(ip3) == "<1,1|1,1>" assert pretty(ip3) == '<1,1|1,1>' assert upretty(ip3) == u'⟨1,1❘1,1⟩' assert latex(ip3) == r'\left\langle 1,1 \right. {\left|1,1\right\rangle }' sT( ip3, "InnerProduct(JzBra(Integer(1),Integer(1)),JzKet(Integer(1),Integer(1)))" ) assert str(ip4) == "<1,1,j1=1,j2=1|1,1,j1=1,j2=1>" assert pretty(ip4) == '<1,1,j1=1,j2=1|1,1,j1=1,j2=1>' assert upretty(ip4) == u'⟨1,1,j₁=1,j₂=1❘1,1,j₁=1,j₂=1⟩' assert latex(ip4) == \ r'\left\langle 1,1,j_{1}=1,j_{2}=1 \right. {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }' sT( ip4, "InnerProduct(JzBraCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))),JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))))" ) assert str(ip_tall1) == '<x/2|x/2>' ascii_str = \ """\ / | \\ \n\ / x|x \\\n\ \\ -|- /\n\ \\2|2/ \ """ ucode_str = \ u"""\ ╱ │ ╲ \n\ ╱ x│x ╲\n\ ╲ ─│─ ╱\n\ ╲2│2╱ \ """ assert pretty(ip_tall1) == ascii_str assert upretty(ip_tall1) == ucode_str assert latex(ip_tall1) == \ r'\left\langle \frac{1}{2} x \right. {\left|\frac{1}{2} x\right\rangle }' sT( ip_tall1, "InnerProduct(Bra(Mul(Rational(1, 2), Symbol('x'))),Ket(Mul(Rational(1, 2), Symbol('x'))))" ) assert str(ip_tall2) == '<x|x/2>' ascii_str = \ """\ / | \\ \n\ / |x \\\n\ \\ x|- /\n\ \\ |2/ \ """ ucode_str = \ u"""\ ╱ │ ╲ \n\ ╱ │x ╲\n\ ╲ x│─ ╱\n\ ╲ │2╱ \ """ assert pretty(ip_tall2) == ascii_str assert upretty(ip_tall2) == ucode_str assert latex(ip_tall2) == \ r'\left\langle x \right. {\left|\frac{1}{2} x\right\rangle }' sT(ip_tall2, "InnerProduct(Bra(Symbol('x')),Ket(Mul(Rational(1, 2), Symbol('x'))))") assert str(ip_tall3) == '<x/2|x>' ascii_str = \ """\ / | \\ \n\ / x| \\\n\ \\ -|x /\n\ \\2| / \ """ ucode_str = \ u"""\ ╱ │ ╲ \n\ ╱ x│ ╲\n\ ╲ ─│x ╱\n\ ╲2│ ╱ \ """ assert pretty(ip_tall3) == ascii_str assert upretty(ip_tall3) == ucode_str assert latex(ip_tall3) == \ r'\left\langle \frac{1}{2} x \right. {\left|x\right\rangle }' sT(ip_tall3, "InnerProduct(Bra(Mul(Rational(1, 2), Symbol('x'))),Ket(Symbol('x')))")