def parityCircuitCheating(cheating=False, cheatingType=0): if cheating: # Cheating operator c1 = cheatingMatrices()[cheatingType] else: c1 = np.identity(2) id_op = Operator(c1) truthtable = "10011001" oracle = TruthTableOracle(truthtable) or_cx = oracle.construct_circuit() # print(oracle.output_register) v = oracle.variable_register o = oracle.output_register cr1 = ClassicalRegister(3) cr2 = ClassicalRegister(1) cx_circ = QuantumCircuit(v, cr2) or_cx.add_register(cr1) cx_circ.h(v[1]) cx_circ.cx(v[1], v[0]) cx_circ.unitary(id_op, v[cheatingType+1:cheatingType+2], label='idop') total_cx = cx_circ + or_cx total_cx.measure(v, cr1) total_cx.measure(o, cr2) return total_cx
def create_grover(oracle_type, oracle_method): # Build the circuit if oracle_method=="log": algorithm = Grover(LogicalExpressionOracle(oracle_type),num_iterations=num_iterations) oracle_circuit = Grover(LogicalExpressionOracle(oracle_type)).construct_circuit() else: algorithm = Grover(TruthTableOracle(oracle_type),num_iterations=num_iterations) oracle_circuit = Grover(TruthTableOracle(oracle_type)).construct_circuit() display(oracle_circuit.draw(output="mpl")) display(algorithm) return(algorithm)
def test_simon(self, simon_input, mct_mode, optimization, simulator): """ Simon test """ # find the two keys that have matching values nbits = int(math.log(len(simon_input[0]), 2)) vals = list(zip(*simon_input))[::-1] def find_pair(): for i, val in enumerate(vals): for j in range(i + 1, len(vals)): if val == vals[j]: return i, j return 0, 0 k_1, k_2 = find_pair() hidden = np.binary_repr(k_1 ^ k_2, nbits) backend = BasicAer.get_backend(simulator) oracle = TruthTableOracle(simon_input, optimization=optimization, mct_mode=mct_mode) algorithm = Simon(oracle) quantum_instance = QuantumInstance(backend) result = algorithm.run(quantum_instance=quantum_instance) # print(result['circuit'].draw(line_length=10000)) self.assertEqual(result['result'], hidden)
def get_circuit(**kwargs): oracle_string = kwargs[ "oracle"] # input is binary String of a truth table, like '1000': A & B = 0 => f(x*) = 1 oracle = TruthTableOracle(oracle_string) grover = Grover(oracle) grover_circuit = grover.construct_circuit(measurement=True) return grover_circuit
def get_circuit(**kwargs): oracle_string = kwargs[ "s"] # input is binary String of a truth table, like '1000' oracle = TruthTableOracle(oracle_string) simon = Simon(oracle) simon_circuit = simon.construct_circuit(measurement=True) return simon_circuit
def grover_general_truthtable_qiskit(oracle_string: str) -> QuantumCircuit: from qiskit.aqua.algorithms import Grover from qiskit.aqua.components.oracles import TruthTableOracle # input is binary String of a truth table, like '1000': A & B = 0 => f(x*) = 1 oracle = TruthTableOracle(oracle_string) grover = Grover(oracle) grover_circuit = grover.construct_circuit(measurement=True) return grover_circuit
def test_deutschjozsa(self, dj_input, mct_mode, optimization='off'): backend = BasicAer.get_backend('qasm_simulator') oracle = TruthTableOracle(dj_input, optimization=optimization, mct_mode=mct_mode) algorithm = DeutschJozsa(oracle) result = algorithm.run(backend) # print(result['circuit'].draw(line_length=10000)) if sum([int(i) for i in dj_input]) == len(dj_input) / 2: self.assertTrue(result['result'] == 'balanced') else: self.assertTrue(result['result'] == 'constant')
def test_with_pass_manager(self): """ Test Bernstein Vazirani using PassManager """ quantum_instance = QuantumInstance( BasicAer.get_backend('qasm_simulator'), pass_manager=level_0_pass_manager( PassManagerConfig(basis_gates=['cx', 'u1', 'u2', 'u3']))) alg = BernsteinVazirani(oracle=TruthTableOracle(bitmaps="01100110"), quantum_instance=quantum_instance) result = alg.run() self.assertEqual(result['result'], '011')
def test_aqua_algorithm() -> None: backends: List[Backend] = [AerBackend(), AerStateBackend()] if use_qulacs: backends.append(QulacsBackend()) for b in backends: for comp in (None, b.default_compilation_pass()): if use_qulacs and type(b) == QulacsBackend and comp is None: continue tb = TketBackend(b, comp) ora = TruthTableOracle(bitmaps="01100110") alg = BernsteinVazirani(oracle=ora, quantum_instance=tb) result = alg.run() assert result["result"] == "011" alg = DeutschJozsa(oracle=ora, quantum_instance=tb) result = alg.run() assert result["result"] == "balanced" ora = TruthTableOracle(bitmaps="11111111") alg = DeutschJozsa(oracle=ora, quantum_instance=tb) result = alg.run() assert result["result"] == "constant"
def test_deutsch_jozsa(self, dj_input, mct_mode, optimization, simulator): """ Deutsch Jozsa test """ backend = BasicAer.get_backend(simulator) oracle = TruthTableOracle(dj_input, optimization=optimization, mct_mode=mct_mode) algorithm = DeutschJozsa(oracle) quantum_instance = QuantumInstance(backend) result = algorithm.run(quantum_instance=quantum_instance) # print(result['circuit'].draw(line_length=10000)) if sum([int(i) for i in dj_input]) == len(dj_input) / 2: self.assertTrue(result['result'] == 'balanced') else: self.assertTrue(result['result'] == 'constant')
def test_bernsteinvazirani(self, bv_input, mct_mode, optimization='off'): nbits = int(math.log(len(bv_input), 2)) # compute the ground-truth classically parameter = "" for i in reversed(range(nbits)): bit = bv_input[2 ** i] parameter += bit backend = get_aer_backend('qasm_simulator') oracle = TruthTableOracle(bv_input, optimization=optimization, mct_mode=mct_mode) algorithm = BernsteinVazirani(oracle) result = algorithm.run(backend) # print(result['circuit'].draw(line_length=10000)) self.assertEqual(result['result'], parameter)
def parityCircuit(theta1=0, theta2=0): # Noise rotation matrix. n1 = rotationMatrix(theta1) n2 = rotationMatrix(theta2) n = np.kron(n1, n2) # Noise operator id_op = Operator(n) truthtable = "10011001" oracle = TruthTableOracle(truthtable) or_cx = oracle.construct_circuit() # print(oracle.output_register) v = oracle.variable_register o = oracle.output_register cr1 = ClassicalRegister(3) cr2 = ClassicalRegister(1) cx_circ = QuantumCircuit(v, cr2) or_cx.add_register(cr1) cx_circ.h(v[1]) cx_circ.cx(v[1], v[0]) cx_circ.unitary(id_op, v[1:3], label='idop') total_cx = cx_circ + or_cx total_cx.measure(v, cr1) total_cx.measure(o, cr2) return total_cx
def call_grover(truth_map: str, num_vertices: int, shots=1024) -> dict: """Call the simulation for grover's algorithm with the truth map and time its execution :param truth_map: The string bitmap :param num_vertices: Number of vertices of the graph for documentation purposes :return: the GroverResult item """ start = time() oracle = TruthTableOracle(truth_map) grover = Grover(oracle) # Wow that's nice that this already exists result = grover.run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=shots)) end = time() print('Grover\'s search on n = {} vertices:\nTime elapsed: {}s\n'.format( num_vertices, end - start)) return result
def test_bernstein_vazirani(self, bv_input, mct_mode, optimization, simulator): """ Bernstein Vazirani test """ nbits = int(math.log(len(bv_input), 2)) # compute the ground-truth classically parameter = "" for i in reversed(range(nbits)): bit = bv_input[2**i] parameter += bit backend = BasicAer.get_backend(simulator) oracle = TruthTableOracle(bv_input, optimization=optimization, mct_mode=mct_mode) algorithm = BernsteinVazirani(oracle) quantum_instance = QuantumInstance(backend) result = algorithm.run(quantum_instance=quantum_instance) # print(result['circuit'].draw(line_length=10000)) self.assertEqual(result['result'], parameter)
def make_oracle(qcount): bitmaps = [''] * qcount for raw_value in range(2**qcount): value = format(raw_value, '0{}b'.format(qcount))[::-1] for index in range(qcount): n = neighbours3(index, value) alive_count = 1 if n[0] == '1' else 0 alive_count += 1 if n[2] == '1' else 0 if n[1] == '0' and alive_count == 2: bitmaps[index] += '1' elif n[1] == '1' and alive_count == 1: bitmaps[index] += '1' else: bitmaps[index] += '0' return TruthTableOracle(bitmaps)
def test_simon(self, simon_input, mct_mode, optimization='off'): # find the two keys that have matching values nbits = int(math.log(len(simon_input[0]), 2)) vals = list(zip(*simon_input))[::-1] def find_pair(): for i in range(len(vals)): for j in range(i + 1, len(vals)): if vals[i] == vals[j]: return i, j return 0, 0 k1, k2 = find_pair() hidden = np.binary_repr(k1 ^ k2, nbits) backend = get_aer_backend('qasm_simulator') oracle = TruthTableOracle(simon_input, optimization=optimization, mct_mode=mct_mode) algorithm = Simon(oracle) result = algorithm.run(backend) # print(result['circuit'].draw(line_length=10000)) self.assertEqual(result['result'], hidden)
for i in ln: qc.cx(q1[i], q2[i]) qc.cx(q2[i], q1[i]) qc.cx(q1[i], q2[i]) s = '' dat_file = open('data.txt', 'r') temp = dat_file.readline() for i in range(2**n): temp = dat_file.readline() s += list(temp.split("\t"))[1][:1] dat_file.close() print('Creating and Extracting oracle') oracle = TruthTableOracle(s) vr = oracle.variable_register vr2 = QuantumRegister(len(vr)) anc = QuantumRegister(len(vr)) otr = oracle.output_register qc1 = QuantumCircuit(vr, vr2, anc, otr) qc1.h(vr) qc1.x(otr) qc1.h(otr) qc1.barrier() qc = oracle.circuit qc2 = QuantumCircuit(vr, vr2, anc, otr) qc2.h(vr) swap(qc2, vr, vr2, anc)
import qiskit from qiskit import IBMQ IBMQ.load_account() from qiskit import BasicAer from qiskit.aqua import QuantumInstance from qiskit.aqua import run_algorithm from qiskit.aqua.algorithms import DeutschJozsa from qiskit.aqua.components.oracles import TruthTableOracle bitstr = '11110000' oracle = TruthTableOracle(bitstr) oracle.circuit.draw(output='mpl') dj = DeutschJozsa(oracle) backend = BasicAer.get_backend('qasm_simulator') result = dj.run(QuantumInstance(backend, shots=1024)) print('The truth table {} represents a {} function.'.format( bitstr, result['result'])) bitstr = '11110000' params = { 'problem': { 'name': 'functionevaluation', }, 'algorithm': { 'name': 'DeutschJozsa' }, 'oracle': { 'name': 'TruthTableOracle', 'bitmaps': [bitstr]