def calculate_expectation(all_qubits_in_circuit, cirq_circuit, operator_circuits): """ Computes the expectation value according to the formula <psi|O|psi> where O is a Pauli operator represented by the state generated from `operator_circuits` for which the expectation is to be calculated over psi where psi is the state generated from `cirq_circuit` Parameters --------- all_qubits_in_circuit : (list) list of all qubits in `cirq_circuit` cirq_circuit : (Circuit) represents the paramterized circuit for the ansatz operator_circuits : (list of Circuit objects) represents a circuit generated by applying a Pauli operator on a qubit. Returns ------- result_overlaps : (list) represents the expectation values of each Pauli operator in `operator_circuits` given the state represented by `cirq_circuit`. """ simulator = Simulator() result_overlaps = [] simulation_result = simulator.simulate(cirq_circuit) cirq_circuit_amplitudes = simulation_result.final_state for op_circuit in operator_circuits: qubits = all_qubits_in_circuit[:] if(len(op_circuit._moments) == 0): result_overlaps.append( np.conj(cirq_circuit_amplitudes).T.dot(cirq_circuit_amplitudes)) else: if(len(all_qubits_in_circuit) != len(op_circuit.all_qubits())): op_circuit = VQE.modify_operator_circuit( qubits, op_circuit) unitary_matrix_op = unitary(op_circuit) result_overlaps.append(np.conj(cirq_circuit_amplitudes).T.dot( unitary_matrix_op).dot(cirq_circuit_amplitudes)) return result_overlaps
def qubit_wavefunction_from_vacuum(ops: 'QubitOperator', qubits: List['LineQubit']) -> numpy.ndarray: """Generate a cirq wavefunction from the vacuum given qubit operators and a set of qubits that this wavefunction will be represented on Args: ops (QubitOperators) - a sum of qubit operations with coefficients \ scheduling the creation of the qubit wavefunction qubits (Qid) - the qubits of the quantum computer Returns: final_state (numpy.array(dtype=numpy.complex64)) - the fully projected \ wavefunction in the cirq representation """ nqubits = len(qubits) vacuum = init_qubit_vacuum(nqubits) final_state = numpy.zeros(2**nqubits, dtype=numpy.complex128) qpu = Simulator(dtype=numpy.complex128) for term in ops.terms: circuit = qubit_ops_to_circuit(term, qubits) state = vacuum.copy() result = qpu.simulate(circuit, qubit_order=qubits, initial_state=state) final_state += result.final_state_vector * ops.terms[term] return final_state
def test_simulate(self): compressed_status = [True, False] rad = 0.75 pauli_word = PauliWord("XZYX") for initial_state in range(2**len(pauli_word)): results = [] for is_compressed in compressed_status: simulator = Simulator() circuit = Circuit() qubits = [GridQubit(i, j) for i in range(3) for j in range(3)] gate = PauliWordExpGate(rad, pauli_word) operation = gate.on(*qubits[0:len(gate.pauli_word)]) if is_compressed: circuit.append(operation) else: circuit.append(cirq.decompose(operation)) result = simulator.simulate( circuit, initial_state=initial_state ) # type: cirq.SimulationTrialResult # print(circuit) print(result.final_state) # print(cirq.unitary(circuit_compressed)) results.append(result) self.assertTrue( np.allclose(results[0].final_state, results[1].final_state, rtol=1e-4, atol=1e-5))
def qubit_projection(ops: QubitOperator, qubits: List[LineQubit], state: numpy.ndarray, coeff: numpy.ndarray) -> None: """Find the projection of each set of qubit operators on a wavefunction. Args: ops (qubit gates) - A sum of qubit operations which represent the \ full ci wavefunction in the qubit basis. qubits (Qid) - The qubits of a quantum computer. state (numpy.array(dtype=numpy.complex64)) - a cirq wavefunction that \ is being projected coeff (numpy.array(dtype=numpy.complex64)) - a coefficient array that \ will store the result of the projection. """ qpu = Simulator(dtype=numpy.complex128) for indx, cluster in enumerate(ops.terms): circuit = qubit_ops_to_circuit(cluster, qubits) work_state = state.copy() result = qpu.simulate(circuit, qubit_order=qubits, initial_state=work_state) coeff[indx] = result.final_state_vector[0]
def main(): qft_circuit = generate_2x2_grid() print("circuit:") print(qft_circuit) sim = Simulator() res = sim.simulate(qft_circuit) print('\nfinal state:') print(np.around(res.final_state, 3))
def expectation(all_qubits_in_circuit, cirq_circuit, cirq_pauli_sum): """ Computes the expectation value of `cirq_pauli_sum` over the distribution generated from `cirq_circuit`. The expectation value is calculated by calculating <psi|O|psi> Parameters --------- all_qubits_in_circuit : (list) list of all qubits in `cirq_circuit` cirq_circuit : (Circuit) represents the paramterized circuit for the ansatz cirq_pauli_sum : (CirqPauliSum or ndarray) CirqPauliSum representing the Pauli operator for which the expectation value is to be calculated or a numpy matrix representing the Hamiltonian tensored up to the appropriate size. Returns ------- expectation.real : (float) represents the expectation value of cirq_pauli_sum given the distribution generated from `cirq_circuit`. """ if isinstance(cirq_pauli_sum, np.ndarray): simulator = Simulator() simulation_result = simulator.simulate(cirq_circuit) cirq_circuit_amplitudes = simulation_result.final_state cirq_circuit_amplitudes = np.reshape( cirq_circuit_amplitudes, (-1, 1)) average_exp = np.conj(cirq_circuit_amplitudes).T.dot( cirq_pauli_sum.dot(cirq_circuit_amplitudes)).real return average_exp else: operator_circuits = [] operator_coeffs = [] for p_string in cirq_pauli_sum.pauli_strings: op_circuit = Circuit() for qubit, pauli in p_string.items(): gate = pauli op_circuit.append( [gate(qubit)], strategy=InsertStrategy.EARLIEST) operator_circuits.append(op_circuit) operator_coeffs.append(p_string.coefficient) result_overlaps = VQE.calculate_expectation( all_qubits_in_circuit, cirq_circuit, operator_circuits) result_overlaps = list(result_overlaps) expectation = sum( list(map(lambda x: x[0]*x[1], zip(result_overlaps, operator_coeffs)))) return expectation.real
def test_symbolic_gate(self): sym_circuit = Circuit() qubits = [GridQubit(i, j) for i in range(3) for j in range(3)] gate = GlobalPhaseGate(sympy.Symbol("rad")) sym_circuit.append(gate.on(qubits[0])) print(sym_circuit) rad_list = np.random.rand(10) * 5 for rad in rad_list: simulator = Simulator() circuit = cirq.resolve_parameters(sym_circuit, {"rad": rad}) result = simulator.simulate(circuit) self.assertTrue( np.allclose(result.final_state, np.exp(1.0j * rad * np.pi) * np.array([1, 0])))
def solve_maxcut(qubit_pairs, steps=1): """ Solves the maxcut problem on the input graph Parameters ---------- qubit_pairs : (list of GridQubit pairs) represents the graph on which maxcut is to be solved steps : (int) number of mixing and cost function steps to use. Default=1 """ cirqMaxCutSolver = CirqMaxCutSolver(qubit_pairs=qubit_pairs, steps=steps) qaoa_instance = cirqMaxCutSolver.solve_max_cut_qaoa() betas, gammas = qaoa_instance.get_angles() t = np.hstack((betas, gammas)) param_circuit = qaoa_instance.get_parameterized_circuit() circuit = param_circuit(t) sim = Simulator() result = sim.simulate(circuit) display_maxcut_results(qaoa_instance, result)
q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(1, 0) def basic_circuit(meas=True): sqrt_x = cirq.X**0.5 yield sqrt_x(q0), sqrt_x(q1) yield cirq.CZ(q0, q1) yield sqrt_x(q0), sqrt_x(q1) if meas: yield cirq.measure(q0, key='q0'), cirq.measure(q1, key='q1') circuit = cirq.Circuit() circuit.append(basic_circuit(False)) print(circuit) result = simulator.simulate(circuit, qubit_order=[q0, q1]) print(np.around(result.final_state, 3)) # Circuit : # (0, 0): ───X^0.5───@───X^0.5─── # │ # (1, 0): ───X^0.5───@───X^0.5─── # # Result # [0.5+0.j 0. +0.5j 0. +0.5j 0.5+0.j ]
import cirq from cirq import Simulator q_stay = cirq.NamedQubit('q_stay') q_flip = cirq.NamedQubit('q_flip') c = cirq.Circuit(cirq.X(q_flip)) simulator = Simulator() # first qubit in order flipped result = simulator.simulate(c, qubit_order=[q_flip, q_stay]) print(abs(result.final_state).round(3)) # prints # [0. 0. 1. 0.] # second qubit in order flipped result = simulator.simulate(c, qubit_order=[q_stay, q_flip]) print(abs(result.final_state).round(3)) # prints # [0. 1. 0. 0.]
n_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L)]) w_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L, 2 * L - 1)]) n_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L)]) w_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L, 2 * L - 1)]) n_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L)]) w_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L, 2 * L - 1)]) timeStepList, P_aList, P_bList, P_phiList, Delta_aList, Delta_bList, Delta_phiList = [], [], [], [], [], [], [] cc.populateParameterLists(N, timeStepList, P_aList, P_bList, P_phiList, Delta_aList, Delta_bList, Delta_phiList, g_a, g_b, eps) cc.U_h(circuit, l, n_i, m, n_phiReg, w_phiReg, n_aReg, w_aReg, n_bReg, w_bReg, wReg, eReg, pReg, hReg, w_hReg, P_phiList[0], P_aList[0], P_bList[0]) result = simulator.simulate(circuit) print(result.final_state_vector) print(circuit) pReg2, hReg2, w_hReg2, eReg2, wReg2, n_aReg2, w_aReg2, n_bReg2, w_bReg2, n_phiReg2, w_phiReg2 = qcc.allocateQubits( N, n_i, L) # circuit = QuantumCircuit(pReg, hReg, w_hReg, eReg, wReg, n_aReg, w_aReg, n_bReg, w_bReg, n_phiReg, w_phiReg) circuit2 = QuantumCircuit(pReg2, hReg2, w_hReg2, eReg2, wReg2, n_aReg2, w_aReg2, n_bReg2, w_bReg2, n_phiReg2) simulator2 = Aer.get_backend('statevector_simulator') timeStepList2, P_aList2, P_bList2, P_phiList2, Delta_aList2, Delta_bList2, Delta_phiList2 = [], [], [], [], [], [], []
def run(formula_original, truth_table): atomics = 0 operations = 0 negations = 0 repetitions = [] formula_original = formula_original.replace(' ', '') formula_original = formula_original.replace('∨', '|') formula_original = formula_original.replace('→', '>') formula_original = formula_original.replace('∧', '&') formula_original = formula_original.replace('¬', '~') formula = list(formula_original) table = list(truth_table) print(formula) #tranforma x > y em ~x | y #ERRO ESTÁ AQUI. A associação é a esquerda, mas o caso (x | y) -> z está vendo traduzido #como x | ~y | z, quando na verdade deve ser ~(x | y) | z # O(n) """ for i in range(len(formula)): if formula[i] == '>': formula[i] = '|' formula.insert(i - 1, '~') """ print(formula) parenteses = 0 # lê a formula, contando cada coisa # O(n) for element in formula: if element == '~': #lidando apenas com a negação de clausulas atomicas. Qualquer negação maior devem ser aplicadas as De Morgan Laws negations = negations + 1 elif element == '|' or element == '&' or element == '>': #aqui deve entrar qualquer uma das operações operations = operations + 1 elif element == '(' or element == ')': parenteses = parenteses + 1 else: atomics = atomics + 1 repetitions.append(element) print("Atomicos: ", end = '') print(atomics) print("operations: ", end = '') print(operations) #print(repetitions) full_size = negations + operations + atomics + parenteses size = operations + atomics + parenteses # cria o numero de qubits adequado qubits = cirq.LineQubit.range(size) circuit = cirq.Circuit() size2 = len(formula) #print(len(formula)) #print(full_size) if full_size != size2: print("Erro nos tamanhos!") exit() # entrelaça os qubits necessários # ignora as negations, que serão lidadas com mais para frente uniques = 0 formula_use = remove_values(formula, '~') #O(n), maximo de ligações é N for i in range(size): if not str(formula_use[i]).isalnum(): #print(formula_use[i]) continue uniques = uniques + 1 circuit.append(cirq.H(qubits[i])) for j in range(i + 1, size): if (formula_use[i] == formula_use[j]): circuit.append([cirq.CNOT(qubits[i], qubits[j])]) formula_use[j] = "_" formula_use[i] = "_" #Cuida das negations #O(n) neg_count = 0 for i in range(full_size): if formula[i] == '~': circuit.append(cirq.X(qubits[i - neg_count])) neg_count = neg_count + 1 indexator = list(range(size)) #faz as operações lógicas #associação a esquerda, não aceita parênteses por enquanto print(formula_use) print(formula) #passada inicial, lidando com os parenteses: print(indexator) print("ENTRANDO -------------") has_parenteses = 1 i = 0 while len(indexator) > 1 and has_parenteses == 1: has_parenteses = 0 for i in range(len(indexator)): if formula_use[indexator[i]] == '(': #achou o abre parenteses print(" ABRIU -------------") has_parenteses = 1 start = i while formula_use[indexator[i]] != ')': #procura o fecha parênteses i = i + 1 if formula_use[indexator[i]] == '(':# achou outro abre parênteses, atualiza o start start = i print("FECHOU ---------") #quando saiu do while, está no primeiro ')' - assumindo que a afirmação está bem formada (numero equilibrado de parenteses) #destruir os parenteses antes internal_count = i - start - 1 print(indexator) del indexator[start] del indexator[i - 1] print(indexator) create_circuit(formula_use, circuit, qubits, indexator, start, start + internal_count) print("CHECK----------") print(i) print(indexator) break #if i >= len(indexator): # i = 0 print("SAINDO ------------------------") print(formula_use) print(indexator) create_circuit(formula_use, circuit, qubits, indexator, 0, len(indexator) - 1) print(indexator) print(circuit) simulator = Simulator() result = simulator.simulate(circuit, initial_state=000000000000000) print(result.dirac_notation()) string_result = str(result.dirac_notation()) original_ones = 0 original_zeros = 0 for i in range(len(table)): if table[i] == 0: original_zeros = original_zeros + 1 else: original_ones = original_ones + 1 ones = 0 zeros = 0 temp_parenteses = 0 for i in range(indexator[0]): if formula_use[i] == ')' or formula_use[i] == '(': temp_parenteses = temp_parenteses + 1 for i in range(len(string_result)): if string_result[i] == "|": if int(string_result[i + indexator[0] + 1 - temp_parenteses]) == 0: zeros = zeros + 1 else: ones = ones + 1 print("Truth Table Ones/Zeros:", end = ' ') print(original_ones, end = '/') print(original_zeros) print("Circuit Result:") print("Ones:", end = '') print(ones) print("Zeros:", end='') print(zeros)
# cooling if not cooling_out_exists: print('\nRunning cooling simulation') stopwatch = time.time() norm_samples = [] energy_samples = [] gsf_samples = [] for _ in range(n_samples): # initialize random computational-basis system state (this emulates the # maximally-mixed system state) tensored with fridge |0> init_state = np.zeros(2**(L + 1), dtype=np.complex64) init_state[np.random.randint(L)] = 1 res = simulator.simulate( circuit, initial_state=init_state, qubit_order=[*system.get_qubits(), qdccirq.FRIDGE]) final_state = res.final_state[::2] # discard fridge # Compute the norm to normalize sampled results: # The numerical error produces a non-normalized final state. # This seems to be the dominant error in the final result. # To keep this under check, we store the resulting state norms. norm = np.sqrt(np.sum(np.abs(final_state)**2)) norm_samples.append( np.float64(norm) ) # conversion to np.float64 needed for compatibility with json. energy_samples.append(system.energy_expval(final_state) / norm**2) gsf_samples.append(system.ground_space_fidelity(final_state) / norm**2) out_dict = dict(L=L,
#monte carlo noise q = cirq.NamedQubit('a') circuit = cirq.Circuit.from_ops(cirq.bit_flip(p=0.2)(q), cirq.measure(q)) #PauliXGate simq = cirq.Simulator() result = simq.run(circuit, repetitions=100) print(result.histogram(key='a')) """Paramatarized values for setting up Studies""" import sympy rot_w_gate = cirq.X**sympy.Symbol('x') circuit = cirq.Circuit() circuit.append([rot_w_gate(q0), rot_w_gate(q1)]) for y in range(5): resolver = cirq.ParamResolver({'x': y / 4.0}) result = simq.simulate(circuit, resolver) print(np.round(result.final_state, 2)) resolvers = [cirq.ParamResolver({'x': y / 2.0}) for y in range(3)] circuit = cirq.Circuit() circuit.append([rot_w_gate(q0), rot_w_gate(q1)]) circuit.append([cirq.measure(q0, key='q0'), cirq.measure(q1, key='q1')]) results = simq.run_sweep(program=circuit, params=resolvers, repetitions=2) for result in results: print(result) #The mixed state simulator """__magic__""" q = cirq.NamedQubit('a') circuit = cirq.Circuit.from_ops(cirq.H(q), cirq.amplitude_damp(0.2)(q), cirq.measure(q))
import tensorflow as tf import tensorflow_quantum as tfq import cirq from cirq.ops import CCX from cirq import Simulator import sympy import numpy as np # visualization tools import matplotlib.pyplot as plt from cirq.contrib.svg import SVGCircuit simulator = Simulator() q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(1, 0) q2 = cirq.GridQubit(2, 0) q3 = cirq.GridQubit(3, 0) rot_w_gate = cirq.X**sympy.Symbol('x') circuit = cirq.Circuit() circuit.append([rot_w_gate(q0), rot_w_gate(q1)]) for y in range(5): resolver = cirq.ParamResolver({'x': y / 4.0}) result = simulator.simulate(circuit, resolver) print(np.round(result.final_state, 2))
'o': 1 / 5, 'u': 1 / 5, }, 8) print(uniform_vowel) vowel_aog = AOG(uniform_vowel) vowel_dist = get_dist(Simulator(), vowel_aog.as_circuit(), 8) print(vowel_dist.print_strs()) print(vowel_aog.pprint()) quantum_vowel = vowel_aog.as_circuit() print(quantum_vowel) exit(0) vowel_sim = Simulator() vowel_res = vowel_sim.simulate(quantum_vowel) print(vowel_res) exit(0) dist = {0b0011: 1 / 2, 0b1011: 1 / 4, 0b0101: 1 / 8, 0b1110: 1 / 8} d = Distribution(dist, 4) aog = AOG(d) aog_circuit, _, _ = aog.to_circuit() print(aog_circuit) simulator = Simulator() result = simulator.simulate(aog_circuit) print(result)
def run(formula_original, truth_table = ""): # Troca simbolos logicos comuns pelos equivalentes esperados formula_original = formula_original.replace(' ', '') formula_original = formula_original.replace('∨', '|') formula_original = formula_original.replace('→', '>') formula_original = formula_original.replace('∧', '&') formula_original = formula_original.replace('¬', '~') formula = list(formula_original) table = list(truth_table) parenteses = 0 atomics = 0 operations = 0 negations = 0 # lê a formula, contando cada elemento # O(n) for element in formula: if element == '~': negations = negations + 1 elif element == '|' or element == '&' or element == '>': #aqui deve entrar qualquer uma das operações operations = operations + 1 elif element == '(' or element == ')': parenteses = parenteses + 1 else: atomics = atomics + 1 full_size = negations + operations + atomics + parenteses size = operations + atomics + parenteses # cria o numero de qubits adequado e o circuito qubits = cirq.LineQubit.range(size) circuit = cirq.Circuit() size2 = len(formula) # checa se há alguma inconsistência na contagem if full_size != size2: print("Erro nos tamanhos") exit() # entrelaça os qubits necessários # ignora as negações, que serão lidadas com mais para frente formula_use = remove_values(formula, '~') #O(n), maximo de ligações é n for i in range(size): if not str(formula_use[i]).isalnum(): # se não for alfanumérico, ignora continue circuit.append(cirq.H(qubits[i])) # aplica o Hadamard no primeiro qubit encontrado para cada clausula atomica for j in range(i + 1, size): # procura no resto da formula outras instâncias da clausula atomica if (formula_use[i] == formula_use[j]): circuit.append([cirq.CNOT(qubits[i], qubits[j])]) # entrelaça as que encontrar com a primeira formula_use[j] = "_" formula_use[i] = "_" # verifica as clausulas que estão negadas, e faz o bit flip #O(n) neg_count = 0 for i in range(full_size): if formula[i] == '~': if formula[i + 1] == '(': #negações aparecem antes de ( ou antes de uma clausula atomica formula_use[i - neg_count] = '[' #troca a representação do parenteses negado neg_count = neg_count + 1 else: circuit.append(cirq.X(qubits[i - neg_count])) neg_count = neg_count + 1 # cria uma lista de inteiros para servir de referência a quais qubits ainda estão com informação importante indexator = list(range(size)) # procura os parenteses mais internos, e chama a função de criar circuito has_parenteses = 1 i = 0 print(formula_use) #O(n^2) while len(indexator) > 1 and has_parenteses == 1: # quando o tamanho de indexador é 1, o algoritmo terminou, e o resultado está no qubit com o indice restante has_parenteses = 0 for i in range(len(indexator)): negated = 0 if formula_use[indexator[i]] == '(' or formula_use[indexator[i]] == '[': #achou o abre parenteses if formula_use[indexator[i]] == '[': negated = 1 has_parenteses = 1 start = i while formula_use[indexator[i]] != ')': #procura o fecha parênteses i = i + 1 if formula_use[indexator[i]] == '(' or formula_use[indexator[i]] == '[':# achou outro abre parênteses, atualiza o start start = i negated = 0 if formula_use[indexator[i]] == '[': negated = 1 #quando saiu do while, está no primeiro ')' - assumindo que a afirmação está bem formada (numero equilibrado de parenteses) internal_count = i - start - 1 #remove os parenteses del indexator[start] del indexator[i - 1] create_circuit(formula_use, circuit, qubits, indexator, start, start + internal_count, negated) break #chama a funçao uma ultima vez, quando nao houver mais nenhum parenteses create_circuit(formula_use, circuit, qubits, indexator, 0, len(indexator) - 1, 0) # a resposta esta no qubit[indexador[0]] print(indexator) print(circuit) simulator = Simulator() result = simulator.simulate(circuit, initial_state=000000000000000) print(result.dirac_notation()) string_result = str(result.dirac_notation()) # conta os 0s e 1s do resultado da simulação e compara com os da truth table original_ones = 0 original_zeros = 0 for i in range(len(table)): if int(table[i]) == 0: original_zeros = original_zeros + 1 elif int(table[i]) == 1: original_ones = original_ones + 1 ones = 0 zeros = 0 temp_parenteses = 0 for i in range(indexator[0]): if formula_use[i] == ')' or formula_use[i] == '(' or formula_use[i] == '[': temp_parenteses = temp_parenteses + 1 for i in range(len(string_result)): if string_result[i] == "|": if int(string_result[i + indexator[0] + 1 - temp_parenteses]) == 0: zeros = zeros + 1 else: ones = ones + 1 print("Truth Table Ones/Zeros:", end = ' ') print(original_ones, end = '/') print(original_zeros) print("Circuit Result:") print("Ones:", end = '') print(ones) print("Zeros:", end='') print(zeros)