def construct_circuit(self, parameter, statevector_mode=False, use_simulator_snapshot_mode=False, circuit_name_prefix=''): """ Generate the circuits. Args: parameter (numpy.ndarray): parameters for variational form. statevector_mode (bool, optional): indicate which type of simulator are going to use. use_simulator_snapshot_mode (bool, optional): is backend from AerProvider, if True and mode is paulis, single circuit is generated. circuit_name_prefix (str, optional): a prefix of circuit name Returns: list[QuantumCircuit]: the generated circuits with Hamiltonian. Raises: AquaError: Circuit cannot be created if an operator has not been provided """ if self._initial_state is None: raise AquaError("Initial state was never provided") circuits = [] dip_test = self._dip_test(parameter, circuit_name_prefix=circuit_name_prefix) num_working_qubits = self._num_working_qubits if not statevector_mode: creg = ClassicalRegister(dip_test.width(), name="dip_creg") qreg = find_regs_by_name(dip_test, 'dip_qreg') dip_test.add_register(creg) dip_test.barrier(qreg) dip_test.measure(qreg[:num_working_qubits], creg[:num_working_qubits]) circuits.append(dip_test) for i in range(self._num_working_qubits): # get relevant qubit indices dip_qubit_idx = [i] swap_qubit_idx = list(set(range(num_working_qubits)) - set(dip_qubit_idx)) swap_qubit_idx += [i + num_working_qubits for i in swap_qubit_idx] dip_qubit_idx += [i + num_working_qubits for i in dip_qubit_idx] pdip_test = self._pdip_test(parameter, dip_qubit_idx, swap_qubit_idx, circuit_name_prefix=circuit_name_prefix) if not statevector_mode: creg = ClassicalRegister(pdip_test.width(), name="dip_creg") qreg = find_regs_by_name(pdip_test, 'pdip_qreg') pdip_test.add_register(creg) pdip_test.barrier(qreg) pdip_test.measure(qreg[swap_qubit_idx + dip_qubit_idx], creg[swap_qubit_idx + dip_qubit_idx]) circuits.append(pdip_test) return circuits
def calc_expectataion(self, pauli_str, sub_circuit): qubit_op = WeightedPauliOperator([[1, Pauli.from_label(pauli_str)]]) sv_mode = False qi = QuantumInstance(backend=Aer.get_backend('qasm_simulator'), shots=1000, seed_simulator=100, seed_transpiler=2) if qi.is_statevector: sv_mode = True # Make sure that the eval quantum/ classical registers in the circuit are named 'q'/'c' qc = qubit_op.construct_evaluation_circuit( statevector_mode=sv_mode, wave_function=sub_circuit, qr=find_regs_by_name(sub_circuit, 'q'), use_simulator_operator_mode=True) result = qi.execute(qc) avg, std = qubit_op.evaluate_with_result( statevector_mode=sv_mode, result=result, use_simulator_operator_mode=True) return avg
def get_optimal_vector(self): from qiskit.aqua.utils.run_circuits import find_regs_by_name if 'opt_params' not in self._ret: raise AquaError("Cannot find optimal vector before running the " "algorithm to find optimal params.") qc = self.get_optimal_circuit() if self._quantum_instance.is_statevector: ret = self._quantum_instance.execute(qc) self._ret['min_vector'] = ret.get_statevector(qc) else: c = ClassicalRegister(qc.width(), name='c') q = find_regs_by_name(qc, 'q') qc.add_register(c) qc.barrier(q) qc.measure(q, c) ret = self._quantum_instance.execute(qc) self._ret['min_vector'] = ret.get_counts(qc) return self._ret['min_vector']
def get_optimal_value(self): """ Computes the eigenvalue estimates of the initial state Returns: numpy.ndarray: array of eigenvalues estimates """ if 'opt_params' not in self._ret: raise AquaError("Cannot find optimal vector before running the " "algorithm to find optimal params.") # TODO : Find better way to do this num_working_qubits = self._num_working_qubits circuit = self.get_optimal_circuit() counts = None if self._quantum_instance.is_statevector: ret = self._quantum_instance.execute(circuit) state_vec = Statevector(ret.get_statevector(circuit)) counts = state_vec.probabilities_dict() else: c = ClassicalRegister(circuit.width(), name='c') q = find_regs_by_name(circuit, 'q') circuit.add_register(c) circuit.barrier(q) circuit.measure(q[:num_working_qubits], c[:num_working_qubits]) ret = self._quantum_instance.execute(circuit) counts = ret.get_counts(circuit) keys = list(map(''.join, product(['0', '1'], repeat=num_working_qubits))) num_shots = sum(counts.values()) probs = dict.fromkeys(keys, 0.0) for i, (k, v) in enumerate(counts.items()): probs[k[-num_working_qubits:]] += v / num_shots print({k: v for k, v in sorted(probs.items(), key=lambda item: -item[1])}) eigvals = np.array(list(probs.values())) idx = np.argsort(-eigvals) return eigvals[idx]
def get_optimal_vector(self) -> Union[List[float], Dict[str, int]]: """Get the simulation outcome of the optimal circuit. """ # pylint: disable=import-outside-toplevel from qiskit.aqua.utils.run_circuits import find_regs_by_name if 'opt_params' not in self._ret: raise AquaError("Cannot find optimal vector before running the " "algorithm to find optimal params.") qc = self.get_optimal_circuit() if self._quantum_instance.is_statevector: ret = self._quantum_instance.execute(qc) self._ret['min_vector'] = ret.get_statevector(qc) else: c = ClassicalRegister(qc.width(), name='c') q = find_regs_by_name(qc, 'q') qc.add_register(c) qc.barrier(q) qc.measure(q, c) ret = self._quantum_instance.execute(qc) self._ret['min_vector'] = ret.get_counts(qc) return self._ret['min_vector']
def construct_evaluation_circuit(self, wave_function, statevector_mode, qr=None, cr=None, use_simulator_snapshot_mode=False, circuit_name_prefix=''): r""" Construct the circuits for evaluation, which calculating the expectation <psi\|H\|psi>. At statevector mode: to simplify the computation, we do not build the whole circuit for <psi|H|psi>, instead of that we construct an individual circuit <psi\|, and a bundle circuit for H\|psi> Args: wave_function (QuantumCircuit): the quantum circuit. statevector_mode (bool): indicate which type of simulator are going to use. qr (QuantumRegister, optional): the quantum register associated with the input_circuit cr (ClassicalRegister, optional): the classical register associated with the input_circuit use_simulator_snapshot_mode (bool, optional): if aer_provider is used, we can do faster evaluation for pauli mode on statevector simulation circuit_name_prefix (str, optional): a prefix of circuit name Returns: list[QuantumCircuit]: a list of quantum circuits and each circuit with a unique name: circuit_name_prefix + Pauli string Raises: AquaError: if Operator is empty AquaError: if quantum register is not provided explicitly and cannot find quantum register with `q` as the name AquaError: The provided qr is not in the wave_function """ if self.is_empty(): raise AquaError("Operator is empty, check the operator.") # pylint: disable=import-outside-toplevel from qiskit.aqua.utils.run_circuits import find_regs_by_name if qr is None: qr = find_regs_by_name(wave_function, 'q') if qr is None: raise AquaError("Either provide the quantum register (qr) explicitly or use" " `q` as the name of the quantum register in the input circuit.") else: if not wave_function.has_register(qr): raise AquaError("The provided QuantumRegister (qr) is not in the circuit.") n_qubits = self.num_qubits instructions = self.evaluation_instruction(statevector_mode, use_simulator_snapshot_mode) circuits = [] if use_simulator_snapshot_mode: circuit = wave_function.copy(name=circuit_name_prefix + 'snapshot_mode') # Add expectation value snapshot instruction instr = instructions.get('expval_snapshot', None) if instr is not None: circuit.append(instr, qr) circuits.append(circuit) elif statevector_mode: circuits.append(wave_function.copy(name=circuit_name_prefix + 'psi')) for _, pauli in self._paulis: inst = instructions.get(pauli.to_label(), None) if inst is not None: circuit = wave_function.copy(name=circuit_name_prefix + pauli.to_label()) circuit.append(inst, qr) circuits.append(circuit) else: base_circuit = wave_function.copy() if cr is not None: if not base_circuit.has_register(cr): base_circuit.add_register(cr) else: cr = find_regs_by_name(base_circuit, 'c', qreg=False) if cr is None: cr = ClassicalRegister(n_qubits, name='c') base_circuit.add_register(cr) for basis, _ in self._basis: circuit = base_circuit.copy(name=circuit_name_prefix + basis.to_label()) circuit.append(instructions[basis.to_label()], qargs=qr, cargs=cr) circuits.append(circuit) return circuits