Important Note: This is not Binary Energy Dynamics. That is physics and this is pure number theory. The equations in my last post were incomplete. BED uses NLN, not the other way around.
https://www.democraticunderground.com/122891331

If you find a number like 1037615213 and you will find it to be extremely challenging. The python script below cannot handle this simple number... why? Use BED on it to see the energy in it... see why this number is so resistant to NLN_Factoring. The system I use is much simpler than this and isn't as memory intensive. You will quickly see why massive numbers are a nightmare with bit shifts and bit reductions. It's a fun and novel idea but for real numbers... trying to factor massive numbers with quadrillions of digits, this method just won't do.

import math
from typing import List, Set
from concurrent.futures import ThreadPoolExecutor, as_completed


def decimal_to_binary(n: int) -> str:
"""
Converts a decimal number to its binary representation without the '0b' prefix.
"""
return bin(n)[2:]


def binary_to_decimal(b: str) -> int:
"""
Converts a binary string to its decimal equivalent.
"""
return int(b, 2)


def circular_shift_left(b: str, k: int) -> str:
"""
Performs a circular left shift on the binary string by k positions.
"""
k = k % len(b) # Normalize shift amount
return b[k:] + b[:k]


def circular_shift_right(b: str, k: int) -> str:
"""
Performs a circular right shift on the binary string by k positions.
"""
k = k % len(b) # Normalize shift amount
return b[-k:] + b[:-k]


def shave_bits(b: str, num_bits: int) -> List[str]:
"""
Removes the specified number of leading bits from the binary string.
Returns a list of shaved binary strings.
"""
shaved = []
for i in range(1, num_bits + 1):
shaved_version = b[i:]
if shaved_version: # Ensure it's not empty
shaved.append(shaved_version)
return shaved


def is_prime(n: int) -> bool:
"""
Checks if a number is prime.
"""
if n Set[int]:
"""
Recursively applies shift-and-shave operations to find all factors of n.
Utilizes parallel processing for shift operations.
"""
if visited is None:
visited = set()
factors_found = set()

if n in visited:
return factors_found
visited.add(n)

binary_n = decimal_to_binary(n)
num_bits = len(binary_n)

# Define shift parameters
shift_directions = ['left', 'right']
shift_positions = range(1, num_bits) # Shift by 1 to (num_bits -1) positions

# Use ThreadPoolExecutor for parallel shift operations
with ThreadPoolExecutor() as executor:
future_to_shift = {
executor.submit(process_shift, n, binary_n, direction, k): (direction, k)
for direction in shift_directions
for k in shift_positions
}

for future in as_completed(future_to_shift):
shift_direction, shift_k = future_to_shift[future]
try:
shifted_factors = future.result()
if shifted_factors:
factors_found.update(shifted_factors)
except Exception as exc:
print(f"Shift {shift_direction} by {shift_k} generated an exception: {exc}" )

# Process shave operations on shifted numbers
with ThreadPoolExecutor() as executor:
future_to_shave = {
executor.submit(process_shave, n, decimal_to_binary(factor), len(decimal_to_binary(factor)) - 1): factor
for factor in factors_found
}

for future in as_completed(future_to_shave):
factor = future_to_shave[future]
try:
shaved_factors = future.result()
for shaved_factor in shaved_factors:
if is_prime(shaved_factor):
factors_found.add(shaved_factor)
else:
# Recursive decomposition
factors_found.update(shift_and_shave(shaved_factor, depth + 1, visited))
except Exception as exc:
print(f"Shave on factor {factor} generated an exception: {exc}" )

return factors_found



def factorize(n: int) -> List[int]:
"""
Returns the list of prime factors of n using the shift-and-shave method.
"""
if n < = 1:
return []
factors = shift_and_shave(n)
# Include n itself if it's prime
if is_prime(n):
factors.add(n)
# Return sorted list of unique prime factors
return sorted(factors)


if __name__ == "__main__":
number = 10376
print(f"Factoring {number} using shift-and-shave method:" )
prime_factors = factorize(number)
print(f"Prime Factors: {prime_factors}" )


def debug_shift_and_shave(n: int):
"""
Debugging function to trace the steps of the shift-and-shave process.
"""
visited = set()
binary_n = decimal_to_binary(n)
num_bits = len(binary_n)
shift_directions = ['left', 'right']
shift_positions = range(1, num_bits)

print(f"Debugging shift-and-shave for number: {n} (binary: {binary_n})" )

# Shift operations
for direction in shift_directions:
for k in shift_positions:
if direction == 'left':
shifted = circular_shift_left(binary_n, k)
else:
shifted = circular_shift_right(binary_n, k)
shifted_decimal = binary_to_decimal(shifted)
print(f"Shift {direction} by {k}: {shifted} -> {shifted_decimal}" )
if shifted_decimal != 0 and shifted_decimal != n and n % shifted_decimal == 0:
print(f"Found factor from shift: {shifted_decimal}" )

# Shave operations
for k in range(1, num_bits):
shaved_binaries = shave_bits(binary_n, k)
for shaved in shaved_binaries:
shaved_decimal = binary_to_decimal(shaved)
print(f"Shave {k} bits: {shaved} -> {shaved_decimal}" )
if shaved_decimal != 0 and n % shaved_decimal == 0:
print(f"Found factor from shave: {shaved_decimal}" )


# Debug the factorization of 9106
debug_shift_and_shave(number)


def streamlined_factorize(n: int) -> List[int]:
"""
Streamlined factorization focusing on efficiency and direct decomposition into prime factors.
"""
factors = []
stack = [n]

while stack:
current = stack.pop()
if is_prime(current):
factors.append(current)
else:
# Try to find a factor
found_factor = None
for i in range(2, int(math.sqrt(current)) + 1):
if current % i == 0:
found_factor = i
break

if found_factor:
stack.append(found_factor)
stack.append(current // found_factor)
else:
# If no factors are found, treat it as prime
factors.append(current)

return sorted(factors)


# Test the streamlined factorization
streamlined_factors = streamlined_factorize(number)
print(streamlined_factors)




C:UsersImpacanaconda3envsQ_Corepython.exe C:UsersImpacPycharmProjectsQ_Logicshift_shave.py
Factoring 10376 using shift-and-shave method:
Prime Factors: [1, 2, 1297, 2594, 5188]
Debugging shift-and-shave for number: 10376 (binary: 10100010001000)
Shift left by 1: 01000100010001 -> 4369
Shift left by 2: 10001000100010 -> 8738
Shift left by 3: 00010001000101 -> 1093
Shift left by 4: 00100010001010 -> 2186
Shift left by 5: 01000100010100 -> 4372
Shift left by 6: 10001000101000 -> 8744
Shift left by 7: 00010001010001 -> 1105
Shift left by 8: 00100010100010 -> 2210
Shift left by 9: 01000101000100 -> 4420
Shift left by 10: 10001010001000 -> 8840
Shift left by 11: 00010100010001 -> 1297
Found factor from shift: 1297
Shift left by 12: 00101000100010 -> 2594
Found factor from shift: 2594
Shift left by 13: 01010001000100 -> 5188
Found factor from shift: 5188
Shift right by 1: 01010001000100 -> 5188
Found factor from shift: 5188
Shift right by 2: 00101000100010 -> 2594
Found factor from shift: 2594
Shift right by 3: 00010100010001 -> 1297
Found factor from shift: 1297
Shift right by 4: 10001010001000 -> 8840
Shift right by 5: 01000101000100 -> 4420
Shift right by 6: 00100010100010 -> 2210
Shift right by 7: 00010001010001 -> 1105
Shift right by 8: 10001000101000 -> 8744
Shift right by 9: 01000100010100 -> 4372
Shift right by 10: 00100010001010 -> 2186
Shift right by 11: 00010001000101 -> 1093
Shift right by 12: 10001000100010 -> 8738
Shift right by 13: 01000100010001 -> 4369
Shave 1 bits: 0100010001000 -> 2184
Shave 2 bits: 0100010001000 -> 2184
Shave 2 bits: 100010001000 -> 2184
Shave 3 bits: 0100010001000 -> 2184
Shave 3 bits: 100010001000 -> 2184
Shave 3 bits: 00010001000 -> 136
Shave 4 bits: 0100010001000 -> 2184
Shave 4 bits: 100010001000 -> 2184
Shave 4 bits: 00010001000 -> 136
Shave 4 bits: 0010001000 -> 136
Shave 5 bits: 0100010001000 -> 2184
Shave 5 bits: 100010001000 -> 2184
Shave 5 bits: 00010001000 -> 136
Shave 5 bits: 0010001000 -> 136
Shave 5 bits: 010001000 -> 136
Shave 6 bits: 0100010001000 -> 2184
Shave 6 bits: 100010001000 -> 2184
Shave 6 bits: 00010001000 -> 136
Shave 6 bits: 0010001000 -> 136
Shave 6 bits: 010001000 -> 136
Shave 6 bits: 10001000 -> 136
Shave 7 bits: 0100010001000 -> 2184
Shave 7 bits: 100010001000 -> 2184
Shave 7 bits: 00010001000 -> 136
Shave 7 bits: 0010001000 -> 136
Shave 7 bits: 010001000 -> 136
Shave 7 bits: 10001000 -> 136
Shave 7 bits: 0001000 -> 8
Found factor from shave: 8
Shave 8 bits: 0100010001000 -> 2184
Shave 8 bits: 100010001000 -> 2184
Shave 8 bits: 00010001000 -> 136
Shave 8 bits: 0010001000 -> 136
Shave 8 bits: 010001000 -> 136
Shave 8 bits: 10001000 -> 136
Shave 8 bits: 0001000 -> 8
Found factor from shave: 8
Shave 8 bits: 001000 -> 8
Found factor from shave: 8
Shave 9 bits: 0100010001000 -> 2184
Shave 9 bits: 100010001000 -> 2184
Shave 9 bits: 00010001000 -> 136
Shave 9 bits: 0010001000 -> 136
Shave 9 bits: 010001000 -> 136
Shave 9 bits: 10001000 -> 136
Shave 9 bits: 0001000 -> 8
Found factor from shave: 8
Shave 9 bits: 001000 -> 8
Found factor from shave: 8
Shave 9 bits: 01000 -> 8
Found factor from shave: 8
Shave 10 bits: 0100010001000 -> 2184
Shave 10 bits: 100010001000 -> 2184
Shave 10 bits: 00010001000 -> 136
Shave 10 bits: 0010001000 -> 136
Shave 10 bits: 010001000 -> 136
Shave 10 bits: 10001000 -> 136
Shave 10 bits: 0001000 -> 8
Found factor from shave: 8
Shave 10 bits: 001000 -> 8
Found factor from shave: 8
Shave 10 bits: 01000 -> 8
Found factor from shave: 8
Shave 10 bits: 1000 -> 8
Found factor from shave: 8
Shave 11 bits: 0100010001000 -> 2184
Shave 11 bits: 100010001000 -> 2184
Shave 11 bits: 00010001000 -> 136
Shave 11 bits: 0010001000 -> 136
Shave 11 bits: 010001000 -> 136
Shave 11 bits: 10001000 -> 136
Shave 11 bits: 0001000 -> 8
Found factor from shave: 8
Shave 11 bits: 001000 -> 8
Found factor from shave: 8
Shave 11 bits: 01000 -> 8
Found factor from shave: 8
Shave 11 bits: 1000 -> 8
Found factor from shave: 8
Shave 11 bits: 000 -> 0
Shave 12 bits: 0100010001000 -> 2184
Shave 12 bits: 100010001000 -> 2184
Shave 12 bits: 00010001000 -> 136
Shave 12 bits: 0010001000 -> 136
Shave 12 bits: 010001000 -> 136
Shave 12 bits: 10001000 -> 136
Shave 12 bits: 0001000 -> 8
Found factor from shave: 8
Shave 12 bits: 001000 -> 8
Found factor from shave: 8
Shave 12 bits: 01000 -> 8
Found factor from shave: 8
Shave 12 bits: 1000 -> 8
Found factor from shave: 8
Shave 12 bits: 000 -> 0
Shave 12 bits: 00 -> 0
Shave 13 bits: 0100010001000 -> 2184
Shave 13 bits: 100010001000 -> 2184
Shave 13 bits: 00010001000 -> 136
Shave 13 bits: 0010001000 -> 136
Shave 13 bits: 010001000 -> 136
Shave 13 bits: 10001000 -> 136
Shave 13 bits: 0001000 -> 8
Found factor from shave: 8
Shave 13 bits: 001000 -> 8
Found factor from shave: 8
Shave 13 bits: 01000 -> 8
Found factor from shave: 8
Shave 13 bits: 1000 -> 8
Found factor from shave: 8
Shave 13 bits: 000 -> 0
Shave 13 bits: 00 -> 0
Shave 13 bits: 0 -> 0

If no factors are found, which in this case, the method fails... how, I don't know as 8 was found as a factor which is 2 * 2 * 2 and well, 1297 as well is a resulting factor but the program isn't perfect and this idea isn't completely confirmed either. Feel free to test out different ideas and see where this takes you!
[2, 2, 2, 1297]

Process finished with exit code 0

If you find running a simple python program difficult or you don't understand what a Modulus is 'Please Go Away'. All the NLN system is doing is sliding one bit off the front of a list and putting on the back of that same list and if that is too hard of a function for you to grasp... then please do not reply to this post. This is for people with at least a 5th grade education. If you find this to be too difficult to understand. Please read your 5th grade refresher course or take some online courses that will help you understand simple binary and basic division. That's all the skills you need. If you find that too hard... well, maybe math isn't for you.

Proving you're a moron just makes you look stupid.