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)