Ejemplo n.º 1
0
def test_unicode_equation():
    """Test printing of the Eq class"""
    eq_1 = Eq(lhs=OperatorSymbol('H', hs=0), rhs=Create(hs=0) * Destroy(hs=0))
    # fmt: off
    eq = (eq_1.apply_to_lhs(lambda expr: expr + 1).apply_to_rhs(
        lambda expr: expr + 1).apply_to_rhs(lambda expr: expr**2).tag(
            3).transform(lambda eq: eq + 1).tag(4).apply_to_rhs('expand').
          apply_to_lhs(lambda expr: expr**2).tag(5).apply(
              'expand').apply_to_lhs(lambda expr: expr**2).tag(6).apply_to_lhs(
                  'expand').apply_to_rhs(lambda expr: expr + 1))
    # fmt: on
    assert unicode(eq_1) == 'Ĥ⁽⁰⁾ = â^(0)† â⁽⁰⁾'
    assert unicode(eq_1.tag(1)) == 'Ĥ⁽⁰⁾ = â^(0)† â⁽⁰⁾    (1)'
    unicode_lines = unicode(eq, show_hs_label=False).split("\n")
    expected = [
        '                                     Ĥ = â^† â',
        '                                 𝟙 + Ĥ = â^† â',
        '                                       = 𝟙 + â^† â',
        '                                       = (𝟙 + â^† â) (𝟙 + â^† â)        (3)',
        '                                 2 + Ĥ = 𝟙 + (𝟙 + â^† â) (𝟙 + â^† â)    (4)',
        '                                       = 2 + â^† â^† â â + 3 â^† â',
        '                       (2 + Ĥ) (2 + Ĥ) = 2 + â^† â^† â â + 3 â^† â      (5)',
        '                         4 + 4 Ĥ + Ĥ Ĥ = 2 + â^† â^† â â + 3 â^† â',
        '       (4 + 4 Ĥ + Ĥ Ĥ) (4 + 4 Ĥ + Ĥ Ĥ) = 2 + â^† â^† â â + 3 â^† â      (6)',
        '16 + 32 Ĥ + Ĥ Ĥ Ĥ Ĥ + 8 Ĥ Ĥ Ĥ + 24 Ĥ Ĥ = 2 + â^† â^† â â + 3 â^† â',
        '                                       = 3 + â^† â^† â â + 3 â^† â',
    ]
    for i, line in enumerate(unicode_lines):
        assert line == expected[i]

    eq = Eq(OperatorSymbol('H', hs=0), 0, eq_sym_str='→')
    assert unicode(eq, show_hs_label=False) == 'Ĥ → 0'
Ejemplo n.º 2
0
def test_unicode_sop_elements():
    """Test the unicode representation of "atomic" Superoperators"""
    hs1 = LocalSpace('q1', dimension=2)
    alpha, beta = symbols('alpha, beta')
    assert unicode(SuperOperatorSymbol("A", hs=hs1)) == 'A^(q₁)'
    assert (unicode(SuperOperatorSymbol("Xi_2",
                                        hs=('q1', 'q2'))) == 'Ξ_2^(q₁⊗q₂)')
    assert (unicode(SuperOperatorSymbol("Xi", alpha, beta,
                                        hs=hs1)) == 'Ξ^(q₁)(α, β)')
    assert unicode(IdentitySuperOperator) == "𝟙"
    assert unicode(ZeroSuperOperator) == "0"
Ejemplo n.º 3
0
def test_two_hs_symbol_sum():
    """Test sum_{ij} a_{ij} Psi_{ij}"""
    i = IdxSym('i')
    j = IdxSym('j')
    a = IndexedBase('a')
    hs1 = LocalSpace('1', dimension=3)
    hs2 = LocalSpace('2', dimension=3)
    hs = hs1 * hs2
    Psi = IndexedBase('Psi')
    a_ij = a[i, j]
    Psi_ij = Psi[i, j]
    KetPsi_ij = KetSymbol(StrLabel(Psi_ij), hs=hs)
    term = a_ij * KetPsi_ij

    expr1 = KetIndexedSum(
        term,
        ranges=(IndexOverFockSpace(i, hs=hs1), IndexOverFockSpace(j, hs=hs2)),
    )

    expr2 = KetIndexedSum(term,
                          ranges=(IndexOverRange(i, 0,
                                                 2), IndexOverRange(j, 0, 2)))

    assert expr1.term.free_symbols == set(
        [i, j, symbols('a'), symbols('Psi'), a_ij, Psi_ij])
    assert expr1.free_symbols == set(
        [symbols('a'), symbols('Psi'), a_ij, Psi_ij])
    assert expr1.variables == [i, j]

    assert (
        ascii(expr1) == 'Sum_{i in H_1} Sum_{j in H_2} a_ij * |Psi_ij>^(1*2)')
    assert unicode(expr1) == '∑_{i ∈ ℌ₁} ∑_{j ∈ ℌ₂} a_ij |Ψ_ij⟩^(1⊗2)'
    assert (latex(expr1) ==
            r'\sum_{i \in \mathcal{H}_{1}} \sum_{j \in \mathcal{H}_{2}} '
            r'a_{i j} \left\lvert \Psi_{i j} \right\rangle^{(1 \otimes 2)}')

    assert ascii(expr2) == 'Sum_{i,j=0}^{2} a_ij * |Psi_ij>^(1*2)'
    assert unicode(expr2) == '∑_{i,j=0}^{2} a_ij |Ψ_ij⟩^(1⊗2)'
    assert (latex(expr2) == r'\sum_{i,j=0}^{2} a_{i j} '
            r'\left\lvert \Psi_{i j} \right\rangle^{(1 \otimes 2)}')

    assert expr1.doit() == expr2.doit()
    assert expr1.doit() == KetPlus(
        a[0, 0] * KetSymbol('Psi_00', hs=hs),
        a[0, 1] * KetSymbol('Psi_01', hs=hs),
        a[0, 2] * KetSymbol('Psi_02', hs=hs),
        a[1, 0] * KetSymbol('Psi_10', hs=hs),
        a[1, 1] * KetSymbol('Psi_11', hs=hs),
        a[1, 2] * KetSymbol('Psi_12', hs=hs),
        a[2, 0] * KetSymbol('Psi_20', hs=hs),
        a[2, 1] * KetSymbol('Psi_21', hs=hs),
        a[2, 2] * KetSymbol('Psi_22', hs=hs),
    )
Ejemplo n.º 4
0
def test_primed_IdxSym():
    """Test that primed IdxSym are rendered correctly not just in QAlgebra's
    printing system, but also in SymPy's printing system"""
    ipp = IdxSym('i').prime.prime
    assert qalgebra.ascii(ipp) == "i''"
    assert qalgebra.latex(ipp) == r'{i^{\prime\prime}}'
    assert qalgebra.srepr(ipp) == "IdxSym('i', integer=True, primed=2)"
    assert qalgebra.unicode(ipp) == "i''"
    assert sympy.printing.sstr(ipp) == qalgebra.ascii(ipp)
    assert sympy.printing.latex(ipp) == qalgebra.latex(ipp)
    assert sympy.printing.srepr(ipp) == qalgebra.srepr(ipp)
    assert sympy.printing.pretty(ipp) == qalgebra.unicode(ipp)
Ejemplo n.º 5
0
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₁)'
Ejemplo n.º 6
0
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'|↑⟩⟨↓|⁽¹⁾'
Ejemplo n.º 7
0
def test_unicode_hilbert_elements():
    """Test the unicode representation of "atomic" Hilbert space algebra
    elements"""
    assert unicode(LocalSpace(1)) == 'ℌ₁'
    assert unicode(LocalSpace(1, dimension=2)) == 'ℌ₁'
    assert unicode(LocalSpace(1, basis=('g', 'e'))) == 'ℌ₁'
    assert unicode(LocalSpace('local')) == 'ℌ_local'
    assert unicode(LocalSpace('kappa')) == 'ℌ_κ'
    assert unicode(TrivialSpace) == 'ℌ_null'
    assert unicode(FullSpace) == 'ℌ_total'
    assert unicode(LocalSpace(StrLabel(IdxSym('i')))) == 'ℌ_i'
Ejemplo n.º 8
0
def test_unicode_matrix():
    """Test unicode representation of the Matrix class"""
    A = OperatorSymbol("A", hs=1)
    B = OperatorSymbol("B", hs=1)
    C = OperatorSymbol("C", hs=1)
    D = OperatorSymbol("D", hs=1)
    assert (unicode(Matrix(
        [[A, B],
         [C, D]])) == '[[A\u0302\u207d\xb9\u207e, B\u0302\u207d\xb9\u207e], '
            '[C\u0302\u207d\xb9\u207e, D\u0302\u207d\xb9\u207e]]')
    #  '[[Â⁽¹⁾, B̂⁽¹⁾], [Ĉ⁽¹⁾, D̂⁽¹⁾]]')
    assert (unicode(Matrix(
        [A, B, C,
         D])) == '[[A\u0302\u207d\xb9\u207e], [B\u0302\u207d\xb9\u207e], '
            '[C\u0302\u207d\xb9\u207e], [D\u0302\u207d\xb9\u207e]]')
    #  '[Â⁽¹⁾], [B̂⁽¹⁾], [Ĉ⁽¹⁾], [D̂⁽¹⁾]]')
    assert unicode(Matrix([[0, 1], [-1, 0]])) == '[[0, 1], [-1, 0]]'
    assert unicode(Matrix([[], []])) == '[[], []]'
    assert unicode(Matrix([])) == '[[], []]'
Ejemplo n.º 9
0
def test_unicode_scalar():
    """Test rendering of scalar values"""
    assert unicode(2) == '2'
    # we always want 2.0 to be printed as '2'. Without this normalization, the
    # state of the cache might introduce non-reproducible behavior, as 2==2.0
    unicode.printer.cache = {}
    assert 2 == 2.0
    assert unicode(2.0) == '2'  # would be '2.0' without normalization
    assert unicode(1j) == '1j'
    assert ((I / 2) - 0.5j) == 0
    assert unicode(I / 2) == 'ⅈ/2'
    assert unicode(0.5j) == '0.5j'
    assert unicode(sympy.pi) == 'π'
    assert unicode(sympy.pi / 4) == 'π/4'

    i = IdxSym('i')
    alpha = IndexedBase('alpha')
    assert unicode(alpha[i]) == 'α_i'
    assert unicode(alpha[1]) == 'α₁'
Ejemplo n.º 10
0
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) == 'σ̂ₙ'
Ejemplo n.º 11
0
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|⁽¹⁾'
Ejemplo n.º 12
0
def test_unicode_derivative(MyScalarFunc):
    s, s0, t, t0, gamma = symbols('s, s_0, t, t_0, gamma', real=True)
    m = IdxSym('m')
    n = IdxSym('n')
    S = IndexedBase('s')
    T = IndexedBase('t')

    f = partial(MyScalarFunc, "f")
    g = partial(MyScalarFunc, "g")

    expr = f(s, t).diff(s, n=2).diff(t)
    assert unicode(expr) == '∂ₛ² ∂ₜ f(s, t)'

    expr = f(s, t).diff(s, n=2).diff(t).evaluate_at({s: s0})
    assert unicode(expr) == '∂ₛ² ∂ₜ f(s, t) |_s=s₀'

    expr = f(S[m], T[n]).diff(S[m], n=2).diff(T[n]).evaluate_at({S[m]: s0})
    assert unicode(expr) == '∂_sₘ^2 ∂_tₙ f(sₘ, tₙ) |_sₘ=s₀'

    expr = f(s, t).diff(s, n=2).diff(t).evaluate_at({s: 0})
    assert unicode(expr) == '∂ₛ² ∂ₜ f(s, t) |ₛ₌₀'

    expr = f(gamma, t).diff(gamma, n=2).diff(t).evaluate_at({gamma: 0})
    assert unicode(expr) == '∂ᵧ² ∂ₜ f(γ, t) |ᵧ₌₀'

    expr = f(s, t).diff(s, n=2).diff(t).evaluate_at({s: s0, t: t0})
    assert unicode(expr) == '∂ₛ² ∂ₜ f(s, t) |_(s=s₀, t=t₀)'

    D = expr.__class__

    expr = D(f(s, t) + g(s, t), derivs={s: 2, t: 1}, vals={s: s0, t: t0})
    assert unicode(expr) == '∂ₛ² ∂ₜ (f(s, t) + g(s, t)) |_(s=s₀, t=t₀)'

    expr = D(2 * f(s, t), derivs={s: 2, t: 1}, vals={s: s0, t: t0})
    assert unicode(expr) == '∂ₛ² ∂ₜ (2 f(s, t)) |_(s=s₀, t=t₀)'

    expr = f(s, t).diff(t) + g(s, t)
    assert unicode(expr) == '∂ₜ f(s, t) + g(s, t)'

    expr = f(s, t).diff(t) * g(s, t)
    assert unicode(expr) == '(∂ₜ f(s, t)) g(s, t)'

    expr = f(s, t).diff(t).evaluate_at({t: 0}) * g(s, t)
    assert unicode(expr) == '(∂ₜ f(s, t) |ₜ₌₀) g(s, t)'

    f = MyScalarFunc("f", S[m], T[n])
    series = f.series_expand(T[n], about=0, order=3)
    assert unicode(series) == ('('
                               'f(sₘ, 0), '
                               '∂_tₙ f(sₘ, tₙ) |_tₙ=0, '
                               '1/2 (∂_tₙ^2 f(sₘ, tₙ) |_tₙ=0), '
                               '1/6 (∂_tₙ^3 f(sₘ, tₙ) |_tₙ=0))')

    f = MyScalarFunc("f", s, t)
    series = f.series_expand(t, about=0, order=2)
    assert (unicode(series) ==
            '(f(s, 0), ∂ₜ f(s, t) |ₜ₌₀, 1/2 (∂ₜ² f(s, t) |ₜ₌₀))')

    f = MyScalarFunc("f", S[m], T[n])
    series = f.series_expand(T[n], about=t0, order=3)
    assert unicode(series) == ('('
                               'f(sₘ, t₀), '
                               '∂_tₙ f(sₘ, tₙ) |_tₙ=t₀, '
                               '1/2 (∂_tₙ^2 f(sₘ, tₙ) |_tₙ=t₀), '
                               '1/6 (∂_tₙ^3 f(sₘ, tₙ) |_tₙ=t₀))')

    expr = (  # nested derivative
        MyScalarFunc("f", s, t).diff(s, n=2).diff(t).evaluate_at({
            t: t0
        }).diff(t0))
    assert unicode(expr) == '∂_t₀ (∂ₛ² ∂ₜ f(s, t) |_t=t₀)'
Ejemplo n.º 13
0
 def _unicode(self, *args, **kwargs):
     return "%s(%s)" % (
         self._name,
         ", ".join([unicode(sym) for sym in self._sym_args]),
     )
Ejemplo n.º 14
0
def test_qubit_state():
    """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)

    expr1 = KetIndexedSum.create(term, ranges=IndexOverFockSpace(i, hs=hs_tls))

    expr2 = KetIndexedSum.create(term, ranges=IndexOverList(i, [0, 1]))

    expr3 = KetIndexedSum.create(term,
                                 ranges=IndexOverRange(i, start_from=0, to=1))

    assert IndexOverFockSpace(i, hs=hs_tls) in expr1.kwargs['ranges']

    assert ascii(expr1) == "Sum_{i in H_tls} alpha_i * |i>^(tls)"
    assert unicode(expr1) == "∑_{i ∈ ℌ_tls} α_i |i⟩⁽ᵗˡˢ⁾"
    assert (
        srepr(expr1) ==
        "KetIndexedSum(ScalarTimesKet(ScalarValue(Indexed(IndexedBase(Symbol('alpha')), IdxSym('i', integer=True))), BasisKet(FockIndex(IdxSym('i', integer=True)), hs=LocalSpace('tls', basis=('g', 'e')))), ranges=(IndexOverFockSpace(IdxSym('i', integer=True), LocalSpace('tls', basis=('g', 'e'))),))"
    )
    with configure_printing(tex_use_braket=True):
        assert (latex(expr1) ==
                r'\sum_{i \in \mathcal{H}_{tls}} \alpha_{i} \Ket{i}^{(tls)}')

    assert ascii(expr2) == 'Sum_{i in {0,1}} alpha_i * |i>^(tls)'
    assert unicode(expr2) == '∑_{i ∈ {0,1}} α_i |i⟩⁽ᵗˡˢ⁾'
    assert (
        srepr(expr2) ==
        "KetIndexedSum(ScalarTimesKet(ScalarValue(Indexed(IndexedBase(Symbol('alpha')), IdxSym('i', integer=True))), BasisKet(FockIndex(IdxSym('i', integer=True)), hs=LocalSpace('tls', basis=('g', 'e')))), ranges=(IndexOverList(IdxSym('i', integer=True), (0, 1)),))"
    )
    with configure_printing(tex_use_braket=True):
        assert (
            latex(expr2) == r'\sum_{i \in \{0,1\}} \alpha_{i} \Ket{i}^{(tls)}')

    assert ascii(expr3) == 'Sum_{i=0}^{1} alpha_i * |i>^(tls)'
    assert unicode(expr3) == '∑_{i=0}^{1} α_i |i⟩⁽ᵗˡˢ⁾'
    assert (
        srepr(expr3) ==
        "KetIndexedSum(ScalarTimesKet(ScalarValue(Indexed(IndexedBase(Symbol('alpha')), IdxSym('i', integer=True))), BasisKet(FockIndex(IdxSym('i', integer=True)), hs=LocalSpace('tls', basis=('g', 'e')))), ranges=(IndexOverRange(IdxSym('i', integer=True), 0, 1),))"
    )
    with configure_printing(tex_use_braket=True):
        assert latex(expr3) == r'\sum_{i=0}^{1} \alpha_{i} \Ket{i}^{(tls)}'

    for expr in (expr1, expr2, expr3):
        assert expr.term.free_symbols == set([i, symbols('alpha'), alpha_i])
        assert expr.term.bound_symbols == set()
        assert expr.free_symbols == set([symbols('alpha'), alpha_i])
        assert expr.variables == [i]
        assert expr.bound_symbols == set([i])
        assert len(expr) == len(expr.ranges[0]) == 2
        assert 0 in expr.ranges[0]
        assert 1 in expr.ranges[0]
        assert expr.space == hs_tls
        assert len(expr.args) == 1
        assert len(expr.kwargs) == 1
        assert len(expr.operands) == 1
        assert expr.args[0] == term
        assert expr.term == term
        expr_expand = expr.doit().substitute({
            alpha[0]: alpha['g'],
            alpha[1]: alpha['e']
        })
        assert expr_expand == (alpha['g'] * BasisKet('g', hs=hs_tls) +
                               alpha['e'] * BasisKet('e', hs=hs_tls))
        assert (
            ascii(expr_expand) == 'alpha_e * |e>^(tls) + alpha_g * |g>^(tls)')

    with pytest.raises(TypeError) as exc_info:
        KetIndexedSum.create(alpha_i * BasisKet(i, hs=hs_tls),
                             IndexOverFockSpace(i, hs=hs_tls))
    assert "label_or_index must be an instance of" in str(exc_info.value)
Ejemplo n.º 15
0
def test_unicode_sop_operations():
    """Test the unicode representation of super operator algebra operations"""
    hs1 = LocalSpace('q_1', dimension=2)
    hs2 = LocalSpace('q_2', dimension=2)
    A = SuperOperatorSymbol("A", hs=hs1)
    B = SuperOperatorSymbol("B", hs=hs1)
    C = SuperOperatorSymbol("C", hs=hs2)
    L = SuperOperatorSymbol("L", hs=1)
    M = SuperOperatorSymbol("M", hs=1)
    A_op = OperatorSymbol("A", hs=1)
    gamma = symbols('gamma', positive=True)
    assert unicode(A + B) == 'A^(q₁) + B^(q₁)'
    assert unicode(A * B) == 'A^(q₁) B^(q₁)'
    assert unicode(A * C) == 'A^(q₁) C^(q₂)'
    assert unicode(2j * A) == '2j A^(q₁)'
    assert unicode(gamma**2 * A) == 'γ² A^(q₁)'
    assert unicode(SuperAdjoint(A)) == 'A^(q₁)†'
    assert unicode(A - B + C) == 'A^(q₁) - B^(q₁) + C^(q₂)'
    assert unicode(2 * A - sqrt(gamma) * (B + C)) in [
        '2 A^(q₁) - sqrt(γ) (B^(q₁) + C^(q₂))',
        '2 A^(q₁) - √γ (B^(q₁) + C^(q₂))',
    ]
    assert unicode(SPre(A_op)) == 'SPre(A\u0302\u207d\xb9\u207e)'
    #                              SPre(Â⁽¹⁾)
    assert unicode(SPost(A_op)) == 'SPost(A\u0302\u207d\xb9\u207e)'
    #                               SPost(Â⁽¹⁾)
    assert (unicode(SuperOperatorTimesOperator(
        L, A_op)) == 'L\u207d\xb9\u207e[A\u0302\u207d\xb9\u207e]')
    #        L⁽¹⁾[Â⁽¹⁾]
    assert unicode(SuperOperatorTimesOperator(
        L,
        sqrt(gamma) * A_op)) in [
            'L\u207d\xb9\u207e[\u221a\u03b3 A\u0302\u207d\xb9\u207e]',
            'L\u207d\xb9\u207e[sqrt(\u03b3) A\u0302\u207d\xb9\u207e]',
        ]
    #        L⁽¹⁾[√γ Â⁽¹⁾]
    assert (unicode(SuperOperatorTimesOperator(
        (L + 2 * M), A_op)) == '(L\u207d\xb9\u207e + 2 M\u207d\xb9\u207e)'
            '[A\u0302\u207d\xb9\u207e]')
Ejemplo n.º 16
0
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₂)'
Ejemplo n.º 17
0
def test_unicode_operator_operations():
    """Test the unicode representation of operator algebra operations"""
    hs1 = LocalSpace('q_1', dimension=2)
    hs2 = LocalSpace('q_2', dimension=2)
    A = OperatorSymbol("A", hs=hs1)
    B = OperatorSymbol("B", hs=hs1)
    C = OperatorSymbol("C", hs=hs2)
    psi = KetSymbol('Psi', hs=hs1)
    gamma = symbols('gamma', positive=True)
    assert unicode(A + B) == 'A\u0302^(q\u2081) + B\u0302^(q\u2081)'
    #                         Â^(q₁) + B̂^(q₁)
    assert unicode(A * B) == 'A\u0302^(q\u2081) B\u0302^(q\u2081)'
    #                         Â^(q₁) B̂^(q₁)
    assert unicode(A * C) == 'A\u0302^(q\u2081) C\u0302^(q\u2082)'
    #                         Â^(q₁) Ĉ^(q₂)
    assert unicode(2 * A) == '2 A\u0302^(q\u2081)'  # 2 Â^(q₁)
    assert unicode(2j * A) == '2j A\u0302^(q\u2081)'
    #                          2j Â^(q₁)
    assert unicode((1 + 2j) * A) == '(1+2j) A\u0302^(q\u2081)'
    #                              (1+2j) Â^(q₁)
    assert unicode(gamma**2 * A) == '\u03b3\xb2 A\u0302^(q\u2081)'
    #                                γ² Â^(q₁)
    assert unicode(-(gamma**2) / 2 * A) == '-\u03b3\xb2/2 A\u0302^(q\u2081)'
    #                                   -γ²/2 Â^(q₁)
    assert (unicode(tr(
        A * C,
        over_space=hs2)) == 'tr_(q\u2082)[C\u0302^(q\u2082)] A\u0302^(q\u2081)'
            )
    #       tr_(q₂)[Ĉ^(q₂)] Â^(q₁)
    assert unicode(Adjoint(A)) == 'A\u0302^(q\u2081)\u2020'
    #                             Â^(q₁)†
    assert unicode(Adjoint(Create(hs=1))) == 'a\u0302\u207d\xb9\u207e'
    #              â⁽¹⁾
    assert unicode(PseudoInverse(A)) == '(A\u0302^(q\u2081))^+'
    #              (Â^(q₁))^+
    assert unicode(NullSpaceProjector(A)) == 'P\u0302_Ker(A\u0302^(q\u2081))'
    #                                         P̂_Ker(Â^(q₁))
    assert unicode(A - B) == 'A\u0302^(q\u2081) - B\u0302^(q\u2081)'
    #                         Â^(q₁) - B̂^(q₁)
    assert unicode(2 * A - sqrt(gamma) * (B + C)) in [
        '2 A\u0302^(q\u2081) - \u221a\u03b3 (B\u0302^(q\u2081) '
        '+ C\u0302^(q\u2082))',
        '2 A\u0302^(q\u2081) - sqrt(\u03b3) (B\u0302^(q\u2081) '
        '+ C\u0302^(q\u2082))',
    ]
    #       2 Â^(q₁) - √γ (B̂^(q₁) + Ĉ^(q₂))
    assert (unicode(Commutator(A,
                               B)) == '[A\u0302^(q\u2081), B\u0302^(q\u2081)]')
    #       [Â^(q₁), B̂^(q₁)]
    expr = (Commutator(A, B) * psi).dag()
    assert unicode(expr, show_hs_label=False) == r'⟨Ψ| [Â, B̂]^†'
Ejemplo n.º 18
0
def test_unicode_ket_elements():
    """Test the unicode representation of "atomic" kets"""
    hs1 = LocalSpace('q1', basis=('g', 'e'))
    hs2 = LocalSpace('q2', basis=('g', 'e'))
    alpha, beta = symbols('alpha, beta')
    psi_hs1 = KetSymbol('Psi', hs=hs1)
    assert unicode(psi_hs1) == '|Ψ⟩^(q₁)'
    assert unicode(psi_hs1, unicode_sub_super=False) == '|Ψ⟩^(q_1)'
    assert unicode(KetSymbol('Psi', hs=1)) == '|Ψ⟩⁽¹⁾'
    assert unicode(KetSymbol('Psi', alpha, beta, hs=1)) == '|Ψ(α, β)⟩⁽¹⁾'
    assert unicode(KetSymbol('Psi', hs=(1, 2))) == '|Ψ⟩^(1⊗2)'
    assert unicode(KetSymbol('Psi', hs=hs1 * hs2)) == '|Ψ⟩^(q₁⊗q₂)'
    assert unicode(ZeroKet) == '0'
    assert unicode(TrivialKet) == '1'
    assert unicode(BasisKet('e', hs=hs1)) == '|e⟩^(q₁)'
    assert unicode(BasisKet(1, hs=1)) == '|1⟩⁽¹⁾'
    assert unicode(CoherentStateKet(2, hs=1)) == '|α=2⟩⁽¹⁾'
    assert unicode(CoherentStateKet(2.0, hs=1)) == '|α=2⟩⁽¹⁾'
    unicode.printer.cache = {}
    assert unicode(CoherentStateKet(2.0, hs=1)) == '|α=2⟩⁽¹⁾'
    assert unicode(CoherentStateKet(2.1, hs=1)) == '|α=2.1⟩⁽¹⁾'
Ejemplo n.º 19
0
def test_unicode_hilbert_operations():
    """Test the unicode representation of Hilbert space algebra operations"""
    H1 = LocalSpace(1)
    H2 = LocalSpace(2)
    assert unicode(H1 * H2) == 'ℌ₁ ⊗ ℌ₂'
Ejemplo n.º 20
0
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|Ψ⟩⁽⁰⁾"