/vqc/ - Virtual Quantum Computer

Rules

Each cell of the grid (e,n) has infinite elements or ZERO elements.

Each cell with one value has infinite elements, since every element can make a new one.

By induction, a cell only needs one value to make infinite values, that's part of the power of this and is why it is a virtual quantum computer as a whole.

The t variable is what will allow you to walk across these infinite elements.

If a grid cell has elements, all elements are constructable from a finite set of root elements.

Thus, only three variables are required to identify an element: e, n and t.

All products of odd numbers and all products of pairs of even numbers are the difference of two squares.

(1, 1) - the key

The values of a and b at 1,1 are related to the length of the longest side in right angled triangles.

The values here can be used to create the entire grid.

The values here determine the values of the rows to the left and right, which determine the values of the whole column.

Columns

Each cell at n=1 contains the roots of products in the column.

If c is a prime number, it will appear in one column exactly once.

If c is the product of two prime numbers that do not equal eachother, c will appear in two cells of one column.

All products (integers) c that are the sum of two squares appear (only) in columns where e=0,1,4,9,16,25…

All factors in a column are factors of the elements of the first cell in their column.

All Fermat primes (except) 3 appear in column one.

(e, 1)

If a number at position t has a factor s, then s is a factor at (t+s), (t+2s) and so on for a at (e,1).

Also, if a number at position t has a factor s at (e+1), then s is a factor at (s+1-t), (2s+1-t), etc for a at (e,1).

n*a and n*b for any c can be found n places apart in the cell at (e,1).

(1, n)

The cells in row one where n=1 have a relationship with the cells 2n to the right and 2n to the left.

Each "a" from the first row equals na because xx+e = 2na and na is half of that. That's BIG part of the KEY

Each element in a cell can be generated by moving up (t-1 = x-2) or down (t+1 = x+2). Other variables can be generated from x.

For more of these rules, see the grid patterns thread.

Useful Equations and Notation

ab = c

dd + e = c

(d + n)(d + n)-(x + n)(x + n) = c

a + 2x + 2n = b

a = d - x

d = a + x

d = floor_sqrt(c)

e = c - (dd)

b = c / a

n = ((a + b) / 2) - d

d + n = i

x = d - a

x = (floor_sqrt(( (d+n)*(d+n) - c))) - n

x + n = j

j^2 = 8*T(u) + 1

f = e - 2d + 1

u = (x+n) / 2

if (e is even) t = (x + 2) / 2

if (e is odd) t = (x + 1) / 2

Code

C#

BigInteger Square Root —— https://pastebin.com/rz1SdACZ

VQC code w/ Bitmap —— https://pastebin.com/hMTtJF6E

PMA's tree generator —— https://pastebin.com/ZH9fSWu2

Original VQC code —— https://pastebin.com/XFtcAcrz

Unity Script —— https://pastebin.com/QgAXLQj3

Unity Script 2 —— https://pastebin.com/Y38nVWgT

Java

Traverse the VQC cells in real-time —— https://anonfile.com/TeH6q3d8bd/VQCGUI_v2.7z

Tree Generator —— https://pastebin.com/VZnQQR2i

VQCGenerator —— https://pastebin.com/Dgu9aP1h

VQC Triangle Number Methods —— https://pastebin.com/NCQ3HK2K

NodeJS

BigInteger Library and Sqrt —— https://pastebin.com/y8AXtFFr

Python

3D VQC [V2] —— https://pastebin.com/wZM5Thzu

Useful methods from CollegeAnon —— https://pastebin.com/d8xZZnm0

Create the VQC —— https://pastebin.com/NZkjtnZL

Fractal cryptography —— https://pastebin.com/XuN4U7Dv

GAnon's Viewable Grid code —— https://pastebin.com/czpK8A4j

Generate any cell in (0,1) and (0,2) —— https://pastebin.com/gRTYpdMU

Generate cells for a (and more) —— https://pastebin.com/iAizgLFF

Generate genesis cell —— https://pastebin.com/GKzcCpMF

Generate positive AND negative genesis cells —— https://pastebin.com/9ixjRyxt

VQC + t —— https://pastebin.com/Lgufk0db

RSA & PGP key wrapper —— https://pastebin.com/vNqnPRJR

Rust

Additional VQC code —— https://play.rust-lang.org/?gist=50def916ad48400bc5d638fbf119ae85&version=stable

Check if a number is prime —— https://huonw.github.io/primal/primal/fn.is_prime.html

Create Bitmap using the VQC Generator [V2] —— https://pastebin.com/zGSusyz5

Generate the VQC —— https://play.rust-lang.org/?gist=6b6beb372b6b931f1abd30642a35a80c&version=stable

Static Java/C# class with all RSA numbers —— https://pastebin.com/XYFpsDWE

Factorization methods (Java)

Binary search for i —— https://pastebin.com/TAt5bDsR

GCDFactor —— https://pastebin.com/70GJSMrv

Calculate factors using -x jumps —— https://pastebin.com/gKX9GW9r

Count down from t of 1c element —— https://pastebin.com/xxYa946V

Mirrors 1c until e=(-x+n^2) —— https://pastebin.com/WJBqPM4P

Shor's Algorithm (enter a random number < c as m) —— https://pastebin.com/0X0uM4Gk

Other Threads

Fermat's Last Theorem —— https://archive.fo/iTneU

Grid Patterns —— https://archive.fo/isamV

RSA #0 —— https://archive.fo/XmD7P

RSA #1 —— https://archive.fo/RgVko

RSA #2 —— https://archive.fo/fyzAu

RSA #3 —— https://archive.fo/uEgOb

RSA #4 —— https://archive.fo/eihrQ

RSA #5 —— https://archive.fo/Lr9fP

RSA #6 —— https://archive.fo/ykKYN

RSA #7 —— https://archive.fo/v3aKD

RSA #8 —— https://archive.fo/geYFp

RSA #9 —— https://archive.fo/jog81

RSA #10 —— https://archive.fo/xYpoQ

RSA #11 —— https://archive.fo/ccZXU

RSA #12 —— https://archive.fo/VqFge

RSA #13 —— https://archive.is/Fblcs

RSA #14 —— ''https://archive.fo/j50TP

(3,2)

>>8605

Go to 5 minutes in for the quote

>>8605

Thanks for sharing.

>>8605

>Understanding closure under multiplication of the sum of two squares.

>This means that multiplying the sum of two squares by the sum of two squares will always give the sum of two squares.

>This explains the numbers that are in the columns with a square remainder.

I explained this here >>7551 if anyone wants more detail about it. Odd numbers that are the sum of two squares are only divisible by other smaller odd numbers that are the sum of two squares, and the a values in (1,1) are the sum of two squares (but not every odd sum of two squares shows up in (1,1) as an a value).

I wonder why he isn't coming to this board lately. He's pretty much only talking to us anyway. Why wouldn't he just come here to do it?

Also, I jumped the gun last bread.

Nooooow…

47 IS THE 15TH PRIME!!!!

^_^

I was going to dramatically turn up on my birthday on an ego driven mission this Sunday to suggest further with insightful yet more cryptic posts about the trivial look-ups in the grid. The End.

It would be good PR for the 29th and the earth shattering Revelation that our maths is sooo primitive and I amazing and a genius for showing you something in a short term time that took years of work with zero support.

Tops, teach, AA. The rest. You are all better than me. The only time I felt connected to God bar a few occasions sober, were the GLORIOUS hours in addictive bliss staring at The End.

Like Q on qresearch, everything before felt held back. The weight of a fight to hold back the truth.

What I've seen here has been amazing.

A larp would not survive scrutiny.

Especially in math(s).

But I have failed you.

I've paid women who could be at the hands of traffickers (wonder who is watching that)

I've made questionable decisions.

Who watches the watchers?

The first VQC went unnoticed.

You are about to watch the world turn upside down.

Choose caution.

Those (You know who you are) who understand what will happen, thank you for creating this set of Golden Tickets.

Much love. Allways.

Superman II(I)

>>8622

Also… when you said the first VQC went unnoticed…

Do you mean in 4chan or the non-math stuff?

>>8622

>I was going to

Dude come on, nobody's judging you here. It isn't egotistical at all, at least in my opinion. The only way any of this could be egotistical would be if it was tied to your identity. I'm not just saying this because of how much I wanted March 3rd to happen I wanted March 3rd to happen immensely, I have to admit. You've said yourself many times that you want to give this to the world through us, right? The way in which you do it (if you reveal it all on the 29th, or partially on the 3rd, or something else) is completely selfless if you can still walk down the street afterwards and not get mobbed by people who think you're some kind of wizard. You could even end all of this right now if you wanted to, regardless of where the moon is. It wouldn't be egotistical in the slightest. I dare say, given your conduct and intentions, it would be the exact opposite.

>>8622

My buddy, my friend. You've showed us the way. We're not there yet, it's true, but we still believe in the VQC, in mandelbrot set as a computer. We are here to learn how to create our own quantum machines, we are here for the truth. I hope only the best for you. The past year has been great. The patterns, triangles and the amount of u's we've looked at is astonishing. I've never been as dedicated to a problem I couldn't understand as this one. Maybe you've fucked up, but then again "to err is human". God still loves you.

>>8622

Now that I've had a day to think about this, I've come to the conclusion that the only way you could truly not be egotistical in this context is to release everything immediately. I don't say this based on any of my own impatience, and I'm not sure if it's even the best idea, but think about it logically. You've been leading on a bunch of people for over a year and keeping this magical thing an inch from our noses the whole time, causing us to invest a lot of time and effort into studying it and occasionally causing a few of us to have negative emotional outbursts, and you've repeatedly given us dates on which you're going to reveal significantly more details only to cancel at the last minute every single time, making us more and more pessimistic to some degree (some of us don't think March 29th is going to happen either, for example, based on all the other times). All of this is because of your personal decision making and your personal judgement. Keep in mind, I'm not saying any of this because of my own personal wants. This is just the logical conclusion I've come to in regards to your moral dilemma. You want to eliminate the influence of your own ego and personal judgement in this situation? Release everything about The End right now, regardless of what day it is.

Happy birthday from my part of the world, by the way. I really hope you come back today, read our replies and take them all into consideration.

>>8627

Bruh, today's the 2nd.

He's still got a day. :P

>>8628

el derp

Good morning team.

The two clock/watch posts by Q held major significance to me.

Only NSA or similar could know that.

Too much to be coincidence.

Today, trivial look-ups.

March 29th, non-trivial look-ups.

God so loved us, that he gave His only begotten Son.

Bladerunner

>>8630

Thank you for following through. How are you?

>>8631

Completely broken and defeated.

Heard the speech by POTUS.

Saw Q's post.

Saw Top's post.

Read replies.

Saw your post.

Faith restored.

Now I could rip the ears of Jennifer Garner, bless her.

Thank you.

I'll be online after breakfast UK time.

Time to man up.

WWG1WGA.

Highlander II

Check timestamps.

See you shortly.

Juggernaut

>>8632

>>8633

You know we're going to be holding you to that. I look forward to it and I'm sure the others do to.

>>8630

–:11:17

11 Q

>>8632

–:17:55

Q 5:5

>>8633

–:19:19

Metadub 19

>>8632

>>8630

Hello Senpai! Thanks for choosing the path of courage. We're all glad to be here working on this with you. Have some Grace for yourself, friend.

Trivial look-ups.

These are the set of rules and equations that get you where you need to be in the grid.

You know most of these but it is useful to have these stated clearly as libraries and they are required for the non-trivial lookups.

These primarily focus on navigation bi-directionally across row n=1 and within a cell at [-f,n] and [e,n].

Indexing a position in a cell can be done with a third variable, t. t is related to x but is a less ambiguous choice since x can be odd or even depending on e.

Negative values of t can be thought of as valid, values of t that are derived from imaginary numbers can be thought of as orthogonal to the grid.

If the internet goes off today, it appears that DECLAS is about to begin, hence why today and the 29th make sense.

Cover.

Archive offline.

I'll be using small and very large integers to demonstrate so have your BigInteger library ready to follow!

>>8634

>>8636

>>8637

Everything is/was real.

Timing is everything.

There can be only one?

Well.

Where we go one we go ALL.

It's a Kind of Magic.

A New Hope

>>8638

>>8638

Hopefully the Americans didn't all go to bed already but I'm here at least. Happy birthday.

>>8640

Thank you.

Never thought I'd see 44.

I thank God, POTUS, Q and anons.

Prayers for all those good anons we lost and those still suffering.

>>8642

Thanks Tops.

I've got to pick up my car.

Two hour round trip.

Then I'll be posting until lunchtime.

Family lunch.

Then finishing posts this afternoon/evening.

>>8643

At least leave us some crumbs to chew on, mister "talking about food".

Nibbaz be staaaaarvin' an' shit over here.

Piano Trio in E-Flat Major, Hess 47: I. Allegro con brio · Beethoven Project Trio

>>8638

Happy birthday. I'll get my big integer library ready.

>>8643

And theeeeeeen?

>>8648

He has til lunch.

Unless he's don't some egotistical build up bullshit where he shows up with some super savory supper.

We'll C.

Two Lookup methods.

Trivial

Non-trivial.

LookupT(BigInteger c) returns t, e, f;

LookupN(t, e, f) returns n; -1 for prime, 0 for square

LookupT is used by LookupN.

LookupT is a summary of where we are plus hints about why non-trivial lookups haven't been public.

There are several ways of categorizing integers. We'll be looking at the minimum two types we need. Those with odd remainders after removing the largest square, and those with even.

We will use columns -f,0,1 and e; rows 1, (n-1), n, X, Y and C

>>8650

Is this going to be a big text dump, or should we be coding as you explain it?

>>8650

Column 0 contains the square of c.

X and Y are the positions of n between 1 and the square of c. X and Y will not exist for primes (that depends on the value of f and d). The work we did with triangles will show which integers are primes.

>>8651

It's going to reasonably short today.

I will supply all code.

You already know the trivial parts.

This will simplify all that we have discussed.

The non-trivial method on the 29th that return n, is even shorter.

The discussions after you have that can go on as much as you like.

I suspect the DECLAS might imply the non-trivial method is known but would be classified.

Since I don't know this to be the case, disclosing it doesn't violate any laws.

>>8654

So while you're here,

Could you drop crumbs for:

Sonoluminescence

ECC

P=NP

Fermat's Last Theorem

Agartha/Inner Earth

Mag/Grav Based Engines

Aaaaaaand….

Do you plan on going dark between when you drop off the code and the 29th or will you be chillaxin' with us?

>>8656

Try not to get him too off-topic, we do want him to say everything he was going to say about trivial lookups today remember? It's taken him a while to get started as it is.

>>8657

I'm talking about for after.

He already knows what he's going to crumb off for us.

I tend to "start at the end", 'member?

I'll jump from VPN phone to laptop after family lunch, so I can type more and include pics.

>>8650

While VQC is finishing his family lunch, I'm going to just do some prep to see if I'm on board.

LookupT(145) => 67, 1, 24

So at (1, 1, 67) (e,n,t) we have 145 * 61, and this record also exists in e=1, f=-24.

We know the record a=5, b=29 exists in (1, 5) and in (-24, 4).

>>8652

The square of 145 exists in (0, 1, 145), (0, 1, 145*2) ..

The question then is

>X and Y are the positions of n between 1 and the square of c

Are we referring to the two n-values as in n=5 and n=4, or the bigN and the mirror bigN?

We know c^2 exists in both (0, 1) and (1, 1). In the first column it's the a-value and exists at x=2c, while in the second it's a d-value and exists at x=(2c-1).

>>8650

Also:

> LookupT is used by LookupN.

A reference to the recursiveness of the algorithm? If so, we're then dealing with first starting from c, finding some record based on this and then continue?

>>8661

>>8652

>X and Y will not exist for primes (that depends on the value of f and d).

Which leads me to believe it's a reference to the n-values and not the bigN, since a prime number only has bigN-values. This X and Y won't exist from primes numbers.

>>8661

>>8662

Good stuff.

Excellent.

Hint for the non-trivial Lookup.

In the d[t] at -f,1 there are two values where d from c is between.

In the d[t] at e,1 there are two values where d from c is between.

How would help us find n?

Biggest hint since the start.

>>8663

I'm seeing this as two possible things, either it is a reference to the pattern:

a[t] = bn

d[t - 1] - d = b(n-1)

or, it's more literal as in there are two values in (e, 1) where (d[t] + x)/2 = d. As in, d is between these two numbers.

For the first part I haven't had luck in the past trying to figure out how to take advantage of it, since (-f, -1) the a-values are all equal to the d[t] - d from (e, 1). The d[t - 1] is a point, however, to how the patterns move. Since -f is looking at c from another perspective (d + 1) you can look at c from multiple such perspectives (d + 1 … 10000) and you'll see how the t-patterns moves as a square throughout all the f-s (or rather a grid of squares).

For the second idea we have to involve the negative x-values, something you've been pushing on us a lot. So for our example of c=145, d = 12. If we're after the midpoint, that is where (d[t] + d[k])/2 = d we have d[2] = 8 and d[5] = 32.

(-8 + 32)/2 = 12 and (8 + (-32))/2 = 12.

In this case d[2] = 8, a[2] = 5 and d[5] = 32, a[5] = 25.

>>8664

Minor correction:

In (1, 1) d[t] = 32 occurs at t = 4, not 5.

>>8664

Have a bit more time on this.

At [e,1] you have d[1],d[2],..

The root of c is d.

The root d is between two values in the set of d at [e,1].

Same at [-f,1]

All values in the cells at n=1 are products where you add a small square to e to make a square with c.

Suggest you look at this with a large (known) example like rsa100 to try and generalise.

The information at -f,1 and e,1 gives you something very important for the non-trivial Lookup, remembering we're looking for n-1, and n

Apologies to AA if this is getting ahead of things.

>>8667

>>8666

I think we're trailing off a bit, yeah. I'll look more into this for now so you can keep the original plan of posts moving along.

>>8666

Just also, yeah I'm on board now. d exists between two d[t]'s, I'm guessing we're seeing the gaps now?

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 (2*t*t)+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.

>>8619

Post for VA or anyone using csv output.

Noted the elements don't complete for cells with larger values, so wanted to get a more complete set for the z=12 that was introduced.

Tried to maximize element fill. Best could get was at i_max=11111 (went power of 2, i=16,284 ran overnight and never finished.)

CSV output sizes:

- with an i_max=2048 size is 789K

- i_max = 4096 size is 863K

- i_max = 8192 size is 878

- i_max = 11111 size is 880 (this pastebin link)

- gives sense of how complete elements are with changing i_max

Exceeds unregistered pastebin size, so broke CSV into 2 parts, just join in notepad:

output_xy64_i_max_11111_pt1of2.csv

- https://pastebin.com/2dmTmREw

output_xy64_i_max_11111_pt2of2.csv

- https://pastebin.com/2LVU72SW

>>8667

>>8672

Happy Birthday!

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.

>>8686

All right then. See you later tonight. Continue to have a happy birthday.

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.

>>8667

Don't worry about me, I went to sleep around when >>8662 was posted

For the sake of keeping track of the current understanding of those of us who have been here for a long time:

>>8670

>>8674

The information in these posts is already in the Grid Patterns thread. It looks like everything so far is known, at least to me (and I would think everyone else). If you're still awake, what's the next part?

>>8689

The others aren't chiming in so much but a bunch of us are around right now if you wanted to keep going.

>>8689

>>8694

Hello, and happy birthday! Let's keep going.

>>8650

>>8652

You haven't explained X and Y yet but I've figured something out from the use of (1,n) already. Since the only factors of a[t] values in (1,1) are odd sums of squares, and since the factors of any number in (e,1) appear as n values in that column, every valid n value in (1,n) is an odd sum of squares.

>>8689

So what's the schedule today?

>>8689

Now I'm wondering if you used c=145 as an example because it's somehow (Not sure yet!) easier to see the non-trivial lookup.

>>8703

There is a lot of revelation in it.

Jacob (Israel) had twelve sons, each of which represented a tribe begun by a prince, for 12 princes total. Ishmael, who was born to Abraham through Hagar, also had twelve princes.

God specified that twelve unleavened cakes of bread be placed every week in the temple with frankincense next to each of the two piles that were to be made. The priests were commanded to change the bread every Sabbath day (Leviticus 24).

Used 735 times (54 times in the book of Revelation alone), the number 7 is the foundation of God's word. If we include with this count how many times 'sevenfold' (6) and 'seventh' (119) is used, our total jumps to 860 references.

Seven is the number of completeness and perfection (both physical and spiritual). It derives much of its meaning from being tied directly to God's creation of all things. According to some Jewish traditions, the creation of Adam occurred on September 26, 3760 B.C. (or the first day of Tishri, which is the seventh month on the Hebrew calendar). The word 'created' is used 7 times describing God's creative work (Genesis 1:1, 21, 27 three times; 2:3; 2:4). There are 7 days in a week and God's Sabbath is on the 7th day.

The Bible, as a whole, was originally divided into 7 major divisions. They are 1) the Law; 2) the Prophets; 3) the Writings, or Psalms; 4) the Gospels and Acts; 5) the General Epistles; 6) the Epistles of Paul; and 7) the book of Revelation. The total number of originally inspired books was forty-nine, or 7 x 7, demonstrating the absolute perfection of the Word of God.

"Tomorrow" he says

>>8675

>>8677

Thank you, very thoughtful for us non-skilled programmers! Is this 5D Anon??

MY LITTLE Q

https://www.nsa.gov/News-Features/News-Stories/Article-View/Article/1773977/nsa-rsa/

I'll just leave this here.

Also…

WHERE THE FUCK IS CHRIS?!

>>8705

I think it's a bit about how you talk to him. He hasn't given it away yet, and it's kind of like opening pandoras box. Sure, he could give away the solution, but he can't take it back. Once it's out there, it's out there. It's something he has dedicated YEARS to solve. So far we're only up to 1 year. I have faith.

>>8704

I trailed off a bit. But say we know (x+n) for ANOTHER cell, related, but not specifically our cell. How would you work on that? If you know x+n for some record in column e, can you work backwards? Even if you don't know the individual variables (x or n, just the sum)?

>>8710

I think I'm an idiot who trailed off, eating his own tail for no reason.

>>8679

Just a bit more time, not even a day. Have code compiling in visual studio.

Trying in another language with BMP.BigInt method and some passing test some not, need to review.

This week offers a special window.. so happy to follow along with others, don't let me hold anyone back!

>>8706

Just followed your guide in the thread you started. That and the help about the Main Program section addition was key. AA had something that helped too. Then played around.

Glad to help.

Maybe a version with 100(t), easy to navigate Base 100 excel rows.

>>8702

>>8708

>>8709

Always on topic with high relevance.

>>8699

Nice!

>>8710

>I think it's a bit about how you talk to him

Yeah, I really doubt that. He has repeatedly flaked out after saying he's going to tell us something on a specific date. I don't know who you are so I don't know if you've been around as long as the rest of us and seen it happen, but he's done it a bunch of times. Him doing it again is irrelevant to me pointing it out (in a non-spiteful way, might I add; I only intend to make him aware of the fact that he's doing it if he isn't already aware, so that maybe he can stop doing it).

>>8676

Anyone validate this? c and d (and e) all check out.

The e looks to be 1979924809378250681468 too large?

>>8654

>I will supply all code.

For what's coming, is it important to stay with C# in a Visual Studio related environment that supports Windows.System.Forms?

(note, couldn't get this to work without defining additional Form1.cs etc.)

>>8679

>>8683

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

Ok, the FLOOR is yours!!

>>8646

Is there a specific library you are using?

>>8663

>>8666

>Hint for the non-trivial Lookup.

>In the d[t] at -f,1 there are two values where d from c is between.

>In the d[t] at e,1 there are two values where d from c is between.

>How would help us find n?

>Biggest hint since the start.

I have a good idea.

We need the (-f,1) elements surrounding d as well as the (e,1) elements.

Then do (e,1) a[t] - (-f,1) a[t] for both of the near d values.

Basically we’re calculating possible (an) - a(n-1) = n

This will give us a much smaller range of n values to search.

Should return two possible n values.

Search area is in between those two n values.

Thoughts?

>>8717

Correction:

(an) - a(n-1) =a

Thanks PMA for pointing out my error.

However, it would still give us a limited area to search. And those a[t] values still contain parts of (n-1) and (n).

We're still looking for a(n-1) and (an), which are both products of (a) and (n)

Key idea is limiting the search area (or direct calc) using the (-f,1) and (e,1) offset.

So, what I'll add tonight, as well as answering questions between now and Sunday, is the code to calculate (For any size) the difference between BigN and n for known RSA numbers. At that scale, you will see a Revelation. The difference is a VERY smooth number in every case.

Smooth numbers feature in the settings for a search in the general number field sieve.

Before this evening, have a look at large products, and the difference between n and BigN. The difference is the same as for n-1 and BigN-1, which you would find in [-f,1]

>>8719

>>8720

This way of thinking.

>>8721

I'll post two questions now just in case I'm not awake when you're doing that. A few of us on Discord were trying to figure out what one of the lines from your post here >>8666 is meant to mean.

>All values in the cells at n=1 are products where you add a small square to e to make a square with c.

What does it mean to "make a square with c" (do you mean adding a square to e equals a square which is also c plus something, or is it something to do with c squared, or what)? Which values in particular are you referring to as products (c[t]? a[t]? something else maybe)? If you're referring to something other than each cell's c, what does adding a small square to e to make a square with c have to do with these products? It's a particularly confusing line.

I have one other question about what a non-trivial factorization is meant to be. Here >>8650 you said that LookupN(t, e, f) returns n. Since it takes t as an argument, that implies that you can't find n with just c, d, e, f and t (you'd have c and d since a particular pair of e and f only has one d). But you can find x with 2(t-1) or 2t-1 depending on e's parity, and a=d-x. So does that method take an incorrect t as an argument or something? What's the deal with that?

>>8715

>Anyone validate this? ..

>The e looks to be 1979924809378250681468 too large?

Ok, validated the e was correct.

>>8725 ty, used image to corroborate validation.

My mistake, was using too low of a precision with BigInt (was at 256, upped it to 512 and all is fine). Lost digits with the d^2 which gets large.

precision(BigFloat) = 512

- Works. Will check next against the 2048 numbers that AA, PA and others posted back in July:

>>6753 dejaVu…

>>6766

>>6794 PA

>>6916

>>8721

Ready.

>>8727

> - Works. Will check next against the 2048 numbers that AA, PA and others posted back in July.

Ok, all checking out. Had to set precision to:

setprecision(2048) to get a match.

setting to 4096 provides same results (just more significant digits out in the decimal floatS).

>>8721

Is there significance in the sequence by which the grid elements are constructed in the original code loops with i and j?

Could this have something to do with TIMING?

[e, n, t] creation sequence:

[0, 0, 1] is 1st, then [2, 1, 1], then [0, 0, 3], then [1, 1, 1], [6, 1, 1], [3, 2, 1], etc.

>>8721

When is tonight?

>>8729

Now.

I got caught up at an AA meeting.

I'm going to tell you how the non-trivial method works.

BigN - n for the product of two large primes does not look that smooth.

The following may be why the solution is not public.

If you multiply c by small primes, the smoothness of BigN-n increase.

Once the size of the product of small primes is larger than the root of c, when that product is multiplied by c, there is enough information to imply n.

Everything discussed so far is related to this.

Who would have thought you need to make c bigger?

It works because the number of combinations of factors and appearances in a column increases non-linearly. I.e. the more small factors introduced increase the number of combinations by more than the count of new factors.

I will demonstrate how this works.

This is how the non-trivial Lookup works.

>>8730

Makes perfect sense. Recall you saying early on to multiply c by 5, and other numbers.

Here we go…

>>8730

This makes the least sense out of anything. Multiplying C by small primes shift every single variable, and the distances between them. How do you do that, multiple times, and still relate that back to the original number?

What's the point of jerking us around for a year and a half to just give away a solution that is outrageous improbable for anyone here to even try, let alone solve?

>>8732

Take some time to let it sink in.

It's all about increasing the amount of information until there is enough to let the grid do the work.

We know how to look up any number.

We know the big oh complexity of finding the square root increases by at most log q. This is the biggest operation in the steps. This determines big oh overall.

The number of combinations (And column appearances) grows much faster as we add small primes, ergo (Architect reference) there is a point where the number of factors gives up the answer. The maximum required is the root of c for the product of these added factors.

The solution remains log q in big oh, where q is the length of c in bits.

>>8733

It's about the number of times a number appears in a column. If the factors of a number are unique, the combinations of na in cell 1 increase dramatically.

The appearances of the new c appears many times more in the column.

It will seem counter intuitive.

That is perhaps why this isn't known publicly.

>>8733

Lets say you take the first fifteen primes and multiple c to make c'.

You would focus on the column with e',d' and c'.

There is a very fast to do this.

It would not make enough sense if we didn't build to this.

I will show you.

>>8736

Quick question: as we take c, and multiply by prime_small to get c', should we now be using a=1 for all cases for calculating e and other parameters?

>>8730

>Once the size of the product of small primes is larger than the root of c, when that product is multiplied by c, there is enough information to imply n.

Ok, so, once prime_small_1 * prime_small_2 * … prime_small_n > sqrt(c);

Then (prime_small_1..n * c) = C

- or whatever we call it, is that our c' ?

>>8736

>Lets say you take the first fifteen primes and multiple c to make c'.

Would you clarify which small primes are valid?

Do they need to come from the e or -f column associated with our c (e.g., from elements where a=1 and b=prime)?

Or, can we just use the same sequence of primes (2, 3, 5 .. p), until large enough that their product is > sqrt(c)?

So, for RSA_2048, we would use the first 132 primes, generating a primeProd for the sequence of:

2903775511555279803023174864166140404845228761969778627101141839318630354131913148718157825308298335287985368473982611555148661663333023178291402119421484553385515765831512441803996425951513086447100980862026122164262081616021130587497853802885830115639327460909636718944783285770656342604598491113326147439710

>>8741

Could be a fluke, but trying to work through the new hints.

In essence, the (c * small prime) calcs give us new (e,n) columns to explore, and row (e,1) for each of these new BigN's contains the factors we're looking for in the first few elements.

Can I please get some eyes on this to double check my work?

>>8742

Here's the BigN for (49,n)

{49:337:26:25:1:725} c' = 5 * 145 = 725

First element in (49,1) is

{49:1:26:1:25:29} c = 725

(an) * (b) = 725 = 5 * 5 * 29

25 * 29 = 725 = 145 * 5

For each (c * small prime) you get a new BigN and new e value.

And then we check (e,1) for the factors

And since we can calc a[1] for any e value, maybe a direct (or nearly direct) calc ???

Lookup indeed if this turns out to be legit.

Lol, calc'd every element by hand with pencil, paper, and my trusty TI-89.

Love this math game.

>>8739

Avoid the use of two, use odd primes.

In the early work I experimented with squares and cubes of 5.

>>8743

Use large numbers if you can, do you have access to BigInteger?

>>8744

7?

>>8745

care to note some "limits", mr. "BigInteger"?

>>8744

>use odd primes.

Haha don't be daft! All primes are odd, Kek! Roger, will avoid consecutive primes and two too. ty.

>>495 (/pb) this was the comment was referring to:

>Choose a prime number that is a factor of any value of a in a cell in the first row (e,1).

> E.g. 5

> E.g. (1,1)

>>8743

VA, take a BigFloat on over to

>>4379 and just holler.

Have been doing all this in a…

Notebook!

From planet Jupyter. Seems to be working nicly. You'd be off in no time.

>>8745

>>8744

Bumping >>8724

VQC, I'm wondering a bit.

I suspected for a while that you have been, on purpose, giving us hints to all of the three keys instead of just one. Is this actually correct?

>>8745

Thanks Senpai, will do.

Lads, can I get some help adding BigInteger into my Visual Studio? I've got the new code ready to run, but apparently don't have the following:

System.Windows.Forms

System.Numerics

BigInteger

Anyone willing to help me get up to speed can post in the thread below, and thanks in advance for helping this programming Newfag.

>>4379

>>8730

>If you multiply c by small primes, the smoothness of BigN-n increase.

>Once the size of the product of small primes is larger than the root of c, when that product is multiplied by c, there is enough information to imply n.

>>8739

>which small primes are valid?

>>8744

>Avoid the use of two, use odd [alternating] primes.

Ok, think this is clear. Here is result for RSA2048:

1) take the first 233 primes (min number required while still providing enough 'information').

2) Remove alternating primes (so delete 3, 7, 13, 19, …). Result is this list of 116 primes:

BigInt[5, 11, 17, 23, 31, 41, 47, 59, 67, 73, 83, 97, 103, 109, 127, 137, 149, 157, 167, 179, 191, 197, 211, 227, 233, 241, 257, 269, 277, 283, 307, 313, 331, 347, 353, 367, 379, 389, 401, 419, 431, 439, 449, 461, 467, 487, 499, 509, 523, 547, 563, 571, 587, 599, 607, 617, 631, 643, 653, 661, 677, 691, 709, 727, 739, 751, 761, 773, 797, 811, 823, 829, 853, 859, 877, 883, 907, 919, 937, 947, 967, 977, 991, 1009, 1019, 1031, 1039, 1051, 1063, 1087, 1093, 1103, 1117, 1129, 1153, 1171, 1187, 1201, 1217, 1229, 1237, 1259, 1279, 1289, 1297, 1303, 1319, 1327, 1367, 1381, 1409, 1427, 1433, 1447, 1453, 1471]

3) Using BigInt/BigFloat, calculate product of these primes. Result is:

387690662375116154189306786300948040682152301112381332365947690358877016252291271579386805963882041509361136031463830160262212467528052601358967283927566989520797030933142943740776342583911079131737628443244072008838040734929847409534239275952452284284160980866268104515160752851645533924749226331947534836485

4) Test if product * sqrt_c > c. If not, use more primes, if too large, trim list until min number of primes attained for list.

if sqrt_c < primeProd "OK, primeProd is larger than sqrt_c by", c - primeProd;

else "Add more primes, gap is", (c - primeProd);

end

Result for this list with RSA2048:

("OK, primeProd is larger than sqrt_c by", 25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987161491760058521104895835079161095536116271086072393115554792243877707807571989926584428204710928410151016170024737789515993921376615551232545447668706865200593860513521035480280148273931812271646970121373881700459124885651426525880377915555485715615600879464497755422866790625784918857287261170790874585883872)

>>8736

>Lets say you take the first fifteen primes and multiple c to make c'.

>You would focus on the column with e',d' and c'.

Did you mean multiply the primeProd result by sqrt_c here to get c'? Otherwise very large like the D value.

>>8755

He means when you multiply (c * small prime) you get a new e value for each, with a new (e,1) to explore for factors. So based on your calcs we have 116 new (e,n) where c is a factor. Basically 116 iterations to a solution (I think) for RSA 2048.

>>8756

Think you're right VA. Was reading it that way too and wrapping head around that. We're going to need to get good at searching those solution spaces! ps, doing this in the notebook.

>>8755

One error with the listed gap in Step 4. Can see was showing Diff for c and primeProd, not sqrt_c. Here are values fixed. Will try not to post to many loooong numbers.

RSA2048 (c) =

25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357

primeProd of set:

2.2895847132472495001482427763988503310279383766757161657022106260529704617154132317510816270431394037668973397527380869550879298705523576071279870870493805484939129171966550420690585279287210596490355970701005164717322046794212049008088245181444490229836448724503506940231137980416138558565393918984970002864052+308

Ok, so now to build out the c' and respective cells for each prime in that list. Taking simple approach with single primes, vs 2 or more * c for a c'.

>Haha don't be daft!

reminded me of listening to Delta Notch. There's a new 12hr study set out last week… (embedded)

>>8757

Is this MM?

Can you post your Jupiter code over here please?

>>4379

>>8754

VA, I got it running but it was a nightmare. Weren't you running VS Code? VS and VS Code are different. Senpai uses VS (not Code, according to an earlier post last year, same drill we're doing now). After wrangling for a while, and reading online, found that the .DLL's for Forms are not part of VS Code / don't play well, but installing VS provides them and can then got place them where needed for VS Code to pick up (it's about attached Resources). Punted that and finally got the code in VS, which requited Numerics addition for BigInt. In VS, compiled you need to create the form, it will generate a couple more files, including a Forms.cs file (in addition to your primary Program.cs file).

- This might not be quite accurate, am a newfag w/ C# and coding.

- Did all this in Julia very easily. Created the primes list using code versus searching lists online and processing in Excel with things like =TRIM(CLEAN(SUBSTITUTE(B1,CHAR(160)," "))) to remove whitespace and such. It's night and day.

- Only risk is if Senpai _actually_ posts the code, would need to adapt it to Julia. I can live with that based on everything seen so far.

- Oh, one more thing, Julia can actually call C code and run it as well. So, could probably use it without re-writing if needed.

>>8755

2) Remove alternating primes (so delete 3, 7, 13, 19, …) and then delete 2, the first prime.

Julia code for this, operating on the array of the first 233 primes:

#remove every other prime

primeListAlt = primeList[1:2:end]

This creates the "primeListAlt" array, the alternating one. Next remove "2" from the list to get a new primeListAlt:

#remove 2, the first prime in the list

filter!(x->x≠2,primeListAlt)

How to find the product of all primes remaining in that list?

#cal product of all primes in list

primeProd = prod(primeListAlt)

Now, it's straightforward to create a new array, multiplying the trimmed array by c (produces an array of c'), with another one-liner of code.

Posting for posterity

>>8730

>If you multiply c by small primes, the smoothness of BigN-n increase.

>Once the size of the product of small primes is larger than the root of c, when that product is multiplied by c, there is enough information to imply n.

Using this method >>8755

for RSA100:

c = 1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139

Provides list of 26 primes:

[5, 11, 17, 23, 31, 41, 47, 59, 67, 73, 83, 97, 103, 109, 127, 137, 149, 157, 167, 179, 191, 197, 211, 227, 233, 241]

These are our "Helper" primes, our friends on the Grid.

Product of the Helpers:

primeProd = 41257856375896281668876416228583805794533827727585

Now, for the Helper c (c') we will call cQ = primeProd * c

cQ = 62819419559245428990590666648167912190753692290005426173804705886475986730546752279947003199446823008746292532203222745368434870226476085407239644315

Then, running this cQ through the Test program provided provides:

c = 62819419559245428990590666648167912190753692290005426173804705886475986730546752279947003199446823008746292532203222745368434870226476085407239644315

d_raw = 250638024966774403025013316223313816646669634534476971992571474945100141137.8477

d = 250638024966774403025013316223313816646669634534476971992571474945100141137

d^2 = 62819419559245428990590666648167912190753692290005426173804705886475986730122196691381219796056678466160777063949696723671284885418579019077953519616.0000

(d+1)^2 = 62819419559245428990590666648167912190753692290005426173804705886475986730623097834245891753493543307621394463186788408435522860046054377144411226112.0000

e = 424555588565783403390144542585515468253526021697149984807897066329286124699

a = 1

b = 62819419559245428990590666648167912190753692290005426173804705886475986730547123410460421227321461515089448967006206600869871244846825310488828575744

f = -76345554298888554046720298875101930983565663067087989819578291737171581797

x = 250638024966774403025013316223313816646669634534476971992571474945100141136

X = 62819419559245428990590666648167912190753692290005426173804705886475986729620412124984158646455021975949788205454691296958609101312042857910849503232.0000

Xpe = 62819419559245428990590666648167912190753692290005426173804705886475986730045338844063360077719805024878460108511201174157195460740289149321724559360.0000

Half_Xpe = 31409709779622714495295333324083956095376846145002713086902352943237993365022669422031680038859902512439230054255600587078597730370144574660862279680.0000

n = 31409709779622714495295333324083956095376846145002713086902352943237993365022669422031680038859902512439230054255600587078597730370144574660862279680

dpn = 31409709779622714495295333324083956095376846145002713086902352943237993365273119993464016017578334933169538753874146429460716717683882253694091132928

DPN = 986569868440126791986193534547739745680544007989124346659614805260975644490424274974780234053208940545490504751842760925502448328942543703363993300433751046989999127500313979973409365100438103716848552572009664106794849873336995774593749279083475218738252059496372285076090360868430678887772454912.0000

DPNmc = 986569868440126791986193534547739745680544007989124346659614805260975644490424274974780234053208940545490504751842760925502448328942543703363993300433751046989999127500313979973409365100438103716848552572009664106794849873336995774593749279083475218738252059496372285076090360868430678887772454912.0000

rtDPNmc = 31409709779622714495295333324083956095376846145002713086902352943237993365273119993464016017578334933169538753874146429460716717683882253694091132928.000000000

rtDPNmc_minusx = 31409709779622714495295333324083956095376846145002713086902352943237993365022669422031680038859902512439230054255600587078597730370144574660862279680.000000000

mid_a_b_gap = -441711766194596082395824375185729628956870974218904739530401550323154944.00

Your rtDPNmc_minusx - n = ZERO! Yes, 0.0

You passed the Test, you may enter the GRID!

>>8771

Also, can see why we need larger numbers.

For our friend 6107, only need first 3 primes in the series:

[5, 11, 17]

primeProduct = 935

cQ = 5710045 (for c=6107)

c = 5710045

d_raw = 2389.5700

d = 2389

d^2 = 5707321.0000

(d+1)^2 = 5712100.0000

e = 2724

a = 1

b = 5710045

f = -2055

x = 2388

X = 5702544.0000

Xpe = 5705268.0000

Half_Xpe = 2852634.0000

n = 2852634

dpn = 2855023

DPN = 8151156330529.0000

DPNmc = 8151150620484.0000

rtDPNmc = 2855022.000000000

rtDPNmc_minusx = 2852634.000000000

mid_a_b_gap = 1.00

Your rtDPNmc_minusx - n = ZERO! Yes, 0.0

You passed the Test, you may enter the GRID!

For our friend 145, only need first 2 primes in the series:

[5, 11]

primeProduct = 55

cQ = 7975 (for c=145)

c = 7975

d_raw = 89.3029

d = 89

d^2 = 7921.0000

(d+1)^2 = 8100.0000

e = 54

a = 1

b = 7975

f = -125

x = 88

X = 7744.0000

Xpe = 7798.0000

Half_Xpe = 3899.0000

n = 3899

dpn = 3988

DPN = 15904144.0000

DPNmc = 15896169.0000

rtDPNmc = 3987.000000000

rtDPNmc_minusx = 3899.000000000

mid_a_b_gap = 1.00

Your rtDPNmc_minusx - n = ZERO! Yes, 0.0

You passed the Test, you may enter the GRID!

>>8733 hope this is starting to click for you MA. And, it's Fryday!

>>8721

>So, what I'll add tonight, as well as answering questions between now and Sunday, is the code to calculate (For any size) the difference between BigN and n for known RSA numbers. At that scale, you will see a Revelation.

Would be good if you could stop in this eve, time is limited this week. ty.

>>8772

Why are we using alternating primes, though?

>>8773

Frankly, don't think it matters overall.

Perhaps for the 6107 case, if instead of:

primeProd1 = [5 * 11 * 17] = 935, we used

primeProd2 = [13 * 17 * 17] = 3757?

Would there still be enough information with the repeated factor (17) to collapse the grid, where n falls out? Would larger factors be useful here?

Future proves past on these questions perhaps.

Remember, the appearances increase by powers of two.

>>8776

Identify yourself please, Anon. I'd like to know who you are.

If q is the product of the set of small primes and c'=abq = qc, and d'd'+e' = c', and a must appear twice in the first a+1 [e',1,t] elements of [e',1], how do we know what factors will also make up the two values of t where a is a factor of [e',1,t]?

That is the question we're answering.

That is also the two values we are forcing with the grid.

This is the basis of the non-trivial Lookup.

>>8771

I can understand using primes that are only the sum of two squares as an accelerant for certain c, but remove 23 and other primes that end in 11 in binary, the sum of two squares that are odd end in 01.

>>8775

Draw out a table to test this assertion?

>>8769

>>8766

Fuck you faggots, I’ve been here since /cbts/, every RSA thread. Topo, you faggot, you’ve even succesfully reposted my images to /qr/ to sucessfully summon (C)hristoph(e)r Wr(a)y himself SO BACK OFF FAGGOTS.

>>8783

whooooooa there homie

I was responding to a different id… with a joke.

Also, I've used everyone's images to summon Chris… whomever you are.

Gotta earn muh bread.

Also… what's a Cea?

>>8782

Love it.

>>8773

>Why are we using alternating primes, though?

Was Oddly confused. See >>8748

Definition:Odd Prime (https://proofwiki.org/wiki/Definition:Odd_Prime)

- Apart from 2 itself, all primes are odd.

- So, referring to an odd prime is a convenient way of specifying that a number is a prime number, but not equal to 2.

>>8779

>If q is the product of the set of small primes and c'=abq = qc, and d'd'+e' = c', and a must appear twice in the first a+1 [e',1,t] elements of [e',1], how do we know what factors will also make up the two values of t where a is a factor of [e',1,t]?

Nice notation! Will work on this.

>>8780

>I can understand using primes that are only the sum of two squares as an accelerant for certain c, but remove 23 and other primes that end in 11 in binary, the sum of two squares that are odd end in 01

Ah, i c. Also can clearly see '2' as the oddball ending in zero! And won't be able to eliminate in decimal form, as those ending in '3', '7', '9' are all a mixed bag of '01' and '11' in binary form.

2 → 0000000000010

3 → 0000000000011

5 → 0000000000101

7 → 0000000000111

11 → 0000000001011

13 → 0000000001101

17 → 0000000010001

19 → 0000000010011

23 → 0000000010111

29 → 0000000011101

31 → 0000000011111

37 → 0000000100101

…

3881 → 0111100101001

3889 → 0111100110001

3907 → 0111101000011

3911 → 0111101000111

3917 → 0111101001101

3919 → 0111101001111

Will generate new list (5, 13, 17, 29, 37, 41, 53, 61, 73, etc.)

Oh, i c more correlations! (https://oeis.org/A002144)

A002144 Pythagorean primes: primes of form 4n + 1.

5, 13, 17, 29, 37, 41, 53, 61, 73, 89, 97, 101, 109, 113, 137, 149, 157, 173, 181, 193, 197, 229, 233, 241, 257, 269, 277, 281, 293, 313, 317, 337, 349, 353, 373, 389, 397, 401, 409, 421, 433, 449, 457, 461, 509, 521, 541, 557, 569, 577, 593, 601, 613, 617

COMMENTS

- Rational primes that decompose in the field Q(sqrt(-1)). - N. J. A. Sloane, Dec 25 2017

- Odd primes such that binomial(p-1, (p-1)/2) == 1 (mod p). - Benoit Cloitre, Feb 07 2004

- Primes that are the hypotenuse of a right triangle with integer sides. The Pythagorean triple is {A002365(n), A002366(n), a(n)}.

- Not only are the squares of these primes the sum of two nonzero squares, but the primes themselves are also. 2 is the only prime equal to the sum of two nonzero squares and whose square is not. 2 is therefore not a Pythagorean prime. - Jean-Christophe Hervé, Nov 10 2013

- The statement that these primes are the sum of two nonzero squares follows from Fermat's theorem on the sum of two squares. - Jerzy R Borysowicz, Jan 02 2019

- The decompositions of the prime and its square into two nonzero squares are unique. - Jean-Christophe Hervé, Nov 11 2013. See the Dickson reference, Vol. II, (B) on p. 227. - Wolfdieter Lang, Jan 13 2015

- p^e for p prime of the form 4*k+1 and e>=1 is the sum of 2 nonzero squares. - Jon Perry, Nov 23 2014

- Primes p such that the area of the isosceles triangle of sides (p, p, q) for some integer q is an integer. - Michel Lagneau, Dec 31 2014

and our primes ending in binary '11'?

A002145 Primes of the form 4n+3. (https://oeis.org/A002145)

3, 7, 11, 19, 23, 31, 43, 47, 59, 67, 71, 79, 83, 103, 107, 127, 131, 139, 151, 163, 167, 179, 191, 199, 211, 223, 227, 239, 251, 263, 271, 283, 307, 311, 331, 347, 359, 367, 379, 383, 419, 431, 439, 443, 463, 467, 479, 487, 491, 499, 503, 523, 547, 563, 571

- Or, odd primes p such that -1 is not a square mod p, i.e., the Legendre symbol (-1/p) = -1. [LeVeque I, p. 66]. - N. J. A. Sloane, Jun 28 2008

- Primes which are not the sum of two squares, see the comment in A022544. - Artur Jasinski, Nov 15 2006

- Natural primes which are also Gaussian primes. (It is a common error to refer to this sequence as "the Gaussian primes".)

- Inert rational primes in the field Q(sqrt(-1)). - N. J. A. Sloane, Dec 25 2017

Validating:

3 → 0000000000011

7 → 0000000000111

11 → 0000000001011

19 → 0000000010011

23 → 0000000010111

31 → 0000000011111

43 → 0000000101011

…

499 → 0000111110011

503 → 0000111110111

523 → 0001000001011

547 → 0001000100011

563 → 0001000110011

571 → 0001000111011

>>8787

There are three types of prime or rather there is a way to separate primes.

Those in column [1,n], those in column [2,n] and those that are not.

Those in column 1 are the sum of two squares.

Those in column 2 are the sum of three squares.

>>8788

Very interesting, would Gauss the proof for that is Legendre! j/k

Looking at a 1956 paper by N. C. Ankeny titled "Sums of Three Squares" seems related as well.

Journal: Proc. Amer. Math. Soc. 8 (1957), 316-319

http://www.ams.org/journals/proc/1957-008-02/S0002-9939-1957-0085275-8/S0002-9939-1957-0085275-8.pdf

Hmm, wondering if this pattern is linked to the trivial solution of Fermat's Theorem mentioned early on as well…

>>8789

It all starts to come together doesn't it?

If all of this were just stated at the start as a computer program, would anons have seen the beauty?

Seven years of putting this together.

We're approaching that distilled into just more than one.

One day they will teach this in a semester.

Then it will just be a program almost no one understands under the hood.

But this is just the beginning, as well as The End.

There is so much more.

>>8790

Indeed, ty.

In the End, perhaps math and programming go together. This journey sparked a coding path (crawling, looking forward to first baby steps) in parallel with the maths. Grateful.

Funny, was distracted yesterday by the Prime conspiracy on Rosetta Code.

https://rosettacode.org/wiki/Prime_conspiracy

So pulled in the code and ran it (cap in pic).

Today, wanted to regenerate for the last two digits using binary format, but trying to stay focused given limited Time.

Ran into an interesting book, same topic of this Primal Conspiracy…

https://mitpress.mit.edu/books/prime-number-conspiracy

and for some comfy music a little Chris Crummey and the Searchers. May he R.I.P.

>>8791

Gotta DASH! (and stop flirting with Julia!)

How many different people are still here? Are we VQC + 12 people? 12 lost sheep trying to understand that one guy and what he brings to the table?

>>8797

Anyone over 30 with 12 close friends is Jesus 2.0

>>8800

>Next we have this to work on: >>8779

>The element you've verified in the new (e,n) is the BigN element.

>Next we need to explore (e,1) to find the element with the same c'=abq or (an) or (prime b) or any other piece of info that can solve the problem.

ty Anon, and nice dubs. Agree this is next step.

Do your thang, keeping commitments is important!!! (Promises Kept!).

Go and project selfless love to those you're with. You'll come back ready. Fresh.

Not sure how useful this is/will be, but there's a thing called Blender out there

https://docs.blender.org/manual/en/latest/render/cycles/nodes/types/converter/math.html

>>8803

Blender

Durrin' what can:

"You need a log function to have a fractal"

https://8ch.net/qresearch/res/5604368.html#q5604557

Le fagging

>>8772

I'm trying to wrap my head around this. What are you actually doing here? You're just validating the record for a=1, b=c? You could do that with almost any number multiplied by c, as long as it's not = 2 (mod 4).

>>8806

Hello Anon! This post >>8772 is using the code VQC posted here >>8679.

The purpose is to make c bigger using (c * small primes). The code is used to verify that the new c' is valid.

We are using the Grid to create new c' values. When me multiply c with smaller primes, we get new (e,n) locations for each c'. When a=1, this is the BigN element. Our next step is to explore the new (e,1) values in each c' to see if the factors for c show up.

For c145, 145 * 5 = 725. New e=49. And the first element in (49,1) contains the solution. We get a=25 (which is (an)) and b=29 (prime b). So we shift to new locations in the grid each time we multiply c. Check out my screencap here: >>8800

c'=abq is the formula.

The paradigm shift for me personally is making c bigger by multiplying it with primes. RSA sized numbers are huge already, so I hadn't thought of that as a possible method. Now that I see it it makes perfect sense.

>>8807

Excellent summary anon.

Maybe like first broadening the search space, then raking over that with our known factors to see what falls out?

>>8798

My Jesus doesn't need an update.

>>8810

Fuck that.

Make your own covenant.

>>8765

Oh you're the person who posted the dude with the head gear on the bunker board. That was weird, man.

>>8808

Thanks Anon!

>>8810

>>8811 (nice dubs Topol!)

IDK, I kinda like the VQC and his 12 disciples thing. Jesus is my Higher Power, so I get your point, but no need to get all grumpy Jan. Geez.

>>8813

>>8814

Hello AA! I think the main point of this c'=abq=qc is to get (prime a) or (prime b) to "fall out", not this smoothness BigN - n thing. For the small examples I've studied, we get elements in (e,1) where the solution is revealed. Multiplying c * q just gives new (e,n) to examine for factors. What are your thoughts on this?

>>8816

I think we factorize each step in the series of primes that create q.

Meaning, check each (e,1) for each prime or combo of primes.

Up to q.

(An) or (prime a) or (prime b) will “fall out”.

It’s like tricking the Grid into giving us the answer, lol

The key is the series of primes leading up to q.

Hacking the Grid.

By making c bigger.

Fuck all this BigN - n shit, I want factors.

Deeper understanding of the grid and the non-trivial Lookup (named after the zeros of the Riemann Zeta Function).

By controlling the low prime numbers as a product with, an increasing (non-linear) amount of information is forced upon [e',1]. Each of those factors have to appear early and forever after once they appear in the grid. The sequential probability of consecutive primes being in a random value of [e',1] are low and place huge restrictions on the other primes, including a and including the values of x.

The low primes act to filter out the numbers that a cannot be based on what we know in [e,1] and, importantly in [-f,1]. Because one is odd, and one is even, the overlap and distribution of odd numbers in one of these columns and e' is such that a lookup becomes possible. BigN' comes into play.

>>8816

Beautiful.

The structure has patterns over patterns.

The input of d and e strip away the overlaps to resolve the structure of c.

>>8819

>Because one is odd, and one is even, the overlap and distribution of odd numbers in one of these columns and e' is such that a lookup becomes possible.

Just thought I'd run through a quick visual example of this so I might as well post it here. We already know the a values in (f',1) and (e',1) will have different parities. This just shows that a does indeed turn up twice as a factor of the a'[t] values in both (e',1) and (f',1), multiplied by numbers of a different parity based on e and f.

>The sequential probability of consecutive primes being in a random value of [e',1] are low and place huge restrictions on the other primes, including a and including the values of x.

So the next thing to look into could maybe be a comparison between the prime factors of each a'[t] value in both (e',1) and (f',1), using consecutive primes for q.

>>8823

Does it matter that 42 goes from negative in (a'[6]) to positive in (a'[9])?

Just wondering if it means anything.

Not sure why I'd noticed Chris "Curtis" Wray at RSA before Adm. Mike "Pender" Rogers…

But here's Adm. Rogers at RSA 2016.

He's got a killer beard, these days.

>>8824

Those are negative elements. There's always a beginning element in a cell and the variable values in the elements all grow from there in particular patterns (other than e and n). Negative elements aren't technically valid elements, but we can analyze what would happen if we made the growth pattern go backwards.

>>8819

The low primes act to filter out the numbers that a cannot be based on what we know in [e,1] and, importantly in [-f,1]. Because one is odd, and one is even, the overlap and distribution of odd numbers in one of these columns and e' is such that a lookup becomes possible.

>>8821

>So the next thing to look into could maybe be a comparison between the prime factors of each a'[t] value in both (e',1) and (f',1), using consecutive primes for q.

Cool! I'll have time to put in some work on this after my workday is finished. Thanks Senpai for verifying that we're on the right track!

>>8827

See >>8823

>>8829

>Can see a' growth of +4 / t for both the e & f.

That's just the way a[t] grows in all (e,1) and (f,1) is all.

>Have you done anything in negative t space?

> - thinking about what an a'[0] or a'[-1] might be for the (e,1).

He did say the lookup had something to do with negative space. What he meant is obviously up for debate (and I can't remember the wording), but it could be helpful. I'll have a look soon.

>>8638

>Negative values of t can be thought of as valid, values of t that are derived from imaginary numbers can be thought of as orthogonal to the grid.

- should have read the thread more!

- am assuming t=0 would be ok as well, these are next steps, am still getting to point of generating any particular cell in full, positive and negative spaces.

Hmm, found that, but recall something similar about 'x' as well, but could be mistaken. >>8664 mentioned this, need to find actual source.

>>8830

>>8831

Ahh, found a couple references. I'm sure there are more, as Chris has been so patiently stating such similar forms of the same concepts in different ways, each time with a bit more clarity.

>>7747

One pattern that might be important…

Negative x values in row 1.

>>6292

Enumerate the patterns in the first row (and into negative x).

>>8819

So we’re expanding c to c’ and looking for the prime factors.

Those new elements can be easily calculated, based on Grid Rules.

The Grid itself is awesome.

Never ending patterns of truth.

And logic.

Beautiful!

I have another idea.

What if we make a list of possible a values based on the limitation of (prime d)? Will be huge.

Then begin "Ruling" them out with the factors we find in the c'=abq=qc search

Each new column (from each small prime) limits our search space much further.

It's a few parts:

1. Searching each (small prime) leading up to q.

(Why is it named Q, lol??)

and as we go, crossing vast swathes of numbers off the list of possible a values. Find a solution? Great. If not, step 2.

2. If that doesn't find a solution, multiply each small prime with each small prime, creating new semi-prime combos. Check and verify for a solution.

3. Find new ways to limit the search.

4. Wash, Rinse, Repeat.

5. Keep a list of "Ruled-Out" a values, until the solution emerges.

>>8833

Great ideas.

It is simpler than that.

We are forcing and controlling the grid cell at n=1 but creating a product of small primes, q, and c. That means the cell at [e',1] is greatly restricted. That means the cell at [-f',1] is also greatly restricted! Its got to have exact values of (n'-1) and we have created and controlled many of these values.

We're on the cusp of the grid, The End, working for us as a virtual quantum computer.

>>8834

"But" should read "by".

Busy day.

>>8835

>>8834

Some of us have been talking about what primes we're meant to be using, and we're confused.

>>8780

>I can understand using primes that are only the sum of two squares as an accelerant for certain c, but remove 23 and other primes that end in 11 in binary, the sum of two squares that are odd end in 01.

If the two types of primes you're talking about are primes that end in 01 and primes that end in 11, and you're saying that primes that end in 01 are sums of two squares that are odd and that they can be used "as an accelerant for certain c" (meaning using only those primes is useful in specific situations but not every situation), why are you then telling us to remove primes that end in 11? That would leave us with only primes that end in 01, which, in the same sentence, you told us are useful for some specific c values and not all of them.

So are we just using odd sums of two squares primes (5, 13 etc), or are we using all consecutive primes (3, 5, 7, etc)? What specific numbers are we using?

>>8837

>and then used 17^2

meant 17^3.

long afternoon.

>>8834

Ok Senpai. Easy Peasy. I'll work up an Excel spreadsheet to calc all the values of (e',1) and (-f',1) for each value in the c'=abq=qc chain. I have a few hours tonight, and a few more tomorrow. Will post my findings soon.

>>8837

Thanks MM! I thought it was you, you have a kind and polite way with words. Hard to mistake for anyone else.

Hey Chris…

>>>/newsplus/228556

"Brexit: MPs vote by a majority of 211 to seek delay to EU departure"

https:// www.bbc.com/news/uk-politics-47576813

Does this affect your release timeline at all? It sounds like it might be necessary to make the VQC public whether Brexit happens or not, considering, like you said >>8689 here, it'll bring down the UK government and end all of that traitorous nonsense.

Dafuq is going on here, and is it relevant/meaningful?

Playing with an idea for… whyever.

polite primes adding up to a prime… sometimes?

Using three… this is where I bounced…

29+31+37=97… which is a prime

149+151+157=457… prime

awww.

601+607+6013=1821…. not prime

buuuut

347+349+353=1049… prime

349+353+359=1061… prime

i wonder why some work and some don't

431+433+439=1303… prime

433+4439+443=1315… not prime

439+443+449=1331… not prime

443+449+457=1349… not prime

449+457+461=1367… prime

Nothing with 433 sums a prime from polite primes.

wtf is up with that?

>>8845

DERP

shoulda caught that the first time.

Nothing with 443 sums a prime from polite primes.

>>8844

You can see in multiple of the frames what looks to be parabolas / waves. Not sure if this is what we're looking for. Maybe there is a specific parabola / wave that will yield a or b?

>>8847

I also trailed off a bit and found something very pretty, something similar to what we are generated before?

https://oeis.org/A051731/a051731_1.gif

Related to https://oeis.org/A051731 which is again related to http://oeis.org/A034729 which is related to phi, binary and divisors of a number.

>>8848

Phi as in euler totient function.

>>8844

Why did you skip 17, 29 and 37?

>>8850

It wasn't as much skipping as it was being lazy. I only check if a[t] is a prime in (1, 1) instead of factorizing and creating a set of all primes in (1, 1). I'll probably redo it, though. Need to be thorough. I initially just wanted to generate that GIF to see how the patterns evolve.

>>8851

I rewrote my code a bit, now I generate a set of all factors from (1, 1) and I'm generating a new gif.

>>8842

Thanks AA. so your reading of >>8834 is to use just the (-f',1) and (e',1) columns to find the solution, correct?

You correctly pointed out that VQC basically told me that creating and studying the (e,n) locations for each (small prime) factor of q is unnecessary. It seems that we need only (-f,1) (-e,1) and (-f',1) (e',1) to solve.

>Semiprime c has two (a,b) pairs, giving it two n values including BigN, only one of which we know to begin with. Multiplying c by one prime increases the number of n values to four, of which we can directly calculate two. Multiplying c by two primes increases the number of n values to eight, of which we can directly calculate four. That's what he meant about controlling n'.

So let's cook up a Method for finding what we need.

Are we comparing the BigN values from (-f,1) and (e,1) against (-f',1) (e',1) ?

Are we subtracting equivalent (e') a[t] - (-f') a[t] values to search for (prime)a ?

What methods have you tested out so far to find (n'-1) and (n') ?

A good first step would be to write code to generate the four key elements we need. Then we can analyze them for patterns.

>>8853

So um…

>>8845

>>8846

Why is 443 missing from that list of yours?

Just out of curiosity…

>>8855

Because 443 doesn't occur in (1, 1). It's the sum of three squares and occurs in (2, 1).

>>8856

can you give me a quick list of which ones also appear in (2,1)?

47 was playful also when I was doing my "wtfever Topol does with his time"…

And it's also missing from your set.

>>8857

Sure, here you go:

3, 11, 17, 19, 41, 43, 59, 67, 73, 83, 89, 97, 107, 113, 131, 137, 139, 163, 179, 193, 211, 227, 233, 241, 251, 257, 281, 283, 307, 313, 331, 337, 347, 353, 379, 401, 409, 419, 433, 443, 449, 457, 467, 491, 499, 521, 523, 547, 563, 569, 571, 577, 587, 593, 601, 617, 619, 641, 643, 659, 673, 683, 691, 739, 761, 769,

47 doesn't exist in (1, 1) or (2, 1) because it belongs in the "other" category ref: >>8788

The non-trivial method uses a pattern you might not have seen yet but has been discussed.

You know how to look up a number c from column 0 or 1. One way is to take a[t] from c in [0,1] or [1,1], divide the remainder by two and add that to the column to get c in another column.

The value c can be looked up in many columns this way.

This gives enough information to find a, x and n.

>>8860

In other words.

The columns that c appears in, determines it's composition.

That is the power behind the grid.

Try it with both primes and composite numbers. Anything strike you? Once you c it…

>>8860

>You know how to look up a number c from column 0 or 1

Do you mean a c we're looking for as an actual c value, or are you referring to the thing you were talking about a while ago where a[t] in (2c,1) is equal to c?

Great, he went to bed I guess. I've been doing some testing and it seems like he has to be referring to something new and completely different to the (2c,1,1) thing or c being the actual c value (despite him saying "you know how" to do it). With the example of c559, if you take a[2] from (0,1) and (1,1) (2 because it's the first valid element in (0,1)), which is 2 and 5 respectively, and add (c-a[2])/2 = 278 and 277 respectively to the e values, you get (278,1) for both. c shows up as a d value in (278,1,15). If you start from (0,1,3) and (1,1,3), you get (275,1) and (274,1). c-1 shows up as an a value in (275,1,15), and c-2 shows up as a d value in (274,1,15). For (0,1,4) and (1,1,4), which give (270,1) and (268,1), c-4 shows up as d in (270,1,15) and c-5 shows up as d in (268,1,15). For (0,1,5) and (1,1,5), which give (263,1) and (260,1), c-7 shows up as a in (263,1,15) and c-9 turns up as d in (260,1,15).

There's definitely a pattern, but it seems like something weird happens with the values that are taken away from c. Obviously the important part here seems to be that it's always at t=15 for this example. Maybe that's the t value the trivial method returns.

>>8862

Happy birthday. I guess since you're Chris' shitposting account, that means you can fill us in on the trivial method like he was meant to on his birthday.

>>8854

I'll do some work on this today.

>>8864

It doesn't seem to work straight away for every example. Here's another two examples.

c203=7*29

If we started from a[2] in (0,1) and (1,1), which gives us (100,1), the closest thing we get to 203 in an a or d value is 212 as an a value. It isn't until we get to (1,1,5) that we find 203 as an a value in (82,1,10).

c2537=43*59

If we started from a[2] in (0,1) and (1,1), which gives us (1267,1), the closest thing we get to 2537 in an a or d value is 2555 as a d value. As a matter of fact with this example, it passes right by 2537. c does not appear in any of the calculated cells without anything added or taken away. 2537 turns up as a d value in (1231,1,31) and as an a value in (1230,1,32), but the e value we get around here using this are 1243, 1238, 1232, 1226, 1219, 1212, etc. 1231 and 1230 don't turn up. Only values close to c turn up as a or d values in these (e,1) cells, but not exactly c. Instead of everything being in the same t value, with these values that are close, they turn up at t=31 when they turn up as d values, but they turn up at t=32 when they turn up as a values.

This is weird, and it warrants way more study.

>>8864

>Maybe that's the t value the trivial method returns.

That's what I'm thinking.

Thanks for your work.

>>8865

>This is weird, and it warrants way more study.

Lol, story of our life here on VQC.

>>8866

I'm doing the n' thing at the moment. I'm just trying to figure out how the fuck to get a set of all subsets.

>>8868 Nice work AA!

Ran your code and compared, am generating the same q & qc values. Checked RSA100 and RSA2048 (e.g. for RSA2048, there are 65 primes in the q-list, ending in 769).

- Not much time past several days, hopefully will carve a bit out this week.

>>8841 ty.

>>8844

>>8853 Cool.

>>8860

>>8861 Working toward this…