def test_PrepareAndMeasureOnWFSim_QubitPlaceholders():
q1, q2 = QubitPlaceholder(), QubitPlaceholder()
p = Program()
params = p.declare("params", memory_type="REAL", memory_size=2)
p.inst(RX(params[0], q1))
p.inst(RX(params[1], q2))
def make_memory_map(params):
return {"params": params}
ham = PauliSum([PauliTerm("Z", q1), PauliTerm("Z", q2)])
qubit_mapping = get_default_qubit_mapping(p)
sim = WavefunctionSimulator()
with local_qvm():
cost_fn = PrepareAndMeasureOnWFSim(
p,
make_memory_map,
ham,
sim,
enable_logging=True,
qubit_mapping=qubit_mapping,
scalar_cost_function=False,
)
out = cost_fn([np.pi, np.pi / 2], nshots=100)
assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.1))
assert np.allclose(out, (-1, 0.1))
def test_PrepareAndMeasureOnQVM_QubitPlaceholders_nondiag_hamiltonian():
q1, q2, q3 = QubitPlaceholder(), QubitPlaceholder(), QubitPlaceholder()
ham = PauliTerm("Y", q1) * PauliTerm("Z", q3)
ham += PauliTerm("Y", q1) * PauliTerm("Z", q2, -0.3)
ham += PauliTerm("Y", q1) * PauliTerm("X", q3, 2.0)
params = [3.0, 0.4, 4.5]
prepare_ansatz = Program()
param_register = prepare_ansatz.declare("params",
memory_type="REAL",
memory_size=3)
prepare_ansatz.inst(RX(param_register[0], q1))
prepare_ansatz.inst(RY(param_register[1], q2))
prepare_ansatz.inst(RY(param_register[2], q3))
def make_memory_map(params):
return {"params": params}
qubit_mapping = get_default_qubit_mapping(prepare_ansatz)
qvm = get_qc("3q-qvm")
with local_qvm():
cost_fn = PrepareAndMeasureOnQVM(prepare_ansatz,
make_memory_map,
qvm=qvm,
hamiltonian=ham,
scalar_cost_function=False,
base_numshots=100,
qubit_mapping=qubit_mapping)
out = cost_fn(params, nshots=10)
assert np.allclose(out, (0.346, 0.07), rtol=1.1)
def test_PrepareAndMeasureOnQVM_QubitPlaceholders():
q1, q2 = QubitPlaceholder(), QubitPlaceholder()
prepare_ansatz = Program()
param_register = prepare_ansatz.declare("params",
memory_type="REAL",
memory_size=2)
prepare_ansatz.inst(RX(param_register[0], q1))
prepare_ansatz.inst(RX(param_register[1], q2))
def make_memory_map(params):
return {"params": params}
ham = PauliSum([PauliTerm("Z", q1), PauliTerm("Z", q2)])
qubit_mapping = get_default_qubit_mapping(prepare_ansatz)
qvm = get_qc("2q-qvm")
with local_qvm():
# qvm = proc.qvm
cost_fn = PrepareAndMeasureOnQVM(prepare_ansatz,
make_memory_map,
qvm=qvm,
hamiltonian=ham,
enable_logging=True,
scalar_cost_function=False,
base_numshots=10,
qubit_mapping=qubit_mapping)
out = cost_fn([np.pi, np.pi / 2], nshots=10)
assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.1), rtol=1.1)
assert np.allclose(out, (-1, 0.1), rtol=1.1)
def test_append_measure_register():
q0 = QubitPlaceholder()
p = Program(H(q0), RX(np.pi/2, 0))
p = append_measure_register(p)
assert str(p[-1]) == "MEASURE 0 ro[1]"
import matplotlib.pyplot as plt
from pytest import raises
from entropica_qaoa.qaoa.cost_function import QAOACostFunctionOnWFSim
from pyquil.api import WavefunctionSimulator
from pyquil.paulis import PauliSum, PauliTerm
from pyquil.quil import QubitPlaceholder, Qubit
from entropica_qaoa.qaoa.parameters import (
ExtendedParams, StandardWithBiasParams, AnnealingParams, FourierParams,
FourierWithBiasParams, FourierExtendedParams, QAOAParameterIterator,
AbstractParams, StandardParams, _is_iterable_empty)
# build a hamiltonian to test everything on
q1 = QubitPlaceholder()
# hamiltonian = PauliSum.from_compact_str("1.0*Z0Z1")
hamiltonian = PauliTerm("Z", 0)
hamiltonian *= PauliTerm("Z", 1)
hamiltonian += PauliTerm("Z", q1, 0.5)
next_term = PauliTerm("Z", 0, -2.0)
next_term *= PauliTerm("Z", q1)
hamiltonian += next_term
ham_wo_bias = PauliSum.from_compact_str("1*Z0Z1 + 0.5*Z1Z2 + 0.7*Z2Z2")
# TODO test fourier params
# TODO Test set_hyperparameters and update_variable_parameters
def test_is_iterable_empty():
from entropica_qaoa.utilities import (random_hamiltonian,
distances_dataset,
gaussian_2Dclusters,
hamiltonian_from_hyperparams,
graph_from_hamiltonian,
graph_from_hyperparams,
hamiltonian_from_graph,
random_k_regular_graph,
plot_graph,
hamiltonian_from_distances,
ring_of_disagrees)
from entropica_qaoa.qaoa.parameters import StandardParams
from entropica_qaoa.qaoa.cost_function import QAOACostFunctionOnWFSim
q1, q2 = QubitPlaceholder(), QubitPlaceholder()
reg = [0, 1, 3, q1, q2]
singles = [0, 3, q1]
biases = [0.4, -0.3, 1.2]
pairs = [(0, 1), (3, q1), (q2, 0)]
couplings = [1.2, 3.4, 4.5]
single_terms = [c * sZ(q) for c, q in zip(biases, singles)]
pair_terms = [c * sZ(q[0]) * sZ(q[1]) for c, q in zip(couplings, pairs)]
hamiltonian = PauliSum([*single_terms, *pair_terms])
graph = nx.Graph()
for node, weight in zip(singles, biases):
graph.add_node(node, weight=weight)
for edge, weight in zip(pairs, couplings):
graph.add_edge(edge[0], edge[1], weight=weight)