def test_ascii_bra_operations():
"""Test the ascii representation of bra operations"""
hs1 = LocalSpace('q_1', dimension=2)
hs2 = LocalSpace('q_2', dimension=2)
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)
bra_psi1 = KetSymbol("Psi_1", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_psi3 = KetSymbol("Psi_3", hs=hs1).dag()
bra_phi = KetSymbol("Phi", hs=hs2).dag()
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma', positive=True)
phase = exp(-I * gamma)
assert ascii((psi1 + psi2).dag()) == '<Psi_1|^(q_1) + <Psi_2|^(q_1)'
assert ascii(bra_psi1 + bra_psi2) == '<Psi_1|^(q_1) + <Psi_2|^(q_1)'
assert (ascii(
(psi1 - psi2 +
psi3).dag()) == '<Psi_1|^(q_1) - <Psi_2|^(q_1) + <Psi_3|^(q_1)')
assert (ascii(bra_psi1 - bra_psi2 +
bra_psi3) == '<Psi_1|^(q_1) - <Psi_2|^(q_1) + <Psi_3|^(q_1)')
assert ascii((psi1 * phi).dag()) == '<Psi_1|^(q_1) * <Phi|^(q_2)'
assert ascii(bra_psi1 * bra_phi) == '<Psi_1|^(q_1) * <Phi|^(q_2)'
assert ascii(Bra(phase * psi1)) == 'exp(I*gamma) * <Psi_1|^(q_1)'
assert ascii((A * psi1).dag()) == '<Psi_1|^(q_1) A_0^(q_1)H'
def test_ascii_symbolic_labels():
"""Test ascii representation of symbols with symbolic labels"""
i = IdxSym('i')
j = IdxSym('j')
hs0 = LocalSpace(0)
hs1 = LocalSpace(1)
Psi = IndexedBase('Psi')
assert ascii(BasisKet(FockIndex(2 * i), hs=hs0)) == '|2*i>^(0)'
assert ascii(KetSymbol(StrLabel(2 * i), hs=hs0)) == '|2*i>^(0)'
assert (ascii(KetSymbol(StrLabel(Psi[i, j]),
hs=hs0 * hs1)) == '|Psi_ij>^(0*1)')
expr = BasisKet(FockIndex(i), hs=hs0) * BasisKet(FockIndex(j), hs=hs1)
assert ascii(expr) == '|i,j>^(0*1)'
assert ascii(Bra(BasisKet(FockIndex(2 * i), hs=hs0))) == '<2*i|^(0)'
assert (ascii(LocalSigma(FockIndex(i), FockIndex(j),
hs=hs0)) == '|i><j|^(0)')
expr = CoherentStateKet(symbols('alpha'), hs=1).to_fock_representation()
assert (ascii(expr) == 'exp(-alpha*conjugate(alpha)/2) * '
'(Sum_{n in H_1} alpha**n/sqrt(n!) * |n>^(1))')
tls = SpinSpace(label='s', spin='1/2', basis=('down', 'up'))
Sig = IndexedBase('sigma')
n = IdxSym('n')
Sig_n = OperatorSymbol(StrLabel(Sig[n]), hs=tls)
assert ascii(Sig_n, show_hs_label=False) == 'sigma_n'
def test_tex_symbolic_labels():
"""Test tex representation of symbols with symbolic labels"""
i = IdxSym('i')
j = IdxSym('j')
hs0 = LocalSpace(0)
hs1 = LocalSpace(1)
Psi = IndexedBase('Psi')
with configure_printing(tex_use_braket=True):
assert latex(BasisKet(FockIndex(2 * i), hs=hs0)) == r'\Ket{2 i}^{(0)}'
assert latex(KetSymbol(StrLabel(2 * i), hs=hs0)) == r'\Ket{2 i}^{(0)}'
assert (latex(KetSymbol(StrLabel(Psi[i, j]), hs=hs0 *
hs1)) == r'\Ket{\Psi_{i j}}^{(0 \otimes 1)}')
expr = BasisKet(FockIndex(i), hs=hs0) * BasisKet(FockIndex(j), hs=hs1)
assert latex(expr) == r'\Ket{i,j}^{(0 \otimes 1)}'
assert (latex(Bra(BasisKet(FockIndex(2 * i),
hs=hs0))) == r'\Bra{2 i}^{(0)}')
assert (latex(LocalSigma(FockIndex(i), FockIndex(j),
hs=hs0)) == r'\Ket{i}\!\Bra{j}^{(0)}')
alpha = symbols('alpha')
expr = CoherentStateKet(alpha, hs=1).to_fock_representation()
assert (latex(expr) == r'e^{- \frac{\alpha \overline{\alpha}}{2}} '
r'\left(\sum_{n \in \mathcal{H}_{1}} '
r'\frac{\alpha^{n}}{\sqrt{n!}} \Ket{n}^{(1)}\right)')
assert (latex(
expr, conjg_style='star') == r'e^{- \frac{\alpha {\alpha}^*}{2}} '
r'\left(\sum_{n \in \mathcal{H}_{1}} '
r'\frac{\alpha^{n}}{\sqrt{n!}} \Ket{n}^{(1)}\right)')
tls = SpinSpace(label='s', spin='1/2', basis=('down', 'up'))
Sig = IndexedBase('sigma')
n = IdxSym('n')
Sig_n = OperatorSymbol(StrLabel(Sig[n]), hs=tls)
assert latex(Sig_n, show_hs_label=False) == r'\hat{\sigma}_{n}'
def test_qubit_state_bra():
"""Test sum_i alpha_i <i| for TLS"""
i = IdxSym('i')
alpha = IndexedBase('alpha')
alpha_i = alpha[i]
hs_tls = LocalSpace('tls', basis=('g', 'e'))
term = alpha_i * BasisKet(FockIndex(i), hs=hs_tls).dag()
expr = KetIndexedSum.create(term, ranges=IndexOverFockSpace(i, hs=hs_tls))
assert IndexOverFockSpace(i, hs=hs_tls) in expr.ket.kwargs['ranges']
assert ascii(expr) == "Sum_{i in H_tls} alpha_i * <i|^(tls)"
assert expr.ket.term.free_symbols == set([i, symbols('alpha'), alpha_i])
assert expr.free_symbols == set([symbols('alpha'), alpha_i])
assert expr.ket.variables == [i]
assert expr.space == hs_tls
assert len(expr.ket.args) == 1
assert len(expr.ket.operands) == 1
assert len(expr.ket.kwargs) == 1
assert expr.ket.args[0] == term.ket
assert expr.ket.term == term.ket
assert len(expr.kwargs) == 0
expr_expand = Bra.create(expr.ket.doit().substitute({
alpha[0]: alpha['g'],
alpha[1]: alpha['e']
}))
assert expr_expand == (alpha['g'] * BasisKet('g', hs=hs_tls).dag() +
alpha['e'] * BasisKet('e', hs=hs_tls).dag())
assert ascii(expr_expand) == 'alpha_e * <e|^(tls) + alpha_g * <g|^(tls)'
def test_tex_bra_elements():
"""Test the tex representation of "atomic" kets"""
hs1 = LocalSpace('q1', basis=('g', 'e'))
hs2 = LocalSpace('q2', basis=('g', 'e'))
alpha, beta = symbols('alpha, beta')
bra = Bra(KetSymbol('Psi', hs=hs1))
assert latex(bra) == r'\left\langle \Psi \right\rvert^{(q_{1})}'
assert latex(Bra(KetSymbol('Psi', alpha, beta, hs=hs1))) == (
r'\left\langle \Psi\left(\alpha, \beta\right) \right\rvert^{(q_{1})}')
assert latex(bra, tex_use_braket=True) == r'\Bra{\Psi}^{(q_{1})}'
assert (latex(bra, tex_use_braket=True,
show_hs_label='subscript') == r'\Bra{\Psi}_{(q_{1})}')
assert (latex(bra, tex_use_braket=True,
show_hs_label=False) == r'\Bra{\Psi}')
assert (latex(Bra(KetSymbol(
'Psi', hs=1))) == r'\left\langle \Psi \right\rvert^{(1)}')
assert (latex(Bra(KetSymbol(
'Psi',
hs=(1, 2)))) == r'\left\langle \Psi \right\rvert^{(1 \otimes 2)}')
assert (latex(Bra(KetSymbol(
'Psi', hs=hs1 *
hs2))) == r'\left\langle \Psi \right\rvert^{(q_{1} \otimes q_{2})}')
assert (latex(KetSymbol(
'Psi', hs=1).dag()) == r'\left\langle \Psi \right\rvert^{(1)}')
assert latex(Bra(ZeroKet)) == '0'
assert latex(Bra(TrivialKet)) == '1'
assert (latex(BasisKet(
'e', hs=hs1).adjoint()) == r'\left\langle e \right\rvert^{(q_{1})}')
assert (latex(BasisKet(
1, hs=1).adjoint()) == r'\left\langle 1 \right\rvert^{(1)}')
assert (latex(CoherentStateKet(
2.0, hs=1).dag()) == r'\left\langle \alpha=2 \right\rvert^{(1)}')
def test_unicode_bra_operations():
"""Test the unicode representation of bra operations"""
hs1 = LocalSpace('q_1', dimension=2)
hs2 = LocalSpace('q_2', dimension=2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
phi = KetSymbol("Phi", hs=hs2)
gamma = symbols('gamma', positive=True)
phase = exp(-I * gamma)
assert unicode((psi1 + psi2).dag()) == '⟨Ψ₁|^(q₁) + ⟨Ψ₂|^(q₁)'
assert unicode((psi1 * phi).dag()) == '⟨Ψ₁|^(q₁) ⊗ ⟨Φ|^(q₂)'
assert unicode(Bra(phase * psi1)) == 'exp(ⅈ γ) ⟨Ψ₁|^(q₁)'
def test_tex_bra_operations():
"""Test the tex representation of bra operations"""
hs1 = LocalSpace('q_1', dimension=2)
hs2 = LocalSpace('q_2', dimension=2)
psi1 = KetSymbol("Psi_1", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
psi2 = KetSymbol("Psi_2", hs=hs1)
bra_psi1 = KetSymbol("Psi_1", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_psi2 = KetSymbol("Psi_2", hs=hs1).dag()
bra_psi3 = KetSymbol("Psi_3", hs=hs1).dag()
bra_phi = KetSymbol("Phi", hs=hs2).dag()
A = OperatorSymbol("A_0", hs=hs1)
gamma = symbols('gamma', positive=True)
phase = exp(-I * gamma)
assert (latex(
(psi1 +
psi2).dag()) == r'\left\langle \Psi_{1} \right\rvert^{(q_{1})} + '
r'\left\langle \Psi_{2} \right\rvert^{(q_{1})}')
assert (latex((psi1 + psi2).dag(), tex_use_braket=True) ==
r'\Bra{\Psi_{1}}^{(q_{1})} + \Bra{\Psi_{2}}^{(q_{1})}')
assert (
latex(bra_psi1 +
bra_psi2) == r'\left\langle \Psi_{1} \right\rvert^{(q_{1})} + '
r'\left\langle \Psi_{2} \right\rvert^{(q_{1})}')
assert (
latex(bra_psi1 - bra_psi2 +
bra_psi3) == r'\left\langle \Psi_{1} \right\rvert^{(q_{1})} - '
r'\left\langle \Psi_{2} \right\rvert^{(q_{1})} + '
r'\left\langle \Psi_{3} \right\rvert^{(q_{1})}')
assert (latex(
bra_psi1 *
bra_phi) == r'\left\langle \Psi_{1} \right\rvert^{(q_{1})} \otimes '
r'\left\langle \Phi \right\rvert^{(q_{2})}')
assert (latex(bra_psi1 * bra_phi, tex_use_braket=True) ==
r'\Bra{\Psi_{1}}^{(q_{1})} \otimes \Bra{\Phi}^{(q_{2})}')
assert (latex(Bra(
phase *
psi1)) == r'e^{i \gamma} \left\langle \Psi_{1} \right\rvert^{(q_{1})}')
assert (latex(
(A * psi1).dag()) == r'\left\langle \Psi_{1} \right\rvert^{(q_{1})} '
r'\hat{A}_{0}^{(q_{1})\dagger}')
def test_unicode_bra_elements():
"""Test the unicode representation of "atomic" kets"""
hs1 = LocalSpace('q1', basis=('g', 'e'))
alpha, beta = symbols('alpha, beta')
assert unicode(Bra(KetSymbol('Psi', hs=hs1))) == '⟨Ψ|^(q₁)'
assert unicode(Bra(KetSymbol('Psi', hs=1))) == '⟨Ψ|⁽¹⁾'
assert unicode(Bra(KetSymbol('Psi', alpha, beta,
hs=hs1))) == ('⟨Ψ(α, β)|^(q₁)')
assert unicode(Bra(KetSymbol('Psi', hs=(1, 2)))) == '⟨Ψ|^(1⊗2)'
assert unicode(Bra(ZeroKet)) == '0'
assert unicode(Bra(TrivialKet)) == '1'
assert unicode(BasisKet('e', hs=hs1).adjoint()) == '⟨e|^(q₁)'
assert unicode(BasisKet(1, hs=1).adjoint()) == '⟨1|⁽¹⁾'
assert unicode(CoherentStateKet(2.0, hs=1).dag()) == '⟨α=2|⁽¹⁾'
assert unicode(CoherentStateKet(0.5j, hs=1).dag()) == '⟨α=0.5j|⁽¹⁾'
assert unicode(CoherentStateKet(I / 2, hs=1).dag()) == '⟨α=ⅈ/2|⁽¹⁾'
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_ascii_bra_elements():
"""Test the ascii representation of "atomic" kets"""
hs1 = LocalSpace('q1', basis=('g', 'e'))
hs2 = LocalSpace('q2', basis=('g', 'e'))
bra = Bra(KetSymbol('Psi', hs=1))
alpha, beta = symbols('alpha, beta')
assert ascii(Bra(KetSymbol('Psi', hs=hs1))) == '<Psi|^(q1)'
assert ascii(bra) == '<Psi|^(1)'
assert ascii(bra, show_hs_label=False) == '<Psi|'
assert ascii(bra, show_hs_label='subscript') == '<Psi|_(1)'
assert ascii(Bra(KetSymbol('Psi', alpha, beta,
hs=hs1))) == ('<Psi(alpha, beta)|^(q1)')
assert ascii(Bra(KetSymbol('Psi', hs=(1, 2)))) == '<Psi|^(1*2)'
assert ascii(Bra(KetSymbol('Psi', hs=hs1 * hs2))) == '<Psi|^(q1*q2)'
assert ascii(KetSymbol('Psi', hs=1).dag()) == '<Psi|^(1)'
assert ascii(Bra(ZeroKet)) == '0'
assert ascii(Bra(TrivialKet)) == '1'
assert ascii(BasisKet('e', hs=hs1).adjoint()) == '<e|^(q1)'
assert ascii(BasisKet(1, hs=1).adjoint()) == '<1|^(1)'
assert ascii(CoherentStateKet(2.0, hs=1).dag()) == '<alpha=2|^(1)'
assert ascii(CoherentStateKet(2.1, hs=1).dag()) == '<alpha=2.1|^(1)'
assert ascii(CoherentStateKet(0.5j, hs=1).dag()) == '<alpha=0.5j|^(1)'
def test_unicode_symbolic_labels():
"""Test unicode representation of symbols with symbolic labels"""
i = IdxSym('i')
j = IdxSym('j')
hs0 = LocalSpace(0)
hs1 = LocalSpace(1)
Psi = IndexedBase('Psi')
assert unicode(BasisKet(FockIndex(2 * i), hs=hs0)) == '|2 i⟩⁽⁰⁾'
assert unicode(KetSymbol(StrLabel(2 * i), hs=hs0)) == '|2 i⟩⁽⁰⁾'
assert (unicode(KetSymbol(StrLabel(Psi[i, j]),
hs=hs0 * hs1)) == '|Ψ_ij⟩^(0⊗1)')
expr = BasisKet(FockIndex(i), hs=hs0) * BasisKet(FockIndex(j), hs=hs1)
assert unicode(expr) == '|i,j⟩^(0⊗1)'
assert unicode(Bra(BasisKet(FockIndex(2 * i), hs=hs0))) == '⟨2 i|⁽⁰⁾'
assert (unicode(LocalSigma(FockIndex(i), FockIndex(j),
hs=hs0)) == '|i⟩⟨j|⁽⁰⁾')
expr = CoherentStateKet(symbols('alpha'), hs=1).to_fock_representation()
assert unicode(expr) == 'exp(-α α ⃰/2) (∑_{n ∈ ℌ₁} αⁿ/√n! |n⟩⁽¹⁾)'
tls = SpinSpace(label='s', spin='1/2', basis=('down', 'up'))
Sig = IndexedBase('sigma')
n = IdxSym('n')
Sig_n = OperatorSymbol(StrLabel(Sig[n]), hs=tls)
assert unicode(Sig_n, show_hs_label=False) == 'σ̂ₙ'
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_series_expand(braket):
"""Test expansion of scalar into a series"""
t = symbols('t', real=True)
alpha = symbols('alpha')
three = ScalarValue(3)
expr = ScalarValue(alpha * t**2 / 2 + 2 * t)
assert expr.series_expand(t, about=0, order=4) == (
Zero,
2,
alpha / 2,
Zero,
Zero,
)
assert expr.series_expand(t, about=0, order=1) == (Zero, 2)
terms = expr.series_expand(t, about=1, order=4)
for term in terms:
assert isinstance(term, Scalar)
expr_from_terms = sum([terms[i] * (t - 1)**i for i in range(1, 5)],
terms[0])
assert expr_from_terms.val.expand() == expr
assert expr.series_expand(alpha, about=0, order=4) == (
2 * t,
t**2 / 2,
Zero,
Zero,
Zero,
)
assert expr.series_expand(symbols('x'), about=0, order=4) == (
expr,
Zero,
Zero,
Zero,
Zero,
)
assert three.series_expand(symbols('x'), 0, 2) == (three, Zero, Zero)
assert Zero.series_expand(symbols('x'), 0, 2) == (Zero, Zero, Zero)
assert One.series_expand(symbols('x'), 0, 2) == (One, Zero, Zero)
expr = One / ScalarValue(t)
with pytest.raises(ValueError) as exc_info:
expr.series_expand(t, 0, 2)
assert "singular" in str(exc_info.value)
expr = sqrt(ScalarValue(t))
assert expr.series_expand(t, 1, 2) == (One, One / 2, -One / 8)
with pytest.raises(ValueError) as exc_info:
expr.series_expand(t, 0, 2)
assert "singular" in str(exc_info.value)
expr = braket.bra
assert expr.series_expand(t, 0, 2) == (
braket.bra,
Bra(ZeroKet),
Bra(ZeroKet),
)
expr = braket
assert expr.series_expand(t, 0, 2) == (braket, Zero, Zero)
expr = t * braket
assert expr.series_expand(t, 0, 2) == (Zero, braket, Zero)
expr = (1 + t * braket)**2
assert expr.series_expand(t, 0, 2) == (One, 2 * braket, braket**2)
expr = (1 + t * braket)**(sympify(1) / 2)
with pytest.raises(ValueError):
expr.series_expand(t, 0, 2)