def setUp(self): super().setUp() seed = 0 aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = aqua_globals.random.random(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) self.var_form = EfficientSU2(self.qubit_op.num_qubits, reps=1) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = \ QuantumInstance(statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def test_ryrz_circuit(self): """Test an EfficientSU2 circuit.""" num_qubits = 3 reps = 2 entanglement = 'circular' parameters = ParameterVector('theta', 2 * num_qubits * (reps + 1)) param_iter = iter(parameters) expected = QuantumCircuit(3) for _ in range(reps): for i in range(num_qubits): expected.ry(next(param_iter), i) for i in range(num_qubits): expected.rz(next(param_iter), i) expected.cx(2, 0) expected.cx(0, 1) expected.cx(1, 2) for i in range(num_qubits): expected.ry(next(param_iter), i) for i in range(num_qubits): expected.rz(next(param_iter), i) library = EfficientSU2(num_qubits, reps=reps, entanglement=entanglement).assign_parameters( parameters ) self.assertCircuitEqual(library, expected)
def _variational(size, id, measure=True): name = 'Variational' + str(size) + '_' + str(id) _var_circ = EfficientSU2(num_qubits=size, entanglement="linear") _var_circ.name = name if measure: _var_circ.measure_all() return _var_circ
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, z2_symmetries, initial_point = system.opt_amplitudes, noise = noise): initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list) var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=z2_symmetries) if noise: var_form = EfficientSU2(num_qubits = no_qubits, entanglement="linear") else: var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=z2_symmetries) vqe = VQE(var_form=var_form, optimizer=SLSQP(maxiter=500), include_custom=True, initial_point = initial_point) vqe.quantum_instance = backend return vqe
def __init__(self, N, method, rand_generator, numberoflayers=2, qiskit_qc=None): """ method can be either efficient_SU2, or random_numbers, or... """ self.N = N self.method = method #Can be either random numbers or... self.rand_generator = rand_generator #self.numpyseed = rand_generator self.numberoflayers = numberoflayers self.qiskit_circuit = None self.statevector_evaluatedbefore = False self.statevector = None if self.method == "own_qiskit_circuit" and qiskit_qc == None: raise (RuntimeError( "You need to include a qiskit circuit to use this method")) if self.method == "efficient_SU2": qc = EfficientSU2(self.N, reps=self.numberoflayers, entanglement="full", skip_final_rotation_layer=False) num_params = qc.num_parameters #np.random.seed(self.numpyseed) #initial_state_params = np.random.rand(num_params) initial_state_params = self.rand_generator.random(num_params) for index in range(num_params): qc = qc.bind_parameters({ qc.ordered_parameters[index]: initial_state_params[index] }) self.qiskit_circuit = qc if self.method == "own_qiskit_circuit": self.qiskit_circuit = deepcopy(qiskit_qc) if self.method == "TFI_hardware_inspired": #Creates layers of single X rotations, followed by ZZ entangling gate rotations qc = QuantumCircuit(self.N) #np.random.seed(self.numpyseed) #self.startingrandomnumbers = np.random.rand(self.numberoflayers*(self.N + self.N-1)+self.N) self.startingrandomnumbers = self.rand_generator.random( self.numberoflayers * (self.N + self.N - 1) + self.N) counter = 0 for i in range(self.numberoflayers): for j in range(self.N): qc.rx(self.startingrandomnumbers[counter], j) counter = counter + 1 for k in range(self.N - 1): qc.rzz(self.startingrandomnumbers[counter], k, k + 1) counter = counter + 1 for j in range(self.N): qc.rx(self.startingrandomnumbers[counter], j) counter = counter + 1 self.qiskit_circuit = qc
def variational_circuit(): # BUILD VARIATIONAL CIRCUIT HERE - START # import required qiskit libraries if additional libraries are required # build the variational circuit #var_circuit = EfficientSU2(num_qubits=3, su2_gates= ['rx', 'ry'], entanglement='circular', reps=3) var_circuit = EfficientSU2(num_qubits=5, su2_gates= ['rx', 'ry'], entanglement='circular', reps=3) # BUILD VARIATIONAL CIRCUIT HERE - END """ # return the variational circuit which is either a VaritionalForm or QuantumCircuit object from qiskit.circuit import QuantumCircuit, ParameterVector num_qubits = 4 reps = 2 # number of times you'd want to repeat the circuit reps_2 = 2 x = ParameterVector('x', length=reps*(5*num_qubits-1)) # creating a list of Parameters qc = QuantumCircuit(num_qubits) # defining our parametric form for k in range(reps): for i in range(num_qubits): qc.rx(x[2*i+k*(5*num_qubits-1)],i) qc.ry(x[2*i+1+k*(5*num_qubits-1)],i) for i in range(num_qubits-1): qc.cx(i,i+1) for i in range(num_qubits-1): qc.rz(2.356194490192345, i) qc.rx(1.5707963267948966, i) qc.rz(-2.356194490192345, i+1) qc.rx(1.5707963267948966, i+1) qc.cz(i, i+1) qc.rz(-1.5707963267948966, i) qc.rx(1.5707963267948966, i) qc.rz(x[i+2*(num_qubits)+k*(5*num_qubits-1)], i) qc.rx(-1.5707963267948966, i) qc.rz(1.5707963267948966, i+1) qc.rx(1.5707963267948966, i+1) qc.rz(x[i+2*(num_qubits)+k*(5*num_qubits-1)], i+1) qc.rx(-1.5707963267948966, i+1) qc.cz(i, i+1) qc.rz(-1.5707963267948966, i) qc.rx(1.5707963267948966, i) qc.rz(0.7853981633974483, i) qc.rz(-1.5707963267948966, i+1) qc.rx(-1.5707963267948966, i+1) qc.rz(2.356194490192345, i+1) for i in range(num_qubits): qc.rx(x[2*i+3*num_qubits-1+k*(5*num_qubits-1)],i) qc.ry(x[2*i+1+3*num_qubits-1+k*(5*num_qubits-1)],i) """ #custom_circ.draw() return var_circuit
def test_circuit_input(self): """Test running the VQE on a plain QuantumCircuit object.""" wavefunction = QuantumCircuit(2).compose(EfficientSU2(2)) optimizer = SLSQP(maxiter=50) vqe = VQE(self.h2_op, wavefunction, optimizer=optimizer) result = vqe.run(self.statevector_simulator) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=5)
def setUp(self): super().setUp() self.sv_backend = BasicAer.get_backend("statevector_simulator") self.qasm_backend = BasicAer.get_backend("qasm_simulator") self.expectation = MatrixExpectation() self.hamiltonian = 0.1 * (Z ^ Z) + (I ^ X) + (X ^ I) self.observable = Z ^ Z self.ansatz = EfficientSU2(2, reps=1) self.initial_parameters = np.zeros(self.ansatz.num_parameters)
def test_construct_circuit(self, expectation, num_circuits): """Test construct circuits returns QuantumCircuits and the right number of them.""" wavefunction = EfficientSU2(2, reps=1) vqe = VQE(self.h2_op, wavefunction, expectation=expectation) params = [0] * wavefunction.num_parameters circuits = vqe.construct_circuit(params) self.assertEqual(len(circuits), num_circuits) for circuit in circuits: self.assertIsInstance(circuit, QuantumCircuit)
def test_ryrz_blocks(self): """Test that the EfficientSU2 circuit is instantiated correctly.""" two = EfficientSU2(3) with self.subTest(msg='test rotation gate'): self.assertEqual(len(two.rotation_blocks), 2) self.assertIsInstance(two.rotation_blocks[0].data[0][0], RYGate) self.assertIsInstance(two.rotation_blocks[1].data[0][0], RZGate) with self.subTest(msg='test parameter bounds'): expected = [(-np.pi, np.pi)] * two.num_parameters np.testing.assert_almost_equal(two.parameter_bounds, expected)
def run_efficientsu2(): # define the circuit to run the benchmark on circuit = EfficientSU2(4) # define the stats for the benchmark benchmark = Benchmark(2**np.arange(2, 6), H, 12) # run benchmark.run_benchmark(circuit) # and plot benchmark.plot(show=True)
def variational_circuit(): # BUILD VARIATIONAL CIRCUIT HERE - START # import required qiskit libraries if additional libraries are required # build the variational circuit var_circuit = EfficientSU2(3, entanglement='full', reps=3) # BUILD VARIATIONAL CIRCUIT HERE - END # return the variational circuit which is either a VaritionalForm or QuantumCircuit object return var_circuit
def test_eval_observables(self, observables: ListOrDict[OperatorBase]): """Tests evaluator of auxiliary operators for algorithms.""" ansatz = EfficientSU2(2) parameters = np.array( [ 1.2, 4.2, 1.4, 2.0, 1.2, 4.2, 1.4, 2.0, 1.2, 4.2, 1.4, 2.0, 1.2, 4.2, 1.4, 2.0 ], dtype=float, ) bound_ansatz = ansatz.bind_parameters(parameters) expected_result = self.get_exact_expectation(bound_ansatz, observables) for backend_name in self.backend_names: shots = 4096 if backend_name == "qasm_simulator" else 1 decimal = (1 if backend_name == "qasm_simulator" else 6 ) # to accommodate for qasm being imperfect with self.subTest(msg=f"Test {backend_name} backend."): backend = BasicAer.get_backend(backend_name) quantum_instance = QuantumInstance( backend=backend, shots=shots, seed_simulator=self.seed, seed_transpiler=self.seed, ) expectation = ExpectationFactory.build( operator=self.h2_op, backend=quantum_instance, ) with self.subTest(msg="Test QuantumCircuit."): self._run_test( expected_result, bound_ansatz, decimal, expectation, observables, quantum_instance, ) with self.subTest(msg="Test Statevector."): statevector = Statevector(bound_ansatz) self._run_test( expected_result, statevector, decimal, expectation, observables, quantum_instance, )
def test_stable_set_vqe(self): """ VQE Stable set test """ result = VQE(self.qubit_op, EfficientSU2( reps=3, entanglement='linear'), L_BFGS_B(maxfun=6000)).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result.eigenstate) self.assertAlmostEqual(result.eigenvalue, -39.5) self.assertAlmostEqual(result.eigenvalue + self.offset, -38.0) ising_sol = stable_set.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1]) self.assertEqual(stable_set.stable_set_value(x, self.w), (4.0, False))
def test_construct_circuit(self, expectation, num_circuits): """Test construct circuits returns QuantumCircuits and the right number of them.""" try: wavefunction = EfficientSU2(2, reps=1) vqe = VQE(self.h2_op, wavefunction, expectation=expectation) params = [0] * wavefunction.num_parameters circuits = vqe.construct_circuit(params) self.assertEqual(len(circuits), num_circuits) for circuit in circuits: self.assertIsInstance(circuit, QuantumCircuit) except MissingOptionalLibraryError as ex: self.skipTest(str(ex)) return
def variational_circuit(): # BUILD VARIATIONAL CIRCUIT HERE - START # import required qiskit libraries if additional libraries are required feature_dim = 3 classifier_circ = EfficientSU2(feature_dim,entanglement='linear', reps=10) # classifier_circ.draw() # build the variational circuit var_circuit = classifier_circ # BUILD VARIATIONAL CIRCUIT HERE - END # return the variational circuit which is either a VaritionalForm or QuantumCircuit object return var_circuit
def variational_circuit(): # BUILD VARIATIONAL CIRCUIT HERE - START # import required qiskit libraries if additional libraries are required # build the variational circuit var_circuit = EfficientSU2(3, entanglement='full', reps=5)#, su2_gates = ['rz', 'y', 'x']) #RealAmplitudes(num_qubits = 3, entanglement = 'full', reps = 4) # # BUILD VARIATIONAL CIRCUIT HERE - END # return the variational circuit which is either a VaritionalForm or QuantumCircuit object return var_circuit
def test_coder_qc(self): """Test runtime encoder and decoder for circuits.""" bell = ReferenceCircuits.bell() unbound = EfficientSU2(num_qubits=4, reps=1, entanglement='linear') subtests = (bell, unbound, [bell, unbound]) for circ in subtests: with self.subTest(circ=circ): encoded = json.dumps(circ, cls=RuntimeEncoder) self.assertIsInstance(encoded, str) decoded = json.loads(encoded, cls=RuntimeDecoder) if not isinstance(circ, list): decoded = [decoded] self.assertTrue( all(isinstance(item, QuantumCircuit) for item in decoded))
def test_usage_in_vqc(self): """Test using the circuit the a single VQC iteration works.""" feature_dim = 4 _, training_input, test_input, _ = wine(training_size=1, test_size=1, n=feature_dim, plot_data=False) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=1), feature_map, EfficientSU2(feature_map.num_qubits, reps=1), training_input, test_input) backend = Aer.get_backend('qasm_simulator') result = vqc.run(backend) self.assertTrue(result['eval_count'] > 0)
def test_exact_cover_vqe(self): """ Exact Cover VQE test """ algorithm_globals.random_seed = 10598 q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) result = VQE(EfficientSU2(self.qubit_op.num_qubits, reps=5), COBYLA(), max_evals_grouped=2, quantum_instance=q_i).compute_minimum_eigenvalue(operator=self.qubit_op) x = sample_most_likely(result.eigenstate) ising_sol = exact_cover.get_solution(x) oracle = self._brute_force() self.assertEqual(exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets), oracle)
def test_gradient_supported(self): """Test the gradient support is correctly determined.""" # gradient supported here wrapped = EfficientSU2(2) # a circuit wrapped into a big instruction plain = wrapped.decompose( ) # a plain circuit with already supported instructions # gradients not supported on the following circuits x = Parameter("x") duplicated = QuantumCircuit(2) duplicated.rx(x, 0) duplicated.rx(x, 1) needs_chainrule = QuantumCircuit(2) needs_chainrule.rx(2 * x, 0) custom_gate = WhatAmI(x) unsupported = QuantumCircuit(2) unsupported.append(custom_gate, [0, 1]) tests = [ (wrapped, True), # tuple: (circuit, gradient support) (plain, True), (duplicated, False), (needs_chainrule, False), (unsupported, False), ] # used to store the info if a gradient callable is passed into the # optimizer of not info = {"has_gradient": None} optimizer = partial(gradient_supplied, info=info) pvqd = PVQD( ansatz=None, initial_parameters=np.array([]), optimizer=optimizer, quantum_instance=self.sv_backend, expectation=self.expectation, ) problem = EvolutionProblem(self.hamiltonian, time=0.01) for circuit, expected_support in tests: with self.subTest(circuit=circuit, expected_support=expected_support): pvqd.ansatz = circuit pvqd.initial_parameters = np.zeros(circuit.num_parameters) _ = pvqd.evolve(problem) self.assertEqual(info["has_gradient"], expected_support)
def test_measurement_error_mitigation_with_vqe(self): """ measurement error mitigation test with vqe """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer from qiskit.providers.aer import noise except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return aqua_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance( backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter) h2_hamiltonian = -1.052373245772859 * (I ^ I) \ + 0.39793742484318045 * (I ^ Z) \ - 0.39793742484318045 * (Z ^ I) \ - 0.01128010425623538 * (Z ^ Z) \ + 0.18093119978423156 * (X ^ X) optimizer = SPSA(maxiter=200) var_form = EfficientSU2(2, reps=1) vqe = VQE( var_form=var_form, operator=h2_hamiltonian, quantum_instance=quantum_instance, optimizer=optimizer, ) result = vqe.compute_minimum_eigenvalue() self.assertGreater(quantum_instance.time_taken, 0.) quantum_instance.reset_execution_results() self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def test_vertex_cover_vqe(self): """ Vertex Cover VQE test """ aqua_globals.random_seed = self.seed result = VQE(self.qubit_op, EfficientSU2(reps=3), SPSA(max_trials=200), max_evals_grouped=2).run( QuantumInstance( BasicAer.get_backend('qasm_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result.eigenstate) sol = vertex_cover.get_graph_solution(x) oracle = self._brute_force() self.assertEqual(np.count_nonzero(sol), oracle)
def test_vertex_cover_vqe(self): """ Vertex Cover VQE test """ algorithm_globals.random_seed = self.seed q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) result = VQE(EfficientSU2(reps=3), SPSA(maxiter=200), max_evals_grouped=2, quantum_instance=q_i).compute_minimum_eigenvalue( operator=self.qubit_op) x = sample_most_likely(result.eigenstate) sol = vertex_cover.get_graph_solution(x) oracle = self._brute_force() self.assertEqual(np.count_nonzero(sol), oracle)
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, z2_symmetries): initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list) # var_form = UCCSD(num_orbitals=num_orbitals, # num_particles=num_particles, # initial_state=initial_state, # qubit_mapping=qubit_mapping, # two_qubit_reduction=two_qubit_reduction, # z2_symmetries=z2_symmetries) var_form = EfficientSU2(num_qubits=no_qubits, entanglement="linear") vqe = VQE(var_form=var_form, optimizer=SPSA(maxiter=500), include_custom=True) vqe.quantum_instance = quantum_instance return vqe
def run_vqe( self, backend=Aer.get_backend("statevector_simulator"), var_form=None, optimizer=None, reps=5, mode="min_val", ): """Run variational quantum eigensolver.""" # N=int(np.ceil(np.log2(len(self.mat)))) # hk = np.zeros((2**N,2**N),dtype='complex') # hk[:self.mat.shape[0], :self.mat.shape[1]] = self.mat N = self.n_qubits() if mode == "max_val": Hamil_mat = aqua.operators.MatrixOperator(-1 * self.mat) # Hamil_mat = MatrixOperator(-1 * self.mat) else: Hamil_mat = aqua.operators.MatrixOperator(self.mat) # Hamil_mat = MatrixOperator(self.mat) Hamil_qop = aqua.operators.op_converter.to_weighted_pauli_operator( Hamil_mat) if var_form is None: from qiskit.circuit.library import EfficientSU2 var_form = EfficientSU2(N, reps=reps) if optimizer is None: vqe = aqua.algorithms.VQE(Hamil_qop, var_form) # vqe = VQE(Hamil_qop, var_form) else: vqe = aqua.algorithms.VQE(Hamil_qop, var_form, optimizer) # vqe = VQE(Hamil_qop, var_form, optimizer) vqe_result = vqe.run(backend) en = np.real(vqe_result["eigenvalue"]) # params=vqe.optimal_params # circuit=vqe.construct_circuit(params) if mode == "max_val": en = -1 * en # states = np.sort( # np.real( # vqe.expectation.convert( # StateFn(vqe.operator, is_measurement=True) # ).to_matrix() # ) # ) return en, vqe_result, vqe
def test_measurement_error_mitigation_with_vqe(self): """measurement error mitigation test with vqe""" try: from qiskit.ignis.mitigation.measurement import CompleteMeasFitter from qiskit import Aer from qiskit.providers.aer import noise except ImportError as ex: self.skipTest( "Package doesn't appear to be installed. Error: '{}'".format( str(ex))) return algorithm_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) backend = Aer.get_backend("aer_simulator") quantum_instance = QuantumInstance( backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=CompleteMeasFitter, ) h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 * (I ^ Z) - 0.39793742484318045 * (Z ^ I) - 0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 * (X ^ X)) optimizer = SPSA(maxiter=200) ansatz = EfficientSU2(2, reps=1) vqe = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian) self.assertGreater(quantum_instance.time_taken, 0.0) quantum_instance.reset_execution_results() self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_measurement_error_mitigation_with_vqe(self, config): """measurement error mitigation test with vqe""" if _ERROR_MITIGATION_IMPORT_ERROR is not None: self.skipTest( f"Package doesn't appear to be installed. Error: '{_ERROR_MITIGATION_IMPORT_ERROR}'" ) return fitter_str, mit_pattern = config algorithm_globals.random_seed = 0 # build noise model noise_model = noise.NoiseModel() read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]]) noise_model.add_all_qubit_readout_error(read_err) fitter_cls = (CompleteMeasFitter if fitter_str == "CompleteMeasFitter" else TensoredMeasFitter) backend = Aer.get_backend("aer_simulator") quantum_instance = QuantumInstance( backend=backend, seed_simulator=167, seed_transpiler=167, noise_model=noise_model, measurement_error_mitigation_cls=fitter_cls, mit_pattern=mit_pattern, ) h2_hamiltonian = (-1.052373245772859 * (I ^ I) + 0.39793742484318045 * (I ^ Z) - 0.39793742484318045 * (Z ^ I) - 0.01128010425623538 * (Z ^ Z) + 0.18093119978423156 * (X ^ X)) optimizer = SPSA(maxiter=200) ansatz = EfficientSU2(2, reps=1) vqe = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian) self.assertGreater(quantum_instance.time_taken, 0.0) quantum_instance.reset_execution_results() self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def test_ryrz_circuit(self): """Test an EfficientSU2 circuit.""" num_qubits = 3 reps = 2 entanglement = "circular" parameters = ParameterVector("theta", 2 * num_qubits * (reps + 1)) param_iter = iter(parameters) # ┌──────────┐┌──────────┐┌───┐ ┌──────────┐┌──────────┐ » # q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[3]) ├┤ X ├──■──┤ Ry(θ[6]) ├┤ Rz(θ[9]) ├─────────────» # ├──────────┤├──────────┤└─┬─┘┌─┴─┐└──────────┘├──────────┤┌───────────┐» # q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[4]) ├──┼──┤ X ├─────■──────┤ Ry(θ[7]) ├┤ Rz(θ[10]) ├» # ├──────────┤├──────────┤ │ └───┘ ┌─┴─┐ ├──────────┤├───────────┤» # q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[5]) ├──■──────────┤ X ├────┤ Ry(θ[8]) ├┤ Rz(θ[11]) ├» # └──────────┘└──────────┘ └───┘ └──────────┘└───────────┘» # « ┌───┐ ┌───────────┐┌───────────┐ # «q_0: ┤ X ├──■──┤ Ry(θ[12]) ├┤ Rz(θ[15]) ├───────────── # « └─┬─┘┌─┴─┐└───────────┘├───────────┤┌───────────┐ # «q_1: ──┼──┤ X ├──────■──────┤ Ry(θ[13]) ├┤ Rz(θ[16]) ├ # « │ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ # «q_2: ──■───────────┤ X ├────┤ Ry(θ[14]) ├┤ Rz(θ[17]) ├ # « └───┘ └───────────┘└───────────┘ expected = QuantumCircuit(3) for _ in range(reps): for i in range(num_qubits): expected.ry(next(param_iter), i) for i in range(num_qubits): expected.rz(next(param_iter), i) expected.cx(2, 0) expected.cx(0, 1) expected.cx(1, 2) for i in range(num_qubits): expected.ry(next(param_iter), i) for i in range(num_qubits): expected.rz(next(param_iter), i) library = EfficientSU2( num_qubits, reps=reps, entanglement=entanglement).assign_parameters(parameters) self.assertCircuitEqual(library, expected)
def setUp(self): super().setUp() self.sv_backend = BasicAer.get_backend("statevector_simulator") self.expectation = MatrixExpectation() self.hamiltonian = 0.1 * (Z ^ Z) + (I ^ X) + (X ^ I) self.ansatz = EfficientSU2(2, reps=1)