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 concatenate_circuits(circuit_set: Union[str, List[Circuit]]):
if isinstance(circuit_set, str):
circuit_set = load_circuit_set(circuit_set)
result_circuit = Circuit()
for circuit in circuit_set:
result_circuit += circuit
save_circuit(result_circuit, "result-circuit.json")
def create_random_circuit(number_of_qubits: int,
number_of_gates: int,
seed: Union[str, int] = "None"):
circuit = _create_random_circuit(number_of_qubits,
number_of_gates,
seed=seed)
save_circuit(circuit, "circuit.json")
def create_random_circuit(number_of_qubits: int,
number_of_gates: int,
seed: Optional[int] = None):
circuit = _create_random_circuit(number_of_qubits,
number_of_gates,
seed=seed)
save_circuit(circuit, "circuit.json")
def build_qaoa_ansatz_circuit(
ansatz_specs: Specs,
cost_hamiltonian: Union[str, List],
mixer_hamiltonian: Union[str, List] = None,
params: Optional[Union[str, List]] = None,
):
if isinstance(ansatz_specs, str):
DeprecationWarning(
"Loading ansatz_specs as a string will be depreciated in future, please change it to a dictionary."
)
ansatz_specs = json.loads(ansatz_specs)
cost_hamiltonian = load_qubit_operator(cost_hamiltonian)
if mixer_hamiltonian:
mixer_hamiltonian = load_qubit_operator(mixer_hamiltonian)
ansatz_specs["cost_hamiltonian"] = cost_hamiltonian
ansatz_specs["mixer_hamiltonian"] = mixer_hamiltonian
ansatz = load_from_specs(ansatz_specs)
if params is not None:
if isinstance(params, str):
params = load_circuit_template_params(params)
else:
params = np.array(params)
circuit = ansatz.get_executable_circuit(params)
elif ansatz.supports_parametrized_circuits:
circuit = ansatz.parametrized_circuit
else:
raise (Exception(
"Ansatz is not parametrizable and no parameters has been provided."
))
save_circuit(circuit, "circuit.json")
def input_circuits_filenames(self, input_circuits):
circuit_filenames = []
for i, circuit in enumerate(input_circuits):
circuit_filenames.append("circuit-{}.json".format(i))
save_circuit(circuit, circuit_filenames[i])
yield circuit_filenames
for filename in circuit_filenames:
remove_file_if_exists(filename)
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 circuit_filename_and_number_of_ancilla_qubits(self, number_of_ancilla_qubits):
number_of_qubits = 4
number_of_gates = 10
circuit = _create_random_circuit(
number_of_qubits, number_of_gates, seed=RNDSEED
)
circuit_filename = "circuit.json"
save_circuit(circuit, circuit_filename)
yield circuit_filename, number_of_ancilla_qubits
remove_file_if_exists(circuit_filename)
def build_ansatz_circuit(ansatz_specs: Dict, params: str = "None"):
ansatz = create_object(json.loads(ansatz_specs))
if params != "None": # TODO Non issue in worklow v1
parameters = load_circuit_template_params(params)
circuit = ansatz.get_executable_circuit(parameters)
elif ansatz.supports_parametrized_circuits:
circuit = ansatz.parametrized_circuit
else:
raise (Exception(
"Ansatz is not parametrizable and no parameters has been provided."
))
save_circuit(circuit, "circuit.json")
def build_ansatz_circuit(ansatz_specs: Specs,
params: Optional[Union[str, List]] = None):
ansatz = load_from_specs(ansatz_specs)
if params is not None:
if isinstance(params, str):
params = load_circuit_template_params(params)
else:
params = np.array(params)
circuit = ansatz.get_executable_circuit(params)
elif ansatz.supports_parametrized_circuits:
circuit = ansatz.parametrized_circuit
else:
raise (Exception(
"Ansatz is not parametrizable and no parameters has been provided."
))
save_circuit(circuit, "circuit.json")
def get_wavefunction(self, circuit):
super().get_wavefunction(circuit)
# First, save the circuit object to file in JSON format
circuit = make_circuit_qhipster_compatible(circuit)
save_circuit(circuit, "./temp_qhipster_circuit.json")
# Parse JSON files for qhipster usage
subprocess.call([
"/app/json_parser/json_to_qasm.o", "./temp_qhipster_circuit.json"
])
# Run simulation
subprocess.call([
"/app/zapata/zapata_interpreter_no_mpi_get_wf.out",
"./temp_qhipster_circuit.txt",
str(self.nthreads),
"./temp_qhipster_wavefunction.json",
])
wavefunction = load_wavefunction("./temp_qhipster_wavefunction.json")
os.remove("./temp_qhipster_circuit.json")
os.remove("./temp_qhipster_wavefunction.json")
return wavefunction
def get_exact_expectation_values(self, circuit, qubit_operator, **kwargs):
self.number_of_circuits_run += 1
self.number_of_jobs_run += 1
circuit = make_circuit_qhipster_compatible(circuit)
save_circuit(circuit, "./temp_qhipster_circuit.json")
if isinstance(qubit_operator, SymbolicOperator):
save_symbolic_operator(qubit_operator,
"./temp_qhipster_operator.json")
else:
raise Exception(
"Unsupported type: " + type(qubit_operator) +
"QHipster works only with openfermion.SymbolicOperator")
# Parse JSON files for qhipster usage
subprocess.call([
"/app/json_parser/json_to_qasm.o", "./temp_qhipster_circuit.json"
])
subprocess.call([
"/app/json_parser/qubitop_to_paulistrings.o",
"./temp_qhipster_operator.json",
])
# Run simulation
subprocess.call([
"/app/zapata/zapata_interpreter_no_mpi_get_exp_vals.out",
"./temp_qhipster_circuit.txt",
str(self.nthreads),
"./temp_qhipster_operator.txt",
"./expectation_values.json",
])
expectation_values = load_expectation_values(
"./expectation_values.json")
term_index = 0
for term in qubit_operator.terms:
expectation_values.values[term_index] = np.real(
qubit_operator.terms[term] *
expectation_values.values[term_index])
term_index += 1
return expectation_values
def concatenate_circuits(circuit_set: str):
circuit_set_object = load_circuit_set(circuit_set)
result_circuit = Circuit()
for circuit in circuit_set_object:
result_circuit += circuit
save_circuit(result_circuit, "result-circuit.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")
def create_farhi_qaoa_circuit(number_of_layers, hamiltonian):
hamiltonian_object = load_qubit_operator(hamiltonian)
circuit = _create_farhi_qaoa_circuits([hamiltonian_object], number_of_layers)[0]
save_circuit(circuit, "circuit.json")