As you can see from the screenshot, its working.
The system is actually learning the associations between the digit sequence of semiprime hidden variables and known variables.

Training loss and value loss are super high at the moment and I'm using an absurdly small training set (10k sequence pairs). I'm running on the assumption that there is a very strong correlation between the structures (and that it isn't just all ephemeral).

This initial run is just to see if training an machine learning model is a viable approach.

Won't know for a while. Training loss could get very low (thats a good thing, indicating actual learning), only for it to spike later on, and if it does, I won't know if the sample size is too small, or if I need to do more training, or if the problem is actually intractable.

If or when that happens I'll experiment with different configurations like batch sizes, and more epochs, as well as upping the training set incrementally.

Either case, once the initial model is trained, I need to test it on samples never seen before (products I want to factor) and see if it generates some or all of the digits needed for rapid factorization.

Even partial digits would be a success here.
And I expect to create multiple training sets for each semiprime product and its unknown internal variables versus deriable known variables. The intersections of the sets, and what digits they have in common might be the best shot available for factorizing very large numbers in this approach.

Regardless, once I see that the model works at the small scale, the next step will be to increase the scope of the training data, and begin building out the distributed training platform so I can cut down the training time on a larger model.

I also want to train on random products of very large primes, just for variety and see what happens with that. But everything appears to be working. Working way better than I expected.

The model is running and learning to factorize primes from the set of identities I've been exploring for the last three fucking years.

Feels like things are paying off finally.

Will post updates specifically to this rant as they come. Probably once a day.

I think I did it. I did the thing I set out to do.

let p = a semiprime of simple factors ab.
let f equal the product of b and i=2...a inclusive, where i is all natural numbers from 2 to a.
let s equal some set of prime factors that are b-smooth up to and including some factor n, with no gaps in the set.
m is a the largest primorial such that f%m == 0, where
the factors of s form the base of a series of powers as part of a product x
1. where (x*p) = f
2. and (x*p)%f == a

if statement 2 is untrue, there still exists an algorithm that
3. trivially derives the exponents of s for f, where the sum of those exponents are less than a.
4. trivially generates f from p without knowing a and b.

For those who have followed what I've been trying to do for so long, and understand the math,
then you know this appears to be it.

I'm just writing and finishing the scripts for it now.

Thank god. It's just in time. Maybe we can prevent the nuclear apocalypse with the crash this will cause if it works.

So I got the LSTM working in keras.
Working from a glorified tutorial.
Why the fuck do people let their github pages go down with no other backup?
Especially if its a link in your blog?
Why would you do that and not post the full script (instead of bits and pieces interspersed with *partial* explanations)?

In any case, its working and training on a test set and examples just to debug my own understanding of the process.

Once thats done I can generate some training data and try training on a small set. If that goes smoothly and the loss looks like it is heading in the right direction, then I'll setup the hardware for the private cloud and start writing the parallel computing component.

I've assembled enough computing power from the trash. Now I can start to build my own personal 'cloud'. Fuck I hate that word.
But I have a bunch of i7s, and i5s on hand, in towers. Next is just to network them, and setup some software to receive commands.

So far I've looked at Ray, and Dispy for distributed computation. If theres others that any of you are aware of, let me know. If you're familiar with any of these and know which one is the easier approach to get started with, I'd appreciate your input.

The goal is to get all these machines up and running, a cloud thats as dirt cheap as possible, and then train it on sequence prediction of the hidden variables derived from semiprimes. Right now the set is unretrievable, but theres a lot of heavily correlated known variables and so I'm hoping the network can derive better and more accurate insights than I can in a pinch.
Because any given semiprime has numerous (hundreds of known) identities which immediately yield both of its factors if say a certain constant or quotient is known (it isn't), knowing any *one* of them and the correct input, is equivalent to knowing the factors of p.

So I can set each machine to train and attempt to predict the unknown sequence for each particular identity.

Once the machines are setup and I've figured out which distributed library to use, the next step is to setup Keras, andtrain the model using say, all the semiprimes under one to ten million.

I'm also working on a new way of measuring information: autoregressive entropy. The idea is that the prevalence of small numbers when searching for patterns in sequences is largely ephemeral (theres no long term pattern) and AE allows us to put a number on the density of these patterns in a partial sequence, but its only an idea at the moment and I'm not sure what use it has.

Heres hoping the sequence prediction approach works.

In 2015 I sent an email to Google labs describing how pareidolia could be implemented algorithmically.
The basis is that a noise function put through a discriminator, could be used to train a generative function.
And now we have transformers.

I also told them if they looked back at the research they would very likely discover that dendrites were analog hubs, not just individual switches. Thats turned out to be true to.

I wrote to them in an email as far back as 2009 that attention was an under-researched topic. In 2017 someone finally got around to writing "attention is all you need."

I wrote that there were very likely basic correlates in the human brain for things like numbers, and simple concepts like color, shape, and basic relationships, that the brain used to bootstrap learning. We found out years later based on research, that this is the case.

I wrote almost a decade ago that personality systems were a means that genes could use to value-seek for efficient behaviors in unknowable environments, a form of adaption. We later found out that is probably true as well.

I came up with the "winning lottery ticket" hypothesis back in 2011, for why certain subgraphs of networks seemed to naturally learn faster than others. I didn't call it that though, it was just a question that arose because of all the "architecture thrashing" I saw in the research, why there were apparent large or marginal gains in slightly different architectures, when we had an explosion of different approaches. It seemed to me the most important difference between countless architectures, was initialization.

This thinking flowed naturally from some ideas about network sparsity (namely that it made no sense that networks should be fully connected, and we could probably train networks by intentionally dropping connections).

All the way back in 2007 I thought this was comparable to masking inputs in training, or a bottleneck architecture, though I didn't think to put an encoder and decoder back to back.

Nevertheless it goes to show, if you follow research real closely, how much low hanging fruit is actually out there to be discovered and worked on.

And to this day, google never fucking once got back to me.

I wonder if anyone ever actually read those emails...

Wait till they figure out "attention is all you need" isn't actually all you need.

p.s. something I read recently got me thinking. Decoders can also be viewed as resolving a manifold closer to an ideal form for some joint distribution. Think of it like your data as points on a balloon (the output of the bottleneck), and decoding as the process of expanding the balloon. In absolute terms, as the balloon expands, your points grow apart, but as long as the datapoints are not uniformly distributed, then *some* points will grow closer together *relatively* even as the surface expands and pushes points apart in the absolute.

In other words, for some symmetry, the encoder and bottleneck introduces an isotropy, and this step also happens to tease out anisotropy, information that was missed or produced by the encoder, which is distortions introduced by the architecture/approach, features of the data that got passed on through the bottleneck, or essentially hidden features.

I would have never considered it but several people thought: why not train our diffusion models on mappings between latent spaces themselves instead of on say, raw data like pixels?

It's a palm-to-face moment because of how obvious it is in hindsight.

Details in the following link (or just google 'latent diffusion models')

https://huggingface.co/docs/...

Found a clever little algorithm for computing the product of all primes between n-m without recomputing them.

We'll start with the product of all primes up to some n.

so [2, 2*3, 2*3*5, 2*3*5*,7..] etc

prods = []
i = 0
total = 1
while i < 100:
....total = total*primes[i]
....prods.append(total)
....i = i + 1

Terrible variable names, can't be arsed at the moment.
The result is a list with the values

2, 6, 30, 210, 2310, 30030, etc.

Now assume you have two factors,with indexes i, and j, where j>i

You can calculate the gap between the two corresponding primes easily.
A gap is defined at the product of all primes that fall between the prime indexes i and j.

To calculate the gap between any two primes, merely look up their index, and then do..
prods[j-1]/prods[i]

That is the product of all primes between the J'th prime and the I'th prime

To get the product of all primes *under* i, you can simply look it up like so:

prods[i-1]

Incidentally, finding a number n that is equivalent to (prods[j+i]/prods[j-i]) for any *possible* value of j and i (regardless of whether you precomputed n from the list generator for prods, or simply iterated n=n+1 fashion), is equivalent to finding an algorithm for generating all prime numbers under n.

Hypothetically you could pick a number N out of a hat, thats a thousand digits long, and it happens to be the product of all primes underneath it.

You could then start generating primes by doing
i = 3
while i < N:
....if (N/k)%1 == 0:
........factors.append(N/k)
....i=i+1

The only caveat is that there should be more false solutions as real ones. In otherwords theres no telling if you found a solution N corresponding to some value of (prods[j+i]/prods[j-i]) without testing the primality of *all* values of k under N.

not dev related..

Olive Garden is nothing but Italian Denny's.

In the grim dark future cryosleep or hypersleep or something similar will probably be used to extend peoples lives (and thus politicians careers) before it is ever used for space travel.

Give it time and you'll eventually have, through repeated extensions, term limits of one thousand years or even ten thousand, for congress/senate/president/etc.

You'll have CEOs and upper executives who have lived for 80k years dropping out of hypersleep once a century to document how the shoreline of north america changes near their beach home, as a sort of hobby.

Fart huffing professors (it's a professional sport in the year 28,841 AD) will come out of sleep once every millenia to track the evolution of something irrelevant, like gnat penises.

Big game hunters will wake up every 100k years to hunt new big game prey that just evolved--back into extinction. That and to check with their portfolio managers who will be AI or a highly evolved mongoloid goblin race of slave-quants.

I'm still working on the game btw. Anyone up for testing some prototypes when they're ready?

The first fruits of almost five years of labor:
7.8% of semiprimes give the magnitude of their lowest prime factor via the following equation:
((p/(((((p/(10**(Mag(p)-1))).sqrt())-x) + x)*w))/10)

I've also learned, given exponents of some variables, to relate other variables to them on a curve to better sense make of the larger algebraic structure. This has mostly been stumbling in the dark but after a while it has become easier to translate these into methods that allow plugging in one known variable to derive an unknown in a series of products.

For example I have a series of variables d4a, d4u, d4z, d4omega, etc, and these are translateable now, through insights that become various methods, into other types of (non-d4) series. What these variables actually represent is less relevant, only that it is possible to translate between them.

I've been doing some initial learning about neural nets (implementation, rather than theoretics as I normally read about). I'm thinking what I might do is build a GPT style sequence generator, and train it on the 'unknowns' from semiprime products with known factors.

The whole point of the project is that a bunch of internal variables can easily be derived, (d4a, c/d4, u*v) from a product, its root, and its mantissa, that relate to *unknown* variables--unknown variables such as u, v, c, and d4, that if known directly give a constant time answer to the factors of the original product.

I think theres sufficient data at this point to train such a machine, I just don't think I'm up to it yet because I'm lacking in the calculus department.

2000+ variables that are derivable from a product, without knowing its factors, which are themselves products of unknown variables derived from the internal algebraic relations of a product--this ought to be enough of an attack surface to do something with.

I'm willing to collaborate with someone familiar with recurrent neural nets and get them up to speed through telegram/element/discord if they're willing to do the setup and training for a neural net of this sort, one that can tease out hidden relationships and map known variables to the unknown set for a given product.

heres something interesting:
The golden ratio is 1.618...

If you're not familiar with it, doing 1/goldenratio
the result is 0.618...
It gives you back the float component exactly.

Discovered that it is actually part of a series.

First of all:
2-(((5-sqrt(5))/2)-1) =
1.618033988749895 -> thats our golden ratio

In other words:
(2%gold) =
0.381966011250106

While:
((5-sqrt(5))/2) =
1.381966011250105

Ok, now we're getting somewhere. We can turn these into variables

First of all, lets see if we can get the golden ratio back out:
2-(((5-sqrt(5))/2)-1) = 1.618033988749895

Okay good.

The formula looks something like
j-(((i-sqrt(i))/2)-1)

Where j = (i*2)+1
That means we can easily figure out what j we need from our i value. (i-1)/2 = j

We run it back far enough we get
1-(((3-sqrt(3))/2)-1) =
1.3660254037844386

Thats the golden ratios little brother. Doesn't look anything like it, but it is part of the series.
And I found a boat load of research documents scattered *all* over the net, where this number and others in the series inexplicably crop up in power series, in chemistry, and elsewhere. Just looks like random floats if you don't know better.

We can actually go lower in the series:
0.5-(((2-sqrt(2))/2)-1)
1.2071067811865475

At the lowest positive value for j, we get
0-(((1-sqrt(1))/2)-1) = 1

It's kinda elegant.

I even wrote a little script to do the conversions:
def gr(k):
....i = k
....j = (i-1)/2
....return j-(((i-sqrt(abs(i)))/2)-1)

The dots are so devrant doesn't break pythons formatting.

First of all, merry christmas to everyone on devrant.

Second, another interesting paper--this time on pattern classification using piecewise linear functions vs classic spiking neural nets.

Supposedly it was a *six million* percent improvement in computation time, versus the spiking simulation. Thats my five minute overview of the document anyway.

Highly unusual application (hadn't seen it done before now but maybe I'm unfamiliar). Check it out:

https://link.springer.com/chapter/...

Fully Homomorphic Encryption (computing addition and multiplication of numbers WITHOUT decrypting) is fucking cool. That is all.

https://bit-ml.github.io/blog/post/...

!programming related

The karman line is bullshit.

If you aren't at escape velocity for your local planet's gravity well, then you aren't in fucking space.

Blue origin is a lie.

While exploring matterverse.ai, I looked at the formula for rubber:

C5H8.

its bandgap is 5.803

After a few minutes I discovered a slight modification:
C2H4, with a bandgap of 6.85!

"Holyshit, why aren't linemen using this instead of rubber for electrical insulation?"

*looks up formula*.

C2H4, the formula for:
Ethylene.

It's ethylene, a highly flammable gas.

And now you know why I don't do chemistry.

No one cares you got kicked off twitter.

Let it die.

While I was exploring multiplication tables I stumbled on something cool.
Take any power of 2 on the multiplication chart.
Now look at the number in the bottom left adjacent box.
The difference of these two numbers will always be a Mersenne number.
Go ahead. Starting on the 2's column of a multiplication table, look in the bottom left of each power of 2 and get the difference.

2-2 = 0
4-3= 1
8-5 = 3
16-9=7
32-17=15

etc.

While the online journal of integer sequences lists a lot of forumlas, I just wrote what came to mind (I'm sure its already known):
((2**i)-(((2**i)/2)+1))

The interesting thing about this is it generates not only the Mersenne numbers, but if you run i *backwards* it generates *additional* numbers.
So its a superset of mersenne numbers.

at i = 0 we get -0.5
i=-1 -> -0.75
i=-2 -> -0.875
i=-3 -> -0.9375
i=-4 -> -0.96875

And while this sequence is *not* mersenne numbers, mersenne numbers *are* in this set.

Just a curious discovery is all.

I setup stable diffusion today. Still figuring it out but I'm like an artist now right? Right?

Next step is figuring out how to train models.

Then I have to make some samples of various words in spectrogram form for training.

After that we'll see if stable diffusion can reconstruct phonemes.

I'll train using both my voice and a couple others, and apply them as styles.

And then finally, I can accomplish my lifes goal.

To have the voice of morgan freeman with me at all times, everywhere I go.

On the game front, I see so much conflicting advice. "Start getting feedback" as soon as possible. "Donnt soft launch on steam! The algol will wreck you.", "soft launch on itch to get feedback", "dont soft launch on itch!"

"Start marketing today", "focus on influencers", "get to know communities *before* you advertise", "dont get to know communities beforehand if you're just planning on self prompting", "dont self promote".
"CPM is important.", "CPA is important". Etc.

Sounds a lot like "have a bunch of money upfront." The solution is just to succeed from the start! It's so obvious. Just invent the next gta. The next facebook. Get a small loan of 50,000 dollars, or a million. Donate for a year to other kickstarter projects so people will know you and reciprocate! But also dont ebeg!

How about no. How about fuck all this advice by silver spoon assholes that didnt have to work on shoestring budgets. The advice is the equivalent of having a 300 page tonedeaf book, every page blank except page 150, where the words "fuck you. I got mine." Are printed in times new Roman, 14pt font, neatly in the center of the page.

The truth is most of the "indies" already made it in the software industry proper, before switching over. $5k kickstarter videos, with $15k marketing budgets, no doubt funded in part through their own money funneled through services that provide shell donations, because KS is being used as a glorified advertising service. People buying off steam curators for promotions, youtubers making sponsored videos without disclosing they're sponsored. Fake viralility. Fake campaigns. Predetermined success for those who could *already* afford to develop and go commercial without a publisher. And they came into the market and cannibalized the opportunity, raising the bar for everyone that wasnt them. I guess that's actually a good thing, because we wouldnt have half the amazing games we do, and the pressure to produce quality. But then I see fantastic games utterly ignored or flailing in an attempt to compete for eyeballs in an industry frequently dominated by gatekeeping marketeers and influencers, where human grace determines success or complete oblivion. And I'm just disgusted with it.

Also buy my game. Preorder NOW! And you'll get a REAL canvas bag, I'll go to like the goodwill and buy one and screen print the game logo on it or some shit. Buy the special collectors edition and get pictures of my feet. Buy the game of the year edition and get a real gasmask. Preorder now and I'll fucking suck your di k right now. No lie. Preorder the diamond edition RIGHT NOW in the next six minutes and I will send you one hundred thousand dollars in gold plated bottle caps. Limited supply. one million per customer. Offer expires soon. This is not a scam. I repeat. This is NOT a scam.

In other news I'm soft launching Atom Ranger in six months (assuming the nuclear apocalypse hasn't *actually* started by then). Its state of decay and fallout meets rimworld. Build and manage a sprawling base, resolving conflicts, exploring post apocalyptic Colorado and surrounding territories of no-mans-land. Navigate hazardous weather, radioactive terrain, collapsed bridges, dangerous rivers, and deal with cultists, bandits, slavers, and hungry cannibals. Broker peace between not just the factions outside your settlements, but within your base too. Manage conflicts, settle disputes, avert disasters, barter, scavenge, and survive in a fully dynamic world, where buildings slowly crumble, grass and trees sprout up in the road and vacant lots, fires burn out of control, and factions loot, ruin, and takeover settlements. Watch the world and the survivors in it change and survive. Help them to survive, or become a warlord and rule over the wastes.

Lets be honest. It's basically kenshi but less complicated.

If you want to volunteer to test (instead of paying to be a glorified tester, aka "alpha") let me know in the comments.

I'm currently setting up a discord and mailing list.

I messaged a professor at MIT and surprisingly got a response back.

He told me that "generating primes deterministically is a solved problem" and he would be very surprised if what I wrote beat wheel factorization, but that he would be interested if it did.

It didnt when he messaged me.

It does now.

Tested on primes up to 26 digits.
Current time tends to be 1-100th to 2-100th of a second.

Seems to be steady.

First n=1million digits *always* returns false for composites, while for primes the rate is 56% true vs false, and now that I've made it faster, I'm fairly certain I can get it to 100% accuracy.

In fact what I'm thinking I'll do is generate a random semiprime using the suspected prime, map it over to some other factor tree using the variation on modular expotentiation several of us on devrant stumbled on, and then see if it still factors. If it does then we know the number in question is prime. And because we know the factor in question, the semiprime mapping function doesnt require any additional searching or iterations.

The false negative rate, I think goes to zero the larger the prime from what I can see. But it wont be an issue if I'm right about the accuracy being correctable.

I'd like to thank the professor for the challenge. He also shared a bunch of useful links.

That ones a rare bird.

In the 90s most people had touched grass, but few touched a computer.

In the 2090s most people will have touched a computer, but not grass.

But at least we'll have fully sentient dildos armed with laser guns to mildly stimulate our mandatory attached cyber-clits, or alternatively annihilate thought criminals.

In other news my prime generator has exhaustively been checked against, all primes from 5 to 1 million. I used miller-rabin with k=40 to confirm the results.

The set the generator creates is the join of the quasi-lucas carmichael numbers, the carmichael numbers, and the primes. So after I generated a number I just had to treat those numbers as 'pollutants' and filter them out, which was dead simple.

Whats left after filtering, is strictly the primes.

I also tested it randomly on 50-55 bit primes, and it always returned true, but that range hasn't been fully tested so far because it takes 9-12 seconds per number at that point.

I was expecting maybe a few failures by my generator. So what I did was I wrote a function, genMillerTest(), and all it does is take some number n, returns the next prime after it (using my functions nextPrime() and isPrime()), and then tests it against miller-rabin. If miller returns false, then I add the result to a list. And then I check *those* results by hand (because miller can occasionally return false positives, though I'm not familiar enough with the math to know how often).

Well, imagine my surprise when I had zero false positives.

Which means either my code is generating the same exact set as miller (under some very large value of n), or the chance of miller (at k=40 tests) returning a false positive is vanishingly small.

My next steps should be to parallelize the checking process, and set up my other desktop to run those tests continuously.
Concurrently I should work on figuring out why my slowest primality tests (theres six of them, though I think I can eliminate two) are so slow and if I can better estimate or derive a pattern that allows faster results by better initialization of the variables used by these tests.

I already wrote some cases to output which tests most frequently succeeded (if any of them pass, then the number isn't prime), and therefore could cut short the primality test of a number. I rewrote the function to put those tests in order from most likely to least likely.

I'm also thinking that there may be some clues for faster computation in other bases, or perhaps in binary, or inspecting the patterns of values in the natural logs of non-primes versus primes. Or even looking into the *execution* time of numbers that successfully pass as prime versus ones that don't. Theres a bevy of possible approaches.

The entire process for the first 1_000_000 numbers, ran 1621.28 seconds, or just shy of a tenth of a second per test but I'm sure thats biased toward the head of the list.

If theres any other approach or ideas I may be overlooking, I wouldn't know where to begin.

It should be possible to prove the collatz conjecture by mapping the unit digit transitions between numbers, namely into a finite state machine. From there we could use predicates and quanitifiers to prove, by process of exclusion, that for any given combination of 10s digit and 1s digit, no number can transition to anything but whats specified in the state machine assuming that number equals x in x3+1 or x/2

Ipso facto, a series of equations proving by process of elimination, that state machines transitions are the only allowable ones, would prove the collatz conjecture by proving the fsm is a valid representation for any given integer N.

I'm actually working on it now but I don't know enough about modular arithmetic and predicate logic to write a proof. I just have the state diagrams on some dot matrix paper at the moment.

If anyone wants to beat me to it, feel free.

So for example any number ending in 13, will, after x3+1, end in 40.

Any number ending in 40 will end in 20. Any number ending in 20 will end in 10, which will end in 5 as the unit digit.

It's easier to prove in the single digit case, and the finite state machine for that is already written, at least on paper.

I'll post pictures when I get a chance.

Anyone tried converting speech waveforms to some type of image and then using those as training data for a stable diffusion model?

Hypothetically it should generate "ultrarealistic" waveforms for phonemes, for any given style of voice. The training labels are naturally the words or phonemes themselves, in text format (well, embedding vectors fwiw)

After that it's a matter of testing text-to-image, which should generate the relevant phonemes as images of waveforms (or your given visual representation, however you choose to pack it)

I would have tried this myself but I only have 3gb vram.

Even rudimentary voice generation that produces recognizable words from text input, would be interesting to see implemented and maybe a first for SD.

In other news:
Implementing SQL for an identity explorer. Basically the system generates sets of values for given known identities, and stores the formulas as strings, along with the values.
For any given value test set we can then cross reference to look up equivalent identities. And then we can test if these same identities hold for other test sets of actual variable values. If not, the identity string cam be removed, or gophered elsewhere in the database for further exploration and experimentation.

I'm hoping by doing this, I can somewhat automate the process of finding identities, instead of relying on logs and using the OS built-in text search for test value (which I can then look up in the files that show up, and cross reference the logged equations that produced those values), which I use to find new identities.

I was even considering processing the logs of equations and identities as some form of training data perhaps for a ML system that generates plausible new identities but that's a little outside my reach I think.

Finally, now that I know the new modular function converts semiprimes into numbers with larger factor trees, I'm thinking of writing a visual browser that maps the connections from factor tree to factor tree, making them expandable and collapsible, andallowong adjusting the formula and regenerating trees on the fly.

When I commented that that there may be non-euclidean equivalents to certain stat functions (average, mean, mode, etc), apparently there were others out there with the same general idea.

Some guys over at stanford are exploring hyperbolic spaces for machine learning, which is exactly the sort of applications I had in mind.

Very fascinating work, go check it out if it's something that interests you..
https://dawn.cs.stanford.edu/2019/...

And the related paper that it is based on:
http://proceedings.mlr.press/v80/...

Managed to derive an inverse to karatsuba's multiplication method, converting it into a factorization technique.

Offers a really elegant reason for why non-trivial semiprimes (square free products) are square free.

For a demonstration of karatsubas method, check out:
https://getpocket.com/explore/item/...

Now for the reverse, like I said something elegant emerges.

So we can start by taking the largest digit in our product. Lets say our product is 697.

We find all the digits that produce 6 when summed, along with their order.

thats (1,5), (5,1), (2,4), (4,2), and (3,3)

That means for one of our factors, its largest digit can ONLY be 1, 5, 2, 4, or 3.

Lets take karatsubas method at step f (in the link) and reverse it. Instead of subtracting, we're adding.

If we assume (3,3)

Then we take our middle digit of our product p, in this case the middle digit of 697. is 9, and we munge it with 3.

Then we add our remaining 3, and our remaining unit digit, to get 3+39+7 = 49.

Now, because karatsuba's method ONLY deals with multiplication in single digits, we only need to consider *at most* two digit products.
And interestingly, the only factors of 49 are 7.
49 is a square!

And the only sums that produce 7, are (2,5), (5,2), (3,4), and (4,3)

These would be the possible digits of the factors of 697 if we initially chose (3,3) as our starting point for calculating karatsubas inverse f step.
But you see, 25 can't be a factor of p=697, because 25 is a square, and ends in a 5, so its clearly not prime. 52 can't be either because it ends in 2, likewise 34 ending in 4.
Only 43 could be our possible factor of p.

And we *only* get one factor because our starting point has two of the same digit. Which would mean p would have to equal 43 (a prime) or 1. And because p DOESNT (it equals 697), we can therefore say (3,3) is the wrong starting point, as are ALL starting points that share only one digit, or end in a square.

Ergo we can say the products of non-squares, are specifically non-prime precisely because if they *were* prime, their only factors would HAVE to be themselves, and 1.

For an even BETTER explanation go try karatsuba's method with any prime as the first factor, and 1 as the second factor (just multiply the tens column by zero). And you can see why the inverse, where you might try a starting point that has two matching digits (like 3,3), would obviously fail, because the values it produces could only have two factors; some prime thats not our product, or the value one, which is also not our product.

It's elegant almost to the level of a tautology.

Anyone know of a machine learning library for python, that supports Decimal module?

Two big moments today:

1. Holy hell, how did I ever get on without a proper debugger? Was debugging some old code by eye (following along and keeping track mentally, of what the variables should be and what each step did). That didn't work because the code isn't intuitive. Tried the print() method, old reliable as it were. Kinda worked but didn't give me enough fine-grain control.

Bit the bullet and installed Wing IDE for python. And bam, it hit me. How did I ever live without step-through, and breakpoints before now?

2. Remember that non-sieve prime generator I wrote a while back? (well maybe some of you do). The one that generated quasi lucas carmichael (QLC) numbers? Well thats what I managed to debug. I figured out why it wasn't working. Last time I released it, I included two core methods, genprimes() and nextPrime(). The first generates a list of primes accurately, up to some n, and only needs a small handful of QLC numbers filtered out after the fact (because the set of primes generated and the set of QLC numbers overlap. Well I think they call it an embedding, as in QLC is included in the series generated by genprimes, but not the converse, but I digress).
nextPrime() was supposed to take any arbitrary n above zero, and accurately return the nearest prime number above the argument. But for some reason when it started, it would return 2,3,5,6...but genprimes() would work fine for some reason.

So genprimes loops over an index, i, and tests it for primality. It begins by entering the loop, and doing "result = gffi(i)".
This calls into something a function that runs four tests on the argument passed to it. I won't go into detail here about what those are because I don't even remember how I came up with them (I'll make a separate post when the code is fully fixed).

If the number fails any of these tests then gffi would just return the value of i that was passed to it, unaltered. Otherwise, if it did pass all of them, it would return i+1.

And once back in genPrimes() we would check if the variable 'result' was greater than the loop index. And if it was, then it was either prime (comparatively plentiful) or a QLC number (comparatively rare)--these two types and no others.

nextPrime() was only taking n, and didn't have this index to compare to, so the prior steps in genprimes were acting as a filter that nextPrime() didn't have, while internally gffi() was returning not only primes, and QLCs, but also plenty of composite numbers.

Now *why* that last step in genPrimes() was filtering out all the composites, idk.

But now that I understand whats going on I can fix it and hypothetically it should be possible to enter a positive n of any size, and without additional primality checks (such as is done with sieves, where you have to check off multiples of n), get the nearest prime numbers. Of course I'm not familiar enough with prime number generation to know if thats an achievement or worthwhile mentioning, so if anyone *is* familiar, and how something like that holds up compared to other linear generators (O(n)?), I'd be interested to hear about it.

I also am working on filtering out the intersection of the sets (QLC numbers), which I'm pretty sure I figured out how to incorporate into the prime generator itself.

I also think it may be possible to generator primes even faster, using the carmichael numbers or related set--or even derive a function that maps one set of upper-and-lower bounds around a semiprime, and map those same bounds to carmichael numbers that act as the upper and lower bound numbers on the factors of a semiprime.

Meanwhile I'm also looking into testing the prime generator on a larger set of numbers (to make sure it doesn't fail at large values of n) and so I'm looking for more computing power if anyone has it on hand, or is willing to test it at sufficiently large bit lengths (512, 1024, etc).

Lastly, the earlier work I posted (linked below), I realized could be applied with ECM to greatly reduce the smallest factor of a large number.
If ECM, being one of the best methods available, only handles 50-60 digit numbers, & your factors are 70+ digits, then being able to transform your semiprime product into another product tree thats non-semiprime, with factors that ARE in range of ECM, and which *does* contain either of the original factors, means products that *were not* formally factorable by ECM, *could* be now.

That wouldn't have been possible though withput enormous help from many others such as hitko who took the time to explain the solution was a form of modular exponentiation, Fast-Nop who contributed on other threads, Voxera who did as well, and support from Scor in particular, and many others.
Thank you all. And more to come.

Links mentioned (because DR wouldn't accept them as they were):
https://pastebin.com/MWechZj9

I have not remotely had the energy to post here. Nor reply. And it is a shame because most of you I consider friends. And if not friends, at least excellent aquitances.

People make comments, I dont reply. People make threads, and I dont respond. People make ++s, and I'm a ghost.

I enjoyed shitposting, and asking questions, and hopefully entertaining some of you. I really do.

I'm just in a funk where nothing seems to matter right now and I dont know why, pr how to get out of it.

I have threads, and responses from scor, nanos, nachoscode, and a dozen others I usually enjoy interacting with and it's like all the life has just been sucked right out of me.

I feel isolated and alienated from everything and everyone and I dont know why or when it started. Its just..there. nor how to talk about it.

I think I'm becoming a misanthrope or something. The more I go on with this sensation, the less I want to be around people, and I dont understand why.

Seen some screenshots of Notion. It's like airtable meets wiki, without dealing with markup.
It's very clean, and their use of templates is very intuitive, as is creating new templates.

Their offerings, even for new users, are also very generous.

Anyone used notion and if so, what did you think of it?

Maybe I'm severely misunderstanding set theory. Hear me out though.

Let f equal the set of all fibonacci numbers, and p equal the set of all primes.

If the density of primes is a function of the number of *multiples* of all primes under n,
then the *number of primes* or density should shrink as n increases, at an ever increasing rate
greater than the density of the number of fibonacci numbers below n.

That means as n grows, the relative density of f to p should grow as well.
At sufficiently large n, the density of p is zero (prime number theorem), not just absolutely, but relative to f as well. The density of f is therefore an upper limit of the density of p.

And the density of p given some sufficiently large n, is therefore also a lower limit on the density of f.

And that therefore the density of p must also be the upper limit on the density of the subset of primes that are Fibonacci numbers.

WHICH MEANS at sufficiently large values of n, there are either NO Fibonacci primes (the functions diverge), and therefore the set of Fibonacci primes is *finite*, OR the density of primes given n in the prime number theorem
*never* truly reaches zero, meaning the primes are in fact infinite.

Proving the Fibonacci primes are infinite, therefore would prove that the prime number line ends (fat chance). While proving the primes are infinite, proves the Fibonacci primes are finite in quantity.

And because the number of primes has been proven time and again to be infinite, as far back as 300BC,the Fibonacci primes MUST be finite.

QED.

If I've made a mistake, I'd like to know.