def test_psiref_bar_p2():
bar = [(0, 1)]
p = 2
with patch('grove.pyqaoa.maxcut_qaoa.api', spec=qvm_mod):
inst = maxcut_qaoa(bar, steps=p)
param_prog = inst.get_parameterized_program()
# returns are the rotations correct?
prog = param_prog([1.2, 3.4, 2.1, 4.5])
result_prog = Program().inst([
H(0),
H(1),
CNOT(0, 1),
RZ(2.1)(1),
CNOT(0, 1),
H(0),
RZ(-2.4)(0),
H(0),
H(1),
RZ(-2.4)(1),
H(1),
CNOT(0, 1),
RZ(4.5)(1),
CNOT(0, 1),
H(0),
RZ(-6.8)(0),
H(0),
H(1),
RZ(-6.8)(1),
H(1),
])
assert prog == result_prog
def test_param_prog_p1_barbell():
test_graph = [(0, 1)]
p = 1
with patch('grove.pyqaoa.maxcut_qaoa.api', spec=qvm_mod):
inst = maxcut_qaoa(test_graph, steps=p)
param_prog = inst.get_parameterized_program()
trial_prog = param_prog([1.2, 3.4])
result_prog = Program().inst([
H(0),
H(1),
X(0),
PHASE(1.7)(0),
X(0),
PHASE(1.7)(0),
CNOT(0, 1),
RZ(3.4)(1),
CNOT(0, 1),
H(0),
RZ(-2.4)(0),
H(0),
H(1),
RZ(-2.4)(1),
H(1)
])
trial_prog == result_prog
def test_hamiltonians():
test_graph = [(0, 1)]
p = 1
inst = maxcut_qaoa(test_graph, steps=p)
cost_ops, ref_func = inst.cost_ham, inst.ref_ham
for op in cost_ops:
for term in op.terms:
assert (np.isclose(np.abs(term.coefficient), 0.5))
assert len(ref_func) == 2
assert len(cost_ops) == 1
import numpy as np
from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa
import pyquil.api as api
qvm_connection = api.QVMConnection()
square_ring = [(0, 1), (1, 2), (2, 3), (3, 0)]
steps = 2
inst = maxcut_qaoa(graph=square_ring, steps=steps)
betas, gammas = inst.get_angles()
t = np.hstack((betas, gammas))
param_prog = inst.get_parameterized_program()
prog = param_prog(t)
wf = qvm_connection.wavefunction(prog)
wf = wf.amplitudes
for state_index in range(inst.nstates):
print(inst.states[state_index], np.conj(wf[state_index])*wf[state_index])
import numpy as np
from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa
import pyquil.api as api
qvm_connection = api.QVMConnection()
square_ring = [(0, 1), (1, 2), (2, 3), (3, 0)]
steps = 2
inst = maxcut_qaoa(graph=square_ring, steps=steps)
betas, gammas = inst.get_angles()
t = np.hstack((betas, gammas))
param_prog = inst.get_parameterized_program()
prog = param_prog(t)
wf = qvm_connection.wavefunction(prog)
wf = wf.amplitudes
for state_index in range(inst.nstates):
print(inst.states[state_index], np.conj(wf[state_index]) * wf[state_index])
nx.draw(G)
# In[91]:
#pip install quantum-grove
import numpy as np
from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa
import pyquil.api as api
qvm_connection = api.QVMConnection()
inst = maxcut_qaoa(G,
steps=1,
rand_seed=None,
connection=None,
samples=None,
initial_beta=None,
initial_gamma=None,
minimizer_kwargs=None,
vqe_option=None)
# Sample Run:
# Cutting 0 - 1 - 2 graph!
betas, gammas = inst.get_angles()
probs = inst.probabilities(np.hstack((betas, gammas)))
#for state, prob in zip(inst.states, probs):
# print(state, prob)
print("Most frequent bitstring from sampling")
most_freq_string, sampling_results = inst.get_string(betas, gammas)
print(most_freq_string)
Uses qaoa on maxcut as outlined in https://grove-docs.readthedocs.io/en/latest/qaoa.html
"""
import numpy as np
from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa
from pyquil import get_qc
from pyquil.api import WavefunctionSimulator
from hidden_prints import hidden_prints
from .rigetti_result_analysis import convert_result
graph = [(0, 1), (0, 2), (0, 3)]
qvm = get_qc('4q-qvm')
with hidden_prints():
maxcut_solver = maxcut_qaoa(graph=graph, steps=4) # qaoa steps
betas, gammas = maxcut_solver.get_angles()
angles = np.hstack((betas, gammas))
param_prog = maxcut_solver.get_parameterized_program()
prog = param_prog(angles) # gives the sequence of qubits and gates
measurements = qvm.run_and_measure(prog,
trials=1000) # simulate the program runs
counts = convert_result(measurements)
# plot_state_histogram(counts)
wavefunction = WavefunctionSimulator().wavefunction(
prog) # use wavefunction class to get theoretical measures
prob_dict = wavefunction.get_outcome_probs(
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed May 22 19:16:11 2019
@author: bram
"""
import numpy as np
from pyquil.api import WavefunctionSimulator
from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa
steps = 2
square_ring = [(0,1),(1,2),(2,3),(3,0)]
inst = maxcut_qaoa(square_ring, steps=steps)
opt_betas, opt_gammas = inst.get_angles()
t = np.hstack((opt_betas, opt_gammas))
param_prog = inst.get_parameterized_program()
prog = param_prog(t)
wf = WavefunctionSimulator().wavefunction(prog)
wf = wf.amplitudes
for state_index in range(inst.nstates):
print(inst.states[state_index], np.conj(wf[state_index]) * wf[state_index])
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
n = 2 #min number of nodes
''' Uncomment for demo
input_graph = nx.complete_graph(n)
nx.draw(input_graph)
plt.show()
'''
for i in range(2, 15):
input_graph = nx.complete_graph(i)
steps = 2
inst = maxcut_qaoa(graph=input_graph, steps=steps)
betas, gammas = inst.get_angles()
t = np.hstack((betas, gammas))
param_prog = inst.get_parameterized_program()
prog = param_prog(t)
wf = qvm_instance.wavefunction(prog)
wf = wf.amplitudes
max_amp = 0
max_amp_ref = -1
for state_index in range(2**inst.n_qubits):
print(inst.states[state_index],
np.conj(wf[state_index]) * wf[state_index])
if np.conj(wf[state_index]) * wf[state_index] > max_amp:
import pyquil.api as api
from convertgraphs import *
import networkx
qvm_connection = api.QVMConnection()
# square_ring = [(0,1),(1,2),(2,3),(3,0)]
# G = read_graph('ring-9')
# G = read_graph('g1')
# G = networkx.gnp_random_graph(25, 0.75)
G = networkx.complete_graph(6)
steps = 2
inst = maxcut_qaoa(graph=G, steps=steps)
betas, gammas = inst.get_angles() # might be a clean way to optimize angles... we shall see
t = np.hstack((betas, gammas))
param_prog = inst.get_parameterized_program()
prog = param_prog(t)
wf = qvm_connection.wavefunction(prog)
wf = wf.amplitudes
exps = {state_index : abs(np.conj(wf[state_index])*wf[state_index]) for state_index in range(inst.nstates)}
exps = {k: v for k, v in sorted(exps.items(), key=lambda item: abs(item[1]))}
argmax = max(exps, key=lambda key: exps[key])
mx = exps[argmax]
print('max:{0}, cut:{1}, idx:{2}'.format(mx, inst.states[argmax], argmax))
for state_index in range(inst.nstates):
