This is all from scratch, since all previous devices are permanently air-gapped.

The basis of all positive integers is either twice the square of a root number (2tt)+k [where k is equal to or greater than 0] or twice the product of two consecutive numbers (2t(t+1)) + k [where k is equal to or greater than 0].

You'll find the sets of these numbers in [0,1] and [1,1] in the grid.

Notice the connection to triangle numbers?

All values of a,b, and d in the row [-f,1] and [e,1] are derived from this single pattern.

The values of a[t] (where t is the index from 1) in every cell in row n=1 ([-f,1] and [e,1]) represent the values for na for every product that exists, where c = ab and c = aa + 2ax + 2an.

The values of a[t] in every cell in row 1, the values of all na, contain the values of all factors that can be found in a column for each cell. These factors also represent all values of n within a column, there are no other values of n in a column except where they exist in a[t] for that column at cell n=1. In other words, the values of n in a column are all limited to the factors with the values of a[t] in a cell.

Are we all happy with this and understand it or shall I add some diagrams or more detail?

The pictorial explanation of this, is in my original youtube video from 2011. https://www.youtube.com/watch?v=9FeROMe0KBU

At 1:34 you'll see the blue strips representing each "na". Since this holds for all products, the list of a[t] in any cell at n=1, represents all the possible values of na for the difference of two squares for c that have the same remainder (in others words, all those in a column). This is true because xx+e = 2na and all the possible values of na are listed at a[t] since they are all constructed from values of x that increase by two each time, creating the full set of possible values. For each cell at n=1, these values at a[t] can all be derived by adding the same number (for a column) to either the values of a[t] for [0,1] or the values of a[t] for [1,1].

For example if na = (xx+e)/2 for any product, if I wanted to list all the possible values for na for a particular e, I would start with x=1, x=3, x=5 for odd e, or x=0,x=2,x=4 for even e. These numbers go up by two each time because 2na = xx+e.

>>8669

Exactly.

Those gaps are significant.

>>8670

NB the youtube account referenced above is not one I still control, use and will never be used to generate money. It is for information purposes only.

The values of na within a[t] for a cell at n=1 contain all possible factors but each a[t] that is an na, does not immediately give you the difference of two squares (the value c, representing an integer) without the value x. A value for x can be calculated from the value t.

For odd e, x=2t-1, for even e, it is 2(t-1); giving the values for each cell at n=1 as 1,3,5,.. and 0,2,4.

The exception is cell [0,1] which has values of x that start at 2, assuming we don't include the product of 0 and 2 as the first entry, which could be implied. This is the exception to the rule. For all even e, aside from this, the values of x are 0,2,4,..

Once x is determined, c, is aa+2ax+2an

b can be looked up as the value at a[t+n]/n in the same cell.

Working example for RSA100.

RSA100=

1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139

d=39020571855401265512289573339484371018905006900194

e=61218444075812733697456051513875809617598014768503

If we have the values for a and b, let's show that this pattern holds for the large number RSA100. Let's find RSA100_na and RSA100_nb in the first cell of the column for RSA100_e, let's find RSA100_x and show that this patterns holds for this larger number and for the next RSA number.

>>8675

Thank you!

RSA100_a is 37975227936943673922808872755445627854565536638199

RSA100_x is RSA100_d - RSA100_a =

1045343918457591589480700584038743164339470261995

The square of RSA100_x is

1092743907856271894192596330571370095810785547197841037478560411276294210342430563138953941380025

The square of RSA100_x + RSA100_e is

1092743907856271894192596330571370095810785547259059481554373144973750261856306372756551956148528

If xx+e = 2na, then dividing the square of RSA100_x + RSA100_e by 2 and then a, should give us RSA100_n.

14387588531011964456730684619177102985211280936

We then check that this is the correct value by adding RSA100_d and RSA100_n, subtracing c and ensure that this is a square.

RSA100d + RSA100n =

39034959443932277476746304024103548121890218181130

Square of (RSA100d + RSA100n)=

1523728058789437697238697847655707846181163742105495411067265721298937551215904586723474405488076900

Square of (d+n) minus RSA100c=

1123030866904336703079469523070416463095627144114722409357226718814587956951689069474054796070761

Square root of ((d+n)(d+n) - c)=

1059731506988603553937431268657920267324681542931

We then check this square is x+n by finding the square root and subtracting RSA100_x to ensure the value is RSA100_n.

And the code to do all that in C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

using System.Windows.Forms;

using System.Numerics;

namespace WindowsFormsApp1

{

static class Program

{

/// <summary>

/// The main entry point for the application.

/// </summary>

[STAThread]

static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Test();

Application.Run(new Form1());

}

static void Test()

{

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

BigInteger d = Sqrt(c);

BigInteger e = BigInteger.Subtract(c, BigInteger.Multiply(d, d));

BigInteger a = BigInteger.Parse("37975227936943673922808872755445627854565536638199");

BigInteger x = BigInteger.Subtract(d, a);

BigInteger X = BigInteger.Multiply(x, x);

BigInteger Xpe = BigInteger.Add(X, e);

BigInteger Half_xpe = BigInteger.Divide(Xpe, BigInteger.Parse("2"));

BigInteger n = BigInteger.Divide(Half_xpe, a);

BigInteger dpn = BigInteger.Add(d, n);

BigInteger DPN = BigInteger.Multiply(dpn, dpn);

BigInteger DPNmc = BigInteger.Subtract(DPN, c);

BigInteger rtDPNmc = Sqrt(DPNmc);

BigInteger rtDPNmc_minusx = BigInteger.Subtract(rtDPNmc, x);

if (rtDPNmc_minusx != n) throw new Exception("Test Failed");

}

public static BigInteger Sqrt(this BigInteger n)

{

if (n == 0) return 0;

if (n 0)

{

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

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

while (!isSqrt(n, root))

{

root += n / root;

root /= 2;

}

return root;

}

throw new ArithmeticException("NaN");

}

private static Boolean isSqrt(BigInteger n, BigInteger root)

{

BigInteger lowerBound = root * root;

BigInteger upperBound = (root + 1) * (root + 1);

return (n >= lowerBound && n < upperBound);

}

}

}

The code steps are in the same order.

I'll add some comments

Some comments:

static void Test()

{

//Some large number

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

BigInteger d = Sqrt(c);//square root

BigInteger e = BigInteger.Subtract(c, BigInteger.Multiply(d, d));//remainder

BigInteger a = BigInteger.Parse("37975227936943673922808872755445627854565536638199");//a - for first round testing, later example, use non-trivial lookup to return a

BigInteger x = BigInteger.Subtract(d, a);//d-a = x for all c

BigInteger X = BigInteger.Multiply(x, x);//the square of x

BigInteger Xpe = BigInteger.Add(X, e);//the sum of the square of x and e

BigInteger Half_xpe = BigInteger.Divide(Xpe, BigInteger.Parse("2"));//half the sum of the square of x and e

BigInteger n = BigInteger.Divide(Half_xpe, a);//divide half the sum of the square of x and e by a

BigInteger dpn = BigInteger.Add(d, n);//assume the value n was correct but test by adding to d for d+n

BigInteger DPN = BigInteger.Multiply(dpn, dpn);//square d plus n

BigInteger DPNmc = BigInteger.Subtract(DPN, c);//subtract c from the square of d and n

BigInteger rtDPNmc = Sqrt(DPNmc);//find the root of the result of subtracting c from the square of d and n

BigInteger rtDPNmc_minusx = BigInteger.Subtract(rtDPNmc, x);//subtract x from the result of finding the root after subtracting c from the square of d and n

if (rtDPNmc_minusx != n) throw new Exception("Test Failed");//check that the value of (x+n)-x = n from earlier

}

Same again with RSA110

static void Test()

{

//Some large number

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

BigInteger c = BigInteger.Parse("35794234179725868774991807832568455403003778024228226193532908190484670252364677411513516111204504060317568667");

BigInteger d = Sqrt(c);//square root

BigInteger e = BigInteger.Subtract(c, BigInteger.Multiply(d, d));//remainder

//BigInteger a = BigInteger.Parse("37975227936943673922808872755445627854565536638199");//a - for first round testing, later example, use non-trivial lookup to return a

BigInteger a = BigInteger.Parse("5846418214406154678836553182979162384198610505601062333");//a - for first round testing, later example, use non-trivial lookup to return a

BigInteger x = BigInteger.Subtract(d, a);//d-a = x for all c

BigInteger X = BigInteger.Multiply(x, x);//the square of x

BigInteger Xpe = BigInteger.Add(X, e);//the sum of the square of x and e

BigInteger Half_xpe = BigInteger.Divide(Xpe, BigInteger.Parse("2"));//half the sum of the square of x and e

BigInteger n = BigInteger.Divide(Half_xpe, a);//divide half the sum of the square of x and e by a

BigInteger dpn = BigInteger.Add(d, n);//assume the value n was correct but test by adding to d for d+n

BigInteger DPN = BigInteger.Multiply(dpn, dpn);//square d plus n

BigInteger DPNmc = BigInteger.Subtract(DPN, c);//subtract c from the square of d and n

BigInteger rtDPNmc = Sqrt(DPNmc);//find the root of the result of subtracting c from the square of d and n

BigInteger rtDPNmc_minusx = BigInteger.Subtract(rtDPNmc, x);//subtract x from the result of finding the root after subtracting c from the square of d and n

if (rtDPNmc_minusx != n) throw new Exception("Test Failed");//check that the value of (x+n)-x = n from earlier

}

Any questions so far to ensure that what is stated is correct. Typos can change the whole meaning of something.

Pick another known RSA number for now. You only need the value of c and a.

The RSA numbers can be found here

https://en.wikipedia.org/wiki/RSA_numbers

I'm going to power down for now as my charger is at work and I have 2hrs battery left.

Someone up there has a sense of humour as I almost never have my charger outside of my bag.

I'll come back after I've put little one to bed and then we'll have two hours to do the next bit, once everyone has their questions answered.

Thank you for those who are up to speed with this already, this bit is really important to understand how the non-trivial lookup works later.

We may be busy between now and the 29th.

Do anons want more time?

Just seen the latest Q drops.

Things are about to go hot between now and the 29th March.

This will bring down the UK government.

Brexit will come and go (no deal!) before things get back to normal.

Many UK politicians will be under indictment.

If anons want more time, we can pick this up tomorrow.