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)