def find_solution_root_fixed(frontiers, target):
if not isinstance(target, INT_TYPES):
target = target.as_int
factors = get_target_factors(target)
assert len(factors) == 2
p, q = map(int_to_digits, factors)
p_digits = tuple(p)
q_digits = tuple(q)
num_found = 0
for num_dig in sorted(frontiers.keys()):
frontier = frontiers[num_dig]
for rank, node in enumerate(frontier):
target_match = set((((p_digits[:node.p.num_fixed_digits_left],
p_digits[-node.p.num_fixed_digits_right:])),
(q_digits[:node.q.num_fixed_digits_left],
q_digits[-node.q.num_fixed_digits_right:])))
node_match = set((((tuple(node.p.digits)[:node.p.num_fixed_digits_left],
tuple(node.p.digits)[-node.p.num_fixed_digits_right:])),
(tuple(node.q.digits)[:node.q.num_fixed_digits_left],
tuple(node.q.digits)[-node.q.num_fixed_digits_right:])))
if target_match == node_match:
num_found += 1
assert num_found == 1
print num_dig, rank, len(frontier), BASE**(num_dig - 2)
assert num_found == 1
def find_solution_root(frontiers, target):
if not isinstance(target, INT_TYPES):
target = target.as_int
factors = get_target_factors(target)
assert len(factors) == 2
p, q = map(IntegerBase, factors)
p_digits = tuple(p.digits)
q_digits = tuple(q.digits)
num_found = 0
for num_dig in sorted(frontiers.keys()):
to_match = set([p_digits[-num_dig:], q_digits[-num_dig:]])
frontier = frontiers[num_dig]
for rank, node in enumerate(frontier):
node_digits = set(map(tuple, [node.p.digits[-num_dig:], node.q.digits[-num_dig:]]))
if to_match == node_digits:
num_found += 1
# assert num_found == 1
print num_dig, rank + 1, len(frontier), BASE**(2*num_dig)
assert num_found == 1
def find_solution_root(frontiers, target):
from verification import get_target_factors
if not isinstance(target, INT_TYPES):
target = target.as_int()
factors = get_target_factors(target)
assert len(factors) == 2
p, q = map(IntegerBase.from_int, factors)
p_digits = tuple(p._digits)
q_digits = tuple(q._digits)
num_found = 0
for num_dig in sorted(frontiers.keys()):
to_match = set([p_digits[:num_dig], q_digits[:num_dig]])
frontier = frontiers[num_dig]
for rank, node in enumerate(frontier):
node_digits = set(map(tuple, [node.p._digits[:num_dig], node.q._digits[:num_dig]]))
if to_match == node_digits:
num_found += 1
assert num_found == 1
print num_dig, rank, len(frontier)
assert num_found == 1
def factorisation_summary(prod):
''' Print a summary of what's going on.
>>> print factorisation_summary(143)
Hamming distance: 2
10001111 =
1101 x
1011
>>> print factorisation_summary(536275525501)
Hamming distance: 11
111110011011100100000110001111101111101 =
10000000000000110101 x
11111001101100101001
'''
# Hack around the circular import
from verification import get_target_factors
summary = []
p, q = get_target_factors(prod)
# summary.append('Hamming distance: {}'.format(factor_binary_differences(p, q)))
summary.append('{} =\n{} x\n{}'.format(bin(prod)[2:], bin(p)[2:], bin(q)[2:]))
return '\n'.join(summary)
