def main():
"""Demonstrates Quantum Fourier transform.
"""
# Create circuit
qft_circuit = generate_2x2_grid_qft_circuit()
cirq.ConvertToCzAndSingleGates().optimize_circuit(
qft_circuit) # cannot work with params
cirq.ExpandComposite().optimize_circuit(qft_circuit)
print('Circuit:')
print(qft_circuit)
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit=qft_circuit,
allow_decomposition=True)
# Simulate and collect final_state
sv_simulator = cirq.Simulator()
qs_simulator = qsimcirq.QSimSimulator(qsim_options={'t': 16, 'v': 2})
sv_result = sv_simulator.simulate(qft_circuit)
qs_result = qs_simulator.simulate(qsim_circuit)
assert sv_result.state_vector().shape == (16, )
assert qs_result.state_vector().shape == (16, )
assert cirq.linalg.allclose_up_to_global_phase(sv_result.state_vector(),
qs_result.state_vector())
kc_simulator = cirq.KnowledgeCompilationSimulator(qft_circuit,
intermediate=False)
kc_result = kc_simulator.simulate(qft_circuit)
print()
print('FinalState')
assert cirq.linalg.allclose_up_to_global_phase(sv_result.state_vector(),
kc_result.state_vector())
print(kc_result.state_vector())
print(np.around(kc_result.final_state_vector, 3))
def __init__(self, *elements: Operation, translate: bool = False) -> None:
circ = Circuit(*elements)
if translate:
circ = translate_circuit_to_qsim(circ)
self._circuit = circ
self._cirq = circuit_to_cirq(self._circuit)
self._qsim_circuit = qsimcirq.QSimCircuit(self._cirq)
def __init__(self,
wires,
shots=1000,
analytic=True,
qubits=None,
qsim_options=None):
super().__init__(wires, shots, analytic, qubits)
self.circuit = qsimcirq.QSimCircuit(cirq_circuit=cirq.Circuit())
self._simulator = qsimcirq.QSimSimulator(
qsim_options=qsim_options or {})
def test_cirq_qsimh_simulate(self):
# Pick qubits.
a, b = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)]
# Create a circuit
cirq_circuit = cirq.Circuit(cirq.CNOT(a, b), cirq.CNOT(b, a), cirq.CZ(a, b))
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit)
qsimh_options = {'k': [0], 'w': 0, 'p': 1, 'r': 1}
qsimhSim = qsimcirq.QSimhSimulator(qsimh_options)
result = qsimhSim.compute_amplitudes(
qsim_circuit, bitstrings=['00', '01', '10', '11'])
self.assertSequenceEqual(result, [(1 + 0j), 0j, 0j, 0j])
def main():
for _ in range(1):
# Choose qubits to use.
q0, q1 = cirq.LineQubit.range(2)
# Pick a secret 2-bit function and create a circuit to query the oracle.
secret_function = [random.randint(0, 1) for _ in range(2)]
oracle = make_oracle(q0, q1, secret_function)
# Embed the oracle into a quantum circuit querying it exactly once.
circuit_no_meas = make_deutsch_circuit(q0, q1, oracle)
qs_circuit = qsimcirq.QSimCircuit(circuit_no_meas)
# Simulate the circuit.
sv_simulator = cirq.Simulator()
qs_simulator = qsimcirq.QSimSimulator(qsim_options={'t': 1, 'v': 4})
sv_result = sv_simulator.simulate(circuit_no_meas)
assert sv_result.state_vector().shape == (4, )
qs_result = qs_simulator.simulate(qs_circuit)
assert qs_result.state_vector().shape == (4, )
assert cirq.linalg.allclose_up_to_global_phase(
sv_result.state_vector(), qs_result.state_vector())
circuit = cirq.Circuit(circuit_no_meas, measure(q0, key='result'))
kc_simulator = cirq.sim.KnowledgeCompilationSimulator(
circuit, intermediate=False)
kc_result = kc_simulator.simulate(circuit)
assert kc_result.state_vector().shape == (4, )
np.testing.assert_almost_equal(sv_result.state_vector(),
kc_result.state_vector(),
decimal=7)
print('Secret function:\nf(x) = <{}>'.format(', '.join(
str(e) for e in secret_function)))
print('Circuit:')
print(circuit)
print('STATE_VECTOR_SIMULATOR: Result of f(0)⊕f(1):')
sv_result = sv_simulator.run(circuit)
print(sv_result)
print('KNOWLEDGE_COMPILATION_SIMULATOR: Result of f(0)⊕f(1):')
kc_result = kc_simulator.run(circuit)
print(kc_result)
assert sv_result == kc_result
def test_cirq_qsim_simulate_fullstate(self):
# Pick qubits.
a, b, c, d = [
cirq.GridQubit(0, 0),
cirq.GridQubit(0, 1),
cirq.GridQubit(1, 1),
cirq.GridQubit(1, 0)
]
# Create a circuit.
cirq_circuit = cirq.Circuit(
cirq.Moment([
cirq.X(a)**0.5, # Square root of X.
cirq.H(b), # Hadamard.
cirq.X(c), # X.
cirq.H(d), # Hadamard.
]),
cirq.Moment([
cirq.X(a)**0.5, # Square root of X.
cirq.CX(b, c), # ControlX.
cirq.S(d), # S (square root of Z).
]),
cirq.Moment([
cirq.I(a),
])
)
# Expected output state is:
# |1> (|01> + |10>) (|0> - |1>)
# = 1/2 * (|1010> - i|1011> + |1100> - i|1101>)
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit)
qsimSim = qsimcirq.QSimSimulator()
result = qsimSim.simulate(qsim_circuit, qubit_order=[a, b, c, d])
assert result.state_vector().shape == (16,)
cirqSim = cirq.Simulator()
cirq_result = cirqSim.simulate(cirq_circuit, qubit_order=[a, b, c, d])
# When using rotation gates such as S, qsim may add a global phase relative
# to other simulators. This is fine, as the result is equivalent.
cirq.linalg.allclose_up_to_global_phase(
result.state_vector(), cirq_result.state_vector())
def test_cirq_qsim_simulate_fullstate(self):
# Pick qubits.
a, b, c, d = [
cirq.GridQubit(0, 0),
cirq.GridQubit(0, 1),
cirq.GridQubit(1, 1),
cirq.GridQubit(1, 0)
]
# Create a circuit
cirq_circuit = cirq.Circuit(
cirq.X(a)**0.5, # Square root of X.
cirq.Y(b)**0.5, # Square root of Y.
cirq.Z(c), # Z.
cirq.CZ(a, d) # ControlZ.
)
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit)
qsimSim = qsimcirq.QSimSimulator()
result = qsimSim.simulate(qsim_circuit)
def test_cirq_qsim_simulate(self):
# Pick qubits.
a, b, c, d = [
cirq.GridQubit(0, 0),
cirq.GridQubit(0, 1),
cirq.GridQubit(1, 1),
cirq.GridQubit(1, 0)
]
# Create a circuit
cirq_circuit = cirq.Circuit(
cirq.X(a)**0.5, # Square root of X.
cirq.Y(b)**0.5, # Square root of Y.
cirq.Z(c), # Z.
cirq.CZ(a, d) # ControlZ.
)
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit)
qsimSim = qsimcirq.QSimSimulator()
result = qsimSim.compute_amplitudes(
qsim_circuit, bitstrings=['0100', '1011'])
self.assertSequenceEqual(result, [0.5j, 0j])
def reset(self):
# pylint: disable=missing-function-docstring
super().reset()
self.circuit = qsimcirq.QSimCircuit(cirq_circuit=cirq.Circuit())
def f(x):
param_resolver = cirq.ParamResolver({ 'alpha':x[0], 'beta':x[1], 'gamma':x[2] })
# VALIDATE STATE VECTOR SIMULATION
solved_circuit = cirq.resolve_parameters(meas_circuit, param_resolver)
cirq.ConvertToCzAndSingleGates().optimize_circuit(solved_circuit) # cannot work with params
cirq.ExpandComposite().optimize_circuit(solved_circuit)
qsim_circuit = qsimcirq.QSimCircuit(solved_circuit)
qs_sim_start = time.time()
qs_sim_result = qs_sim_16.simulate(qsim_circuit)
qs_sim_time = time.time() - qs_sim_start
# kc_sim_start = time.time()
# kc_sim_result = kc_sim.simulate(cirq_circuit, param_resolver=param_resolver)
# kc_sim_time = time.time() - kc_sim_start
# print("kc_sim_result.state_vector()=")
# print(kc_sim_result.state_vector())
# print("qs_sim_result.state_vector()=")
# print(qs_sim_result.state_vector())
# assert qs_sim_result.state_vector().shape == (1<<(length*length),)
# assert cirq.linalg.allclose_up_to_global_phase(
# qs_sim_result.state_vector(),
# kc_sim_result.state_vector(),
# rtol = 1.e-4,
# atol = 1.e-6,
# )
# VALIDATE SAMPLING HISTOGRAMS
# Sample bitstrings from circuit
qs_smp_16_start = time.time()
qs_smp_16_result = qs_sim_16.run(qsim_circuit, repetitions=repetitions)
qs_smp_16_time = time.time() - qs_smp_16_start
qs_bitstrings = qs_smp_16_result.measurements['x']
# Process histogram
qs_histogram = defaultdict(int)
for bitstring in qs_bitstrings:
integer = 0
for pos, bit in enumerate(bitstring):
integer += bit<<pos
qs_histogram[integer] += 1
# Process bitstrings
qs_value = obj_func(qs_smp_16_result, h, jr, jc)
print('Objective value is {}.'.format(qs_value))
# Sample bitstrings from circuit
kc_smp_start = time.time()
kc_smp_result = kc_smp.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions)
kc_smp_time = time.time() - kc_smp_start
# Process histogram
kc_bitstrings = kc_smp_result.measurements['x']
kc_histogram = defaultdict(int)
for bitstring in kc_bitstrings:
integer = 0
for pos, bit in enumerate(reversed(bitstring)):
integer += bit<<pos
kc_histogram[integer] += 1
# Process bitstrings
kc_value = obj_func(kc_smp_result, h, jr, jc)
print('Objective value is {}.'.format(kc_value))
nonlocal iter
# PRINT HISTOGRAMS
kc_kl_div = 0
qs_kl_div = 0
print ('iter,index,bitstring,bitstring_bin,qs_probability,qs_samples,kc_samples')
probabilities = np.zeros(1<<(length*length))
for bitstring, amplitude in enumerate(qs_sim_result.state_vector()):
probability = abs(amplitude) * abs(amplitude)
kc_samples = kc_histogram[bitstring]/repetitions
qs_samples = qs_histogram[bitstring]/repetitions
kc_kl_div += 0 if kc_samples==0 else kc_samples*math.log(kc_samples/probability)
qs_kl_div += 0 if qs_samples==0 else qs_samples*math.log(qs_samples/probability)
probabilities[bitstring]=probability
kc_kl_divs[length].append(kc_kl_div)
qs_kl_divs[length].append(qs_kl_div)
sorted_bitstrings = np.argsort(probabilities)
# for index, bitstring in enumerate(sorted_bitstrings):
# print (str(iter)+','+str(index)+','+str(bitstring)+','+format(bitstring,'b').zfill(length*length)+','+str(probabilities[bitstring])+','+"{:.6e}".format(qs_histogram[bitstring]/repetitions)+','+"{:.6e}".format(kc_histogram[bitstring]/repetitions))
print ('qs_value='+str(qs_value)+' kc_value='+str(kc_value))
# print ( 'qs_sim_time='+str(qs_sim_time)+' kc_sim_time='+str(kc_sim_time) )
print ( 'qs_smp_16_time='+str(qs_smp_16_time)+' kc_smp_time='+str(kc_smp_time) )
print ('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
iter += 1
return qs_value
def main():
q0, q1, q2 = cirq.LineQubit.range(3)
for iteration in range(1):
random_circuit = cirq.testing.random_circuit(qubits=[q0, q1, q2],
n_moments=32,
op_density=0.99)
cirq.ConvertToCzAndSingleGates().optimize_circuit(
random_circuit) # cannot work with params
cirq.ExpandComposite().optimize_circuit(random_circuit)
qs_circuit = qsimcirq.QSimCircuit(random_circuit)
random_circuit._to_quil_output().save_to_file('kc_qtorch.quil')
qs_simulator = qsimcirq.QSimSimulator(qsim_options={'t': 16, 'v': 2})
qs_result = qs_simulator.simulate(qs_circuit)
assert qs_result.state_vector().shape == (8, )
kc_simulator = cirq.KnowledgeCompilationSimulator(random_circuit)
kc_result = kc_simulator.simulate(random_circuit)
print("qs_result.state_vector()")
print(qs_result.state_vector())
print("kc_result.state_vector()")
print(kc_result.state_vector())
assert cirq.linalg.allclose_up_to_global_phase(
qs_result.state_vector(),
kc_result.state_vector(),
rtol=1.e-4,
atol=1.e-6,
)
path_to_qtorch = '/common/home/yh804/research/qtorch/bin/qtorch'
with open('kc_qtorch.inp', 'w') as inp_file:
inp_file.write('''# Line graph decomposition method for contraction
>string qasm kc_qtorch.quil
# >string contractmethod simple-stoch
>string contractmethod linegraph-qbb
>int quickbbseconds 65536
# >string measurement kc_qtorch.meas
# >string outputpath kc_qtorch.out
>bool qbbonly true
# >bool readqbbresonly true
# >int threads 8
''')
stdout = os.system(path_to_qtorch + ' kc_qtorch.inp')
probs = np.zeros(1 << 3)
for bitstring in range(1 << 3):
with open('kc_qtorch.inp', 'w') as inp_file:
inp_file.write(
'''# Line graph decomposition method for contraction
>string qasm kc_qtorch.quil
# >string contractmethod simple-stoch
>string contractmethod linegraph-qbb
# >int quickbbseconds 65536
>string measurement kc_qtorch.meas
>string outputpath kc_qtorch.out
# >bool qbbonly true
>bool readqbbresonly true
>int threads 8
''')
with open('kc_qtorch.meas', 'w') as meas_file:
meas_file.write("{:03b}".format(bitstring))
stdout = os.system(path_to_qtorch + ' kc_qtorch.inp')
with open('kc_qtorch.out', 'r') as out_file:
for line in out_file.readlines():
words = re.split(r'\(|,', line)
if words[0] == 'Result of Contraction: ':
probs[bitstring] = float(words[1])
print(
"np.diag(np.outer(qs_result.state_vector(),np.conj(qs_result.state_vector())))"
)
print(
np.diag(
np.outer(qs_result.state_vector(),
np.conj(qs_result.state_vector()))))
print("probs")
print(probs)
assert cirq.linalg.allclose_up_to_global_phase(
np.diag(
np.outer(qs_result.state_vector(),
np.conj(qs_result.state_vector()))),
probs,
rtol=1.e-4,
atol=1.e-6,
)
circuit_unitary = []
for x in range(8):
result = kc_simulator.simulate(random_circuit, initial_state=x)
circuit_unitary.append(result.final_state_vector)
print("np.transpose(circuit_unitary) = ")
print(np.transpose(circuit_unitary))
print("random_circuit.unitary() = ")
print(random_circuit.unitary())
np.testing.assert_almost_equal(np.transpose(circuit_unitary),
random_circuit.unitary(),
decimal=4)
