def main():
qr, qc, crx, crz = setup()
# initialize state to teleport
vector_to_teleport = random_statevector(2)
qc = initialize_teleport_state(qc, tel_qbit=TELEPORT_QBIT, state=vector_to_teleport.data)
qc.barrier()
# craete bell pair, as q1 and q2 where q1 shared with Alice and q2 with Bob
qc = create_bell_pair(qc, a=A_QBIT, b=B_QBIT)
# find i, j value (which bell states craetes pair q0 and q1 together), i is related to state (q0) and
# j to Alice's entangeletn quibit q1
qc.barrier()
qc = alice_bell_measurement(qc, psi=TELEPORT_QBIT, a=A_QBIT)
qc.barrier()
# evaluate bell measurment of Alice's total state
# measured values are stored in crz and crx
qc = measure_and_send(qc, a=TELEPORT_QBIT, b=A_QBIT, bit_a=0, bit_b=1)
# apply gates regards to teleportation protocol theory
qc.barrier()
qc, crz, crx = bob_gates(qc, B_QBIT, crz=crz, crx=crx)
plot_teleport_state_vector(vector_to_teleport.data)
out_vector = q.execute(qc, STATE_VECTOR_BACKEND).result().get_statevector()
plot_bloch_multivector(out_vector)
# qc.draw("mpl")
plt.show()
def get_state_fidelity(self, ori_circ, new_circ):
num_qubits = ori_circ.num_qubits
num_test = 10
fid_all = 0
for i in range(num_test):
qc_ori = QuantumCircuit(num_qubits, num_qubits)
qc_new = QuantumCircuit(num_qubits, num_qubits)
init_state = random_statevector(2**num_qubits,
np.random.randint(2000000))
qc_ori.initialize(init_state.data, range(num_qubits))
qc_new.initialize(init_state.data, range(num_qubits))
qc_ori.compose(ori_circ, inplace=True)
qc_new.compose(new_circ, inplace=True)
backend = Aer.get_backend('statevector_simulator')
ori_job = execute(qc_ori, backend)
state_ori = ori_job.result().get_statevector(qc_ori)
new_job = execute(qc_new, backend)
state_new = new_job.result().get_statevector(qc_new)
fid = qk.quantum_info.state_fidelity(state_ori, state_new)
fid_all += fid
return fid_all / num_test
def test_set_statevector(self, num_qubits):
"""Test SetStatevector for instruction"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'matrix_product_state'
]
seed = 100
save_label = 'state'
target = qi.random_statevector(2 ** num_qubits, seed=seed)
circ = QuantumCircuit(num_qubits)
circ.set_statevector(target)
circ.save_statevector(label=save_label)
# Run
opts = self.BACKEND_OPTS.copy()
qobj = assemble(circ, self.SIMULATOR)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(save_label, data)
value = qi.Statevector(result.data(0)[save_label])
self.assertAlmostEqual(value, target)
def main():
L = [i for i in range(1, 11)]
print('Considering {} layers'.format(L))
#need a vector of random numbers that is normalized to 1,
#easiest way to just take function from qiskit
vec = random_statevector(16)
epsilon = []
for l in L:
#define random phi
#scipy minimize wants a vector not array
theta = np.random.rand(l * 2 * 4) * np.pi * 2
res = minimize(norm,
theta,
args=(vec, l),
method='BFGS',
options={
'disp': True,
'maxiter': 1000
})
epsilon.append(norm(res.x, vec, l))
print(epsilon)
plt.plot(L, epsilon, 'd-')
plt.xlabel('layers L', fontsize=14)
plt.ylabel('epsilon', fontsize=14)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.ylim([0, 0.75])
plt.savefig('epsilon.eps')
def test_full_qst(self, num_qubits, fitter):
"""Test 1-qubit QST experiment"""
backend = AerSimulator(seed_simulator=9000)
seed = 1234
f_threshold = 0.95
target = qi.random_statevector(2**num_qubits, seed=seed)
qstexp = StateTomography(target)
if fitter:
qstexp.analysis.set_options(fitter=fitter)
expdata = qstexp.run(backend)
results = expdata.analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not density matrix")
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, target, validate=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_local_pbasis_default_statevector(self):
"""Test default states kwarg"""
default_states = [qi.random_statevector(2, seed=30 + i) for i in range(3)]
basis = LocalPreparationBasis("fitter_basis", default_states=default_states)
for i, state in enumerate(default_states):
basis_state = qi.DensityMatrix(basis.matrix([i], [0]))
fid = qi.state_fidelity(state, basis_state)
self.assertTrue(isclose(fid, 1))
def test_statevector_evolve(self):
orig = qi.random_statevector(2, seed=10)
compat = cqi.Statevector(orig.data)
orig_op = qi.random_unitary(2, seed=10)
compat_op = cqi.Operator(orig_op.data)
target = orig.evolve(orig_op)
self.assertEqual(orig.evolve(compat_op), target)
self.assertEqual(compat.evolve(orig_op), target)
self.assertEqual(compat.evolve(compat_op), target)
def test_local_pbasis_qubit_states_no_default(self):
"""Test matrix method raises for invalid qubit with no default states"""
size = 2
qubits = [0, 2]
qubit_states = {
qubits[0]: [qi.random_density_matrix(2, seed=30 + i) for i in range(size)],
qubits[1]: [qi.random_statevector(2, seed=40 + i) for i in range(size)],
}
basis = LocalPreparationBasis("fitter_basis", qubit_states=qubit_states)
# No default states so should raise an exception
with self.assertRaises(ValueError):
basis.matrix([0, 0], [0, 1])
def test_local_mbasis_default_statevector(self):
"""Test default povms kwarg"""
size = 2
outcomes = 3
default_povms = [
[qi.random_statevector(2, seed=30 + i + j) for j in range(outcomes)]
for i in range(size)
]
basis = LocalMeasurementBasis("fitter_basis", default_povms=default_povms)
for i, povm in enumerate(default_povms):
for outcome, effect in enumerate(povm):
basis_state = qi.DensityMatrix(basis.matrix([i], outcome, [0]))
fid = qi.state_fidelity(effect, basis_state)
self.assertTrue(isclose(fid, 1))
def generate_random_psi(num_qbits=2, debug=False):
"""
Initialize our target state |psi>
:param num_qbits: int, number of qbits
:param debug: bool, will print |psi>
:return: qiskit.quantum_info Statevector object
"""
dim = 2**num_qbits
psi = random_statevector(dim, seed=random_seed)
if debug:
print(psi)
return psi
def test_local_pbasis_default_and_qubit_states(self):
"""Test qubit states kwarg"""
size = 3
qubits = [2, 0]
default_states = [qi.random_density_matrix(2, seed=20 + i) for i in range(size)]
qubit_states = {2: [qi.random_statevector(2, seed=40 + i) for i in range(size)]}
basis = LocalPreparationBasis(
"fitter_basis", default_states=default_states, qubit_states=qubit_states
)
# Check states
indices = it.product(range(size), repeat=2)
states0 = qubit_states[qubits[0]] if qubits[0] in qubit_states else default_states
states1 = qubit_states[qubits[1]] if qubits[1] in qubit_states else default_states
for index in indices:
basis_state = qi.DensityMatrix(basis.matrix(index, qubits))
target = qi.DensityMatrix(states0[index[0]]).expand(states1[index[1]])
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def test_local_pbasis_qubit_states(self):
"""Test qubit states kwarg"""
size = 3
qubits = [0, 2]
qubit_states = {
qubits[0]: [qi.random_density_matrix(2, seed=30 + i) for i in range(size)],
qubits[1]: [qi.random_statevector(2, seed=40 + i) for i in range(size)],
}
basis = LocalPreparationBasis("fitter_basis", qubit_states=qubit_states)
# Check states
indices = it.product(range(size), repeat=2)
for index in indices:
basis_state = qi.DensityMatrix(basis.matrix(index, qubits))
target0 = qi.DensityMatrix(qubit_states[qubits[0]][index[0]])
target1 = qi.DensityMatrix(qubit_states[qubits[1]][index[1]])
target = target0.expand(target1)
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def test_full_qst(self, num_qubits):
"""Test QST experiment"""
seed = 1234
shots = 5000
f_threshold = 0.99
# Generate tomography data without analysis
backend = AerSimulator(seed_simulator=seed, shots=shots)
target = qi.random_statevector(2**num_qubits, seed=seed)
exp = StateTomography(target)
expdata = exp.run(backend, analysis=None)
self.assertExperimentDone(expdata)
# Run each tomography fitter analysis as a subtest so
# we don't have to re-run simulation data for each fitter
for fitter in FITTERS:
with self.subTest(fitter=fitter):
if fitter:
exp.analysis.set_options(fitter=fitter)
fitdata = exp.analysis.run(expdata)
self.assertExperimentDone(fitdata)
results = expdata.analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(
isinstance(state, qi.DensityMatrix),
msg=f"{fitter} fitted state is not density matrix",
)
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid,
f_threshold,
msg=f"{fitter} fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, target, validate=False)
self.assertAlmostEqual(
fid,
target_fid,
places=6,
msg=f"{fitter} result fidelity is incorrect")
def update_configs(self, opt_config: Dict[str, Any],
circ_config: Dict[str, Any]) -> None:
"""
If continuing from previous run, it will update the configs with previous values and ignore current ones.
Update is done in place.
"""
if self.result is None:
# If no previous run then generate random target state
state = random_statevector(2**circ_config['nqubit'])
else:
state = Statevector(self.result['target_state'])
opt_config['precision'] = self.result.get('error_precision',
opt_config['precision'])
opt_config['max_iter'] = self.result.get('max_iter',
opt_config['max_iter'])
opt_config['error_convergence'] = self.result.get(
'error_convergence', opt_config['error_convergence'])
circ_config['nqubit'] = self.result.get('nqubit',
circ_config['nqubit'])
circ_config.update({'target_state': state})
def test_set_statevector(self, method, device, num_qubits):
"""Test SetStatevector for instruction"""
backend = self.backend(method=method, device=device)
seed = 100
label = 'state'
target = qi.random_statevector(2**num_qubits, seed=seed)
circ = QuantumCircuit(num_qubits)
circ.set_statevector(target)
circ.save_statevector(label=label)
# Run
result = backend.run(transpile(circ, backend, optimization_level=0),
shots=1).result()
self.assertTrue(result.success)
simdata = result.data(0)
self.assertIn(label, simdata)
value = simdata[label]
self.assertEqual(value, target)
def test_local_mbasis_default_and_qubit_states(self):
"""Test qubit and default povm kwarg"""
size = 3
outcomes = 2
qubits = [2, 0]
default_povms = (
[
[qi.random_statevector(2, seed=20 + i + j) for i in range(outcomes)]
for j in range(size)
],
)
qubit_povms = {
qubits[0]: [
[qi.random_density_matrix(2, seed=30 + i + j) for i in range(outcomes)]
for j in range(size)
],
qubits[1]: [
[qi.random_density_matrix(2, seed=40 + i + j) for i in range(outcomes)]
for j in range(size)
],
}
basis = LocalMeasurementBasis(
"fitter_basis", default_povms=default_povms, qubit_povms=qubit_povms
)
# Check states
states0 = qubit_povms[qubits[0]] if qubits[0] in qubit_povms else default_povms
states1 = qubit_povms[qubits[1]] if qubits[1] in qubit_povms else default_povms
indices = it.product(range(size), repeat=2)
outcomes = it.product(range(outcomes), repeat=len(qubits))
for index in indices:
for outcome in outcomes:
basis_state = qi.DensityMatrix(
basis.matrix(index, self._outcome_tup_to_int(outcome), qubits)
)
target0 = qi.DensityMatrix(states0[index[0]][outcome[0]])
target1 = qi.DensityMatrix(states1[index[1]][outcome[1]])
target = target0.expand(target1)
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def main():
# Parse all command line arguments
args = parser.parse_args()
maxL = args.maxL
minL = args.minL
outfile = args.outfile
odd_gates = args.odd
even_gates = args.even
seed = args.seed
logfile = args.logfile
verbose = args.verbose
iterations = args.iterations
# Define the logger
logger = logging.getLogger('task1')
if logfile:
logger.addHandler(logging.FileHandler(logfile))
if verbose:
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.DEBUG)
np.random.seed(seed=seed)
backend = Aer.get_backend('statevector_simulator')
for i in range(iterations):
random_vector = random_statevector(dims=(2, 2, 2, 2), seed=seed)
for j in range(minL, maxL + 1):
circuit = build_circuit(j,
odd_gates=odd_gates,
even_gates=even_gates)
res = optimize.minimize(
fun=objective_function,
x0=np.random.rand(len(circuit.parameters)) * 2 * np.pi,
args=(circuit, random_vector, backend),
jac='2-point',
bounds=[(0, 2 * np.pi)] * len(circuit.parameters),
callback=lambda v: v % (2 * np.pi))
logger.debug(f'Iteration: {i + 1}')
logger.debug(f'Goal statevector: {random_vector.data}')
logger.debug(f'Number of layers: {j}')
logger.debug(f'Odd gates: {odd_gates}')
logger.debug(f'Even gates: {even_gates}')
logger.debug(circuit.decompose())
logger.debug('\nResult')
logger.debug(
'===================================================================================='
)
logger.debug(f'{res}')
logger.debug(
'====================================================================================\n'
)
with open(outfile, 'a') as f:
f.write(f'{i},{j},{res.fun}')
f.write('\n')
sys.exit(ExitStatus.success)
def test_roundtrip_statevector(self):
"""Test round-trip serialization of a Statevector"""
obj = qi.random_statevector(4, seed=10)
self.assertRoundTripSerializable(obj)
def test_statevector_tensor(self):
orig = qi.random_statevector(2, seed=10)
compat = cqi.Statevector(orig.data)
target = orig.tensor(orig)
self.assertEqual(compat.tensor(orig), target)
self.assertEqual(orig.tensor(compat), target)
def test_statevector_linop(self):
orig = qi.random_statevector(4, seed=10)
compat = cqi.Statevector(orig.data)
self.assertEqual(2 * compat - orig, orig)
self.assertEqual(2 * orig - compat, orig)
def test_statevector_eq(self):
orig = qi.random_statevector(4, seed=10)
compat = cqi.Statevector(orig.data)
self.assertEqual(compat, orig)
self.assertEqual(orig, compat)
def test_unitary_evolve(self):
orig = qi.random_unitary(2, seed=10)
compat = cqi.Operator(orig.data)
state = qi.random_statevector(2, seed=10)
target = state.evolve(orig)
self.assertEqual(state.evolve(compat), target)
def generate(self) -> list:
b = [1, 0]
sv1 = Statevector(random_statevector((2, 1)))
sv2 = Statevector(random_statevector((2, 1)))
return [[sv1.data, b], [sv2.data, b]]
def random_state(self):
self.state = random_statevector(self.state.dim)
self.original = self.state
def test_local_pbasis_no_inst(self):
"""Test circuits method raises if no instructions"""
default_states = [qi.random_statevector(2, seed=30 + i) for i in range(2)]
basis = LocalPreparationBasis("fitter_basis", default_states=default_states)
with self.assertRaises(NotImplementedError):
basis.circuit([0], [0])
qc.h(qr[a])
qc.measure(qr[a], crx)
qc.measure(qr[b], crz)
#Bobs transformation
def bob_transformation(qc, qubit):
qc.barrier()
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
#note: bob's transformation may change depending upon the entanglement channel
#creating a state that we want to teleport : alice will be the sender
state = random_statevector(2, seed=3)
state.probabilities()
init_gate = Initialize(state.data)
qc.append(init_gate, [0])
create_ent_channel(qc, 1, 2)
bell_measurement(qc, 0, 1)
bob_transformation(qc, 2)
#qc.draw('mpl')
#thus the bob qubit will be transformed to state which alice want to sent.
#state of the alice's qubit get collapsed during the process
'''#checking the bobs state
backend=BasicAer.get_backend('statevector_simulator')
in_state=state
plot_bloch_multivector(in_state)'''
# Otherwise return the circuit and final vector (for tests and debugging)
if optimise:
return distance
else:
return distance, circuit, result_vector
#Number of q-bits / c-bits
n = 4
#Number of layers
layers = [1, 2, 3, 4, 5]
maxiter = 2000
#Random vector
ref_vector = random_statevector(2**n).data
# Setup output file
f = open('output.txt', 'w')
print('REFERENCE VECTOR', ref_vector, file=f)
# Initialise list of distances vs layer number
min_distance = []
for l in layers:
# Initialise random angles between 0 and 2pi - angles for odd(even) blocks have odd(even) indices
angle_random = 2 * pi * random.rand(2 * l, n)
# Minimise cost function 'vec_stance' by optimising the angles of Rx and Rz gates
res = optimize.minimize(vec_distance,
angle_random,
args=(n, l, ref_vector, True, False),
