def test_tex_spin_arrows_multi_sigma():
# when fixed, combine with test_tex_spin_arrows
tls1 = SpinSpace('1', spin='1/2', basis=("down", "up"))
tls2 = SpinSpace('2', spin='1/2', basis=("down", "up"))
tls3 = SpinSpace('3', spin='1/2', basis=("down", "up"))
sig1 = LocalSigma("up", "down", hs=tls1)
sig2 = LocalSigma("up", "up", hs=tls2)
sig3 = LocalSigma("down", "down", hs=tls3)
assert latex(sig1 * sig2 * sig3) == r''
def test_operator_kronecker_sum():
"""Test that Kronecker delta are eliminiated from indexed sums over
operators"""
i = IdxSym('i')
j = IdxSym('j')
alpha = symbols('alpha')
delta_ij = KroneckerDelta(i, j)
delta_0i = KroneckerDelta(0, i)
delta_1j = KroneckerDelta(1, j)
delta_0j = KroneckerDelta(0, j)
delta_1i = KroneckerDelta(1, i)
def A(i, j):
return OperatorSymbol(StrLabel(IndexedBase('A')[i, j]), hs=0)
term = delta_ij * A(i, j)
sum = OperatorIndexedSum.create(term,
ranges=(IndexOverList(i, (1, 2)),
IndexOverList(j, (1, 2))))
assert sum == OperatorIndexedSum.create(A(i, i),
ranges=(IndexOverList(i,
(1, 2)), ))
assert sum.doit() == (OperatorSymbol("A_11", hs=0) +
OperatorSymbol("A_22", hs=0))
term = alpha * delta_ij * A(i, j)
range_i = IndexOverList(i, (1, 2))
range_j = IndexOverList(j, (1, 2))
sum = OperatorIndexedSum.create(term, ranges=(range_i, range_j))
assert isinstance(sum, ScalarTimesOperator)
expected = alpha * OperatorIndexedSum.create(
A(i, i), ranges=(IndexOverList(i, (1, 2)), ))
assert sum == expected
hs = LocalSpace('0', basis=('g', 'e'))
i_range = IndexOverFockSpace(i, hs)
j_range = IndexOverFockSpace(j, hs)
sig_ij = LocalSigma(FockIndex(i), FockIndex(j), hs=hs)
sig_0j = LocalSigma('g', FockIndex(j), hs=hs)
sig_i1 = LocalSigma(FockIndex(i), 'e', hs=hs)
term = delta_0i * delta_1j * sig_ij
sum = OperatorIndexedSum.create(term, ranges=(i_range, ))
expected = delta_1j * sig_0j
assert sum == expected
sum = OperatorIndexedSum.create(term, ranges=(j_range, ))
expected = delta_0i * sig_i1
assert sum == expected
term = (delta_0i * delta_1j + delta_0j * delta_1i) * sig_ij
sum = OperatorIndexedSum.create(term, ranges=(i_range, j_range))
expected = LocalSigma('g', 'e', hs=hs) + LocalSigma('e', 'g', hs=hs)
assert sum == expected
def operator_exprs():
"""Prepare a list of operator algebra expressions"""
hs1 = LocalSpace('q1', dimension=2)
hs2 = LocalSpace('q2', dimension=2)
A = OperatorSymbol("A", hs=hs1)
B = OperatorSymbol("B", hs=hs1)
C = OperatorSymbol("C", hs=hs2)
a, b = symbols('a, b')
A_ab = OperatorSymbol("A", a, b, hs=0)
gamma = symbols('gamma')
return [
OperatorSymbol("A", hs=hs1),
OperatorSymbol("A_1", hs=hs1 * hs2),
OperatorSymbol("A_1", symbols('alpha'), symbols('beta'), hs=hs1 * hs2),
A_ab.diff(a, n=2).diff(b),
A_ab.diff(a, n=2).diff(b).evaluate_at({a: 0}),
OperatorSymbol("Xi_2", hs=(r'q1', 'q2')),
OperatorSymbol("Xi_full", hs=1),
IdentityOperator,
ZeroOperator,
Create(hs=1),
Create(hs=LocalSpace(1, local_identifiers={'Create': 'b'})),
Destroy(hs=1),
Destroy(hs=LocalSpace(1, local_identifiers={'Destroy': 'b'})),
Jz(hs=SpinSpace(1, spin=1)),
Jz(hs=SpinSpace(1, spin=1, local_identifiers={'Jz': 'Z'})),
Jplus(hs=SpinSpace(1, spin=1, local_identifiers={'Jplus': 'Jp'})),
Jminus(hs=SpinSpace(1, spin=1, local_identifiers={'Jminus': 'Jm'})),
Phase(0.5, hs=1),
Phase(0.5, hs=LocalSpace(1, local_identifiers={'PhaseCC': 'Ph'})),
Displace(0.5, hs=1),
Squeeze(0.5, hs=1),
LocalSigma('e', 'g', hs=LocalSpace(1, basis=('g', 'e'))),
LocalSigma('e', 'e', hs=LocalSpace(1, basis=('g', 'e'))),
A + B,
A * B,
A * C,
2 * A,
2j * A,
(1 + 2j) * A,
gamma**2 * A,
-(gamma**2) / 2 * A,
tr(A * C, over_space=hs2),
Adjoint(A),
Adjoint(A + B),
PseudoInverse(A),
NullSpaceProjector(A),
A - B,
2 * A - sqrt(gamma) * (B + C),
Commutator(A, B),
]
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_ascii_operator_elements():
"""Test the ascii representation of "atomic" operator algebra elements"""
hs1 = LocalSpace('q1', dimension=2)
hs2 = LocalSpace('q2', dimension=2)
alpha, beta = symbols('alpha, beta')
assert ascii(OperatorSymbol("A", hs=hs1)) == 'A^(q1)'
A_1 = OperatorSymbol("A_1", hs=1)
assert ascii(A_1, show_hs_label='subscript') == 'A_1,(1)'
assert ascii(OperatorSymbol("A", hs=hs1), show_hs_label=False) == 'A'
assert ascii(OperatorSymbol("A_1", hs=hs1 * hs2)) == 'A_1^(q1*q2)'
assert ascii(OperatorSymbol("Xi_2", hs=('q1', 'q2'))) == 'Xi_2^(q1*q2)'
assert ascii(OperatorSymbol("Xi_full", hs=1)) == 'Xi_full^(1)'
assert ascii(OperatorSymbol("Xi", alpha, beta,
hs=1)) == ('Xi^(1)(alpha, beta)')
with pytest.raises(ValueError):
OperatorSymbol(r'\Xi^2', hs='a')
assert ascii(IdentityOperator) == "1"
assert ascii(ZeroOperator) == "0"
assert ascii(Create(hs=1)) == "a^(1)H"
assert ascii(Create(hs=1), show_hs_label=False) == "a^H"
assert ascii(Create(hs=1), show_hs_label='subscript') == "a_(1)^H"
assert ascii(Destroy(hs=1)) == "a^(1)"
fock1 = LocalSpace(1,
local_identifiers={
'Create': 'b',
'Destroy': 'b',
'Phase': 'Ph'
})
spin1 = SpinSpace(1,
spin=1,
local_identifiers={
'Jz': 'Z',
'Jplus': 'Jp',
'Jminus': 'Jm'
})
assert ascii(Create(hs=fock1)) == "b^(1)H"
assert ascii(Destroy(hs=fock1)) == "b^(1)"
assert ascii(Jz(hs=SpinSpace(1, spin=1))) == "J_z^(1)"
assert ascii(Jz(hs=spin1)) == "Z^(1)"
assert ascii(Jplus(hs=spin1)) == "Jp^(1)"
assert ascii(Jminus(hs=spin1)) == "Jm^(1)"
assert ascii(Phase(0.5, hs=1)) == 'Phase^(1)(0.5)'
assert ascii(Phase(0.5, hs=fock1)) == 'Ph^(1)(0.5)'
assert ascii(Displace(0.5, hs=1)) == 'D^(1)(0.5)'
assert ascii(Squeeze(0.5, hs=1)) == 'Squeeze^(1)(0.5)'
hs_tls = LocalSpace('1', basis=('g', 'e'))
sig_e_g = LocalSigma('e', 'g', hs=hs_tls)
assert ascii(sig_e_g) == '|e><g|^(1)'
assert ascii(sig_e_g, sig_as_ketbra=False) == 'sigma_e,g^(1)'
sig_e_e = LocalProjector('e', hs=hs_tls)
assert ascii(sig_e_e, sig_as_ketbra=False) == 'Pi_e^(1)'
assert (ascii(BasisKet(0, hs=1) * BasisKet(0, hs=2) *
BasisKet(0, hs=3)) == '|0,0,0>^(1*2*3)')
assert ascii(BasisKet(0, hs=hs1) * BasisKet(0, hs=hs2)) == '|00>^(q1*q2)'
assert (ascii(
BasisKet(0, hs=LocalSpace(0, dimension=20)) *
BasisKet(0, hs=LocalSpace(1, dimension=20))) == '|0,0>^(0*1)')
def test_unicode_operator_elements():
"""Test the unicode representation of "atomic" operator algebra elements"""
hs1 = LocalSpace('q1', dimension=2)
hs2 = LocalSpace('q2', dimension=2)
alpha, beta = symbols('alpha, beta')
assert unicode(OperatorSymbol("A", hs=hs1)) == 'A\u0302^(q\u2081)'
# Â^(q₁)
assert (unicode(OperatorSymbol('A', hs=1),
show_hs_label='subscript') == 'A\u0302\u208d\u2081\u208e'
) # Â₍₁₎
assert (unicode(
OperatorSymbol("A", hs=hs1),
unicode_op_hats=False,
unicode_sub_super=False,
) == 'A^(q_1)')
assert (unicode(OperatorSymbol(
"A_1",
hs=hs1 * hs2)) == 'A\u0302_1^(q\u2081\u2297q\u2082)') # Â_1^(q₁⊗q₂)
assert (unicode(OperatorSymbol(
"Xi_2", hs=('q1', 'q2'))) == '\u039e\u0302_2^(q\u2081\u2297q\u2082)'
) # Ξ̂_2^(q₁⊗q₂)
assert unicode(OperatorSymbol("Xi", alpha, beta, hs=1)) == ('Ξ̂⁽¹⁾(α, β)')
assert unicode(IdentityOperator) == "𝟙"
assert unicode(ZeroOperator) == "0"
assert unicode(Create(hs=1)) == 'a\u0302^(1)\u2020' # â^(1)†
assert unicode(Destroy(hs=1)) == 'a\u0302\u207d\xb9\u207e' # â⁽¹⁾
assert unicode(Destroy(hs=1), unicode_sub_super=False) == 'a\u0302^(1)'
assert unicode(Destroy(hs=1), unicode_op_hats=False) == 'a\u207d\xb9\u207e'
assert (unicode(Destroy(hs=1),
unicode_op_hats=False,
unicode_sub_super=False) == 'a^(1)')
assert (unicode(Squeeze(Rational(1, 2),
hs=1)) == 'Squeeze\u207d\xb9\u207e(1/2)')
# Squeeze⁽¹⁾(1/2)
hs_tls = LocalSpace('1', basis=('g', 'e'))
sig_e_g = LocalSigma('e', 'g', hs=hs_tls)
assert unicode(sig_e_g) == '|e⟩⟨g|⁽¹⁾'
assert unicode(sig_e_g, unicode_sub_super=False) == '|e⟩⟨g|^(1)'
assert unicode(sig_e_g, show_hs_label=False) == '|e⟩⟨g|'
assert (unicode(sig_e_g, sig_as_ketbra=False) == '\u03c3\u0302_e,g^(1)'
) # σ̂_e,g^(1)
sig_e_e = LocalProjector('e', hs=hs_tls)
assert unicode(sig_e_e) == '|e⟩⟨e|⁽¹⁾'
assert (unicode(
sig_e_e,
sig_as_ketbra=False) == '\u03a0\u0302\u2091\u207d\xb9\u207e') # Π̂ₑ⁽¹⁾
assert (unicode(BasisKet(0, hs=1) * BasisKet(0, hs=2) *
BasisKet(0, hs=3)) == '|0,0,0⟩^(1⊗2⊗3)')
assert unicode(BasisKet(0, hs=hs1) * BasisKet(0, hs=hs2)) == '|00⟩^(q₁⊗q₂)'
def test_unicode_spin_arrows():
"""Test the representation of spin-1/2 spaces with special labels "down",
"up" as arrows"""
tls1 = SpinSpace('1', spin='1/2', basis=("down", "up"))
tls2 = SpinSpace('2', spin='1/2', basis=("down", "up"))
tls3 = SpinSpace('3', spin='1/2', basis=("down", "up"))
down1 = BasisKet('down', hs=tls1)
up1 = BasisKet('up', hs=tls1)
down2 = BasisKet('down', hs=tls2)
up3 = BasisKet('up', hs=tls3)
assert unicode(down1) == r'|↓⟩⁽¹⁾'
assert unicode(up1) == r'|↑⟩⁽¹⁾'
ket = down1 * down2 * up3
assert unicode(ket) == r'|↓↓↑⟩^(1⊗2⊗3)'
sig = LocalSigma("up", "down", hs=tls1)
assert unicode(sig) == r'|↑⟩⟨↓|⁽¹⁾'
def test_tex_spin_arrows():
"""Test the representation of spin-1/2 spaces with special labels "down",
"up" as arrows"""
tls1 = SpinSpace('1', spin='1/2', basis=("down", "up"))
tls2 = SpinSpace('2', spin='1/2', basis=("down", "up"))
tls3 = SpinSpace('3', spin='1/2', basis=("down", "up"))
down1 = BasisKet('down', hs=tls1)
up1 = BasisKet('up', hs=tls1)
down2 = BasisKet('down', hs=tls2)
up3 = BasisKet('up', hs=tls3)
assert latex(down1) == r'\left\lvert \downarrow \right\rangle^{(1)}'
assert latex(up1) == r'\left\lvert \uparrow \right\rangle^{(1)}'
ket = down1 * down2 * up3
assert (
latex(ket) == r'\left\lvert \downarrow\downarrow\uparrow \right\rangle'
r'^{(1 \otimes 2 \otimes 3)}')
sig = LocalSigma("up", "down", hs=tls1)
assert (latex(sig) == r'\left\lvert \uparrow \middle\rangle\!'
r'\middle\langle \downarrow \right\rvert^{(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 test_spin_pauli_matrices():
"""Test correctness of Pauli matrices on a spin space"""
hs = SpinSpace("s", spin='1/2', basis=('down', 'up'))
assert PauliX(hs) == (LocalSigma('down', 'up', hs=hs) +
LocalSigma('up', 'down', hs=hs))
assert PauliX(hs) == PauliX(hs, states=('down', 'up'))
assert PauliY(hs).expand() == (-I * LocalSigma('down', 'up', hs=hs) +
I * LocalSigma('up', 'down', hs=hs))
assert PauliY(hs) == PauliY(hs, states=('down', 'up'))
assert PauliZ(hs) == (LocalProjector('down', hs=hs) -
LocalProjector('up', hs=hs))
assert PauliZ(hs) == PauliZ(hs, states=('down', 'up'))
hs = SpinSpace("s", spin=1, basis=('-', '0', '+'))
with pytest.raises(TypeError):
PauliX(hs, states=(0, 2))
assert PauliX(hs, states=('-', '+')) == (LocalSigma('-', '+', hs=hs) +
LocalSigma('+', '-', hs=hs))
assert PauliX(hs) == PauliX(hs, states=('-', '0'))
def test_fock_pauli_matrices():
"""Test correctness of Pauli matrices on a Fock space"""
assert PauliX(1) == LocalSigma(0, 1, hs=1) + LocalSigma(1, 0, hs=1)
assert PauliX(1) == PauliX('1') == PauliX(LocalSpace('1'))
assert PauliY(1).expand() == (-I * LocalSigma(0, 1, hs=1) +
I * LocalSigma(1, 0, hs=1))
assert PauliY(1) == PauliY('1') == PauliY(LocalSpace('1'))
assert PauliZ(1) == LocalProjector(0, hs=1) - LocalProjector(1, hs=1)
assert PauliZ(1) == PauliZ('1') == PauliZ(LocalSpace('1'))
assert PauliX(1, states=(0, 2)) == (LocalSigma(0, 2, hs=1) +
LocalSigma(2, 0, hs=1))
hs = LocalSpace("1", basis=('g', 'e', 'r'))
assert PauliX(hs) == LocalSigma(0, 1, hs=hs) + LocalSigma(1, 0, hs=hs)
assert PauliX(hs) == PauliX(hs, states=('g', 'e'))
assert PauliY(hs).expand() == (-I * LocalSigma(0, 1, hs=hs) +
I * LocalSigma(1, 0, hs=hs))
assert PauliY(hs) == PauliY(hs, states=('g', 'e'))
assert PauliZ(hs) == LocalProjector(0, hs=hs) - LocalProjector(1, hs=hs)
assert PauliZ(hs) == PauliZ(hs, states=('g', 'e'))
assert PauliX(hs, states=(0, 2)) == (LocalSigma('g', 'r', hs=hs) +
LocalSigma('r', 'g', hs=hs))
assert PauliX(hs, states=(0, 2)) == PauliX(hs, states=('g', 'r'))
def test_tex_operator_elements():
"""Test the tex representation of "atomic" operator algebra elements"""
hs1 = LocalSpace('q1', dimension=2)
hs2 = LocalSpace('q2', dimension=2)
alpha, beta = symbols('alpha, beta')
fock1 = LocalSpace(1,
local_identifiers={
'Create': 'b',
'Destroy': 'b',
'Phase': 'Phi'
})
spin1 = SpinSpace(1,
spin=1,
local_identifiers={
'Jz': 'Z',
'Jplus': 'Jp',
'Jminus': 'Jm'
})
assert latex(OperatorSymbol("A", hs=hs1)) == r'\hat{A}^{(q_{1})}'
assert (latex(OperatorSymbol(
"A_1", hs=hs1 * hs2)) == r'\hat{A}_{1}^{(q_{1} \otimes q_{2})}')
assert (latex(OperatorSymbol(
"Xi_2", hs=(r'q1', 'q2'))) == r'\hat{\Xi}_{2}^{(q_{1} \otimes q_{2})}')
assert (latex(OperatorSymbol("Xi_full",
hs=1)) == r'\hat{\Xi}_{\text{full}}^{(1)}')
assert latex(
OperatorSymbol("Xi", alpha, beta,
hs=1)) == (r'\hat{\Xi}^{(1)}\left(\alpha, \beta\right)')
assert latex(IdentityOperator) == r'\mathbb{1}'
assert latex(IdentityOperator, tex_identity_sym='I') == 'I'
assert latex(ZeroOperator) == r'\mathbb{0}'
assert latex(Create(hs=1)) == r'\hat{a}^{(1)\dagger}'
assert latex(Create(hs=fock1)) == r'\hat{b}^{(1)\dagger}'
assert latex(Destroy(hs=1)) == r'\hat{a}^{(1)}'
assert latex(Destroy(hs=fock1)) == r'\hat{b}^{(1)}'
assert latex(Jz(hs=SpinSpace(1, spin=1))) == r'\hat{J}_{z}^{(1)}'
assert latex(Jz(hs=spin1)) == r'\hat{Z}^{(1)}'
assert latex(Jplus(hs=SpinSpace(1, spin=1))) == r'\hat{J}_{+}^{(1)}'
assert latex(Jplus(hs=spin1)) == r'\text{Jp}^{(1)}'
assert latex(Jminus(hs=SpinSpace(1, spin=1))) == r'\hat{J}_{-}^{(1)}'
assert latex(Jminus(hs=spin1)) == r'\text{Jm}^{(1)}'
assert (latex(Phase(Rational(
1, 2), hs=1)) == r'\text{Phase}^{(1)}\left(\frac{1}{2}\right)')
assert latex(Phase(0.5, hs=1)) == r'\text{Phase}^{(1)}\left(0.5\right)'
assert latex(Phase(0.5, hs=fock1)) == r'\hat{\Phi}^{(1)}\left(0.5\right)'
assert latex(Displace(0.5, hs=1)) == r'\hat{D}^{(1)}\left(0.5\right)'
assert latex(Squeeze(0.5, hs=1)) == r'\text{Squeeze}^{(1)}\left(0.5\right)'
hs_tls = LocalSpace('1', basis=('g', 'e'))
sig_e_g = LocalSigma('e', 'g', hs=hs_tls)
assert latex(sig_e_g, sig_as_ketbra=False) == r'\hat{\sigma}_{e,g}^{(1)}'
assert (
latex(sig_e_g) ==
r'\left\lvert e \middle\rangle\!\middle\langle g \right\rvert^{(1)}')
hs_tls = LocalSpace('1', basis=('excited', 'ground'))
sig_excited_ground = LocalSigma('excited', 'ground', hs=hs_tls)
assert (latex(sig_excited_ground, sig_as_ketbra=False) ==
r'\hat{\sigma}_{\text{excited},\text{ground}}^{(1)}')
assert (latex(sig_excited_ground) ==
r'\left\lvert \text{excited} \middle\rangle\!'
r'\middle\langle \text{ground} \right\rvert^{(1)}')
hs_tls = LocalSpace('1', basis=('mu', 'nu'))
sig_mu_nu = LocalSigma('mu', 'nu', hs=hs_tls)
assert (latex(sig_mu_nu) == r'\left\lvert \mu \middle\rangle\!'
r'\middle\langle \nu \right\rvert^{(1)}')
hs_tls = LocalSpace('1', basis=('excited', 'ground'))
sig_excited_excited = LocalProjector('excited', hs=hs_tls)
assert (latex(sig_excited_excited,
sig_as_ketbra=False) == r'\hat{\Pi}_{\text{excited}}^{(1)}')
hs_tls = LocalSpace('1', basis=('g', 'e'))
sig_e_e = LocalProjector('e', hs=hs_tls)
assert latex(sig_e_e, sig_as_ketbra=False) == r'\hat{\Pi}_{e}^{(1)}'