Spaces:
Running
Running
File size: 4,940 Bytes
6a86ad5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
from sympy.core.mul import Mul
from sympy.core.numbers import I
from sympy.matrices.dense import Matrix
from sympy.printing.latex import latex
from sympy.physics.quantum import (Dagger, Commutator, AntiCommutator, qapply,
Operator, represent)
from sympy.physics.quantum.pauli import (SigmaOpBase, SigmaX, SigmaY, SigmaZ,
SigmaMinus, SigmaPlus,
qsimplify_pauli)
from sympy.physics.quantum.pauli import SigmaZKet, SigmaZBra
from sympy.testing.pytest import raises
sx, sy, sz = SigmaX(), SigmaY(), SigmaZ()
sx1, sy1, sz1 = SigmaX(1), SigmaY(1), SigmaZ(1)
sx2, sy2, sz2 = SigmaX(2), SigmaY(2), SigmaZ(2)
sm, sp = SigmaMinus(), SigmaPlus()
sm1, sp1 = SigmaMinus(1), SigmaPlus(1)
A, B = Operator("A"), Operator("B")
def test_pauli_operators_types():
assert isinstance(sx, SigmaOpBase) and isinstance(sx, SigmaX)
assert isinstance(sy, SigmaOpBase) and isinstance(sy, SigmaY)
assert isinstance(sz, SigmaOpBase) and isinstance(sz, SigmaZ)
assert isinstance(sm, SigmaOpBase) and isinstance(sm, SigmaMinus)
assert isinstance(sp, SigmaOpBase) and isinstance(sp, SigmaPlus)
def test_pauli_operators_commutator():
assert Commutator(sx, sy).doit() == 2 * I * sz
assert Commutator(sy, sz).doit() == 2 * I * sx
assert Commutator(sz, sx).doit() == 2 * I * sy
def test_pauli_operators_commutator_with_labels():
assert Commutator(sx1, sy1).doit() == 2 * I * sz1
assert Commutator(sy1, sz1).doit() == 2 * I * sx1
assert Commutator(sz1, sx1).doit() == 2 * I * sy1
assert Commutator(sx2, sy2).doit() == 2 * I * sz2
assert Commutator(sy2, sz2).doit() == 2 * I * sx2
assert Commutator(sz2, sx2).doit() == 2 * I * sy2
assert Commutator(sx1, sy2).doit() == 0
assert Commutator(sy1, sz2).doit() == 0
assert Commutator(sz1, sx2).doit() == 0
def test_pauli_operators_anticommutator():
assert AntiCommutator(sy, sz).doit() == 0
assert AntiCommutator(sz, sx).doit() == 0
assert AntiCommutator(sx, sm).doit() == 1
assert AntiCommutator(sx, sp).doit() == 1
def test_pauli_operators_adjoint():
assert Dagger(sx) == sx
assert Dagger(sy) == sy
assert Dagger(sz) == sz
def test_pauli_operators_adjoint_with_labels():
assert Dagger(sx1) == sx1
assert Dagger(sy1) == sy1
assert Dagger(sz1) == sz1
assert Dagger(sx1) != sx2
assert Dagger(sy1) != sy2
assert Dagger(sz1) != sz2
def test_pauli_operators_multiplication():
assert qsimplify_pauli(sx * sx) == 1
assert qsimplify_pauli(sy * sy) == 1
assert qsimplify_pauli(sz * sz) == 1
assert qsimplify_pauli(sx * sy) == I * sz
assert qsimplify_pauli(sy * sz) == I * sx
assert qsimplify_pauli(sz * sx) == I * sy
assert qsimplify_pauli(sy * sx) == - I * sz
assert qsimplify_pauli(sz * sy) == - I * sx
assert qsimplify_pauli(sx * sz) == - I * sy
def test_pauli_operators_multiplication_with_labels():
assert qsimplify_pauli(sx1 * sx1) == 1
assert qsimplify_pauli(sy1 * sy1) == 1
assert qsimplify_pauli(sz1 * sz1) == 1
assert isinstance(sx1 * sx2, Mul)
assert isinstance(sy1 * sy2, Mul)
assert isinstance(sz1 * sz2, Mul)
assert qsimplify_pauli(sx1 * sy1 * sx2 * sy2) == - sz1 * sz2
assert qsimplify_pauli(sy1 * sz1 * sz2 * sx2) == - sx1 * sy2
def test_pauli_states():
sx, sz = SigmaX(), SigmaZ()
up = SigmaZKet(0)
down = SigmaZKet(1)
assert qapply(sx * up) == down
assert qapply(sx * down) == up
assert qapply(sz * up) == up
assert qapply(sz * down) == - down
up = SigmaZBra(0)
down = SigmaZBra(1)
assert qapply(up * sx, dagger=True) == down
assert qapply(down * sx, dagger=True) == up
assert qapply(up * sz, dagger=True) == up
assert qapply(down * sz, dagger=True) == - down
assert Dagger(SigmaZKet(0)) == SigmaZBra(0)
assert Dagger(SigmaZBra(1)) == SigmaZKet(1)
raises(ValueError, lambda: SigmaZBra(2))
raises(ValueError, lambda: SigmaZKet(2))
def test_use_name():
assert sm.use_name is False
assert sm1.use_name is True
assert sx.use_name is False
assert sx1.use_name is True
def test_printing():
assert latex(sx) == r'{\sigma_x}'
assert latex(sx1) == r'{\sigma_x^{(1)}}'
assert latex(sy) == r'{\sigma_y}'
assert latex(sy1) == r'{\sigma_y^{(1)}}'
assert latex(sz) == r'{\sigma_z}'
assert latex(sz1) == r'{\sigma_z^{(1)}}'
assert latex(sm) == r'{\sigma_-}'
assert latex(sm1) == r'{\sigma_-^{(1)}}'
assert latex(sp) == r'{\sigma_+}'
assert latex(sp1) == r'{\sigma_+^{(1)}}'
def test_represent():
assert represent(sx) == Matrix([[0, 1], [1, 0]])
assert represent(sy) == Matrix([[0, -I], [I, 0]])
assert represent(sz) == Matrix([[1, 0], [0, -1]])
assert represent(sm) == Matrix([[0, 0], [1, 0]])
assert represent(sp) == Matrix([[0, 1], [0, 0]])
|