def test_add_ancilla_register_to_circuit_artifact_file( self, circuit_filename_and_number_of_ancilla_qubits): # Given ( circuit_filename, number_of_ancilla_qubits, ) = circuit_filename_and_number_of_ancilla_qubits expected_extended_circuit_filename = "extended-circuit.json" circuit = load_circuit(circuit_filename) expected_extended_circuit = _add_ancilla_register_to_circuit( circuit, number_of_ancilla_qubits) # When add_ancilla_register_to_circuit(number_of_ancilla_qubits, circuit_filename) # Then try: extended_circuit = load_circuit(expected_extended_circuit_filename) assert (len(extended_circuit.qubits) == len(circuit.qubits) + number_of_ancilla_qubits) assert extended_circuit.gates == expected_extended_circuit.gates finally: remove_file_if_exists(expected_extended_circuit_filename)
def test_build_ansatz_circuit_with_parameter_values( self, params_filename_and_number_of_layers): # Given params_filename, number_of_layers = params_filename_and_number_of_layers ansatz_specs = { "module_name": "zquantum.core.interfaces.mock_objects", "function_name": "MockAnsatz", "number_of_layers": number_of_layers, "problem_size": 2, } parameters = load_circuit_template_params(params_filename) ansatz = create_object(copy.deepcopy(ansatz_specs)) expected_circuit = ansatz.get_executable_circuit(parameters) # When build_ansatz_circuit(ansatz_specs=ansatz_specs, params=params_filename) # Then try: circuit_filename = "circuit.json" circuit = load_circuit(circuit_filename) assert isinstance(circuit, Circuit) assert circuit == expected_circuit finally: remove_file_if_exists(circuit_filename)
def test_add_ancilla_register_to_circuit_python_object( self, number_of_ancilla_qubits ): # Given number_of_qubits = 4 number_of_gates = 10 circuit = _create_random_circuit( number_of_qubits, number_of_gates, seed=RNDSEED ) expected_extended_cirucit = _add_ancilla_register_to_circuit( copy.deepcopy(circuit), number_of_ancilla_qubits ) expected_extended_circuit_filename = "extended-circuit.json" # When add_ancilla_register_to_circuit(number_of_ancilla_qubits, circuit) # Then try: extended_circuit = load_circuit(expected_extended_circuit_filename) assert ( len(extended_circuit.qubits) == number_of_qubits + number_of_ancilla_qubits ) assert extended_circuit.gates == expected_extended_cirucit.gates finally: remove_file_if_exists(expected_extended_circuit_filename)
def get_expectation_values_for_qubit_operator( backend_specs: Specs, circuit: Union[str, Circuit], qubit_operator: Union[str, SymbolicOperator], ): """Measure the expection values of the terms in an input operator with respect to the state prepared by the input circuit on the backend described by the backend_specs. The results are serialized into a JSON under the file: "expectation-values.json" ARGS: backend_specs (Union[dict, str]): The backend on which to run the quantum circuit circuit (Union[str, Circuit]): The circuit that prepares the state to be measured qubit_operator (Union[str, SymbolicOperator]): The operator to measure """ if isinstance(circuit, str): circuit = load_circuit(circuit) if isinstance(qubit_operator, str): qubit_operator = load_qubit_operator(qubit_operator) if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) backend = create_object(backend_specs) expectation_values = backend.get_expectation_values( circuit, qubit_operator) save_expectation_values(expectation_values, "expectation-values.json")
def test_create_random_circuit(self, number_of_qubits, number_of_gates, seed): # Given expected_filename = "circuit.json" expected_circuit = _create_random_circuit( number_of_qubits, number_of_gates, seed=seed, ) # When create_random_circuit( number_of_qubits=number_of_qubits, number_of_gates=number_of_gates, seed=seed, ) # Then try: circuit = load_circuit(expected_filename) if seed is not None: assert circuit.gates == expected_circuit.gates else: assert circuit.gates != expected_circuit.gates finally: remove_file_if_exists(expected_filename)
def add_ancilla_register_to_circuit(number_of_ancilla_qubits: int, circuit: Union[Circuit, str]): if isinstance(circuit, str): circuit = load_circuit(circuit) extended_circuit = _add_ancilla_register_to_circuit( circuit, number_of_ancilla_qubits) save_circuit(extended_circuit, "extended-circuit.json")
def evaluate_parametrized_circuit(parametrized_circuit: Union[str, Circuit], parameters: Union[str, np.ndarray]): if isinstance(parametrized_circuit, str): parametrized_circuit = load_circuit(parametrized_circuit) if isinstance(parameters, str): parameters = load_circuit_template_params(parameters) symbols_map = create_symbols_map(parametrized_circuit.symbolic_params, parameters) evaluated_circuit = parametrized_circuit.evaluate(symbols_map) save_circuit(evaluated_circuit, "evaluated-circuit.json")
def batch_circuits( circuits: List[Union[str, Circuit]], circuit_set: Optional[Union[str, List[Circuit]]] = None, ): if circuit_set is None: circuit_set = [] else: if isinstance(circuit_set, str): circuit_set = load_circuit_set(circuit_set) for circuit in circuits: if isinstance(circuit, str): circuit = load_circuit(circuit) circuit_set.append(circuit) save_circuit_set(circuit_set, "circuit-set.json")
def test_concatenate_circuits_python_objects(self, circuit_set): # Given expected_concatenated_circuit_filename = "result-circuit.json" expected_concatenated_circuit = Circuit() for circuit in copy.deepcopy(circuit_set): expected_concatenated_circuit += circuit # When concatenate_circuits(circuit_set) # Then try: concatenated_circuit = load_circuit(expected_concatenated_circuit_filename) assert concatenated_circuit.gates == expected_concatenated_circuit.gates finally: remove_file_if_exists(expected_concatenated_circuit_filename)
def test_batch_circuits_all_artifacts_no_circuit_set( self, input_circuits_filenames): # Given expected_circuit_set_filename = "circuit-set.json" expected_circuit_set = [] for circuit_filename in input_circuits_filenames: expected_circuit_set.append(load_circuit(circuit_filename)) # When batch_circuits(input_circuits_filenames) # Then try: circuit_set = load_circuit_set(expected_circuit_set_filename) assert circuit_set == expected_circuit_set finally: remove_file_if_exists(expected_circuit_set_filename)
def run_circuit_and_measure( backend_specs: Dict, circuit: str, noise_model: str = "None", device_connectivity: str = "None", ): backend_specs = json.loads(backend_specs) if noise_model != "None": backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) measurements = backend.run_circuit_and_measure(circuit) measurements.save("measurements.json")
def create_circuit_set_from_circuit_artifacts( circuit1: str, circuit2: str = "None", circuit3: str = "None", circuit4: str = "None", circuit_set: str = "None", ): if circuit_set != "None": # TODO None isse in workflow v1 circuit_set_object = load_circuit_set(circuit_set) else: circuit_set_object = [] object_names = [circuit1, circuit2, circuit3, circuit4] for object in object_names: if object != "None": circuit_set_object.append(load_circuit(object)) save_circuit_set(circuit_set_object, "circuit-set.json")
def get_bitstring_distribution( backend_specs: Dict, circuit: str, noise_model: str = "None", device_connectivity: str = "None", ): backend_specs = json.loads(backend_specs) if noise_model != "None": backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) bitstring_distribution = backend.get_bitstring_distribution(circuit) save_bitstring_distribution(bitstring_distribution, "bitstring-distribution.json")
def run_circuit_and_measure( backend_specs: Dict, circuit: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) measurements = backend.run_circuit_and_measure(circuit) measurements.save("measurements.json")
def get_bitstring_distribution( backend_specs: Specs, circuit: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) bitstring_distribution = backend.get_bitstring_distribution(circuit) save_bitstring_distribution(bitstring_distribution, "bitstring-distribution.json")
def run_circuit_and_measure( backend_specs: Specs, circuit: Union[str, Dict], n_samples: Optional[int] = None, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) if isinstance(circuit, str): circuit = load_circuit(circuit) else: circuit = Circuit.from_dict(circuit) measurements = backend.run_circuit_and_measure(circuit, n_samples=n_samples) measurements.save("measurements.json")
def test_build_ansatz_circuit_ansatz_specs_as_string(self): # Given number_of_layers = 2 ansatz_specs = { "module_name": "zquantum.core.interfaces.mock_objects", "function_name": "MockAnsatz", "number_of_layers": number_of_layers, "problem_size": 2, } ansatz = create_object(copy.deepcopy(ansatz_specs)) expected_circuit = ansatz.parametrized_circuit # When build_ansatz_circuit(ansatz_specs=json.dumps(ansatz_specs)) # Then try: circuit_filename = "circuit.json" circuit = load_circuit(circuit_filename) assert isinstance(circuit, Circuit) assert circuit == expected_circuit finally: remove_file_if_exists(circuit_filename)
def optimize_parametrized_circuit_for_ground_state_of_operator( optimizer_specs: Specs, target_operator: Union[SymbolicOperator, str], parametrized_circuit: Union[Circuit, str], backend_specs: Specs, estimator_specs: Optional[Specs] = None, estimator_kwargs: Optional[Union[Dict, str]] = None, initial_parameters: Union[str, np.ndarray, List[float]] = None, fixed_parameters: Optional[Union[np.ndarray, str]] = None, parameter_precision: Optional[float] = None, parameter_precision_seed: Optional[int] = None, ): """Optimize the parameters of a parametrized quantum circuit to prepare the ground state of a target operator. Args: optimizer_specs (Union[Dict, str]): The specs of the optimizer to use to refine the parameter values target_operator (Union[SymbolicOperator, str]): The operator of which to prepare the ground state parametrized_circuit (Union[Circuit, str]): The parametrized quantum circuit that prepares trial states backend_specs (Union[Dict, str]): The specs of the quantum backend (or simulator) to use to run the circuits estimator_specs (Union[Dict, str]): The estimator to use to estimate the expectation value of the operator. The default is the BasicEstimator. estimator_kwargs (dict): kwargs required to run get_estimated_expectation_values method of the estimator. initial_parameters (Union[str, np.ndarray, List[float]]): The initial parameter values to begin optimization fixed_parameters (Optional[Union[np.ndarray, str]]): values for the circuit parameters that should be fixed. parameter_precision (float): the standard deviation of the Gaussian noise to add to each parameter, if any. parameter_precision_seed (int): seed for randomly generating parameter deviation if using parameter_precision initial_parameters (Union[str, np.ndarray, List[float]] = None, """ if estimator_kwargs is not None: if isinstance(estimator_kwargs, str): estimator_kwargs = json.loads(estimator_kwargs) estimator = create_object(estimator_kwargs) else: estimator_kwargs = {} if isinstance(optimizer_specs, str): optimizer_specs = json.loads(optimizer_specs) optimizer = create_object(optimizer_specs) if isinstance(target_operator, str): with open(target_operator, "r") as f: target_operator = json.loads(f.read()) if isinstance(parametrized_circuit, str): parametrized_circuit = load_circuit(parametrized_circuit) if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) backend = create_object(backend_specs) if estimator_specs is not None: if isinstance(estimator_specs, str): estimator_specs = json.loads(estimator_specs) estimator = create_object(estimator_specs) else: estimator = BasicEstimator() if initial_parameters is not None: if isinstance(initial_parameters, str): initial_parameters = load_circuit_template_params( initial_parameters) if fixed_parameters is not None: if isinstance(fixed_parameters, str): fixed_parameters = load_circuit_template_params(fixed_parameters) cost_function = get_ground_state_cost_function( target_operator, parametrized_circuit, backend, estimator=estimator, estimator_kwargs=estimator_kwargs, fixed_parameters=fixed_parameters, parameter_precision=parameter_precision, parameter_precision_seed=parameter_precision_seed, ) optimization_results = optimizer.minimize(cost_function, initial_parameters) save_optimization_results(optimization_results, "optimization_results.json")
def get_expectation_values_for_qubit_operator(backend_specs, circuit, qubit_operator): circuit = load_circuit(circuit) qubit_operator = load_qubit_operator(qubit_operator) backend = create_object(json.loads(backend_specs)) expectation_values = backend.get_expectation_values(circuit, qubit_operator) save_expectation_values(expectation_values, "expectation-values.json")
def add_ancilla_register_to_circuit(number_of_ancilla_qubits: int, circuit: str): circuit_object = load_circuit(circuit) extended_circuit = _add_ancilla_register_to_circuit( circuit_object, number_of_ancilla_qubits) save_circuit(extended_circuit, "extended-circuit.json")