Q_NLN_Factoring - an extension of Binary Energy Dynamics

[mikelewis]

Last edited Mon Dec 30, 2024, 09:16 AM - Edit history (18)

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.

After writing the last post, I found out that no one has ever heard of the bit reduction method of factoring. Lacking any formal education, I thought this was common knowledge. I mean, with Binary, you can just look and see factors. They're right there!

So this method is two distinct methods. The first thing you do is to take any number and convert it to binary. You then just circulate the same bit pattern into every possible arrangement. Then you test each number and the factors of each number. That is the shifting part.

Next, you reduce. You take each number and shave off the first bit and do the exact same test to each derived number. You keep recursively testing every number until you get all the factors. It's pretty simple. I will be releasing the math of this later but the process and the python program is in this post for your testing.

I am calling it the NLN Factorization Method as it was derived directly from the works of Noether, Newton and Leibniz. What sucks is Euler is still not in any of my math. How in the hell is that remotely possible?

---------------------------------------------------------------

NLN Method – Redefining Factorization

Welcome, I will be looking at conventional factorization and introducing a unique technique that's set to revolutionize how you break down integers. Meet the NLN Method—a simple approach that cuts through the complexity and gets straight to the heart of prime factorization. Forget the overcomplicated algorithms and convoluted theories; it's time to embrace simplicity with ease and precision.

The Revelation: Unveiling a Game-Changing Factorization Technique

Picture this: you're navigating through a dense mathematical forest, where traditional factoring methods are tangled vines of complexity. Now, imagine wielding a sharp machete—efficient, straightforward, and brutally effective—that slices through the chaos effortlessly. That's the NLN Method for you. By manipulating binary bits through shifting and shaving, this technique exposes the prime factors of any given number with startling efficiency. It's like turning a labyrinth of numbers into an open field where every path leads directly to the solution.

The Mechanics of NLN Method: A Relentless Dissection of Bits

At its core, the NLN Method is a relentless pursuit of simplicity, leveraging two fundamental operations on a number's binary representation: shifting and shaving. Let's break down these operations without the fluff.

1. Shifting Bits: The Art of Relentless Rotation

Shifting bits is more than just moving them left or right—it's about strategically rotating the binary sequence to expose hidden factors without losing any crucial information. Unlike standard shifts that discard bits, circular shifts ensure that every bit remains in play, maximizing the chances of uncovering potential factors.

- Circular Left Shift (CLS):
- Original Binary: 1001 (which is 9 in decimal)
- Circular Left Shift by 1: 0011 (3 in decimal)
- Circular Left Shift by 2: 0110 (6 in decimal)
- Circular Left Shift by 3: 1100 (12 in decimal)

- Circular Right Shift (CRS):
- Original Binary: 1001
- Circular Right Shift by 1: 1100 (12 in decimal)
- Circular Right Shift by 2: 0110 (6 in decimal)
- Circular Right Shift by 3: 0011 (3 in decimal)

Why Circular Shifts? Because losing bits is not an option. In the world of factoring, every bit counts, and circular shifts ensure that no potential factor slips through the cracks. It's a method that demands attention to detail and refuses to let anything go to waste.

Importantly, there are other equations that incorporate chirality that make shifting left and shifting right more important. For now, just ensure you cycle through all the bits and it won't matter what direction you're heading.

2. Shaving Bits: Trimming the Unnecessary

Once we've rotated the bits, it's time to shave—cutting away the leading bits to simplify the binary string and reveal smaller, more manageable numbers that could be factors of the original number.

Shaving Examples:

- Original Binary: 1001
- Shave 1 Bit: 001 (1 in decimal)
- Shave 2 Bits: 01 (1 in decimal)
- Shave 3 Bits: 1 (1 in decimal)

- Original Binary: 0110
- Shave 1 Bit: 110 (6 in decimal)
- Shave 2 Bits: 10 (2 in decimal)
- Shave 3 Bits: 0 (0 in decimal)

- Original Binary: 0011
- Shave 1 Bit: 011 (3 in decimal)
- Shave 2 Bits: 11 (3 in decimal)
- Shave 3 Bits: 1 (1 in decimal)

Key Insight: Shaving doesn't just trim the bits; it refines the number, stripping away the unnecessary to reveal the core factors. It's about cutting through the noise and getting straight to the point.

Integrating Mathematical Titans: A Symphony of Precision and Elegance

The NLN Method isn't developed in isolation—it's a culmination of the systematic problem-solving of Newton, the elegant notation of Leibniz, and the pattern recognition prowess of Noether. These giants laid the groundwork, and now, we're building upon it with a technique that embodies their collective genius.

Newton's Systematic Decomposition

Newton's approach was all about breaking down complex problems into manageable parts. The NLN Method mirrors this by systematically applying shifts and shaves to dissect a number's binary representation, revealing its prime factors layer by layer. It's a method that doesn't shy away from complexity but tackles it head-on with structured precision.

Leibniz's Elegant Notation

Leibniz revolutionized mathematics with his clear and concise notation. Similarly, the binary system provides a straightforward framework for the NLN Method, allowing for precise manipulations that uncover factors without unnecessary complications. It's about clarity, efficiency, and elegance in every operation.

Noether's Pattern Recognition

Emmy Noether's work on symmetries and invariants underscores the importance of recognizing underlying patterns. The NLN Method leverages this by identifying patterns within binary sequences, using shifts to explore symmetrical arrangements that reveal factors. It's a testament to how pattern recognition can lead to profound mathematical discoveries.

The NLN Method Triumph: Making the Complex Simple

Here's where the magic happens. The NLN Method takes what seems like a daunting task—factoring large numbers—and breaks it down into simple, repeatable steps that anyone can follow. It's about making the hard easy, cutting through complexity with sheer ingenuity.

Step-by-Step Exploration

Let's walk through the NLN Method with concrete examples to illustrate its effectiveness.

Example 1: Factoring 9

Number to Factor: 9
Binary Representation: 1001

1. Circular Left Shift by 1:
- 1001 ~ 0011 (3 in decimal)
- 9 ÷ 3 = 3 ~ Factor Found: 3

2. Shave 0011:
- Shave 1 Bit: 011 (3 in decimal)
- 9 ÷ 3 = 3 ~ Prime Factor Confirmed: 3
- Shave 2 Bits: 11 (3 in decimal)
- 9 ÷ 3 = 3 ~ Prime Factor Confirmed: 3
- Shave 3 Bits: 1 (1 in decimal)
- 9 ÷ 1 = 9 ~ Not a prime factor

Conclusion: Through precise shifting and shaving, we've successfully identified that 3 is a prime factor of 9.

Example 2: Factoring 16628

Number to Factor: 16628
Binary Representation: 100000011001100

1. Circular Left Shift by 1:
- 100000011001100 ~ 000000110011001 (409 in decimal)
- 16628 ÷ 409 = 40.68 ~ Not a factor

2. Circular Left Shift by 2:
- 100000011001100 ~ 000001100110010 (402 in decimal)
- 16628 ÷ 402 = 41.33 ~ Not a factor

3. Circular Right Shift by 1:
- 100000011001100 ~ 110000001100110 (12342 in decimal)
- 16628 ÷ 12342 = 1.347 ~ Not a factor

4. Shave and Test:
- Shave 1100 (12 in decimal):
- 16628 ÷ 12 = 1385.67 ~ Not a factor
- Shave 1100 (12 in decimal):
- Further shaving leads to identifying 2 as a prime factor.
- 16628 ÷ 2 = 8314 ~ Factor Found: 2
- Decompose 2: Prime ~ No further decomposition needed
- Remaining Factor: 4157 (Prime)

Conclusion: The prime factors of 16628 are 2 and 4157, uncovered through methodical shifting and shaving. Efficiency meets precision.

Embracing the NLN Revolution

The NLN Method is more than a novel technique—it's a revolution in how we approach integer factorization. By embracing simplicity and leveraging binary elegance, this method offers a streamlined and efficient alternative to traditional algorithms. Here's why it stands out:

1. Efficiency Through Precision
Circular shifts ensure no bits are lost, providing a thorough exploration of potential factors without redundancy.

2. Elegance in Simplicity
Achieving profound results through simple operations aligns with the timeless mathematical pursuit of elegance and efficiency.

3. Recursive Brilliance
The method's recursive nature ensures that once a factor is found, it can be decomposed further until only prime factors remain.

4. Accessibility and Intuitiveness
With its foundational reliance on binary manipulations, the NLN Method is both intuitive and accessible to mathematicians and enthusiasts alike.

A Challenge to the Reader: Break Free from Complacency

Now, here's where you come in. Don't just sit back and let this method pass you by. Challenge yourself to break free from the complacency that often plagues even the sharpest minds. Dare to take on the NLN Method, push your boundaries, and prove to yourself that what seems complex is often just a series of simple steps waiting to be unraveled.

I'm not looking for a fight or am I willing to suffer a bunch of nonsensical heckling. If you have a question about this idea, wonderful. If all you want to do is just... well, I have no idea what some of your reasons for just being as horrible for no reason as possible but if that's your schtick... take it to X. I want nothing to do with that sort of nonsense. This is not hard to do or understand. If you find it so... well, it's not my fault now is it?

https://github.com/mikelewis1971/NLN_Factorization_Method

Test it out and see if it works before telling me it's useless or too difficult to understand. I do understand math is hard so please don't take your frustration over your lack of comprehension out on me. And if I have previously uninvited you to my chats, that means you're ignored and I would appreciate you avoiding my discussions. Whoever you are... if you are posting here, it's just to be as shitty as possible and that has been a proven fact for over a year. All you do is make yourself look ignorant... go away! No more. Leave me be, you know who you are. I never want anything to do with people like you ever again.
------------------

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

A Note on RSA and the NLN Method

The NLN method presented here offers a novel approach to exploring factors through shifts and shaves of binary representations. While it provides an intriguing perspective on factorization, it is important to clarify its implications (or lack thereof) for modern cryptographic systems, particularly RSA.

RSA's Security in Practice: The RSA cryptosystem relies on the difficulty of factoring the product of two large prime numbers. Current implementations of RSA use primes so large (2048 bits or more) that even highly optimized algorithms, including those informed by emerging techniques, remain computationally infeasible for breaking RSA keys.

The NLN Method Today: In its current form, the NLN method is an experimental approach with potential for further development. However, it is not yet efficient or consistent enough to pose any immediate risk to RSA encryption. The recursive nature of the method and the inefficiencies in exploring large binary numbers mean that traditional RSA implementations remain secure.

Implications for Future Research: While this method does not undermine RSA as we know it, it opens up a new direction for studying factorization in binary systems. Cryptographers and mathematicians may find it useful as a complementary perspective for analyzing and understanding the underlying structures of numbers.

Bottom Line: Both RSA in its current implementation and the NLN method in its current formulation are secure in their respective domains. This method is not a "silver bullet" for breaking cryptographic systems, but rather an intellectual exploration with potential for growth. Researchers are encouraged to build upon this work and explore its implications responsibly.

(This Method won't Break RSA immediately. This one here, the one I am describing. This bit shifting and shaving method can't. Well, not in its current form anyway. Registers are wonderful and all but when you get to quadrillions of digits, you need a much better plan and this is not it.)

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.

[Ptah]

1. This was published in 1944,

— John Hellins Quick, 2nd paragraph of "The turbo-encabulator in industry", Students' Quarterly Journal, Vol. 15, Iss. 58, p. 22 (December 1944)

Rockwell Retro Encabulator

...The original machine had a base-plate of prefabulated aluminite, surmounted by a malleable logarithmic casing in such a way that the two main spurving bearings were in a direct line with the pentametric fan. The latter consisted simply of six hydrocoptic marzlevanes, so fitted to the ambifacient lunar waneshaft that side fumbling was effectively prevented. The main winding was of the normal lotus-o-delta type placed in panendermic semi-bovoid slots in the stator, every seventh conductor being connected by a non-reversible tremie pipe to the differential girdlespring on the "up" end of the grammeters...

[eppur_se_muova]

2. "If you find a number like 1037615213 and you will find it to be extremely challenging."

GP/PARI CALCULATOR Version 2.11.1 (released)
i386 running darwin (x86-64/GMP-6.0.0 kernel) 64-bit version
compiled: Nov 21 2018, Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)
threading engine: single
(readline v6.3 enabled, extended help enabled)

Copyright (C) 2000-2018 The PARI Group

PARI/GP is free software, covered by the GNU General Public License, and comes
WITHOUT ANY WARRANTY WHATSOEVER.

Type ? for help, q to quit.
Type ?17 for how to get moral (and possibly technical) support.

parisize = 8000000, primelimit = 500000
? factor(1037615213)
%1 =
[ 17 1]

[ 19 1]

[3212431 1]

?

That wasn't so challenging. 17*19*3212431=1037615213 -- not just a single factor found, but a *complete* prime factorization. Took very much less than one eyeblink.

Apparently, you don't have much idea of how much work has been done in the field of factorization. It looks like your "algorithm" just generates a list of trial factors, then tries to divide by each one. Any randomly generated list should do at least as well. Of course, there are *lots* of better ways to do it than that, and any good book on number theory will list several approaches. Good old trial factoring is perfectly adequate in this case, since SQRT(1037615213) = 32212.0352... and there aren't that many numbers below 32213. Trying each number between 2 and 32212 in turn would show that there are no small factors besides 17 and 19, hence the remaining factor must be prime, and prime factorization is complete. This algorithm is made even faster by trying only *primes* below 33213, of which there are only ~4850 (by the Prime Number Theorem; an exact number can be found by an inclusion-exclusion algorithm).

I'm afraid your method "works" only in the sense that a broken clock is right twice a day.

BTW, no one uses division to test factors. It's too slow and inefficient. Use modular arithmetic -- the larger the numbers you're working with, the greater the advantage. Also, if your candidates may be composite numbers, you should find the Greatest Common Divisor (GCD) rather then just checking for even division.

Politely as I can put it -- please don't waste any more of your time, or further posts, on this topic without doing a LOT of reading in number theory first. I've included links to Wikipedia articles on various topics, but there are many more you could benefit from, if you're serious about really accomplishing something, rather than just trying things at random.

[mikelewis]

3. Sympy is actually much faster than that and it works every time.

Last edited Tue Dec 31, 2024, 09:39 AM - Edit history (5)

Thank you for whatever your point was...

I'm assuming you're finding my posts irrelevant and a blight on science? I'm not allowed to post ideas about Math? Or what? And you are here to what? Fix my stupid?

1037615213
Is resistant to the binary shifting and reduction method, not normal methods of factoring. It's not completely resistant to this one either... just in this form. This post is just a discussion about this new idea, not the be all and end all of factoring. It's not even the final word on Binary Energy... it's just a post on the Democratic Underground.

And when you're factoring a lot and using massive numbers... 1037615213 is nothing. It's tiny and completely useless.

1037615213**1037615213 **1037615213 * 4532845093485928093 is a big number and slightly harder to factor no matter what system you are using. Even Primality tests at his stage are at best probabilistic. So I needed a new way to factor and well... this NLN method isn't completely it but it's good enough to show you. And yes 1037615213, extremely easy to factor normally, you can do it very easily with pencil and paper but the contention is is that the math might be contained in the binary signatures.

It also might not which why I actually showed you 1037615213 and not the other way around. Understanding why 1037615213 is resistant to energy factoring was the point of why I raised the issue. I know why you can't factor that number with this method, I also know why some just dissolve like salt in water.

You are of course invited to not read my posts any longer. You find them to be so wasteful so kindly leave me to my ignorance. Explaining that my system doesn't work for a number that I told you it doesn't work for isn't really anything.

Plus you're just perpetuating a post that you find to be trivial. If you find it so beneath contempt, why continue to kick it to the top of a list? Let it die or get it banned for ruining the sanctity of these hallowed halls of learning. I posted two posts about Binary Energy... to my understanding that concept does not exist in mathematics. This post is just an extension of that original post as I discussed.

I'm not certain why I have to defend my right to post information on the Science Channel on the DU. I posted and now I'm being told by the moderator of the channel to stop posting my nonsense... ok... how is that fair?

[eppur_se_muova]

4. "Fix my stupid" ... I never assume that's possible, so no.

""whatever your point was..." applies to your whole post. There's a lot of nothing here -- no proofs, just showing that a method sometimes produces usable results, often doesn't. That's not an improvement over anything.

There is a "Science, Speculation, and Pseudoscience" Forum. Check it out, and consider posting there.

I haven't even looked at "Binary Energy" yet -- I have the feeling I'm about to go down another Plutonium Atom Totality Theory rabbit hole, but I'll eventually hold my nose and dive in.

For future reference, including such remarks as this

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.

won't win you any converts -- it has quite the opposite effect. And you should probably reflect on your last sentence for a good, long while before posting again. DU is home to open exchange of many different types of ideas, but doing so with rudeness is not welcome in any DU Forum.

[mikelewis]

5. So am I allowed to post on your discussion forum or not?

You can ban me for life as a moderator. It's your call.

[eppur_se_muova]

6. No one's saying it's fair. I'm just saying you're being unnecessarily, premptively abrasive.

And you're right, I have the option to block you at anytime.