def test_cmp() -> None:
x = sX(1)
x2 = sX(1)
y = sY(2, 2.0)
y2 = sY(2, 2.0)
assert x < y
assert x2 <= y
assert x <= x2
assert x == x2
assert y2 > x
assert y >= y2
with pytest.raises(TypeError):
"foo" > y
with pytest.raises(TypeError):
"foo" >= y
with pytest.raises(TypeError):
"foo" < y
with pytest.raises(TypeError):
"foo" <= y
assert not 2 == y
def test_check_commutation():
term1 = sX(0) * sX(1)
term2 = sY(0) * sY(1)
term3 = sY(0) * sZ(2)
assert qf.paulis_commute(term2, term3)
assert qf.paulis_commute(term2, term3)
assert not qf.paulis_commute(term1, term3)
def test_zero():
z = qf.Pauli.scalar(0.0)
assert z.is_zero()
assert z.is_scalar()
z2 = qf.Pauli.zero()
assert z == z2
assert sX(0) - sX(0) == qf.Pauli.zero()
def test_get_qubits() -> None:
term = sZ(0) * sX(1)
assert term.qubits == (0, 1)
term += sY(10) + sX(2) + sY(2)
assert term.qubits == (0, 1, 2, 10)
sum_term = qf.Pauli.term(
[0], "X",
0.5) + 0.5j * qf.Pauli.term([10], "Y") * qf.Pauli.term([0], "Y", 0.5j)
assert sum_term.qubits == (0, 10)
def test_commuting_sets():
term1 = sX(0) * sX(1)
term2 = sY(0) * sY(1)
term3 = sY(0) * sZ(2)
ps = term1 + term2 + term3
pcs = qf.pauli_commuting_sets(ps)
assert len(pcs) == 2
pcs = qf.pauli_commuting_sets(term1)
assert len(pcs) == 1
def test_pauli_rewire() -> None:
term = sZ(0) * sX(1)
term = term.on(5, 4)
assert term.qubits == (4, 5)
assert term == sZ(5) * sX(4)
term = term.rewire({5: "a", 4: "b"})
assert term.qubits == ("a", "b")
assert term == sZ("a") * sX("b")
with pytest.raises(ValueError):
term.on(1, 2, 3, 4)
def test_product():
p = qf.pauli_product(sX(0), sY(0))
assert p == sZ(0, 1j)
p = qf.pauli_product(sY(0), sX(0))
assert p == sZ(0, -1j)
p = qf.pauli_product(sX(0), sY(1))
assert p == qf.Pauli.term([0, 1], 'XY', 1)
p = qf.pauli_product(sX(0), sY(1), sY(0))
assert p == qf.Pauli.term([0, 1], 'ZY', 1j)
p = qf.pauli_product(sY(0), sX(0), sY(1))
assert p == qf.Pauli.term([0, 1], 'ZY', -1j)
def test_product() -> None:
p = qf.pauli_product(sX(0), sY(0))
assert p == sZ(0, 1j)
p = qf.pauli_product(sY(0), sX(0))
assert p == sZ(0, -1j)
p = qf.pauli_product(sX(0), sY(1))
assert p == qf.Pauli.term([0, 1], "XY", 1)
p = qf.pauli_product(sX(0), sY(1), sY(0))
assert p == qf.Pauli.term([0, 1], "ZY", 1j)
p = qf.pauli_product(sY(0), sX(0), sY(1))
assert p == qf.Pauli.term([0, 1], "ZY", -1j)
def test_get_qubits():
term = sZ(0) * sX(1)
assert term.qubits == [0, 1]
sum_term = qf.Pauli.term([0], 'X', 0.5) \
+ 0.5j * qf.Pauli.term([10], 'Y') * qf.Pauli.term([0], 'Y', 0.5j)
assert sum_term.qubits == [0, 10]
def test_run() -> None:
x = sX(1)
y = sY(2, 1.2)
s = x + y
ket0 = qf.zero_state(3)
_ = s.run(ket0)
def test_sub():
x = sX(1)
y = sY(2, 2.0)
s = x - y
assert ((((1, 'X'),), (1+0j)), (((2, 'Y'),), (-2+0j))) == s.terms
s = 2 - y
assert str(s) == '+ (+2+0j) + (-2+0j) Y(2)'
def test_isclose() -> None:
x = sX(1)
y = sY(2, 2.0)
y2 = sY(2, 2.00000001)
assert qf.paulis_close(x, x)
assert not qf.paulis_close(x, y)
assert qf.paulis_close(y, y2)
def test_sub() -> None:
x = sX(1)
y = sY(2, 2.0)
s = x - y
assert s == qf.Pauli(([1], "X", 1), ([2], "Y", -2))
s = 2 - y
assert str(s) == "+(2+0j) +(-2+0j) sY(2)"
def test_zero_term():
qubit_id = 0
coefficient = 10
ps = sI(qubit_id) + sX(qubit_id)
assert coefficient * qf.Pauli.zero() == qf.Pauli.zero()
assert qf.Pauli.zero() * coefficient == qf.Pauli.zero()
assert qf.Pauli.zero() * qf.Pauli.identity() == qf.Pauli.zero()
assert qf.Pauli.zero() + qf.Pauli.identity() == qf.Pauli.identity()
assert qf.Pauli.zero() + ps == ps
assert ps + qf.Pauli.zero() == ps
def test_power():
p = sX(0) + sY(1) + qf.Pauli.term([2, 3], 'XY')
assert p**0 == qf.Pauli.identity()
assert p**1 == p
assert p * p == p**2
assert p * p * p == p**3
assert p * p * p * p * p * p * p * p * p * p == p**10
with pytest.raises(ValueError):
p ** -1
p ** 400
def test_cmp():
x = sX(1)
y = sY(2, 2.0)
assert x < y
assert x <= y
assert x <= x
assert x == x
assert y > x
assert y >= y
with pytest.raises(TypeError):
'foo' > y
assert not 2 == y
def test_scalar():
a = qf.Pauli.scalar(1.0)
assert a.is_scalar()
assert a.is_identity()
b = qf.Pauli.scalar(2.0)
assert b + b == qf.Pauli.scalar(4.0)
assert b * b == qf.Pauli.scalar(4.0)
assert -b == qf.Pauli.scalar(-2.0)
assert +b == qf.Pauli.scalar(2.0)
assert b * 3 == qf.Pauli.scalar(6.0)
assert 3 * b == qf.Pauli.scalar(6.0)
assert sX(0) * 2 == sX(0, 2)
x = sX(0) + sY(1)
assert not x.is_scalar()
assert not x.is_identity()
c = sX(0) * sY(1)
assert not c.is_scalar()
assert not c.is_identity()
def test_add():
x = sX(1)
y = sY(2, 2.0)
s = x + y
assert ((((1, 'X'),), (1+0j)), (((2, 'Y'),), (2+0j))) == s.terms
def test_neg() -> None:
ps = sY(0) - sX(0)
ps -= sZ(1)
ps = ps - 3
_ = 3 + ps
def test_neg():
ps = sY(0) - sX(0)
ps -= sZ(1)
ps = ps - 3
ps = 3 + ps
def test_mul():
# TODO CHECK ALL PAULI MULTIPLICATIONS HERE
assert sX(0) * sY(0) == sZ(0, 1j)
def test_hash():
x = sX(5)
d = {x: 4}
assert d[x] == 4
def test_paulisum_iteration():
term_list = [sX(2), sZ(4)]
ps = sum(term_list)
for ii, term in enumerate(ps):
assert term_list[ii].terms[0] == term
def test_hash() -> None:
x = sX(5)
d = {x: 4}
assert d[x] == 4
def test_add() -> None:
x = sX(1)
y = sY(2, 2.0)
s = y + x
assert s == qf.Pauli(([1], "X", 1), ([2], "Y", 2))
