/vqc/ - Virtual Quantum Computer

>>12438

>The actual value of n would be way smaller.

Kek.

Hello Senpai, thanks for the hint!

Hello anons! The big idea is working, and my heart stopped for a sec when my program crunched R260 in about 60 seconds with the updated a * b = c = n2-n1 formulas. Having fun over here, and peacefully working as time allows. No solutions yet.

When n2 div n1 = 1 AND n2 mod n1 = 0, it’s the equivalent of n = 36.0000000 / 36.0000000 which is what we’re looking for.

In lieu of using a huge floating point decimal, I’ll be writing code to deal with the large remainder of n2 / n1 using n2 mod n1.

For example, n2 div n1 might be 1.3333333, which means the answer is 1 and there is a remainder of 0.33333333

When working with BigInteger, the 0.333333 just gets chopped off, so the answer isn’t accurate.

I’m pretty sure this is why my code is crunching half of the cTest vs. c value and then getting stuck.

The important mods are being cut off, so I gotta figure that out.

Honestly, figuring out how to code the ideas in C# takes a lot of thought for a newb like me, but it's challenging and fun. I'll update you all later this week once I've written the new code.

"Y Viva La Libertad, Carajo!"

```

//Semi-Prime Factorization Method For Large Integers, where c = a * b

//VA (feat. PMA, AA, Tops, and VQC CLAN)

using System;

using System.Diagnostics;

using System.Numerics;

namespace SolutionPaths

{

class MainClassOffset

{

public static void Main(string[] args)

{

Top:

//RSA100 c value

//BigInteger c = BigInteger.Parse("1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139");

//Starting from only c

Console.WriteLine("Please enter c value:");

BigInteger c = BigInteger.Parse(Console.ReadLine());

BigInteger d = SqrtByDualRootsMethod(c);

BigInteger e = c - (d * d);

Console.WriteLine("c= " + c);

Console.WriteLine("d= " + d);

Console.WriteLine("e= " + e);

Console.Read();

//solution path using (an) a(n-1) (bn) b(n-1) offset in (e,1,t) and (-f,1,t) and (-f,1,t-1)

//first we need separate methods for even or odd e values, as these determine even on odd x value

//solve for n1 using (an) and a(n-1). Please see GetN1 method.

//calculate a'/(a'-a") = n1

//note: (e,1) (an) = a'

//note: (-f,1) a(n-1) = a" = d[t] - d

//this requires the a[t] values in (e,1,t) and (-f,1,t)

//formula: (e,1): (xx+e)/2 = a'

//formula: (-f,1): d[t]-d = ((xx+e)/2 + x) - d = a"

//next solve for n using a'/(a'-a") = n1

//solve for n2 using (bn) and b(n-1). Please see GetN2 method.

//calculate b'/(b'-b") = n2

//note: (e,1) (bn) = b'

//note: (-f,1) b(n-1) = b" = d[t-1] - d

//this requires the a[t] values in (e,1,t) and (-f,1,t-1)

//formula: (e,1): (xx+e)/2 = b'

//formula: (-f,1): d[t-1]-d = (((x-2)(x-2)+e)/2 + (x-2)) - d = b"

//"take back two X to honor the Hebrew God whose ark this is" b(n-1) = d[t-1]-d.

// This creates the offset which causes n to appear twice for a semiprime c in row 1.

//next solve for n using b'/(b'-b") = n2

//set initial x values

BigInteger xLow_n1 = e % 2;

BigInteger xHigh_n1 = (d - 1);

BigInteger xLow_n2 = (d - 1);

BigInteger xHigh_n2 = (2 * d);

Console.WriteLine("xLow_n1 =" + xLow_n1);

Console.WriteLine("xHigh_n1 = " + xHigh_n1);

Console.WriteLine("xLow_n2 = " + xLow_n2);

Console.WriteLine("xHigh_n2 =" + xHigh_n2);

Console.Read();

BigInteger n1_Low = GetN1(e, d, xLow_n1);

BigInteger n1_High = GetN1(e, d, xHigh_n1);

BigInteger n2_Low = GetN2(e, d, xLow_n2);

BigInteger n2_High = GetN2(e, d, xHigh_n2);

Console.WriteLine("n1_low = " + n1_Low);

Console.WriteLine("n1_high = " + n1_High);

Console.WriteLine("n2_low = " + n2_Low);

Console.WriteLine("n2_High = " + n2_High);

Console.Read();

BigInteger newXn1 = 0;

BigInteger newXn2 = 0;

BigInteger tempN1 = 0;

BigInteger tempN2 = 0;

int loopCounter = 0;

```

```

MainMenu:

Console.WriteLine("--");

Console.WriteLine("Main Menu");

Console.WriteLine("--");

Console.WriteLine("For (-f,1) and (e,1) offset a * b = c search, enter 1");

Console.WriteLine("For n2 - n1 = 0 Search Loop, enter 2 ");

Console.WriteLine("New c value, enter 3 ");

int menu = int.Parse(Console.ReadLine());

if (menu == 1)

{

goto cSearch;

}

if (menu == 2)

{

goto Loop;

}

else if (menu == 3)

{

goto Top;

}

else

{

goto MainMenu;

}

Console.WriteLine("");

cSearch:

BigInteger aTemp = GetA(e, d, xHigh_n1);

BigInteger n1Temp = 2 * GetN1(e, d, xHigh_n1);

BigInteger bTemp = GetB(e, d, xLow_n2);

BigInteger n2Temp = 2 * GetN2(e, d, xLow_n2);

BigInteger cTemp = aTemp * bTemp;

BigInteger nDistance = (xLow_n2 - xHigh_n1);

if (cTemp < c)

{

Console.WriteLine("Actual c value = " + c);

Console.WriteLine("Current cTest = " + cTemp);

Console.WriteLine("");

Console.WriteLine("n Distance = " + nDistance);

Console.WriteLine("");

newXn1 = xHigh_n1 * 999999 / 1000000;

newXn2 = xLow_n2 * 1000001 / 1000000;

xHigh_n1 = newXn1;

xHigh_n2 = newXn2;

goto cSearch;

}

else if (cTemp >= c)

{

Console.WriteLine("cTemp > c! Get n2-n1 average…");

Console.ReadLine();

BigInteger n1n2Average = (n1Temp + n2Temp) / 2;

BigInteger Ratio_n2n1 = n2Temp / n1Temp;

BigInteger RatioMods_n2n1 = n2Temp % n1Temp;

BigInteger n2MinusOneHalfOfRatioMods = n1n2Average- (RatioMods_n2n1 / 2);

Console.WriteLine("n1 = " + n1Temp);

Console.WriteLine("n2 = " + n2Temp);

Console.WriteLine("n1n2 Average = " + n1n2Average);

Console.WriteLine("");

Console.WriteLine("n2/n1 ratio = " + Ratio_n2n1);

Console.WriteLine("n2/n1 ratio mods = " + RatioMods_n2n1);

Console.WriteLine("");

Console.WriteLine("n1n2 average minus half of the mods = " + n2MinusOneHalfOfRatioMods);

Console.WriteLine("goto Check Solution…");

Console.ReadLine();

tempN2 = n2MinusOneHalfOfRatioMods;

goto CheckSolution;

}

CheckSolution:

Console.WriteLine("----");

Console.WriteLine("Check Solution");

Console.WriteLine("----");

//Console.ReadLine();

BigInteger n2 = tempN2;

BigInteger x = SqrtByDualRootsMethod((d + n2) * (d + n2) - c) - n2;

BigInteger a = d - x;

BigInteger b = c / a;

BigInteger cTest = a * b;

if (cTest == c)

{

Console.WriteLine("Congratultions! You Have Solved Your c Value! ");

Console.WriteLine("a = " + a);

Console.WriteLine("b = " + b);

Console.WriteLine("n = " + n2);

Console.ReadLine();

goto Top;

```

```

//PMA and JAN's Dual Root Method

private static BigInteger SqrtByDualRootsMethod(BigInteger n)

{

if (n == 0) { return 0; }

if (n < 1) { throw new ArithmeticException("NaN"); }

int bitLength = Convert.ToInt32(Math.Ceiling(BigInteger.Log(n + 1, 2)));

BigInteger root = BigInteger.One << (bitLength / 2);

for (; ; )

{

BigInteger root2 = n / root;

if (root == root2) { return root; }

// we always want root2 > root

if (root > root2)

{

BigInteger temp = root2;

root2 = root;

root = temp;

}

// one apart

if ((root2 - root) == 1)

{

return root;

}

root += (root2 - root) / 2;

}

}

private static BigInteger GetA(BigInteger e, BigInteger d, BigInteger x)

{

return (((x * x + e) / 2) - (((x * x + e) / 2) + x - d));

}

private static BigInteger GetB(BigInteger e, BigInteger d, BigInteger x)

{

return (((((x * x + e) / 2))) - ((((x - 2) * (x - 2) + e) / 2) + (x - 2) - d));

}

private static BigInteger GetN1(BigInteger e, BigInteger d, BigInteger x)

{

return ((x * x + e) / 2) / (((x * x + e) / 2) - (((x * x + e) / 2) + x - d));

}

private static BigInteger GetN2(BigInteger e, BigInteger d, BigInteger x)

{

return ((x * x + e) / 2) / (((((x * x + e) / 2))) - ((((x - 2) * (x - 2) + e) / 2) + (x - 2) - d));

}

}

}

```

Here's the last part of >>12448, the else portion.

```

else

{

Console.WriteLine("Sorry, You Have Not Solved Your c Value.");

Console.WriteLine("c = ");

Console.WriteLine(c);

Console.WriteLine("c Test = ");

Console.WriteLine(cTest);

Console.WriteLine("a = " + a);

Console.WriteLine("b = " + b);

Console.WriteLine("");

Console.WriteLine("Searching…");

Console.ReadLine();

goto Iterate;

}

Iterate:

if (cTest < c)

{

tempN2 = n2 / 2;

goto CheckSolution;

}

else if (cTest > c)

{

tempN2 = n2 * 2;

goto CheckSolution;

}

else if (cTest == c)

{

Console.WriteLine("Solved! n = " + n2);

Console.ReadLine();

goto MainMenu;

}

Any anon can run this C# code in MS Visual Studio.

You'll need to also download .Net

Copypasta and run.

This is the distilled wisdom of this board.

6+ years or research into a few powerful formulas.

e and (-f)

n and (n-1)

(an) and a(n-1)

(bn) and b(n-1)

n1

n2

a

b

all can be found with the Offset.

private static BigInteger GetA(BigInteger e, BigInteger d, BigInteger x)

{

return (((x * x + e) / 2) - (((x * x + e) / 2) + x - d));

}

private static BigInteger GetB(BigInteger e, BigInteger d, BigInteger x)

{

return (((((x * x + e) / 2))) - ((((x - 2) * (x - 2) + e) / 2) + (x - 2) - d));

}

private static BigInteger GetN1(BigInteger e, BigInteger d, BigInteger x)

{

return ((x * x + e) / 2) / (((x * x + e) / 2) - (((x * x + e) / 2) + x - d));

}

private static BigInteger GetN2(BigInteger e, BigInteger d, BigInteger x)

{

return ((x * x + e) / 2) / (((((x * x + e) / 2))) - ((((x - 2) * (x - 2) + e) / 2) + (x - 2) - d));

}

More Jan Code:

public override TheEndRecord GetByEnx( BigInteger e, BigInteger n, BigInteger x ) {

BigInteger a = ((x * x) + e) / (2 * n);

BigInteger d = a + x;

BigInteger b = a + 2 * (x + n);

return new TheEndRecord( e, n, d, x, a, b );

}

Alright lads, I know what I have to do. A major portion of my code has to be updated to n2/n1 instead of n2-n1.

This gives us the ability to search for n2/n1 = 1, with the reminder expressed as n2 mod n1. I have to re-write a bunch of code, but it should only take a day or two based on my current free time.

I'm literally working in my spare room office drinking whiskey neat tonight. Chores are complete, this is my time.

I am supremely confident that we will solve this.

Next thread once this one's full >>12463

>>12457

I can't quite figure out what you mean. There's nothing for me to say, unless you're interested in learning sieve methods.

There is a window of acceptable n values that will solve for x.

There are two sliding scales that the Offset allows us to view in every (e,1) and (-f,1) combo.

One is n

One is a

That is why every a[t] value is (an) in (e,1)

That is why every a[t] value is a(n-1) in (-f,1)

Using the Offset, we see the following:

From (na transform) towards a[1] we see decreasing n values.

From (na transform) towards a[1] we see increasing a values.

This is only possible due to the second calculation of c in (-f,1)

for example:

{-134,35,79,48,31,197} = 6107

{23,36,78,47,31,197} = 6107

e is (-f)

n is less by 1

d is greater by 1

x is greater by 1n is less by 1

a is the same

b is the same

The fact that a second factorization exists makes solving possible.

The mystery undoes itself by being itself.

How very archetypical of you, c

The Hero With A Thousand Faces rises yet again to meet the challenge.

>>12468

>From (na transform) towards a[1] we see decreasing n values.

>From (na transform) towards a[1] we see increasing a values.

The point(s) where they meet up as whole integers is where we find (an) (bn) a(n-1) b(n-1)

Those point(s) can be approximated / searched using the Offset.

>>12465

interested.

Are there any particular sieve methods that may be applicable to the grid?

>>12475

That's because it has narrowed down the search space of RSA numbers from larger than the span of the universe to something that can be processed in a human lifetime. Pretty good achievemnt in my opinion.

>>12474

The grid is a language. We can speak in it or in the regular mathematical language of functions narrowed down to a single independent variable and a single dependent variable. The process of how it works is in fact just like the an actual sieve. Take the search space and cut out significant parts of it using factor bases. Factor bases let you construct candidates for the factorization by multiplying many small primes together on the RHS of the modular equation. The magic trick is when you solve the linear system to have every exponent of the primes be even. It makes a square on both sides of the modulo equation, which is equivalent to a difference of squares.

>>12477

>That's because it has narrowed down the search space of RSA numbers from larger than the span of the universe to something that can be processed in a human lifetime.

>Pretty good achievemnt in my opinion.

True. And I have Faith based on Reason that an even better way is at hand.

Two side by side calculations in (e,1) and (-f,1) allow us to calculate (a) and (n) for any a[t] location in the Grid.

>>12477

>The grid is a language.

>We can speak in it or in the regular mathematical language of functions narrowed down to a single independent variable and a single dependent variable.

>The process of how it works is in fact just like the an actual sieve.

>Take the search space and cut out significant parts of it using factor bases.

>Factor bases let you construct candidates for the factorization by multiplying many small primes together on the RHS of the modular equation.

>The magic trick is when you solve the linear system to have every exponent of the primes be even.

>It makes a square on both sides of the modulo equation, which is equivalent to a difference of squares.

>modulo equation

Yes, That's the key.

from a[1] to a(na transform)

(a) moves from large to small

(n) moves from small to large

They overlap at (an) in (e,1) and a(n-1) in (-f,1)

(a) / (n)

(n) / (a)

a' / a"

b' / b"

My deep intuition says that there is a way to use the modulo of these to find a decreasing modulo that leads towards (an) or (bn).

>>12477

Chris / Jan, solid post.

You are absolutely correct, the Grid acts as a sieve.

The Offset acts as an even greater sieve.

It allows us to calculate (a) and (n) for each (an) a[t] value.

>Take the search space and cut out significant parts of it using factor bases.

Using modulo we could rule out all non-integer answers, or even realize when we're approaching the correct whole integer answer.

>a new modulo based method of solution.

>Factor bases let you construct candidates for the factorization by multiplying many small primes together on the RHS of the modular equation.

Yes, multiplying (-f,1) a[t] * (e,1) a[t] is the essence of the Offset. I think this accomplishes what you're talking about.

>The magic trick is when you solve the linear system to have every exponent of the primes be even.

>It makes a square on both sides of the modulo equation, which is equivalent to a difference of squares.

You're saying use what we already have to find the Offset equation where modulo = 0.

Mission accepted.

Every (an) is also a (bn) in (e,1).

Every a(n-1) has a b(n-1) which is -1[t] above in (-f,1)

Updated the Grid Patterns thread.

>>12482

>>12477

>a square on both sides of the modulo equation, which is equivalent to a difference of squares.

This is a reference to Dixon's factorization method, discussed in RSA #17 posts >>10466, >>10468, >>10469