def test_unicode_ket_operations():
"""Test the unicode representation of ket operations"""
hs1 = LocalSpace('q_1', basis=('g', 'e'))
hs2 = LocalSpace('q_2', basis=('g', 'e'))
ket_g1 = BasisKet('g', hs=hs1)
ket_e1 = BasisKet('e', hs=hs1)
ket_g2 = BasisKet('g', hs=hs2)
ket_e2 = BasisKet('e', hs=hs2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
phi = KetSymbol("Phi", hs=hs2)
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma', positive=True)
alpha = symbols('alpha')
beta = symbols('beta')
phase = exp(-I * gamma)
i = IdxSym('i')
assert unicode(psi1 + psi2) == '|Ψ₁⟩^(q₁) + |Ψ₂⟩^(q₁)'
assert unicode(psi1 * phi) == '|Ψ₁⟩^(q₁) ⊗ |Φ⟩^(q₂)'
assert unicode(phase * psi1) == 'exp(-ⅈ γ) |Ψ₁⟩^(q₁)'
assert unicode((alpha + 1) * KetSymbol('Psi', hs=0)) == '(α + 1) |Ψ⟩⁽⁰⁾'
assert (unicode(
A * psi1) == 'A\u0302_0^(q\u2081) |\u03a8\u2081\u27e9^(q\u2081)')
# Â_0^(q₁) |Ψ₁⟩^(q₁)
assert unicode(BraKet(psi1, psi2)) == '⟨Ψ₁|Ψ₂⟩^(q₁)'
expr = BraKet(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert unicode(expr) == '⟨Ψ₁(α)|Ψ₂(β)⟩^(q₁)'
assert unicode(ket_e1.dag() * ket_e1) == '1'
assert unicode(ket_g1.dag() * ket_e1) == '0'
assert unicode(KetBra(psi1, psi2)) == '|Ψ₁⟩⟨Ψ₂|^(q₁)'
expr = KetBra(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert unicode(expr) == '|Ψ₁(α)⟩⟨Ψ₂(β)|^(q₁)'
bell1 = (ket_e1 * ket_g2 - I * ket_g1 * ket_e2) / sqrt(2)
bell2 = (ket_e1 * ket_e2 - ket_g1 * ket_g2) / sqrt(2)
assert unicode(bell1) == '1/√2 (|eg⟩^(q₁⊗q₂) - ⅈ |ge⟩^(q₁⊗q₂))'
assert (unicode(BraKet.create(
bell1,
bell2)) == r'1/2 (⟨eg|^(q₁⊗q₂) + ⅈ ⟨ge|^(q₁⊗q₂)) (|ee⟩^(q₁⊗q₂) - '
r'|gg⟩^(q₁⊗q₂))')
assert (unicode(KetBra.create(
bell1,
bell2)) == r'1/2 (|eg⟩^(q₁⊗q₂) - ⅈ |ge⟩^(q₁⊗q₂))(⟨ee|^(q₁⊗q₂) - '
r'⟨gg|^(q₁⊗q₂))')
assert (unicode(
KetBra.create(bell1, bell2),
show_hs_label=False) == r'1/2 (|eg⟩ - ⅈ |ge⟩)(⟨ee| - ⟨gg|)')
expr = KetBra(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert unicode(expr) == "|Ψ⟩⟨i|⁽⁰⁾"
expr = KetBra(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert unicode(expr) == "|i⟩⟨Ψ|⁽⁰⁾"
expr = BraKet(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert unicode(expr) == "⟨Ψ|i⟩⁽⁰⁾"
expr = BraKet(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert unicode(expr) == "⟨i|Ψ⟩⁽⁰⁾"
def test_tls_norm():
"""Test that calculating the norm of a TLS state results in 1"""
hs = LocalSpace('tls', dimension=2)
i = IdxSym('i')
ket_i = BasisKet(FockIndex(i), hs=hs)
nrm = BraKet.create(ket_i, ket_i)
assert nrm == 1
psi = KetIndexedSum((1 / sympy.sqrt(2)) * ket_i,
ranges=IndexOverFockSpace(i, hs))
nrm = BraKet.create(psi, psi)
assert nrm == 1
def braket():
"""An example symbolic braket"""
Psi = KetSymbol("Psi", hs=0)
Phi = KetSymbol("Phi", hs=0)
res = BraKet.create(Psi, Phi)
assert isinstance(res, ScalarExpression)
return res
def test_indexed_sum_over_scalartimes():
"""Test ScalarIndexedSum over a term that is an ScalarTimes instance"""
i, j = symbols('i, j', cls=IdxSym)
hs = LocalSpace(1, dimension=2)
Psi_i = KetSymbol(StrLabel(IndexedBase('Psi')[i]), hs=hs)
Psi_j = KetSymbol(StrLabel(IndexedBase('Psi')[j]), hs=hs)
term = KroneckerDelta(i, j) * BraKet(Psi_i, Psi_j)
assert isinstance(term, ScalarTimes)
i_range = IndexOverFockSpace(i, hs)
j_range = IndexOverFockSpace(j, hs)
sum = ScalarIndexedSum.create(term, ranges=(i_range, j_range))
assert sum == hs.dimension
def test_braket_indexed_sum():
"""Test braket product of sums"""
i = IdxSym('i')
hs = LocalSpace(1, dimension=5)
alpha = IndexedBase('alpha')
psi = KetSymbol('Psi', hs=hs)
psi1 = KetIndexedSum(
alpha[1, i] * BasisKet(FockIndex(i), hs=hs),
ranges=IndexOverFockSpace(i, hs),
)
psi2 = KetIndexedSum(
alpha[2, i] * BasisKet(FockIndex(i), hs=hs),
ranges=IndexOverFockSpace(i, hs),
)
expr = Bra.create(psi1) * psi2
assert expr.space == TrivialSpace
assert expr == ScalarIndexedSum.create(
alpha[1, i].conjugate() * alpha[2, i],
ranges=(IndexOverFockSpace(i, hs), ),
)
assert BraKet.create(psi1, psi2) == expr
expr = psi.dag() * psi2
assert expr == ScalarIndexedSum(
alpha[2, i] * BraKet(psi, BasisKet(FockIndex(i), hs=hs)),
ranges=IndexOverFockSpace(i, hs),
)
assert BraKet.create(psi, psi2) == expr
expr = psi1.dag() * psi
assert expr == ScalarIndexedSum(
alpha[1, i].conjugate() * BraKet(BasisKet(FockIndex(i), hs=hs), psi),
ranges=IndexOverFockSpace(i, hs),
)
assert BraKet.create(psi1, psi) == expr
def test_scalar_conjugate(braket):
"""Test taking the complex conjugate (adjoint) of a scalar"""
Psi = KetSymbol("Psi", hs=0)
Phi = KetSymbol("Phi", hs=0)
phi = symbols('phi', real=True)
alpha = symbols('alpha')
expr = ScalarValue(1 + 1j)
assert expr.adjoint() == expr.conjugate() == 1 - 1j
assert braket.adjoint() == BraKet.create(Phi, Psi)
expr = 1j + braket
assert expr.adjoint() == expr.conjugate() == braket.adjoint() - 1j
expr = (1 + 1j) * braket
assert expr.adjoint() == expr.conjugate() == (1 - 1j) * braket.adjoint()
expr = braket**(I * phi)
assert expr.conjugate() == braket.adjoint()**(-I * phi)
expr = braket**alpha
assert expr.conjugate() == braket.adjoint()**(alpha.conjugate())
def state_exprs():
"""Prepare a list of state algebra expressions"""
hs1 = LocalSpace('q1', basis=('g', 'e'))
hs2 = LocalSpace('q2', basis=('g', 'e'))
ket_g1 = BasisKet('g', hs=hs1)
ket_e1 = BasisKet('e', hs=hs1)
ket_g2 = BasisKet('g', hs=hs2)
ket_e2 = BasisKet('e', hs=hs2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi1_l = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi3 = KetSymbol("Psi_3", hs=hs1)
phi = KetSymbol("Phi", hs=hs2)
phi_l = KetSymbol("Phi", hs=hs2)
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma')
phase = exp(-I * gamma)
bell1 = (ket_e1 * ket_g2 - I * ket_g1 * ket_e2) / sqrt(2)
bell2 = (ket_e1 * ket_e2 - ket_g1 * ket_g2) / sqrt(2)
bra_psi1 = KetSymbol("Psi_1", hs=hs1).dag()
bra_psi1_l = KetSymbol("Psi_1", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_phi_l = KetSymbol("Phi", hs=hs2).dag()
return [
KetSymbol('Psi', hs=hs1),
KetSymbol('Psi', hs=1),
KetSymbol('Psi', hs=(1, 2)),
KetSymbol('Psi', symbols('alpha'), symbols('beta'), hs=(1, 2)),
KetSymbol('Psi', hs=1),
ZeroKet,
TrivialKet,
BasisKet('e', hs=hs1),
BasisKet('excited', hs=LocalSpace(1, basis=('ground', 'excited'))),
BasisKet(1, hs=1),
CoherentStateKet(2.0, hs=1),
CoherentStateKet(2.0, hs=1).to_fock_representation(),
Bra(KetSymbol('Psi', hs=hs1)),
Bra(KetSymbol('Psi', hs=1)),
Bra(KetSymbol('Psi', hs=(1, 2))),
Bra(KetSymbol('Psi', hs=hs1 * hs2)),
KetSymbol('Psi', hs=1).dag(),
Bra(ZeroKet),
Bra(TrivialKet),
BasisKet('e', hs=hs1).adjoint(),
BasisKet(1, hs=1).adjoint(),
CoherentStateKet(2.0, hs=1).dag(),
psi1 + psi2,
psi1 - psi2 + psi3,
psi1 * phi,
psi1_l * phi_l,
phase * psi1,
A * psi1,
BraKet(psi1, psi2),
ket_e1.dag() * ket_e1,
ket_g1.dag() * ket_e1,
KetBra(psi1, psi2),
bell1,
BraKet.create(bell1, bell2),
KetBra.create(bell1, bell2),
(psi1 + psi2).dag(),
bra_psi1 + bra_psi2,
bra_psi1_l * bra_phi_l,
Bra(phase * psi1),
(A * psi1).dag(),
]
def test_scalar_numeric_methods(braket):
"""Test all of the numerical magic methods for scalars"""
three = ScalarValue(3)
two = ScalarValue(2)
spOne = sympify(1)
spZero = sympify(0)
spHalf = spOne / 2
assert three == 3
assert three == three
assert three != symbols('alpha')
assert three <= 3
assert three <= ScalarValue(4)
assert three >= 3
assert three >= ScalarValue(2)
assert three < 3.1
assert three < ScalarValue(4)
assert three > ScalarValue(2)
assert three == sympify(3)
assert three <= sympify(3)
assert three >= sympify(3)
assert three < sympify(3.1)
assert three > sympify(2.9)
with pytest.raises(TypeError):
assert three < symbols('alpha')
with pytest.raises(TypeError):
assert three <= symbols('alpha')
with pytest.raises(TypeError):
assert three > symbols('alpha')
with pytest.raises(TypeError):
assert three >= symbols('alpha')
assert hash(three) == hash(3)
v = -three
assert v == -3
assert isinstance(v, ScalarValue)
v = three + 1
assert v == 4
assert isinstance(v, ScalarValue)
v = three + two
assert v == 5
assert isinstance(v, ScalarValue)
v = three + Zero
assert v is three
assert three + spZero == three
v = three + One
assert v == 4
assert isinstance(v, ScalarValue)
assert three + spOne == 4
v = abs(ScalarValue(-3))
assert v == 3
assert isinstance(v, ScalarValue)
v = three - 4
assert v == -1
assert isinstance(v, ScalarValue)
v = three - two
assert v == 1
assert v is One
v = three - Zero
assert v is three
assert three - spZero == three
v = three - One
assert v == 2
assert isinstance(v, ScalarValue)
assert three - spOne == 2
v = three * 2
assert v == 6
assert isinstance(v, ScalarValue)
v = three * two
assert v == 6
assert isinstance(v, ScalarValue)
v = three * Zero
assert v == 0
assert v is Zero
assert three * spZero is Zero
v = three * One
assert v is three
assert three * spOne == three
v = three // 2
assert v is One
assert ScalarValue(3.5) // 1 == 3.0
v = three // two
assert v is One
v = three // One
assert v == three
assert three // spOne == three
with pytest.raises(ZeroDivisionError):
v = three // Zero
with pytest.raises(ZeroDivisionError):
v = three // spZero
with pytest.raises(ZeroDivisionError):
v = three // 0
v = three / 2
assert v == 3 / 2
assert isinstance(v, ScalarValue)
v = three / two
assert v == 3 / 2
assert isinstance(v, ScalarValue)
v = three / One
assert v is three
assert three / spOne == three
with pytest.raises(ZeroDivisionError):
v = three / Zero
with pytest.raises(ZeroDivisionError):
v = three / spZero
with pytest.raises(ZeroDivisionError):
v = three / 0
v = three % 2
assert v is One
assert three % 0.2 == 3 % 0.2
v = three % two
assert v is One
v = three % One
assert v is Zero
assert three % spOne is Zero
with pytest.raises(ZeroDivisionError):
v = three % Zero
with pytest.raises(ZeroDivisionError):
v = three % spZero
with pytest.raises(ZeroDivisionError):
v = three % 0
v = three**2
assert v == 9
assert isinstance(v, ScalarValue)
v = three**two
assert v == 9
assert isinstance(v, ScalarValue)
v = three**One
assert v is three
assert three**spOne == three
v = three**Zero
assert v is One
assert three**spZero is One
v = 1 + three
assert v == 4
assert isinstance(v, ScalarValue)
v = two + three
assert v == 5
assert isinstance(v, ScalarValue)
v = sympify(2) + three
assert v == 5
assert isinstance(v, SympyBasic)
v = 2.0 + three
assert v == 5
assert isinstance(v, ScalarValue)
v = Zero + three
assert v is three
with pytest.raises(TypeError):
None + three
assert spZero + three == three
v = One + three
assert v == 4
assert isinstance(v, ScalarValue)
assert spOne + three == 4
v = 1 - three
assert v == -2
assert isinstance(v, ScalarValue)
v = two - three
assert v == -1
assert isinstance(v, ScalarValue)
v = 2.0 - three
assert v == -1
assert isinstance(v, ScalarValue)
v = sympify(2) - three
assert v == -1
assert isinstance(v, SympyBasic)
v = Zero - three
assert v == -3
assert isinstance(v, ScalarValue)
with pytest.raises(TypeError):
None - three
assert spZero - three == -3
v = One - three
assert v == -2
assert isinstance(v, ScalarValue)
assert spOne - three == -2
v = 2 * three
assert v == 6
assert isinstance(v, ScalarValue)
v = Zero * three
assert v == 0
assert v is Zero
v = spZero * three
assert v == Zero
assert isinstance(v, SympyBasic)
v = One * three
assert v is three
assert spOne * three == three
with pytest.raises(TypeError):
None * three
v = 2 // three
assert v is Zero
v = two // three
assert v is Zero
v = One // three
assert v is Zero
v = spOne // three
assert v == Zero
assert isinstance(v, SympyBasic)
v = Zero // three
assert v is Zero
v = spZero // three
assert v == Zero
assert isinstance(v, SympyBasic)
v = 1 // three
assert v is Zero
with pytest.raises(TypeError):
None // three
v = 2 / three
assert float(v) == 2 / 3
assert v == Rational(2, 3)
assert isinstance(v, ScalarValue)
v = two / three
assert v == 2 / 3
assert isinstance(v, ScalarValue)
v = One / three
assert v == 1 / 3
assert isinstance(v, ScalarValue)
v = 1 / three
assert v == Rational(1, 3)
assert isinstance(v, ScalarValue)
assert float(spOne / three) == 1 / 3
v = Zero / three
assert v is Zero
v = spZero / three
assert v == Zero
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
None / three
v = 2**three
assert v == 8
assert isinstance(v, ScalarValue)
v = 0**three
assert v is Zero
v = two**three
assert v == 8
assert isinstance(v, ScalarValue)
v = One**three
assert v is One
with pytest.raises(TypeError):
None**three
v = 1**three
assert v is One
v = One**spHalf
assert v is One
v = spOne**three
assert v == One
assert isinstance(v, SympyBasic)
v = Zero**three
assert v is Zero
v = spZero**three
assert v == Zero
assert isinstance(v, SympyBasic)
v = complex(three)
assert v == 3 + 0j
assert isinstance(v, complex)
v = int(ScalarValue(3.45))
assert v == 3
assert isinstance(v, int)
v = float(three)
assert v == 3.0
assert isinstance(v, float)
assert Zero == 0
assert Zero != symbols('alpha')
assert Zero <= One
assert Zero <= three
assert Zero >= Zero
assert Zero >= -three
assert Zero < One
assert Zero < three
assert Zero > -One
assert Zero > -three
assert Zero == spZero
assert Zero <= spZero
assert Zero >= spZero
assert Zero < spOne
assert Zero > -spOne
with pytest.raises(TypeError):
assert Zero < symbols('alpha')
with pytest.raises(TypeError):
assert Zero <= symbols('alpha')
with pytest.raises(TypeError):
assert Zero > symbols('alpha')
with pytest.raises(TypeError):
assert Zero >= symbols('alpha')
assert hash(Zero) == hash(0)
assert abs(Zero) is Zero
assert abs(One) is One
assert abs(ScalarValue(-1)) is One
assert -Zero is Zero
v = -One
assert v == -1
assert isinstance(v, ScalarValue)
assert Zero + One is One
assert One + Zero is One
assert Zero + Zero is Zero
assert Zero - Zero is Zero
assert One + One == 2
assert One - One is Zero
v = Zero + 2
assert v == 2
assert isinstance(v, ScalarValue)
v = Zero - One
assert v == -1
assert isinstance(v, ScalarValue)
v = Zero - 5
assert v == -5
assert isinstance(v, ScalarValue)
v = 2 + Zero
assert v == 2
assert isinstance(v, ScalarValue)
v = 2 - Zero
assert v == 2
assert isinstance(v, ScalarValue)
v = sympify(2) + Zero
assert v == 2
assert isinstance(v, SympyBasic)
v = sympify(2) - Zero
assert v == 2
assert isinstance(v, SympyBasic)
v = One + 2
assert v == 3
assert isinstance(v, ScalarValue)
v = 2 + One
assert v == 3
assert isinstance(v, ScalarValue)
v = 2 - One
assert v is One
v = 3 - One
assert v == 2
assert isinstance(v, ScalarValue)
v = One - 3
assert v == -2
assert isinstance(v, ScalarValue)
v = sympify(2) + One
assert v == 3
assert isinstance(v, SympyBasic)
v = sympify(2) - One
assert v == 1
assert isinstance(v, SympyBasic)
v = sympify(3) - One
assert v == 2
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
None + Zero
with pytest.raises(TypeError):
None - Zero
with pytest.raises(TypeError):
None + One
with pytest.raises(TypeError):
None - One
alpha = symbols('alpha')
assert Zero * alpha is Zero
v = alpha * Zero
assert v == Zero
assert isinstance(v, SympyBasic)
assert 3 * Zero is Zero
with pytest.raises(TypeError):
None * Zero
assert Zero * alpha is Zero
assert Zero // 3 is Zero
assert One // 1 is One
assert One / 1 is One
assert One == 1
assert One != symbols('alpha')
assert One <= One
assert One <= three
assert One >= Zero
assert One >= -three
assert One < three
assert One > -three
assert One == spOne
assert One <= spOne
assert One >= spOne
assert One < sympify(3)
assert One > -sympify(3)
with pytest.raises(TypeError):
assert One < symbols('alpha')
with pytest.raises(TypeError):
assert One <= symbols('alpha')
with pytest.raises(TypeError):
assert One > symbols('alpha')
with pytest.raises(TypeError):
assert One >= symbols('alpha')
with pytest.raises(ZeroDivisionError):
One // 0
with pytest.raises(ZeroDivisionError):
One / 0
with pytest.raises(TypeError):
One // None
with pytest.raises(TypeError):
One / None
with pytest.raises(ZeroDivisionError):
3 // Zero
with pytest.raises(TypeError):
Zero // None
with pytest.raises(TypeError):
None // Zero
assert Zero / 3 is Zero
with pytest.raises(TypeError):
Zero / None
assert Zero % 3 is Zero
assert Zero % three is Zero
with pytest.raises(TypeError):
assert Zero % None
assert One % 3 is One
assert One % three is One
assert three % One is Zero
assert 3 % One is Zero
with pytest.raises(TypeError):
None % 3
v = sympify(3) % One
assert v == 0
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
assert One % None
with pytest.raises(TypeError):
assert None % One
assert Zero**2 is Zero
assert Zero**spHalf is Zero
with pytest.raises(TypeError):
Zero**None
with pytest.raises(ZeroDivisionError):
v = Zero**-1
with pytest.raises(ZeroDivisionError):
v = 1 / Zero
v = spOne / Zero
assert v == sympy_infinity
with pytest.raises(ZeroDivisionError):
v = 1 / Zero
assert One - Zero is One
assert Zero * One is Zero
assert One * Zero is Zero
with pytest.raises(ZeroDivisionError):
v = 3 / Zero
with pytest.raises(ZeroDivisionError):
v = 3 % Zero
v = 3 / One
assert v == 3
assert isinstance(v, ScalarValue)
v = 3 % One
assert v is Zero
v = 1 % three
assert v is One
v = spOne % three
assert v == 1
assert isinstance(v, SympyBasic)
v = sympify(2) % three
assert v == 2
with pytest.raises(TypeError):
None % three
assert 3**Zero is One
v = 3**One
assert v == 3
assert isinstance(v, ScalarValue)
v = complex(Zero)
assert v == 0j
assert isinstance(v, complex)
v = int(Zero)
assert v == 0
assert isinstance(v, int)
v = float(Zero)
assert v == 0.0
assert isinstance(v, float)
v = complex(One)
assert v == 1j
assert isinstance(v, complex)
v = int(One)
assert v == 1
assert isinstance(v, int)
v = float(One)
assert v == 1.0
assert isinstance(v, float)
assert braket**Zero is One
assert braket**0 is One
assert braket**One is braket
assert braket**1 is braket
v = 1 / braket
assert v == braket**(-1)
assert isinstance(v, ScalarPower)
assert v.base == braket
assert v.exp == -1
v = three * braket
assert isinstance(v, ScalarTimes)
assert v == braket * 3
assert v == braket * sympify(3)
assert v == 3 * braket
assert v == sympify(3) * braket
assert braket * One is braket
assert braket * Zero is Zero
assert One * braket is braket
assert Zero * braket is Zero
assert spOne * braket is braket
assert spZero * braket is Zero
with pytest.raises(TypeError):
braket // 3
with pytest.raises(TypeError):
braket % 3
with pytest.raises(TypeError):
1 // braket
with pytest.raises(TypeError):
3 % braket
with pytest.raises(TypeError):
3**braket
assert 0**braket is Zero
assert 1**braket is One
assert spZero**braket is Zero
assert spOne**braket is One
assert One**braket is One
assert 0 // braket is Zero
assert 0 / braket is Zero
assert 0 % braket is Zero
with pytest.raises(ZeroDivisionError):
assert 0 / Zero
with pytest.raises(ZeroDivisionError):
assert 0 / ScalarValue.create(0)
assert 0 / ScalarValue(0) == sympy.nan
A = OperatorSymbol('A', hs=0)
v = A / braket
assert isinstance(v, ScalarTimesOperator)
assert v.coeff == braket**-1
assert v.term == A
with pytest.raises(TypeError):
v = None / braket
assert braket / three == (1 / three) * braket == (spOne / 3) * braket
assert braket / 3 == (1 / three) * braket
v = braket / 0.25
assert v == 4 * braket # 0.25 and 4 are exact floats
assert braket / sympify(3) == (1 / three) * braket
assert 3 / braket == 3 * braket**-1
assert three / braket == 3 * braket**-1
assert spOne / braket == braket**-1
braket2 = BraKet.create(KetSymbol("Chi", hs=0), KetSymbol("Psi", hs=0))
v = braket / braket2
assert v == braket * braket2**-1
with pytest.raises(ZeroDivisionError):
braket / Zero
with pytest.raises(ZeroDivisionError):
braket / 0
with pytest.raises(ZeroDivisionError):
braket / sympify(0)
assert braket / braket is One
with pytest.raises(TypeError):
braket / None
v = 1 + braket
assert v == braket + 1
assert isinstance(v, Scalar)
v = One + braket
assert v == braket + One
assert isinstance(v, Scalar)
assert Zero + braket is braket
assert spZero + braket is braket
assert braket + Zero is braket
assert braket + spZero is braket
assert 0 + braket is braket
assert braket + 0 is braket
assert (-1) * braket == -braket
assert Zero - braket == -braket
assert spZero - braket == -braket
assert braket - Zero is braket
assert braket - spZero is braket
assert 0 - braket == -braket
assert braket - 0 is braket
assert sympify(3) - braket == 3 - braket
def test_ascii_ket_operations():
"""Test the ascii representation of ket operations"""
hs1 = LocalSpace('q_1', basis=('g', 'e'))
hs2 = LocalSpace('q_2', basis=('g', 'e'))
ket_g1 = BasisKet('g', hs=hs1)
ket_e1 = BasisKet('e', hs=hs1)
ket_g2 = BasisKet('g', hs=hs2)
ket_e2 = BasisKet('e', hs=hs2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi3 = KetSymbol("Psi_3", hs=hs1)
phi = KetSymbol("Phi", hs=hs2)
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma', positive=True)
alpha = symbols('alpha')
beta = symbols('beta')
phase = exp(-I * gamma)
i = IdxSym('i')
assert ascii(psi1 + psi2) == '|Psi_1>^(q_1) + |Psi_2>^(q_1)'
assert (ascii(psi1 - psi2 +
psi3) == '|Psi_1>^(q_1) - |Psi_2>^(q_1) + |Psi_3>^(q_1)')
with pytest.raises(UnequalSpaces):
psi1 + phi
with pytest.raises(AttributeError):
(psi1 * phi).label
assert ascii(psi1 * phi) == '|Psi_1>^(q_1) * |Phi>^(q_2)'
with pytest.raises(OverlappingSpaces):
psi1 * psi2
assert ascii(phase * psi1) == 'exp(-I*gamma) * |Psi_1>^(q_1)'
assert (ascii(
(alpha + 1) * KetSymbol('Psi', hs=0)) == '(alpha + 1) * |Psi>^(0)')
assert ascii(A * psi1) == 'A_0^(q_1) |Psi_1>^(q_1)'
with pytest.raises(SpaceTooLargeError):
A * phi
assert ascii(BraKet(psi1, psi2)) == '<Psi_1|Psi_2>^(q_1)'
expr = BraKet(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert ascii(expr) == '<Psi_1(alpha)|Psi_2(beta)>^(q_1)'
assert ascii(psi1.dag() * psi2) == '<Psi_1|Psi_2>^(q_1)'
assert ascii(ket_e1.dag() * ket_e1) == '1'
assert ascii(ket_g1.dag() * ket_e1) == '0'
assert ascii(KetBra(psi1, psi2)) == '|Psi_1><Psi_2|^(q_1)'
expr = KetBra(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert ascii(expr) == '|Psi_1(alpha)><Psi_2(beta)|^(q_1)'
bell1 = (ket_e1 * ket_g2 - I * ket_g1 * ket_e2) / sqrt(2)
bell2 = (ket_e1 * ket_e2 - ket_g1 * ket_g2) / sqrt(2)
assert ascii(bell1) == '1/sqrt(2) * (|eg>^(q_1*q_2) - I * |ge>^(q_1*q_2))'
assert ascii(bell2) == '1/sqrt(2) * (|ee>^(q_1*q_2) - |gg>^(q_1*q_2))'
expr = BraKet.create(bell1, bell2)
expected = (
r'1/2 * (<eg|^(q_1*q_2) + I * <ge|^(q_1*q_2)) * (|ee>^(q_1*q_2) '
r'- |gg>^(q_1*q_2))')
assert ascii(expr) == expected
assert (ascii(KetBra.create(bell1, bell2)) ==
'1/2 * (|eg>^(q_1*q_2) - I * |ge>^(q_1*q_2))(<ee|^(q_1*q_2) '
'- <gg|^(q_1*q_2))')
expr = KetBra(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert ascii(expr) == "|Psi><i|^(0)"
expr = KetBra(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert ascii(expr) == "|i><Psi|^(0)"
expr = BraKet(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert ascii(expr) == "<Psi|i>^(0)"
expr = BraKet(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert ascii(expr) == "<i|Psi>^(0)"
def test_tex_ket_operations():
"""Test the tex representation of ket operations"""
hs1 = LocalSpace('q_1', basis=('g', 'e'))
hs2 = LocalSpace('q_2', basis=('g', 'e'))
ket_g1 = BasisKet('g', hs=hs1)
ket_e1 = BasisKet('e', hs=hs1)
ket_g2 = BasisKet('g', hs=hs2)
ket_e2 = BasisKet('e', hs=hs2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi3 = KetSymbol("Psi_3", hs=hs1)
phi = KetSymbol("Phi", hs=hs2)
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma', positive=True)
alpha = symbols('alpha')
beta = symbols('beta')
phase = exp(-I * gamma)
i = IdxSym('i')
assert (latex(psi1 +
psi2) == r'\left\lvert \Psi_{1} \right\rangle^{(q_{1})} + '
r'\left\lvert \Psi_{2} \right\rangle^{(q_{1})}')
assert (latex(psi1 - psi2 +
psi3) == r'\left\lvert \Psi_{1} \right\rangle^{(q_{1})} - '
r'\left\lvert \Psi_{2} \right\rangle^{(q_{1})} + '
r'\left\lvert \Psi_{3} \right\rangle^{(q_{1})}')
assert (latex(
psi1 * phi) == r'\left\lvert \Psi_{1} \right\rangle^{(q_{1})} \otimes '
r'\left\lvert \Phi \right\rangle^{(q_{2})}')
assert (latex(phase * psi1) ==
r'e^{- i \gamma} \left\lvert \Psi_{1} \right\rangle^{(q_{1})}')
assert (latex((alpha + 1) * KetSymbol('Psi', hs=0)) ==
r'\left(\alpha + 1\right) \left\lvert \Psi \right\rangle^{(0)}')
assert (latex(
A * psi1
) == r'\hat{A}_{0}^{(q_{1})} \left\lvert \Psi_{1} \right\rangle^{(q_{1})}')
braket = BraKet(psi1, psi2)
assert (
latex(braket, show_hs_label='subscript') ==
r'\left\langle \Psi_{1} \middle\vert \Psi_{2} \right\rangle_{(q_{1})}')
assert (latex(braket, show_hs_label=False) ==
r'\left\langle \Psi_{1} \middle\vert \Psi_{2} \right\rangle')
expr = BraKet(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert (latex(expr) ==
r'\left\langle \Psi_{1}\left(\alpha\right) \middle\vert '
r'\Psi_{2}\left(\beta\right) \right\rangle^{(q_{1})}')
assert (latex(
ket_e1 *
ket_e2) == r'\left\lvert ee \right\rangle^{(q_{1} \otimes q_{2})}')
assert latex(ket_e1.dag() * ket_e1) == r'1'
assert latex(ket_g1.dag() * ket_e1) == r'0'
ketbra = KetBra(psi1, psi2)
assert (latex(ketbra) == r'\left\lvert \Psi_{1} \middle\rangle\!'
r'\middle\langle \Psi_{2} \right\rvert^{(q_{1})}')
assert (latex(
ketbra,
show_hs_label='subscript') == r'\left\lvert \Psi_{1} \middle\rangle\!'
r'\middle\langle \Psi_{2} \right\rvert_{(q_{1})}')
assert (latex(
ketbra,
show_hs_label=False) == r'\left\lvert \Psi_{1} \middle\rangle\!'
r'\middle\langle \Psi_{2} \right\rvert')
expr = KetBra(KetSymbol('Psi_1', alpha, hs=hs1),
KetSymbol('Psi_2', beta, hs=hs1))
assert (
latex(expr) ==
r'\left\lvert \Psi_{1}\left(\alpha\right) \middle\rangle\!'
r'\middle\langle \Psi_{2}\left(\beta\right) \right\rvert^{(q_{1})}')
bell1 = (ket_e1 * ket_g2 - I * ket_g1 * ket_e2) / sqrt(2)
bell2 = (ket_e1 * ket_e2 - ket_g1 * ket_g2) / sqrt(2)
assert (latex(bell1) ==
r'\frac{1}{\sqrt{2}} \left(\left\lvert eg \right\rangle^{(q_{1} '
r'\otimes q_{2})} - i \left\lvert ge \right\rangle'
r'^{(q_{1} \otimes q_{2})}\right)')
assert (latex(bell2) ==
r'\frac{1}{\sqrt{2}} \left(\left\lvert ee \right\rangle^{(q_{1} '
r'\otimes q_{2})} - \left\lvert gg \right\rangle'
r'^{(q_{1} \otimes q_{2})}\right)')
assert (latex(bell2, show_hs_label=False) ==
r'\frac{1}{\sqrt{2}} \left(\left\lvert ee \right\rangle - '
r'\left\lvert gg \right\rangle\right)')
assert BraKet.create(bell1, bell2).expand() == 0
assert (latex(BraKet.create(
bell1, bell2)) == r'\frac{1}{2} \left(\left\langle eg \right\rvert'
r'^{(q_{1} \otimes q_{2})} + i \left\langle ge \right\rvert'
r'^{(q_{1} \otimes q_{2})}\right) '
r'\left(\left\lvert ee \right\rangle^{(q_{1} \otimes q_{2})} '
r'- \left\lvert gg \right\rangle^{(q_{1} \otimes q_{2})}\right)')
assert (
latex(KetBra.create(
bell1, bell2)) == r'\frac{1}{2} \left(\left\lvert eg \right\rangle'
r'^{(q_{1} \otimes q_{2})} - i \left\lvert ge \right\rangle'
r'^{(q_{1} \otimes q_{2})}\right)\left(\left\langle ee \right\rvert'
r'^{(q_{1} \otimes q_{2})} - \left\langle gg \right\rvert'
r'^{(q_{1} \otimes q_{2})}\right)')
with configure_printing(tex_use_braket=True):
expr = KetBra(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert latex(expr) == r'\Ket{\Psi}\!\Bra{i}^{(0)}'
expr = KetBra(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert latex(expr) == r'\Ket{i}\!\Bra{\Psi}^{(0)}'
expr = BraKet(KetSymbol('Psi', hs=0), BasisKet(FockIndex(i), hs=0))
assert latex(expr) == r'\Braket{\Psi | i}^(0)'
expr = BraKet(BasisKet(FockIndex(i), hs=0), KetSymbol('Psi', hs=0))
assert latex(expr) == r'\Braket{i | \Psi}^(0)'