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")
