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)}'