def _state_tomography_quantum_program(self,
target,
state,
n_qubits,
shots=1):
qp = qiskit.QuantumProgram()
try:
backend = 'local_qiskit_simulator'
qp.get_backend_configuration(backend)
except LookupError:
backend = 'local_qasm_simulator'
# Prepared target state and assess quality
qp = self.target_prep(state, target, n_qubits, qp=qp)
prep_result = qp.execute(['prep'], backend=backend, shots=1)
prep_state = prep_result.get_data('prep')['quantum_state']
F_prep = state_fidelity(prep_state, target)
print('Prepared state fidelity =', F_prep)
# Run state tomography simulation and fit data to reconstruct circuit
qp, tomo_set, tomo_circuits = self.add_tomo_circuits(qp)
tomo_result = qp.execute(tomo_circuits, backend=backend, shots=shots)
tomo_data = tomo.tomography_data(tomo_result, 'prep', tomo_set)
rho_fit = tomo.fit_tomography_data(tomo_data)
# calculate fidelity and purity of fitted state
F_fit = state_fidelity(rho_fit, target)
pur = purity(rho_fit)
print('Fitted state fidelity =', F_fit)
print('Fitted state purity =', str(pur))
def test_output_unitary_same_as_qiskit():
qubits = tuple(_make_qubits(5))
operations = _all_operations(*qubits, include_measurments=False)
output = cirq.QasmOutput(operations,
qubits,
header='Generated from Cirq',
precision=10)
text = str(output)
# coverage: ignore
try:
# We don't want to require qiskit as a dependency but
# if Qiskit is installed, test QASM output against it.
import qiskit # type: ignore
except ImportError:
return
circuit = cirq.Circuit.from_ops(operations)
cirq_unitary = circuit.to_unitary_matrix(qubit_order=qubits[::-1])
p = qiskit.QuantumProgram()
p.load_qasm_text(text)
result = p.execute(backend='local_unitary_simulator')
qiskit_unitary = result.get_unitary()
cirq.testing.assert_allclose_up_to_global_phase(cirq_unitary,
qiskit_unitary,
rtol=1e-8,
atol=1e-8)
def setup(self):
version_parts = qiskit.__version__.split('.')
if version_parts[0] == '0' and int(version_parts[1]) < 5:
self.local_qasm_simulator = None
elif hasattr(qiskit, 'BasicAer'):
self.local_qasm_simulator = qiskit.BasicAer.get_backend(
'qasm_simulator')
elif hasattr(qiskit, 'get_backend'):
self.local_qasm_simulator = qiskit.get_backend(
'local_qasm_simulator')
else:
self.local_qasm_simulator = qiskit.BasicAer.get_backend(
"qasm_simulator")
self.has_compile = False
if hasattr(qiskit, 'compile'):
self.has_compile = True
self.single_gate_circuit = self._build_single_gate_circuit()
self.cx_circuit = self._build_cx_circuit()
self.qasm_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'qasm'))
large_qasm_path = os.path.join(self.qasm_path, 'test_eoh_qasm.qasm')
if hasattr(qiskit, 'load_qasm_file'):
self.large_qasm = qiskit.load_qasm_file(large_qasm_path)
elif version_parts[0] == '0' and int(version_parts[1]) < 5:
self.large_qasm = qiskit.QuantumProgram()
self.large_qasm.load_qasm_file(large_qasm_path, name='large_qasm')
else:
self.large_qasm = qiskit.QuantumCircuit.from_qasm_file(
large_qasm_path)
def _build_single_gate_circuit(self):
if self.local_qasm_simulator is None:
qp = qiskit.QuantumProgram()
single_register = qp.create_quantum_register('qr', 1)
single_gate_circuit = qp.create_circuit('single_gate',
[single_register])
single_gate_circuit.h(single_register[0])
return qp
if self.local_qasm_simulator is not None:
single_register = qiskit.QuantumRegister(1)
single_gate_circuit = qiskit.QuantumCircuit(single_register)
single_gate_circuit.h(single_register[0])
return single_gate_circuit
return None
def main():
if (len(sys.argv) != 2):
print("Usage: python3 run_qasm.py [qasm_filename]")
name = "test"
qp = qiskit.QuantumProgram()
qp.load_qasm_file(sys.argv[1], name=name)
ret = qp.execute([name], backend="local_qasm_simulator", shots=1,\
max_credits=5, hpc=None, timeout=60*60*24)
sim_result = ret.get_counts(name)
sim_result_keys = sim_result.keys()
print(ret)
print(sim_result)
print(sim_result_keys)
return
def _ansatz():
"""Mimics the circuits from the appendix of the paper, with the exception of
the ordering of the circuit.cx gates (before and after compilation they still do not match).
This is probably best just left up to the compiler.
For ease of reading the printed operations, the qubits are looped over several times.
"""
program = qiskit.QuantumProgram()
qubits = self.qc.qubits()
n_qubits = self.q
var = 'theta'
ro = program.declare('ro', memory_type='BIT', memory_size=n_qubits)
thetas = {
var + str(qubit): program.declare(var + str(qubit),
memory_type='REAL')
for qubit in qubits
}
sq = int(np.sqrt(n_qubits))
lim = n_qubits - sq - 1
for m in qubits:
program += qiskit.rx(thetas[var + str(m)], m)
for m in qubits:
m_1 = m + 1
m_sq = m + sq
skip = (m_1) % sq
if m_1 < n_qubits:
if (m_sq >= n_qubits):
program += qiskit.circuit.cx(m, m_1)
else:
program += qiskit.circuit.cx(m, m_sq)
if (m < lim) and (skip != 0):
program += qiskit.circuit.cx(m, m_1)
for m in qubits:
program += qiskit.measure(m, ro[m])
print("program instructions from Qiskit:\n")
for instruction in program.instructions:
print(instruction)
return program
def _build_cx_circuit(self):
if self.local_qasm_simulator is None:
qp = qiskit.QuantumProgram()
cx_register = qp.create_quantum_register('qr', 2)
cx_circuit = qp.create_circuit("cx_circuit", [cx_register])
cx_circuit.h(cx_register[0])
cx_circuit.h(cx_register[0])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
return qp
if self.local_qasm_simulator is not None:
cx_register = qiskit.QuantumRegister(2)
cx_circuit = qiskit.QuantumCircuit(cx_register)
cx_circuit.h(cx_register[0])
cx_circuit.h(cx_register[0])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
cx_circuit.cx(cx_register[0], cx_register[1])
return cx_circuit
return None
"StatePreparation",
"circuits": [
{
"name": "initializerCirc",
"quantum_registers": [{
"name": "qr",
"size": qubit_number
}],
"classical_registers": [{
"name": "cr",
"size": qubit_number
}]
},
],
}
Q_program = qiskit.QuantumProgram(specs=Q_SPECS)
## State preparation
import numpy as np
from qiskit.extensions.quantum_initializer import _initializer
def psi_0_coefficients(qubit_number: int):
T = 2**qubit_number
tau = np.arange(T)
return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1 / 2) / T)
def get_coeffs(qubit_number: int):
# Can be changed to anything, the initialize function will take
# care of the initialisation.
def runBenchmark(name, qubit, backend, depth, verify, seed):
if seed:
seed = int(seed)
if depth > 0:
qasm_files = name + "/" + name + "_n" + str(qubit) + "_d" + str(
depth) + "*.qasm"
pattern1 = name + "_n" + str(qubit) + "_d" + str(
depth) + "[^0-9]*\.qasm"
pattern2 = name + "_n" + str(qubit) + "_d" + str(depth) + "\D.*\.qasm"
else:
qasm_files = name + "/" + name + "_n" + str(qubit) + "*.qasm"
pattern1 = name + "_n" + str(qubit) + "[^0-9]*\.qasm"
pattern2 = name + "_n" + str(qubit) + "\D.*\.qasm"
file_list = glob.glob(qasm_files)
if not file_list:
raise Exception("No qasm file")
for qasm in file_list:
ret = None
if not ((re.search(pattern1, os.path.basename(qasm))) or
(re.search(pattern2, os.path.basename(qasm)))):
continue
qp = qiskit.QuantumProgram()
if backend.startswith("ibmqx"):
import Qconfig
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
elif not backend.startswith("local"):
raise Exception('only ibmqx or local simulators are supported')
qp.load_qasm_file(qasm, name=name)
start = time.time()
ret = qp.execute([name],
backend=backend,
shots=1,
max_credits=5,
hpc=None,
timeout=60 * 60 * 24,
seed=seed)
elapsed = time.time() - start
#print(ret.get_data(name))
if not ret.get_circuit_status(0) == "DONE":
return False
if backend.startswith("ibmqx"):
elapsed = ret.get_data(name)["time"]
print(name + "," + backend + "," + str(qubit) + "," + str(depth) +
"," + str(elapsed),
flush=True)
#print(ret.get_counts(name))
if verify:
verify_result(ret, name, qasm)
if not ret:
raise Exception("No qasm file")
return True
qr = qiskit.QuantumRegister("qr", 2)
# Create a Classical Register called "cr" with 2 bits.
cr = qiskit.ClassicalRegister("cr", 2)
# Create a Quantum Circuit called involving "qr" and "cr"
qc = qiskit.QuantumCircuit(qr, cr)
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(qr[0])
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(qr[0], qr[1])
# Add a Measure gate to see the state.
qc.measure(qr, cr)
# Create a Quantum Program for execution
qp = qiskit.QuantumProgram()
# Add the circuit you created to it, and call it the "bell" circuit.
# (You can add multiple circuits to the same program, for batch execution)
qp.add_circuit("bell", qc)
# Compile and run the Quantum Program on a simulator backend
print("(Local Backends)")
for backend in local_backends:
print(backend)
sim_result = qp.execute("bell", backend='local_qasm_simulator', shots=1024, seed=1)
# Show the results
print("simulation: ", sim_result)
print(sim_result.get_counts("bell"))
# Compile and run the Quantum Program on a real device backend
def run_benchmark(args, qubit):
"""
Run simulation by each qasm files
"""
name = args.name
backend = args.backend
depth = int(args.depth)
seed = args.seed
if seed:
seed = int(seed)
if depth > 0:
qasm_files = name + "/" + name + "_n" + \
str(qubit) + "_d" + str(depth) + "*.qasm"
pattern1 = name + "_n" + str(qubit) + \
"_d" + str(depth) + r"[^0-9]*\.qasm"
pattern2 = name + "_n" + str(qubit) + "_d" + str(depth) + r"\D.*\.qasm"
else:
qasm_files = name + "/" + name + "_n" + str(qubit) + "*.qasm"
pattern1 = name + "_n" + str(qubit) + r"[^0-9]*\.qasm"
pattern2 = name + "_n" + str(qubit) + r"\D.*\.qasm"
qasm_files = glob.glob(qasm_files)
if not qasm_files:
raise Exception("No qasm file")
for qasm in qasm_files:
ret = None
if not ((re.search(pattern1, os.path.basename(qasm))) or
(re.search(pattern2, os.path.basename(qasm)))):
continue
q_prog = qiskit.QuantumProgram()
if backend.startswith("ibmqx"):
import Qconfig
q_prog.set_api(Qconfig.APItoken, Qconfig.config['url'])
elif not backend.startswith("local"):
raise Exception('only ibmqx or local simulators are supported')
q_prog.load_qasm_file(qasm, name=name)
start = time.time()
ret = q_prog.execute([name],
backend=backend,
shots=1,
max_credits=5,
hpc=None,
timeout=60 * 60 * 24,
seed=seed)
elapsed = time.time() - start
if not ret.get_circuit_status(0) == "DONE":
return False
if backend.startswith("ibmqx"):
elapsed = ret.get_data(name)["time"]
print(name + "," + backend + "," + str(qubit) + "," + str(depth) +
"," + str(elapsed),
flush=True)
if args.verify:
verify_result(ret, name, qasm)
if not ret:
raise Exception("No qasm file")
return True
