def test_fast_population_count(self, name):
nwr_dict = hwc.get_circuit_for_qubits_weight_get_pattern(len(name))
result_bit_length = len(nwr_dict['results'])
a = QuantumRegister(nwr_dict['n_lines'], 'a')
cin = QuantumRegister(1, 'cin')
cout = QuantumRegister(nwr_dict['n_couts'], 'cout')
cr = ClassicalRegister(len(nwr_dict['results']))
qc = QuantumCircuit(cin, a, cout, cr, name='test_fpt_{0}'.format(name))
_ = qregs.initialize_qureg_given_bitstring(name, a, qc)
to_measure_qubits = hwc.get_circuit_for_qubits_weight(
qc, a, cin, cout, nwr_dict)
for i, qb in enumerate(to_measure_qubits):
qc.measure(qb, cr[i])
result = CircuitTestCase.execute_qasm(qc, 2048)
counts = result.get_counts()
self.logger.info(counts)
exp_w = name.count("1")
exp_w_bitstring = binary.get_bitstring_from_int(
exp_w, result_bit_length)
self.assertEqual(len(counts), 1)
self.assertIn(exp_w_bitstring, counts)
def test_fast_population_count_w_hadamards(self, name, weight_int, n_bits):
nwr_dict = hwc.get_circuit_for_qubits_weight_get_pattern(n_bits)
result_bit_length = len(nwr_dict['results'])
a = QuantumRegister(nwr_dict['n_lines'], 'a')
cin = QuantumRegister(1, 'cin')
cout = QuantumRegister(nwr_dict['n_couts'], 'cout')
qc = QuantumCircuit(cin, a, cout, name='test_fpt_{0}'.format(name))
eq = QuantumRegister(1, 'eq')
anc = QuantumRegister(1, 'anc')
# Have to measure a and eq
cr = ClassicalRegister(a.size + eq.size, "ans")
qc.add_register(eq, anc, cr)
qc.h(a)
result_qubits = hwc.get_circuit_for_qubits_weight_check(
qc, a, cin, cout, eq, anc, weight_int, nwr_dict)
hwc.get_circuit_for_qubits_weight_check_i(qc,
a,
cin,
cout,
eq,
anc,
weight_int,
nwr_dict,
result_qubits,
uncomputeEq=False)
qc.measure([aq for aq in a] + [eq[0]], cr)
# QASM
result = CircuitTestCase.execute_qasm(qc, 2048)
counts = result.get_counts()
self.logger.debug(counts)
total_actives = 0
for i in counts.keys():
if i[0] == '1':
total_actives += 1
self.logger.debug("Eq active, full state is {0}".format(i))
self.assertEqual(i[1:].count('1'), weight_int)
exp_actives = factorial(n_bits) / factorial(weight_int) / factorial(
n_bits - weight_int)
self.assertEqual(total_actives, exp_actives)
def test_fast_population_count_i(self, name):
nwr_dict = hwc.get_circuit_for_qubits_weight_get_pattern(len(name))
result_bit_length = len(nwr_dict['results'])
a = QuantumRegister(nwr_dict['n_lines'], 'a')
cin = QuantumRegister(1, 'cin')
cout = QuantumRegister(nwr_dict['n_couts'], 'cout')
cr = ClassicalRegister(len(a))
qc = QuantumCircuit(cin, a, cout, cr, name='test_fpt_{0}'.format(name))
_ = qregs.initialize_qureg_given_bitstring(name, a, qc)
to_measure_qubits = hwc.get_circuit_for_qubits_weight(
qc, a, cin, cout, nwr_dict)
hwc.get_circuit_for_qubits_weight_i(qc, a, cin, cout, nwr_dict)
qc.measure(a, cr)
result = CircuitTestCase.execute_qasm(qc, 2048)
counts = result.get_counts()
self.logger.debug(counts)
self.assertEqual(len(counts), 1)
self.assertIn(name, counts)
def test_fast_population_count_w_hadamards_and_reset(
self, name, weight_int, n_bits):
nwr_dict = hwc.get_circuit_for_qubits_weight_get_pattern(n_bits)
result_bit_length = len(nwr_dict['results'])
a = QuantumRegister(nwr_dict['n_lines'], 'a')
cin = QuantumRegister(1, 'cin')
cout = QuantumRegister(nwr_dict['n_couts'], 'cout')
qc = QuantumCircuit(cin, a, cout, name='test_fpt_{0}'.format(name))
eq = QuantumRegister(1, 'eq')
anc = QuantumRegister(1, 'anc')
# Have to measure a and eq
cr = ClassicalRegister(a.size + eq.size, "ans")
qc.add_register(eq, anc, cr)
qc.h(a)
result_qubits = hwc.get_circuit_for_qubits_weight_check(
qc, a, cin, cout, eq, anc, weight_int, nwr_dict)
hwc.get_circuit_for_qubits_weight_check_i(qc,
a,
cin,
cout,
eq,
anc,
weight_int,
nwr_dict,
result_qubits,
uncomputeEq=True)
qc.h(a)
qc.measure([aq for aq in a] + [eq[0]], cr)
# QASM
result = CircuitTestCase.execute_qasm(qc, 2048)
counts = result.get_counts()
self.logger.debug(counts)
exp_state = '0' * len(cr)
self.assertEqual(len(counts), 1)
self.assertIn(exp_state, counts)
def _initialize_circuit(self):
"""
Initialize the circuit with n qubits. The n is the same n of the H parity matrix and it is used to represent the choice of the column of the matrix.
:param n: The number of qubits
:returns: the quantum circuit and the selectors_q register
:rtype:
"""
self.circuit = QuantumCircuit(
name="bruteforce_{0}_{1}_{2}_{3}_{4}".format(
self.n, self.r, self.w, self.mct_mode, self.nwr_mode))
# TODO
qubits_involved_in_multicontrols = []
if self.nwr_mode == self.NWR_BENES:
# To compute benes_flip_q size and the permutation pattern
self.benes_dict = hwg.generate_qubits_with_given_weight_benes_get_pattern(
self.n, self.w)
# We don't use only n qubits, but the nearest power of 2
self.selectors_q = QuantumRegister(self.benes_dict['n_lines'],
'select')
self.benes_flip_q = QuantumRegister(self.benes_dict['n_flips'],
"flip")
self.n_func_domain = len(self.benes_flip_q) + self.w
self.circuit.add_register(self.selectors_q)
self.circuit.add_register(self.benes_flip_q)
self.inversion_about_zero_qubits = self.benes_flip_q
elif self.nwr_mode == self.NWR_FPC:
self.fpc_dict = hwc.get_circuit_for_qubits_weight_get_pattern(
self.n)
self.selectors_q = QuantumRegister(self.fpc_dict['n_lines'],
'select')
self.fpc_cout_q = QuantumRegister(self.fpc_dict['n_couts'], 'cout')
self.fpc_cin_q = QuantumRegister(1, 'cin')
self.fpc_eq_q = QuantumRegister(1, 'eq')
self.fpc_two_eq_q = QuantumRegister(1, 'f2eq')
self.n_func_domain = 2**len(self.selectors_q)
self.circuit.add_register(self.fpc_cin_q)
self.circuit.add_register(self.selectors_q)
self.circuit.add_register(self.fpc_cout_q)
self.circuit.add_register(self.fpc_eq_q)
self.circuit.add_register(self.fpc_two_eq_q)
self.inversion_about_zero_qubits = self.selectors_q
qubits_involved_in_multicontrols.append(
len(self.fpc_dict['results']))
# We should implement a check on n if it's not a power of 2
if len(self.selectors_q) != self.n:
raise Exception("A.T.M. we can't have less registers")
qubits_involved_in_multicontrols.append(
len(self.inversion_about_zero_qubits[1:]))
self.sum_q = QuantumRegister(self.r, 'sum')
self.circuit.add_register(self.sum_q)
if self.mct_mode == self.MCT_ADVANCED:
self.mct_anc = QuantumRegister(1, 'mctAnc')
self.circuit.add_register(self.mct_anc)
elif self.mct_mode == self.MCT_BASIC:
_logger.debug("qubits involved in multicontrols are {}".format(
qubits_involved_in_multicontrols))
self.mct_anc = QuantumRegister(
max(qubits_involved_in_multicontrols) - 2, 'mctAnc')
self.circuit.add_register(self.mct_anc)
elif self.mct_mode == self.MCT_NOANCILLA:
# no ancilla to add
self.mct_anc = None
self.to_measure = self.selectors_q