def test_incrementer() -> None:
"""
Simulate an 8-bit incrementer
"""
b = QsharpToffoliSimulatorBackend()
c = Circuit(8)
c.add_gate(OpType.CnX, [0, 1, 2, 3, 4, 5, 6, 7])
c.add_gate(OpType.CnX, [0, 1, 2, 3, 4, 5, 6])
c.add_gate(OpType.CnX, [0, 1, 2, 3, 4, 5])
c.add_gate(OpType.CnX, [0, 1, 2, 3, 4])
c.add_gate(OpType.CnX, [0, 1, 2, 3])
c.CCX(0, 1, 2)
c.CX(0, 1)
c.X(0)
for x in [0, 23, 79, 198, 255]: # some arbitrary 8-bit numbers
circ = Circuit(8)
# prepare the state corresponding to x
for i in range(8):
if (x >> i) % 2 == 1:
circ.X(i)
# append the incrementer
circ.add_circuit(c, list(range(8)))
circ.measure_all()
# run the simulator
b.compile_circuit(circ)
bits = b.get_shots(circ, 1)[0]
# check the result
for i in range(8):
assert bits[i] == ((x + 1) >> i) % 2
def test_classical() -> None:
# circuit to cover capabilities covered in HQS example notebook
c = Circuit(1)
a = c.add_c_register("a", 8)
b = c.add_c_register("b", 10)
c.add_c_register("c", 10)
c.add_c_setbits([True], [a[0]])
c.add_c_setbits([False, True] + [False] * 6, list(a))
c.add_c_setbits([True, True] + [False] * 8, list(b))
c.X(0, condition=reg_eq(a ^ b, 1))
c.X(0, condition=(a[0] ^ b[0]))
c.X(0, condition=reg_eq(a & b, 1))
c.X(0, condition=reg_eq(a | b, 1))
c.X(0, condition=a[0])
c.X(0, condition=reg_neq(a, 1))
c.X(0, condition=if_not_bit(a[0]))
c.X(0, condition=reg_gt(a, 1))
c.X(0, condition=reg_lt(a, 1))
c.X(0, condition=reg_geq(a, 1))
c.X(0, condition=reg_leq(a, 1))
b = HoneywellBackend("HQS-LT-S1-APIVAL")
b.compile_circuit(c)
assert b.get_counts(c, 10)
def t1_circ(n_orbitals: int, n_electrons: int):
"""
Args:
n_orbitals (int) = number of qubits/spin orbitals from MolecularData
n_electrons (int) = number of electrons from MolecularData
Returns:
circ (pytket.circuit.Circuit object) = in T1 configuration from H**O->LUMO
"""
circ = Circuit(n_orbitals)
for i in range(n_electrons-1): # for all but one electrons
circ.X(i) # rotates from |0> to |1>
circ.X(n_electrons) # rotate from |0> to |1> for the triplet spin orbital
return circ
def test_estimates() -> None:
"""
Check that the resource estimator gives reasonable results.
"""
b = QsharpEstimatorBackend()
c = Circuit(3)
c.H(0)
c.CX(0, 1)
c.CCX(0, 1, 2)
c.Rx(0.3, 1)
c.Ry(0.4, 2)
c.Rz(1.1, 0)
c.S(1)
c.SWAP(0, 2)
c.T(1)
c.X(0)
c.Y(1)
c.Z(2)
pbox = PauliExpBox([Pauli.X, Pauli.I, Pauli.Z], 0.25)
c.add_pauliexpbox(pbox, [2, 0, 1])
b.compile_circuit(c, 0)
resources = b.get_resources(c)
assert resources["CNOT"] >= 1
assert resources["QubitClifford"] >= 1
assert resources["R"] >= 1
assert resources["T"] >= 1
assert resources["Depth"] >= 1
assert resources["Width"] == 3
assert resources["BorrowedWidth"] == 0
def test_aer_placed_expectation() -> None:
# bug TKET-695
n_qbs = 3
c = Circuit(n_qbs, n_qbs)
c.X(0)
c.CX(0, 2)
c.CX(1, 2)
c.H(1)
# c.measure_all()
b = AerBackend()
operator = QubitPauliOperator({
QubitPauliString(Qubit(0), Pauli.Z): 1.0,
QubitPauliString(Qubit(1), Pauli.X): 0.5,
})
assert b.get_operator_expectation_value(c, operator) == (-0.5 + 0j)
with open(os.path.join(sys.path[0], "ibmqx2_properties.pickle"),
"rb") as f:
properties = pickle.load(f)
noise_model = NoiseModel.from_backend(properties)
noise_b = AerBackend(noise_model)
with pytest.raises(RuntimeError) as errorinfo:
noise_b.get_operator_expectation_value(c, operator)
assert "not supported with noise model" in str(errorinfo.value)
c.rename_units({Qubit(1): Qubit("node", 1)})
with pytest.raises(ValueError) as errorinfoCirc:
b.get_operator_expectation_value(c, operator)
assert "default register Qubits" in str(errorinfoCirc.value)
def test_ilo() -> None:
b = AerBackend()
bs = AerStateBackend()
bu = AerUnitaryBackend()
c = Circuit(2)
c.X(1)
assert (bs.get_state(c) == np.asarray([0, 1, 0, 0])).all()
assert (bs.get_state(c, basis=BasisOrder.dlo) == np.asarray([0, 0, 1,
0])).all()
assert (bu.get_unitary(c) == np.asarray([[0, 1, 0, 0], [1, 0, 0, 0],
[0, 0, 0, 1], [0, 0, 1,
0]])).all()
assert (bu.get_unitary(c,
basis=BasisOrder.dlo) == np.asarray([[0, 0, 1, 0],
[0, 0, 0, 1],
[1, 0, 0, 0],
[0, 1, 0,
0]])).all()
c.measure_all()
assert (b.get_shots(c, 2) == np.asarray([[0, 1], [0, 1]])).all()
assert (b.get_shots(c, 2,
basis=BasisOrder.dlo) == np.asarray([[1, 0],
[1, 0]])).all()
assert b.get_counts(c, 2) == {(0, 1): 2}
assert b.get_counts(c, 2, basis=BasisOrder.dlo) == {(1, 0): 2}
def test_pauli() -> None:
c = Circuit(2)
c.Rz(0.5, 0)
b = ProjectQBackend()
zi = QubitPauliString({Qubit(0): Pauli.Z})
assert np.isclose(get_pauli_expectation_value(c, zi, b), complex(1))
c.X(0)
assert np.isclose(get_pauli_expectation_value(c, zi, b), complex(-1))
def test_pauli_statevector(qvm: None, quilc: None) -> None:
c = Circuit(2, 2)
c.Rz(0.5, 0)
b = ForestStateBackend()
zi = QubitPauliString(Qubit(0), Pauli.Z)
assert get_pauli_expectation_value(c, zi, b) == 1
c.X(0)
assert get_pauli_expectation_value(c, zi, b) == -1
def test_pauli() -> None:
for b in [AerBackend(), AerStateBackend()]:
c = Circuit(2)
c.Rz(0.5, 0)
b.compile_circuit(c)
zi = QubitPauliString(Qubit(0), Pauli.Z)
assert cmath.isclose(get_pauli_expectation_value(c, zi, b), 1)
c.X(0)
assert cmath.isclose(get_pauli_expectation_value(c, zi, b), -1)
def test_pauli_statevector() -> None:
c = Circuit(2)
c.Rz(0.5, 0)
Transform.OptimisePostRouting().apply(c)
b = AerStateBackend()
zi = QubitPauliString(Qubit(0), Pauli.Z)
assert get_pauli_expectation_value(c, zi, b) == 1
c.X(0)
assert get_pauli_expectation_value(c, zi, b) == -1
def test_swaps_basisorder() -> None:
# Check that implicit swaps can be corrected irrespective of BasisOrder
b = AerStateBackend()
c = Circuit(4)
c.X(0)
c.CX(0, 1)
c.CX(1, 0)
c.CX(1, 3)
c.CX(3, 1)
c.X(2)
cu = CompilationUnit(c)
CliffordSimp(True).apply(cu)
c1 = cu.circuit
assert c1.n_gates_of_type(OpType.CX) == 2
b.compile_circuit(c)
b.compile_circuit(c1)
handles = b.process_circuits([c, c1])
s_ilo = b.get_state(c1, basis=BasisOrder.ilo)
correct_ilo = b.get_state(c, basis=BasisOrder.ilo)
assert np.allclose(s_ilo, correct_ilo)
s_dlo = b.get_state(c1, basis=BasisOrder.dlo)
correct_dlo = b.get_state(c, basis=BasisOrder.dlo)
assert np.allclose(s_dlo, correct_dlo)
qbs = c.qubits
for result in b.get_results(handles):
assert (result.get_state([qbs[1], qbs[2], qbs[3],
qbs[0]]).real.tolist().index(1.0) == 6)
assert (result.get_state([qbs[2], qbs[1], qbs[0],
qbs[3]]).real.tolist().index(1.0) == 9)
assert (result.get_state([qbs[2], qbs[3], qbs[0],
qbs[1]]).real.tolist().index(1.0) == 12)
bu = AerUnitaryBackend()
u_ilo = bu.get_unitary(c1, basis=BasisOrder.ilo)
correct_ilo = bu.get_unitary(c, basis=BasisOrder.ilo)
assert np.allclose(u_ilo, correct_ilo)
u_dlo = bu.get_unitary(c1, basis=BasisOrder.dlo)
correct_dlo = bu.get_unitary(c, basis=BasisOrder.dlo)
assert np.allclose(u_dlo, correct_dlo)
def test_operator_statevector(qvm: None, quilc: None) -> None:
c = Circuit(2, 2)
c.Rz(0.5, 0)
b = ForestStateBackend()
zi = QubitPauliString(Qubit(0), Pauli.Z)
iz = QubitPauliString(Qubit(1), Pauli.Z)
op = QubitPauliOperator({zi: 0.3, iz: -0.1})
assert get_operator_expectation_value(c, op, b) == pytest.approx(0.2)
c.X(0)
assert get_operator_expectation_value(c, op, b) == pytest.approx(-0.4)
def test_pauli_sim(qvm: None, quilc: None) -> None:
c = Circuit(2, 2)
c.Rz(0.5, 0)
b = ForestBackend("9q-square")
zi = QubitPauliString(Qubit(0), Pauli.Z)
energy = get_pauli_expectation_value(c, zi, b, 10)
assert abs(energy - 1) < 0.001
c.X(0)
energy = get_pauli_expectation_value(c, zi, b, 10)
assert abs(energy + 1) < 0.001
def test_handles() -> None:
b = QsharpSimulatorBackend()
c = Circuit(4)
c.X(0).X(1).X(2)
c.add_gate(OpType.CnX, [0, 1, 2, 3])
c.measure_all()
b.compile_circuit(c)
n_shots = 3
shots = b.get_shots(c, n_shots=n_shots)
assert all(shots[i, 3] == 1 for i in range(n_shots))
def test_convert() -> None:
c = Circuit(3)
c.H(0)
c.H(1)
c.CX(1, 0)
c.X(1)
pbox = PauliExpBox([Pauli.X, Pauli.Z, Pauli.X], 0.25)
c.add_pauliexpbox(pbox, [2, 0, 1])
qs = tk_to_qsharp(c)
assert "H(q[1]);" in qs
def test_state_handle() -> None:
b = ForestStateBackend()
c0 = Circuit(1)
c1 = Circuit(1)
c1.X(0)
b.compile_circuit(c0)
b.compile_circuit(c1)
state0 = b.get_state(c0)
state1 = b.get_state(c1)
assert np.allclose(state0, np.asarray([1.0, 0.0]))
assert np.allclose(state1, np.asarray([0.0, 1.0]))
def test_pauli_sim() -> None:
c = Circuit(2, 2)
c.Rz(0.5, 0)
Transform.OptimisePostRouting().apply(c)
b = AerBackend()
zi = QubitPauliString(Qubit(0), Pauli.Z)
energy = get_pauli_expectation_value(c, zi, b, 8000)
assert abs(energy - 1) < 0.001
c.X(0)
energy = get_pauli_expectation_value(c, zi, b, 8000)
assert abs(energy + 1) < 0.001
def test_condition_errors() -> None:
with pytest.raises(Exception) as errorinfo:
c = Circuit(2, 2)
c.X(0, condition_bits=[0], condition_value=1)
tk_to_qiskit(c)
assert "OpenQASM conditions must be an entire register" in str(
errorinfo.value)
with pytest.raises(Exception) as errorinfo:
c = Circuit(2, 2)
b = c.add_c_register("b", 2)
c.X(Qubit(0), condition_bits=[b[0], Bit(0)], condition_value=1)
tk_to_qiskit(c)
assert "OpenQASM conditions can only use a single register" in str(
errorinfo.value)
with pytest.raises(Exception) as errorinfo:
c = Circuit(2, 2)
c.X(0, condition_bits=[1, 0], condition_value=1)
tk_to_qiskit(c)
assert "OpenQASM conditions must be an entire register in order" in str(
errorinfo.value)
def test_ilo() -> None:
b = ProjectQBackend()
c = Circuit(2)
c.X(1)
assert np.allclose(b.get_state(c),
np.asarray([0, 1, 0, 0], dtype=complex),
atol=1e-10)
assert np.allclose(
b.get_state(c, basis=BasisOrder.dlo),
np.asarray([0, 0, 1, 0], dtype=complex),
atol=1e-10,
)
def test_basisorder() -> None:
for b in backends:
c = Circuit(2)
c.X(1)
b.process_circuit(c)
assert (b.get_state(c) == np.asarray([0, 1, 0, 0])).all()
assert (b.get_state(c,
basis=BasisOrder.dlo) == np.asarray([0, 0, 1,
0])).all()
c.measure_all()
assert b.get_shots(c, n_shots=4, seed=4).shape == (4, 2)
assert b.get_counts(c, n_shots=4, seed=4) == {(0, 1): 4}
def test_operator_sim(qvm: None, quilc: None) -> None:
c = Circuit(2, 2)
c.Rz(0.5, 0)
b = ForestBackend("9q-square")
zi = QubitPauliString(Qubit(0), Pauli.Z)
iz = QubitPauliString(Qubit(1), Pauli.Z)
op = QubitPauliOperator({zi: 0.3, iz: -0.1})
assert get_operator_expectation_value(c, op, b,
10) == pytest.approx(0.2, rel=0.001)
c.X(0)
assert get_operator_expectation_value(c, op, b,
10) == pytest.approx(-0.4, rel=0.001)
def test_big_circuit_ionq() -> None:
token = cast(str, os.getenv("IONQ_AUTH"))
backend = IonQBackend(api_key=token,
device_name="simulator",
label="test 2")
circ = Circuit(4)
circ.X(0).Y(0).Z(0).H(1).S(1).Sdg(1).H(1).T(2).Tdg(2).V(3).Vdg(3)
circ.SWAP(0, 1)
circ.CX(3, 2)
circ.ZZPhase(1.2, 0, 1)
circ.measure_all()
counts = backend.get_counts(circ, n_shots=100)
assert counts[(0, 0, 0, 0)] == 100
def test_from_tket() -> None:
c = Circuit(4, 2)
c.X(0)
c.H(1)
c.S(1)
c.CX(2, 0)
c.Ry(0.5, 3)
c.Measure(3, 0)
c.Measure(1, 1)
p = tk_to_pyquil(c)
assert (
len(p.instructions) == 8
) # 5 gates, 2 measures, and an initial declaration of classical register
def test_handles() -> None:
b = QsharpToffoliSimulatorBackend()
c = Circuit(4)
c.CX(0, 1)
c.CCX(0, 1, 2)
c.add_gate(OpType.CnX, [0, 1, 2, 3])
c.add_gate(OpType.noop, [2])
c.X(3)
c.SWAP(1, 2)
c.measure_all()
b.compile_circuit(c)
shots = b.get_shots(c, n_shots=2)
assert all(shots[0] == shots[1])
def test_handle() -> None:
b = ForestBackend("9q-square")
c0 = Circuit(1)
c0.measure_all()
c1 = Circuit(1)
c1.X(0)
c1.measure_all()
b.compile_circuit(c0)
b.compile_circuit(c1)
counts0 = b.get_counts(c0, n_shots=10)
counts1 = b.get_counts(c1, n_shots=10)
assert counts0 == {(0, ): 10}
assert counts1 == {(1, ): 10}
def test_expectation() -> None:
b = BraketBackend(local=True)
assert b.supports_expectation
c = Circuit(2, 2)
c.Rz(0.5, 0)
zi = QubitPauliString(Qubit(0), Pauli.Z)
iz = QubitPauliString(Qubit(1), Pauli.Z)
op = QubitPauliOperator({zi: 0.3, iz: -0.1})
assert get_pauli_expectation_value(c, zi, b) == 1
assert get_operator_expectation_value(c, op, b) == pytest.approx(0.2)
c.X(0)
assert get_pauli_expectation_value(c, zi, b) == -1
assert get_operator_expectation_value(c, op, b) == pytest.approx(-0.4)
def s0_circ(n_orbitals: int, n_electrons: int):
"""
Args:
n_orbitals (int) = number of qubits/spin orbitals from MolecularData
n_electrons (int) = number of electrons from MolecularData
Returns:
circ (pytket.circuit.Circuit object) = in Hartree-Fock ground state
"""
circ = Circuit(n_orbitals)
for i in range(n_electrons):
circ.X(i) #rotates from |0> to |1>
return circ
def test_mixed_circuit() -> None:
c = Circuit()
qr = c.add_q_register("q", 2)
ar = c.add_c_register("a", 1)
br = c.add_c_register("b", 1)
c.H(qr[0])
c.Measure(qr[0], ar[0])
c.X(qr[1], condition=reg_eq(ar, 0))
c.Measure(qr[1], br[0])
backend = AerBackend()
backend.compile_circuit(c)
counts = backend.get_counts(c, 1024)
for key in counts.keys():
assert key in {(0, 1), (1, 0)}
def h2_JW_sto3g_ansatz():
symbols = [Symbol("s0"), Symbol("s1"), Symbol("s2")]
ansatz = Circuit(4)
# Initialise in Hartree-Fock state
ansatz.X(0)
ansatz.X(1)
# Single excitations
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.X, Pauli.Z, Pauli.Y, Pauli.I], -symbols[0]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.Y, Pauli.Z, Pauli.X, Pauli.I], symbols[0]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.I, Pauli.X, Pauli.Z, Pauli.Y], -symbols[1]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.I, Pauli.Y, Pauli.Z, Pauli.X], symbols[1]), [0, 1, 2, 3]
)
# Double excitations
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.X, Pauli.X, Pauli.X, Pauli.Y], -symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.X, Pauli.X, Pauli.Y, Pauli.X], -symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.X, Pauli.Y, Pauli.X, Pauli.X], symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.Y, Pauli.X, Pauli.X, Pauli.X], symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.X, Pauli.Y, Pauli.Y, Pauli.Y], -symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.Y, Pauli.X, Pauli.Y, Pauli.Y], -symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.Y, Pauli.Y, Pauli.X, Pauli.Y], symbols[2]), [0, 1, 2, 3]
)
ansatz.add_pauliexpbox(
PauliExpBox([Pauli.Y, Pauli.Y, Pauli.Y, Pauli.X], symbols[2]), [0, 1, 2, 3]
)
# Synthesise structures into primitive gates
DecomposeBoxes().apply(ansatz)
return ansatz, symbols
def toffoli_from_tk1(a: float, b: float, c: float) -> Circuit:
""" Only accept operations equivalent to I or X. """
circ = Circuit(1)
if is_approx_0_mod_2(b) and is_approx_0_mod_2(a + c):
# identity
pass
elif is_approx_0_mod_2(b + 1) and is_approx_0_mod_2(a - c):
# X
circ.X()
else:
raise RuntimeError(
"Cannot compile to Toffoli gate set: TK1({}, {}, {}) ∉ {{I, X}}".
format(a, b, c))
return circ
