def test_run_empty_circuit(dtype): circuit = cirq.Circuit() simulator = cirq.KnowledgeCompilationSimulator(circuit, dtype=dtype) with pytest.raises(ValueError, match="no measurements"): simulator.run(circuit)
def trial(n=6, p=2, repetitions=1000, maxiter=2): # Generate a random 3-regular graph on n nodes graph = networkx.random_regular_graph(3, n) # Make qubits qubits = cirq.LineQubit.range(n) # Print an example circuit cirq_circuit = qaoa_max_cut_circuit_no_meas(qubits, p, graph) print('Example QAOA circuit:') print(cirq_circuit.to_text_diagram(transpose=True)) # noise = cirq.ConstantQubitNoiseModel(cirq.asymmetric_depolarize(0.005,0.005,0.005)) # mixture: size four noise not implemented noise = cirq.ConstantQubitNoiseModel( cirq.depolarize(0.005)) # mixture: size four noise not implemented # noise = cirq.ConstantQubitNoiseModel(cirq.phase_flip(0.01)) # mixture: works well # noise = cirq.ConstantQubitNoiseModel(cirq.bit_flip(0.01)) # mixture: works well cirq_circuit = cirq.Circuit( cirq.NoiseModel.from_noise_model_like(noise).noisy_moments( cirq_circuit, sorted(cirq_circuit.all_qubits()))) meas_circuit = cirq.Circuit(cirq_circuit, cirq.measure(*qubits, key='m')) # Initialize simulators dm_sim = cirq.DensityMatrixSimulator() # kc_sim = cirq.KnowledgeCompilationSimulator(cirq_circuit, initial_state=0) kc_smp = cirq.KnowledgeCompilationSimulator(meas_circuit, initial_state=0) # Create variables to store the largest cut and cut value found dm_largest_cut_found = None dm_largest_cut_value_found = 0 kc_largest_cut_found = None kc_largest_cut_value_found = 0 # Define objective function (we'll use the negative expected cut value) iter = 0 def f(x): # Create circuit betas = x[:p] betas_dict = {'beta' + str(index): betas[index] for index in range(p)} gammas = x[p:] gammas_dict = { 'gamma' + str(index): gammas[index] for index in range(p) } param_resolver = cirq.ParamResolver({**betas_dict, **gammas_dict}) # VALIDATE DENSITY MATRIX SIMULATION # dm_sim_start = time.time() # dm_sim_result = dm_sim.simulate(cirq_circuit, param_resolver=param_resolver) # dm_sim_time = time.time() - dm_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("dm_sim_result.final_density_matrix=") # print(dm_sim_result.final_density_matrix) # print("kc_sim_result.final_density_matrix=") # print(kc_sim_result.final_density_matrix) # # np.testing.assert_almost_equal( # dm_sim_result.final_density_matrix, # kc_sim_result.final_density_matrix, # decimal=6 # ) # VALIDATE SAMPLING HISTOGRAMS # Sample bitstrings from circuit if n <= cirq_max: dm_smp_start = time.time() dm_smp_result = dm_sim.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) dm_smp_time = time.time() - dm_smp_start dm_smp_time_dict[n].append(dm_smp_time) # Process histogram dm_bitstrings = dm_smp_result.measurements['m'] dm_histogram = defaultdict(int) for bitstring in dm_bitstrings: integer = 0 for pos, bit in enumerate(reversed(bitstring)): integer += bit << pos dm_histogram[integer] += 1 # Process bitstrings nonlocal dm_largest_cut_found nonlocal dm_largest_cut_value_found dm_values = cut_values(dm_bitstrings, graph) dm_max_value_index = np.argmax(dm_values) dm_max_value = dm_values[dm_max_value_index] if dm_max_value > dm_largest_cut_value_found: dm_largest_cut_value_found = dm_max_value dm_largest_cut_found = dm_bitstrings[dm_max_value_index] dm_mean = np.mean(dm_values) # 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 kc_smp_time_dict[n].append(kc_smp_time) # Process histogram kc_bitstrings = kc_smp_result.measurements['m'] 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 nonlocal kc_largest_cut_found nonlocal kc_largest_cut_value_found kc_values = cut_values(kc_bitstrings, graph) kc_max_value_index = np.argmax(kc_values) kc_max_value = kc_values[kc_max_value_index] if kc_max_value > kc_largest_cut_value_found: kc_largest_cut_value_found = kc_max_value kc_largest_cut_found = kc_bitstrings[kc_max_value_index] kc_mean = np.mean(kc_values) nonlocal iter # PRINT HISTOGRAMS # print ('iter,index,bitstring,bitstring_bin,dm_probability,dm_samples,kc_samples') # probabilities = np.zeros(1<<n) # for bitstring, probability in enumerate(cirq.sim.density_matrix_utils._probs( # dm_sim_result.final_density_matrix, # [index for index in range(n)], # cirq.protocols.qid_shape(qubits) # )): # probabilities[bitstring]=probability # sorted_bitstrings = np.argsort(probabilities) # for index, bitstring in enumerate(sorted_bitstrings): # print (str(iter)+','+str(index)+','+str(bitstring)+','+format(bitstring,'b').zfill(n)+','+str(probabilities[bitstring])+','+"{:.6e}".format(dm_histogram[bitstring]/repetitions)+','+"{:.6e}".format(kc_histogram[bitstring]/repetitions)) if n <= cirq_max: print('dm_mean=' + str(dm_mean) + ' kc_mean=' + str(kc_mean)) # print ( 'dm_sim_time='+str(dm_sim_time)+' kc_sim_time='+str(kc_sim_time) ) print('dm_smp_time=' + str(dm_smp_time) + ' kc_smp_time=' + str(kc_smp_time)) print( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') iter += 1 return -kc_mean # Pick an initial guess x0 = np.random.uniform(-np.pi, np.pi, size=2 * p) # Optimize f print('Optimizing objective function ...') scipy.optimize.minimize(f, x0, method='Nelder-Mead', options={'maxiter': maxiter}) # Compute best possible cut value via brute force search all_bitstrings = np.array(list(itertools.product(range(2), repeat=n))) all_values = cut_values(all_bitstrings, graph) max_cut_value = np.max(all_values) # Print the results print('The largest cut value found was {}.'.format( dm_largest_cut_value_found)) print('The largest possible cut has size {}.'.format(max_cut_value)) print('The approximation ratio achieved is {}.'.format( dm_largest_cut_value_found / max_cut_value))
def test_run_repetitions_terminal_measurement_stochastic(): q = cirq.LineQubit(0) c = cirq.Circuit(cirq.H(q), cirq.measure(q, key='q')) results = cirq.KnowledgeCompilationSimulator(c).run(c, repetitions=10000) assert 1000 <= sum(v[0] for v in results.measurements['q']) < 9000
def test_invalid_dtype(): with pytest.raises(ValueError, match='complex'): cirq.KnowledgeCompilationSimulator(cirq.Circuit(), dtype=np.int32)
def experiment_multiplier(n=2): qubits = cirq.LineQubit.range(5 * n) # c = qubits[0:n*3:3] # a = qubits[1:n*3:3] b = qubits[2:n * 3:3] y = qubits[n * 3:n * 4] x = qubits[n * 4:] kc_circuit = cirq.Circuit( init_qubits_sym( [sympy.Symbol('x_bin' + str(index)) for index in range(n)], *x), init_qubits_sym( [sympy.Symbol('y_bin' + str(index)) for index in range(n)], *y), cirq.decompose(Multiplier(5 * n).on(*qubits)), cirq.measure(*b, key='result')) cirq.optimizers.SynchronizeTerminalMeasurements().optimize_circuit( kc_circuit) kc_simulator = cirq.KnowledgeCompilationSimulator(kc_circuit, initial_state=0, intermediate=False) for p in range(2**n): for q in range(2**n): y_bin = '{:08b}'.format(p)[-n:] x_bin = '{:08b}'.format(q)[-n:] x_bin_dict = { 'x_bin' + str(index): x_bin[index] for index in range(n) } y_bin_dict = { 'y_bin' + str(index): y_bin[index] for index in range(n) } param_resolver = cirq.ParamResolver({**x_bin_dict, **y_bin_dict}) dm_circuit = cirq.Circuit( init_qubits(x_bin, *x), init_qubits(y_bin, *y), Multiplier(5 * n).on(*qubits), ) np.testing.assert_almost_equal( cirq.Simulator().simulate(dm_circuit).state_vector(), kc_simulator.simulate( kc_circuit, param_resolver=param_resolver).state_vector()) sv_circuit = cirq.Circuit(init_qubits(x_bin, *x), init_qubits(y_bin, *y), Multiplier(5 * n).on(*qubits), cirq.measure(*b, key='result')) sv_result = cirq.Simulator().run( sv_circuit, repetitions=1).measurements['result'] sv_sum_bin = ''.join(sv_result[0][::-1].astype(int).astype(str)) kc_result = kc_simulator.run(kc_circuit, param_resolver=param_resolver, repetitions=1).measurements['result'] kc_sum_bin = ''.join(kc_result[0][::-1].astype(int).astype(str)) print('{} * {} = {}'.format(y_bin, x_bin, sv_sum_bin)) print('{} * {} = {}'.format(y_bin, x_bin, kc_sum_bin)) assert sv_sum_bin == kc_sum_bin
ansatz = openfermioncirq.SwapNetworkTrotterAnsatz(hamiltonian, iterations=iterations) print('Created a variational ansatz with the following circuit:') print(ansatz.circuit.to_text_diagram(transpose=True)) # Use preparation circuit for mean-field state import cirq preparation_circuit = cirq.Circuit( openfermioncirq.prepare_gaussian_state( ansatz.qubits, openfermion.QuadraticHamiltonian(hamiltonian.one_body), occupied_orbitals=range(n_electrons))) kc_simulator = cirq.KnowledgeCompilationSimulator(preparation_circuit + ansatz.circuit, initial_state=0) # Create a Hamiltonian variational study study = openfermioncirq.VariationalStudy( 'jellium_study', ansatz, objective, preparation_circuit=preparation_circuit) print("Created a variational study with {} qubits and {} parameters".format( len(study.ansatz.qubits), study.num_params)) print( "The value of the objective with default initial parameters is {}".format( study.value_of(kc_simulator, ansatz.default_initial_params())))
def main(num_qubits=8): # Setup non-eavesdropped protocol print('Simulating non-eavesdropped protocol') alice_basis = [np.random.randint(0, 2) for _ in range(num_qubits)] alice_state = [np.random.randint(0, 2) for _ in range(num_qubits)] bob_basis = [np.random.randint(0, 2) for _ in range(num_qubits)] expected_key = bitstring([ alice_state[i] for i in range(num_qubits) if alice_basis[i] == bob_basis[i] ]) circuit = make_bb84_circ(num_qubits, alice_basis, bob_basis, alice_state) # Run simulations. repetitions = 1 result = cirq.KnowledgeCompilationSimulator( circuit, intermediate=True).run(program=circuit, repetitions=repetitions) print("result=") print(result) result_bitstring = bitstring( [int(result.measurements[str(i)]) for i in range(num_qubits)]) # Take only qubits where bases match obtained_key = ''.join([ result_bitstring[i] for i in range(num_qubits) if alice_basis[i] == bob_basis[i] ]) assert expected_key == obtained_key, "Keys don't match" print(circuit) print_results(alice_basis, bob_basis, alice_state, expected_key, obtained_key) # Setup eavesdropped protocol print('Simulating eavesdropped protocol') np.random.seed(200) # Seed random generator for consistent results alice_basis = [np.random.randint(0, 2) for _ in range(num_qubits)] alice_state = [np.random.randint(0, 2) for _ in range(num_qubits)] bob_basis = [np.random.randint(0, 2) for _ in range(num_qubits)] eve_basis = [np.random.randint(0, 2) for _ in range(num_qubits)] expected_key = bitstring([ alice_state[i] for i in range(num_qubits) if alice_basis[i] == bob_basis[i] ]) # Eve intercepts the qubits alice_eve_circuit = make_bb84_circ(num_qubits, alice_basis, eve_basis, alice_state) # Run simulations. repetitions = 1 result = cirq.KnowledgeCompilationSimulator(alice_eve_circuit, intermediate=True).run( program=alice_eve_circuit, repetitions=repetitions) eve_state = [int(result.measurements[str(i)]) for i in range(num_qubits)] eve_bob_circuit = make_bb84_circ(num_qubits, eve_basis, bob_basis, eve_state) # Run simulations. repetitions = 1 result = cirq.KnowledgeCompilationSimulator(eve_bob_circuit, intermediate=True).run( program=eve_bob_circuit, repetitions=repetitions) result_bitstring = bitstring( [int(result.measurements[str(i)]) for i in range(num_qubits)]) # Take only qubits where bases match obtained_key = ''.join([ result_bitstring[i] for i in range(num_qubits) if alice_basis[i] == bob_basis[i] ]) assert expected_key != obtained_key, "Keys shouldn't match" circuit = alice_eve_circuit + eve_bob_circuit print(circuit) print_results(alice_basis, bob_basis, alice_state, expected_key, obtained_key)
def main( repetitions=256, maxiter=1 ): # Set problem parameters kc_kl_divs={} qs_kl_divs={} for length in range (2,6,1): kc_kl_divs[length]=[] qs_kl_divs[length]=[] for print_length in range(2,length,1): for kc_kl_div, qs_kl_div in zip(kc_kl_divs[print_length],qs_kl_divs[print_length]): print("print_length="+str(print_length)+" kc_kl_div="+str(kc_kl_div)+" qs_kl_div="+str(qs_kl_div)) for _ in range(16): steps = 1 h, jr, jc = random_instance(length) print('transverse fields: {}'.format(h)) print('row j fields: {}'.format(jr)) print('column j fields: {}'.format(jc)) # prints something like # transverse fields: [[-1, 1, -1], [1, -1, -1], [-1, 1, -1]] # row j fields: [[1, 1, -1], [1, -1, 1]] # column j fields: [[1, -1], [-1, 1], [-1, 1]] # define qubits on the grid. # [cirq.GridQubit(i, j) for i in range(length) for j in range(length)] qubits = cirq.LineQubit.range(length*length) print(qubits) # prints # [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(0, 2), cirq.GridQubit(1, 0), cirq.GridQubit(1, 1), cirq.GridQubit(1, 2), cirq.GridQubit(2, 0), cirq.GridQubit(2, 1), cirq.GridQubit(2, 2)] cirq_circuit = cirq.Circuit() alpha = sympy.Symbol('alpha') beta = sympy.Symbol('beta') gamma = sympy.Symbol('gamma') for _ in range(steps): cirq_circuit.append(one_step(h, jr, jc, alpha, beta, gamma)) meas_circuit = cirq.Circuit( cirq_circuit, cirq.measure(*qubits, key='x') ) print(meas_circuit) # Initialize simulators qs_sim_16 = qsimcirq.QSimSimulator( qsim_options={'t':16, 'v': 0} ) kc_sim = cirq.KnowledgeCompilationSimulator(cirq_circuit, initial_state=0) kc_smp = cirq.KnowledgeCompilationSimulator(meas_circuit, initial_state=0) iter = 0 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 # Pick an initial guess x0 = np.random.uniform(0.0, 1.0, size=3) # Optimize f print('Optimizing objective function ...') scipy.optimize.minimize(f, x0, method='Nelder-Mead', options={'maxiter': maxiter})
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)
def main( # repetitions=16384, maxiter=8 ): # Set problem parameters n = 8 p = 1 # Generate a random 3-regular graph on n nodes graph = networkx.random_regular_graph(3, n) # Make qubits qubits = cirq.LineQubit.range(n) # Print an example circuit betas = np.random.uniform(-np.pi, np.pi, size=p) gammas = np.random.uniform(-np.pi, np.pi, size=p) circuit_no_meas = qaoa_max_cut_circuit_no_meas(qubits, p, graph) print('Example QAOA circuit:') print(circuit_no_meas.to_text_diagram(transpose=True)) # noise = cirq.ConstantQubitNoiseModel(cirq.generalized_amplitude_damp(0.05,0.05)) # noise = cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.25)) # noise = cirq.ConstantQubitNoiseModel(cirq.phase_damp(0.25)) # noise = cirq.ConstantQubitNoiseModel(cirq.asymmetric_depolarize(0.05,0.05,0.05)) # asymmetric depolarizing noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.005)) # symmetric depolarizing # noise = cirq.ConstantQubitNoiseModel(cirq.phase_flip(0.25)) # mixture # noise = cirq.ConstantQubitNoiseModel(cirq.bit_flip(0.03125)) # mixture circuit_no_meas = cirq.Circuit(cirq.NoiseModel.from_noise_model_like(noise).noisy_moments(circuit_no_meas, sorted(circuit_no_meas.all_qubits()))) circuit = cirq.Circuit( circuit_no_meas, cirq.measure(*qubits, key='m') ) cirq.optimizers.ExpandComposite().optimize_circuit(circuit) # seems to actually increase BN size # Initialize simulator kc_simulator = cirq.KnowledgeCompilationSimulator( circuit, initial_state=0, intermediate=False ) dm_simulator = cirq.Simulator() # Create variables to store the largest cut and cut value found kc_largest_cut_found = None kc_largest_cut_value_found = 0 dm_largest_cut_found = None dm_largest_cut_value_found = 0 # Define objective function (we'll use the negative expected cut value) iter = 0 def f(x): # Create circuit betas = x[:p] betas_dict = { 'beta'+str(index):betas[index] for index in range(p) } gammas = x[p:] gammas_dict = { 'gamma'+str(index):gammas[index] for index in range(p) } param_resolver = cirq.ParamResolver({**betas_dict,**gammas_dict}) # kc_chisqs = {} # dm_chisqs = {} kc_power_divergences = {} dm_power_divergences = {} ks_2samps = {} for rep_pow in range(12): repetitions = 1<<rep_pow # VALIDATE STATE VECTOR SIMULATION # kc_sim_result = kc_simulator.simulate(circuit_no_meas, param_resolver=param_resolver) dm_sim_result = dm_simulator.simulate(circuit_no_meas, param_resolver=param_resolver) # print("kc_sim_result.final_density_matrix") # print(kc_sim_result.final_density_matrix) # print("dm_sim_result.final_density_matrix") # print(dm_sim_result.final_density_matrix) # np.testing.assert_almost_equal( # kc_sim_result.final_density_matrix, # dm_sim_result.final_density_matrix, # decimal=5 # ) # VALIDATE SAMPLING HISTOGRAMS # Sample bitstrings from circuit kc_smp_start = time.time() kc_smp_result = kc_simulator.run(circuit, param_resolver=param_resolver, repetitions=repetitions) kc_smp_time = time.time() - kc_smp_start kc_bitstrings = kc_smp_result.measurements['m'] # Process histogram kc_histogram = np.zeros(1<<n) kc_integers = [] for bitstring in kc_bitstrings: integer = 0 for pos, bit in enumerate(bitstring): integer += bit<<pos kc_histogram[integer] += 1 kc_integers.append(integer) # Process bitstrings nonlocal kc_largest_cut_found nonlocal kc_largest_cut_value_found kc_values = cut_values(kc_bitstrings, graph) kc_max_value_index = np.argmax(kc_values) kc_max_value = kc_values[kc_max_value_index] if kc_max_value > kc_largest_cut_value_found: kc_largest_cut_value_found = kc_max_value kc_largest_cut_found = kc_bitstrings[kc_max_value_index] kc_mean = np.mean(kc_values) # Sample bitstrings from circuit dm_smp_start = time.time() dm_smp_result = dm_simulator.run(circuit, param_resolver=param_resolver, repetitions=repetitions) dm_smp_time = time.time() - dm_smp_start dm_bitstrings = dm_smp_result.measurements['m'] # Process histogram dm_histogram = np.zeros(1<<n) dm_integers = [] for bitstring in dm_bitstrings: integer = 0 for pos, bit in enumerate(bitstring): integer += bit<<pos dm_histogram[integer] += 1 dm_integers.append(integer) # Process bitstrings nonlocal dm_largest_cut_found nonlocal dm_largest_cut_value_found dm_values = cut_values(dm_bitstrings, graph) dm_max_value_index = np.argmax(dm_values) dm_max_value = dm_values[dm_max_value_index] if dm_max_value > dm_largest_cut_value_found: dm_largest_cut_value_found = dm_max_value dm_largest_cut_found = dm_bitstrings[dm_max_value_index] dm_mean = np.mean(dm_values) nonlocal iter # PRINT HISTOGRAMS exact_histogram = np.zeros(1<<n) for index, amplitude in enumerate(dm_sim_result.state_vector()): probability = abs(amplitude) * abs(amplitude) exact_histogram[index] = probability * repetitions # print ('iter='+str(iter)+' bitstring='+str(index)+' kc_probability='+str(kc_histogram[index]/repetitions)+' dm_probability='+str(dm_histogram[index]/repetitions)+' probability='+str(probability)) # exact_probabilities = cirq.sim.density_matrix_utils._probs( # dm_sim_result.final_density_matrix, # [index for index in range(n)], # cirq.protocols.qid_shape(qubits) # ) # for index, probability in enumerate(exact_probabilities): # exact_histogram[index] = probability * repetitions # print ('iter='+str(iter)+' bitstring='+str(index)+' kc_probability='+str(kc_histogram[index]/repetitions)+' dm_probability='+str(dm_histogram[index]/repetitions)+' probability='+str(probability)) # kc_chisq, _ = scipy.stats.chisquare( f_obs=kc_histogram, f_exp=exact_histogram ) # dm_chisq, _ = scipy.stats.chisquare( f_obs=dm_histogram, f_exp=exact_histogram ) # kc_power_divergence, _ = scipy.stats.power_divergence( f_obs=kc_histogram, f_exp=exact_histogram, lambda_="pearson" ) # dm_power_divergence, _ = scipy.stats.power_divergence( f_obs=dm_histogram, f_exp=exact_histogram, lambda_="pearson" ) kc_power_divergence, _ = scipy.stats.power_divergence( f_obs=kc_histogram, f_exp=exact_histogram, lambda_="log-likelihood" ) dm_power_divergence, _ = scipy.stats.power_divergence( f_obs=dm_histogram, f_exp=exact_histogram, lambda_="log-likelihood" ) ks_2samp, _ = scipy.stats.ks_2samp( data1=kc_integers, data2=dm_integers ) # kc_chisqs[repetitions]=kc_chisq # dm_chisqs[repetitions]=dm_chisq # kc_power_divergences[repetitions]=kc_power_divergence # dm_power_divergences[repetitions]=dm_power_divergence kc_power_divergences[repetitions]=kc_power_divergence / 2 / repetitions dm_power_divergences[repetitions]=dm_power_divergence / 2 / repetitions ks_2samps[repetitions]=ks_2samp print ( 'repetitions='+str(repetitions)+ # ' kc_chisq='+str(kc_chisq)+ # ' dm_chisq='+str(dm_chisq)+ # ' kc_power_divergence='+str(kc_power_divergence)+ # ' dm_power_divergence='+str(dm_power_divergence)+ ' kc_power_divergence='+str(kc_power_divergence / 2 / repetitions)+ ' dm_power_divergence='+str(dm_power_divergence / 2 / repetitions)+ ' ks_2samp='+str(ks_2samp) ) # print ('kc_mean='+str(kc_mean)+' dm_mean='+str(dm_mean)) # print ( 'kc_smp_time=' + str(kc_smp_time) + ' dm_smp_time=' + str(dm_smp_time) ) # print ('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') iter += 1 return -dm_mean # Pick an initial guess x0 = np.random.uniform(-np.pi, np.pi, size=2 * p) # Optimize f print('Optimizing objective function ...') scipy.optimize.minimize(f, x0, method='Nelder-Mead', options={'maxiter': maxiter}) # Compute best possible cut value via brute force search all_bitstrings = np.array(list(itertools.product(range(2), repeat=n))) all_values = cut_values(all_bitstrings, graph) max_cut_value = np.max(all_values) # Print the results print('The largest cut value found was {}.'.format(dm_largest_cut_value_found)) print('The largest possible cut has size {}.'.format(max_cut_value)) print('The approximation ratio achieved is {}.'.format( dm_largest_cut_value_found / max_cut_value))
def trial(length=2, steps=1, repetitions=1000, maxiter=2): h, jr, jc = random_instance(length) print('transverse fields: {}'.format(h)) print('row j fields: {}'.format(jr)) print('column j fields: {}'.format(jc)) # prints something like # transverse fields: [[-1, 1, -1], [1, -1, -1], [-1, 1, -1]] # row j fields: [[1, 1, -1], [1, -1, 1]] # column j fields: [[1, -1], [-1, 1], [-1, 1]] # define qubits on the grid. # [cirq.GridQubit(i, j) for i in range(length) for j in range(length)] qubits = cirq.LineQubit.range(length * length) print(qubits) # prints # [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(0, 2), cirq.GridQubit(1, 0), cirq.GridQubit(1, 1), cirq.GridQubit(1, 2), cirq.GridQubit(2, 0), cirq.GridQubit(2, 1), cirq.GridQubit(2, 2)] cirq_circuit = cirq.Circuit() alpha = sympy.Symbol('alpha') beta = sympy.Symbol('beta') gamma = sympy.Symbol('gamma') for _ in range(steps): cirq_circuit.append(one_step(h, jr, jc, alpha, beta, gamma)) # noise = cirq.ConstantQubitNoiseModel(cirq.asymmetric_depolarize(0.005,0.005,0.005)) # mixture: size four noise not implemented noise = cirq.ConstantQubitNoiseModel( cirq.depolarize(0.005)) # mixture: size four noise not implemented # noise = cirq.ConstantQubitNoiseModel(cirq.phase_flip(0.01)) # mixture: works well # noise = cirq.ConstantQubitNoiseModel(cirq.bit_flip(0.01)) # mixture: works well cirq_circuit = cirq.Circuit( cirq.NoiseModel.from_noise_model_like(noise).noisy_moments( cirq_circuit, sorted(cirq_circuit.all_qubits()))) meas_circuit = cirq.Circuit(cirq_circuit, cirq.measure(*qubits, key='x')) print(meas_circuit) # Initialize simulators dm_sim = cirq.DensityMatrixSimulator() # kc_sim = cirq.KnowledgeCompilationSimulator(cirq_circuit, initial_state=0) kc_smp = cirq.KnowledgeCompilationSimulator(meas_circuit, initial_state=0) # eval_iter = 0 def f(x): param_resolver = cirq.ParamResolver({ 'alpha': x[0], 'beta': x[1], 'gamma': x[2] }) # VALIDATE DENSITY MATRIX SIMULATION # dm_sim_start = time.time() # dm_sim_result = dm_sim.simulate(cirq_circuit, param_resolver=param_resolver) # dm_sim_time = time.time() - dm_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("dm_sim_result.final_density_matrix=") # print(dm_sim_result.final_density_matrix) # print("kc_sim_result.final_density_matrix=") # print(kc_sim_result.final_density_matrix) # np.testing.assert_almost_equal( # dm_sim_result.final_density_matrix, # kc_sim_result.final_density_matrix, # decimal=6 # ) # VALIDATE SAMPLING HISTOGRAMS # Sample bitstrings from circuit if length * length <= cirq_max: dm_smp_start = time.time() dm_smp_result = dm_sim.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) dm_smp_time = time.time() - dm_smp_start dm_smp_time_dict[length * length].append(dm_smp_time) # Process histogram dm_bitstrings = dm_smp_result.measurements['x'] dm_histogram = defaultdict(int) for bitstring in dm_bitstrings: integer = 0 for pos, bit in enumerate(reversed(bitstring)): integer += bit << pos dm_histogram[integer] += 1 # Process bitstrings dm_value = obj_func(dm_smp_result, h, jr, jc) print('Objective value is {}.'.format(dm_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 kc_smp_time_dict[length * length].append(kc_smp_time) # 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 eval_iter # PRINT HISTOGRAMS # print ('eval_iter,index,bitstring,bitstring_bin,dm_probability,dm_samples,kc_samples') # probabilities = np.zeros(1<<(length*length)) # for bitstring, probability in enumerate(cirq.sim.density_matrix_utils._probs( # dm_sim_result.final_density_matrix, # [index for index in range(length*length)], # cirq.protocols.qid_shape(qubits) # )): # probabilities[bitstring]=probability # sorted_bitstrings = np.argsort(probabilities) # for index, bitstring in enumerate(sorted_bitstrings): # print (str(eval_iter)+','+str(index)+','+str(bitstring)+','+format(bitstring,'b').zfill(length*length)+','+str(probabilities[bitstring])+','+"{:.6e}".format(dm_histogram[bitstring]/repetitions)+','+"{:.6e}".format(kc_histogram[bitstring]/repetitions)) if length * length <= cirq_max: print('dm_value=' + str(dm_value) + ' kc_value=' + str(kc_value)) # print ( 'dm_sim_time='+str(dm_sim_time)+' kc_sim_time='+str(kc_sim_time) ) print('dm_smp_time=' + str(dm_smp_time) + ' kc_smp_time=' + str(kc_smp_time)) print( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') # eval_iter += 1 return kc_value # Pick an initial guess x0 = np.random.uniform(0.0, 1.0, size=3) # Optimize f print('Optimizing objective function ...') scipy.optimize.minimize(f, x0, method='Nelder-Mead', options={'maxiter': maxiter})
def main(): q0, q1 = cirq.LineQubit.range(2) circuit_no_meas = cirq.Circuit( # cirq.H(q0), cirq.bit_flip(9/25)(q0), # cirq.bit_flip(9/25)(q1), cirq.CNOT(q0,q1), ) kc_simulator = cirq.KnowledgeCompilationSimulator(circuit_no_meas, intermediate=True) dm_simulator = cirq.DensityMatrixSimulator() kc_sim_result = kc_simulator.simulate(circuit_no_meas) dm_sim_result = dm_simulator.simulate(circuit_no_meas) print("kc_sim_result.final_density_matrix") print(kc_sim_result.final_density_matrix) np.testing.assert_almost_equal( kc_sim_result.final_density_matrix, dm_sim_result.final_density_matrix, decimal=7 ) circuit = cirq.Circuit( circuit_no_meas, cirq.measure(q0,q1) ) kc_simulator = cirq.KnowledgeCompilationSimulator(circuit, initial_state=0, intermediate=False) repetitions = 65536 dm_run_result = dm_simulator.run(circuit, repetitions=repetitions) dm_histogram = np.zeros(1<<2) for bitstring in dm_run_result.measurements['0,1']: integer = 0 for pos, bit in enumerate(bitstring): integer += bit<<pos dm_histogram[integer] += 1 print ("DM") print (dm_histogram/repetitions) kc_run_result = kc_simulator.run(circuit, repetitions=repetitions) kc_histogram = np.zeros(1<<2) for bitstring in kc_run_result.measurements['0,1']: integer = 0 for pos, bit in enumerate(bitstring): integer += bit<<pos kc_histogram[integer] += 1 print ("KC") print (kc_histogram/repetitions) for _ in range (2): dm_run_result = dm_simulator.run(circuit, repetitions=repetitions) dm_histogram = np.zeros(1<<2) for bitstring in dm_run_result.measurements['0,1']: integer = 0 for pos, bit in enumerate(bitstring): integer += bit<<pos dm_histogram[integer] += 1 print ("DM") print (dm_histogram/repetitions) exit()
def trial(n=6, p=2, repetitions=1000, maxiter=2): # Generate a random 3-regular graph on n nodes graph = networkx.random_regular_graph(3, n) # Make qubits qubits = cirq.LineQubit.range(n) # Print an example circuit cirq_circuit = qaoa_max_cut_circuit_no_meas(qubits, p, graph) print('Example QAOA circuit:') print(cirq_circuit.to_text_diagram(transpose=True)) meas_circuit = cirq.Circuit(cirq_circuit, cirq.measure(*qubits, key='m')) # Initialize simulators # sv_sim = cirq.Simulator() # dm_simulator = cirq.DensityMatrixSimulator() qs_sim_01 = qsimcirq.QSimSimulator(qsim_options={'t': 1, 'v': 0}) # qs_sim_02 = qsimcirq.QSimSimulator( qsim_options={'t': 2, 'v': 0} ) qs_sim_04 = qsimcirq.QSimSimulator(qsim_options={'t': 4, 'v': 0}) # qs_sim_08 = qsimcirq.QSimSimulator( qsim_options={'t': 8, 'v': 0} ) qs_sim_16 = qsimcirq.QSimSimulator(qsim_options={'t': 16, 'v': 0}) # qh_sim_16 = qsimcirq.QSimhSimulator( qsimh_options={ # 't': 64, # 'v': 2, # 'k': [k for k in range(int(n/2))], # 'w': 0, # 'p': int(2*n/3), # 'r': int(2*n/3) # } ) # kc_sim = cirq.KnowledgeCompilationSimulator(cirq_circuit, initial_state=0) kc_smp = cirq.KnowledgeCompilationSimulator(meas_circuit, initial_state=0) # Create variables to store the largest cut and cut value found # sv_largest_cut_found = None # sv_largest_cut_value_found = 0 qs_largest_cut_found = None qs_largest_cut_value_found = 0 kc_largest_cut_found = None kc_largest_cut_value_found = 0 # Define objective function (we'll use the negative expected cut value) # iter = 0 def f(x): # Create circuit betas = x[:p] betas_dict = {'beta' + str(index): betas[index] for index in range(p)} gammas = x[p:] gammas_dict = { 'gamma' + str(index): gammas[index] for index in range(p) } param_resolver = cirq.ParamResolver({**betas_dict, **gammas_dict}) # VALIDATE STATE VECTOR SIMULATION # qsim_circuit = cirq.resolve_parameters(cirq_circuit, param_resolver) # qsim_circuit_01 = qsimcirq.QSimCircuit(cirq.resolve_parameters(meas_circuit, param_resolver)) # qsim_circuit_04 = qsimcirq.QSimCircuit(cirq.resolve_parameters(meas_circuit, param_resolver)) # qsim_circuit_16 = qsimcirq.QSimCircuit(cirq.resolve_parameters(meas_circuit, param_resolver)) # sv_sim_start = time.time() # sv_sim_result = sv_sim.simulate(cirq_circuit, param_resolver=param_resolver) # sv_sim_time = time.time() - sv_sim_start qs_sim_start = time.time() qs_sim_result = qs_sim_16.simulate(cirq_circuit, param_resolver=param_resolver) 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<<n,) # assert cirq.linalg.allclose_up_to_global_phase( # sv_sim_result.state_vector(), # qs_sim_result.state_vector(), # rtol = 1.e-5, # atol = 1.e-7, # ) # 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 # sv_smp_start = time.time() # sv_smp_result = sv_sim.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) # sv_smp_time = time.time() - sv_smp_start # sv_bitstrings = sv_smp_result.measurements['m'] # Process histogram # sv_histogram = defaultdict(int) # for bitstring in sv_bitstrings: # integer = 0 # for pos, bit in enumerate(reversed(bitstring)): # integer += bit<<pos # sv_histogram[integer] += 1 # Process bitstrings # nonlocal sv_largest_cut_found # nonlocal sv_largest_cut_value_found # sv_values = cut_values(sv_bitstrings, graph) # sv_max_value_index = np.argmax(sv_values) # sv_max_value = sv_values[sv_max_value_index] # if sv_max_value > sv_largest_cut_value_found: # sv_largest_cut_value_found = sv_max_value # sv_largest_cut_found = sv_bitstrings[sv_max_value_index] # sv_mean = np.mean(sv_values) # Sample bitstrings from circuit qs_smp_01_start = time.time() qs_smp_01_result = qs_sim_01.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) qs_smp_01_time = time.time() - qs_smp_01_start qs_smp_01_time_dict[n].append(qs_smp_01_time) # qs_smp_02_start = time.time() # qs_smp_02_result = qs_sim_02.run(qsim_circuit_02, repetitions=repetitions) # qs_smp_02_time = time.time() - qs_smp_02_start # qs_smp_02_time_dict[n].append(qs_smp_02_time) qs_smp_04_start = time.time() qs_smp_04_result = qs_sim_04.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) qs_smp_04_time = time.time() - qs_smp_04_start qs_smp_04_time_dict[n].append(qs_smp_04_time) # qs_smp_08_start = time.time() # qs_smp_08_result = qs_sim_08.run(qsim_circuit_08, repetitions=repetitions) # qs_smp_08_time = time.time() - qs_smp_08_start # qs_smp_08_time_dict[n].append(qs_smp_08_time) qs_smp_16_start = time.time() qs_smp_16_result = qs_sim_16.run(meas_circuit, param_resolver=param_resolver, repetitions=repetitions) qs_smp_16_time = time.time() - qs_smp_16_start qs_smp_16_time_dict[n].append(qs_smp_16_time) qs_bitstrings = qs_smp_16_result.measurements['m'] # Process histogram qs_histogram = defaultdict(int) # qs_bitstring_strs = [] for bitstring in qs_bitstrings: integer = 0 # string = '' for pos, bit in enumerate(bitstring): integer += bit << pos # string += str(bit) qs_histogram[integer] += 1 # qs_bitstring_strs.append(string) # Process bitstrings nonlocal qs_largest_cut_found nonlocal qs_largest_cut_value_found qs_values = cut_values( np.array([np.flip(qs_bitstring) for qs_bitstring in qs_bitstrings]), graph) qs_max_value_index = np.argmax(qs_values) qs_max_value = qs_values[qs_max_value_index] if qs_max_value > qs_largest_cut_value_found: qs_largest_cut_value_found = qs_max_value qs_largest_cut_found = qs_bitstrings[qs_max_value_index] qs_mean = np.mean(qs_values) # qh_smp_16_start = time.time() # qh_smp_16_result = qh_sim_16.compute_amplitudes(program=qsim_circuit, bitstrings=qs_bitstring_strs) # qh_smp_16_time = time.time() - qh_smp_16_start # qh_smp_16_time_dict[n].append(qh_smp_16_time) # 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 kc_smp_time_dict[n].append(kc_smp_time) # Process histogram kc_bitstrings = kc_smp_result.measurements['m'] 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 nonlocal kc_largest_cut_found nonlocal kc_largest_cut_value_found kc_values = cut_values(kc_bitstrings, graph) kc_max_value_index = np.argmax(kc_values) kc_max_value = kc_values[kc_max_value_index] if kc_max_value > kc_largest_cut_value_found: kc_largest_cut_value_found = kc_max_value kc_largest_cut_found = kc_bitstrings[kc_max_value_index] kc_mean = np.mean(kc_values) # nonlocal iter # PRINT HISTOGRAMS # print ('iter,index,bitstring,bitstring_bin,sv_probability,sv_samples,qs_samples,kc_samples') # probabilities = np.zeros(1<<n) # for bitstring, amplitude in enumerate(sv_sim_result.state_vector()): # probability = abs(amplitude) * abs(amplitude) # probabilities[bitstring]=probability # sorted_bitstrings = np.argsort(probabilities) # for index, bitstring in enumerate(sorted_bitstrings): # print (str(iter)+','+str(index)+','+str(bitstring)+','+format(bitstring,'b').zfill(n)+','+str(probabilities[bitstring])+','+"{:.6e}".format(sv_histogram[bitstring]/repetitions)+','+"{:.6e}".format(qs_histogram[bitstring]/repetitions)+','+"{:.6e}".format(kc_histogram[bitstring]/repetitions)) print('qs_mean=' + str(qs_mean) + ' kc_mean=' + str(kc_mean)) # print ( 'sv_sim_time='+str(sv_sim_time)+' qs_sim_time='+str(qs_sim_time)+' kc_sim_time='+str(kc_sim_time) ) print('qs_smp_01_time=' + str(qs_smp_01_time) + ' qs_smp_04_time=' + str(qs_smp_04_time) + ' qs_smp_16_time=' + str(qs_smp_16_time) + ' kc_smp_time=' + str(kc_smp_time)) print( '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') # iter += 1 return -qs_mean # Pick an initial guess x0 = np.random.uniform(-np.pi, np.pi, size=2 * p) # Optimize f print('Optimizing objective function ...') scipy.optimize.minimize(f, x0, method='Nelder-Mead', options={'maxiter': maxiter}) # Compute best possible cut value via brute force search # all_bitstrings = np.array(list(itertools.product(range(2), repeat=n))) # all_values = cut_values(all_bitstrings, graph) # max_cut_value = np.max(all_values) # Print the results print('The largest cut value found was {}.'.format( qs_largest_cut_value_found))