def test_ref_program_pass():
ref_prog = Program().inst([X(0), Y(1), Z(2)])
fakeQVM = Mock(spec=qvm_module.Connection())
inst = QAOA(fakeQVM, 2, driver_ref=ref_prog)
param_prog = inst.get_parameterized_program()
test_prog = param_prog([0, 0])
compare_progs(ref_prog, test_prog)
def main():
qvm = forest.Connection()
num_qubits = 2
sol_index = 1
p = grover(num_qubits, sol_index)
print p
output = qvm.run(p, [i for i in range(num_qubits)], 20)
print most_common(output)
def test_probabilities():
p = 1
n_qubits = 2
# known set of angles for barbell
angles = [1.96348709, 4.71241069]
wf = np.array([
-1.17642098e-05 - 1j * 7.67538040e-06,
-7.67563580e-06 - 1j * 7.07106781e-01,
-7.67563580e-06 - 1j * 7.07106781e-01,
-1.17642098e-05 - 1j * 7.67538040e-06
])
fakeQVM = Mock(spec=qvm_module.Connection())
fakeQVM.wavefunction = Mock(return_value=(wf, 0))
inst = QAOA(fakeQVM, n_qubits, steps=p, rand_seed=42)
true_probs = np.zeros_like(wf)
for xx in xrange(wf.shape[0]):
true_probs[xx] = np.conj(wf[xx]) * wf[xx]
probs = inst.probabilities(angles)
assert isinstance(probs, np.ndarray)
prob_true = np.zeros((2**inst.n_qubits, 1))
prob_true[1] = 0.5
prob_true[2] = 0.5
assert np.isclose(probs, prob_true).all()
def cxn():
c = qvm.Connection()
c.post_json = MockPostJson()
c.post_json.return_value.text = json.dumps("Success")
c.measurement_noise = 1
return c
def vqe_run(self,
parametric_state_evolve,
hamiltonian,
initial_params,
gate_noise=None,
measurement_noise=None,
jacobian=None,
qvm=None,
disp=None,
samples=None,
return_all=False):
"""
functional minimization loop.
:param parametric_state_evolve: function that takes a set of parameters
and returns a quil program.
:param hamiltonian: (PauliSum) object representing the hamiltonian of
which to take the expectation value.
:param initial_params: (ndarray) vector of initial parameters for the
optimization
:param gate_noise: list of Px, Py, Pz probabilities of gate being
applied to every gate after each get application
:param measurement_noise: list of Px', Py', Pz' probabilities of a X, Y
or Z being applied before a measurement.
:param jacobian: (optional) method of generating jacobian for parameters
(Default=None).
:param qvm: (optional, QVM) forest connection object.
:param disp: (optional, bool) display level. If True then each iteration
expectation and parameters are printed at each
optimization iteration.
:param samples: (int) Number of samples for calculating the expectation
value of the operators. If `None` then faster method
,dotting the wave function with the operator, is used.
Default=None.
:param return_all: (optional, bool) request to return all intermediate
parameters determined during the optimization.
:return: (vqe.OptResult()) object :func:`OptResult <vqe.OptResult>`.
The following fields are initialized in OptResult:
-x: set of w.f. ansatz parameters
-fun: scalar value of the objective function
-iteration_params: a list of all intermediate parameter vectors. Only
returned if 'return_all=True' is set as a vqe_run()
option.
-expectation_vals: a list of all intermediate expectation values. Only
returned if 'return_all=True' is set as a
vqe_run() option.
"""
self._disp_fun = disp if disp is not None else lambda x: None
iteration_params = []
expectation_vals = []
self._current_expectation = None
if samples is None:
print """WARNING: Fast method for expectation will be used. Noise
models will be ineffective"""
if qvm is None:
qvm = qvm_module.Connection(gate_noise=gate_noise,
measurement_noise=measurement_noise)
else:
self.qvm = qvm
def objective_function(params):
"""
closure representing the functional
:param params: (ndarray) vector of parameters for generating the
the function of the functional.
:return: (float) expectation value
"""
quil_prog = parametric_state_evolve(params)
mean_value = self.expectation(quil_prog, hamiltonian, samples, qvm)
self._current_expectation = mean_value # store for printing
return mean_value
def print_current_iter(iter_vars):
self._disp_fun("\tParameters: {} ".format(iter_vars))
if jacobian is not None:
grad = jacobian(iter_vars)
self._disp_fun("\tGrad-L1-Norm: {}".format(np.max(
np.abs(grad))))
self._disp_fun("\tGrad-L2-Norm: {} ".format(
np.linalg.norm(grad)))
self._disp_fun("\tE => {}".format(self._current_expectation))
if return_all:
iteration_params.append(iter_vars)
expectation_vals.append(self._current_expectation)
# using self.minimizer
arguments, _, _, _ = inspect.getargspec(self.minimizer)
if disp is not None and 'callback' in arguments:
self.minimizer_kwargs['callback'] = print_current_iter
args = [objective_function, initial_params]
args.extend(self.minimizer_args)
if 'jac' in arguments:
self.minimizer_kwargs['jac'] = jacobian
result = self.minimizer(*args, **self.minimizer_kwargs)
if hasattr(result, 'status'):
if result.status != 0:
self._disp_fun(
"Classical optimization exited with an error index: %i" %
result.status)
results = OptResults()
if hasattr(result, 'x'):
results.x = result.x
results.fun = result.fun
else:
results.x = result
if return_all:
results.iteration_params = iteration_params
results.expectation_vals = expectation_vals
return results
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##############################################################################
import numpy as np
from pyquil.paulis import PauliTerm, PauliSum
import pyquil.forest as qvm_module
from scipy.optimize import minimize
from grove.pyqaoa.qaoa import QAOA
CXN = qvm_module.Connection()
def numpart_qaoa(asset_list, A=1.0, minimizer_kwargs=None, steps=1):
"""
generate number partition driver and cost functions
:param asset_list: list to binary parition
:param A: (float) optional constant for level separation. Default=1.
:param steps: (int) number of steps approximating the solution.
"""
cost_operators = []
ref_operators = []
for ii in xrange(len(asset_list)):
for jj in xrange(ii + 1, len(asset_list)):
cost_operators.append(
def test_make_connection():
qvm_endpoint.Connection()
def cxn_wf():
c = qvm.Connection()
c.post_json = Mock()
c.post_json.return_value.content = WAVEFUNCTION_BINARY
return c
"""
This module runs basic Quil text files against the Forest QVM API.
"""
from __future__ import print_function
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from pyquil.quil import Program
import pyquil.forest as forest
qvm = forest.Connection()
help_string = "Script takes two arguments. Quil program filename is required as the first " \
"argument and number of classical registers to return is the optional second " \
"argument (defaults to 8)."
def parse():
parser = ArgumentParser(__doc__,
formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument('filepath', help='Quil program filename')
parser.add_argument('--classical-register-num',
'-n',
metavar='N',
default=8,
type=int,
help="Number of classical registers to return.")
args = parser.parse_args()
main(args.filepath, args.classical_register_num)
def main(filepath, classical_register_num):
prog.measure(q, [q])
return prog
def process_result(r):
"""
Convert a list of measurements to a die value.
"""
return reduce(lambda s, x: 2 * s + x, r, 0)
BATCH_SIZE = 10
dice = {}
CXN = forest.Connection()
def roll_die(n):
"""
Roll an n-sided quantum die.
"""
addresses = range(qubits_needed(n))
if not n in dice:
dice[n] = die_program(n)
die = dice[n]
# Generate results and do rejection sampling.
while True:
results = CXN.run(die, addresses, BATCH_SIZE)
for r in results:
x = process_result(r)
