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