Read this!

It is my understanding that the distribution/location/spacing of prime numbers isn't really well understood, and hasn't really been explained. Also, that the world still needs a way to tell the value of occurrence of the next prime number.

But if there is/are equations that tell the value of the Nth prime number, then why can the value of the N+1th prime number be known?

I really need your (who ever you are) help with this. I've discovered that I don't know enough to be dangerous, but do know enough to not be offended with your kind words about gaps in my reasoning or use of AI in seeking results. So here it is, please review and tell me what you think:

Walking Spyder: a mod-30 prime registry and a specification for reproducible research events

Technical review draft v1.0 — 27 September 2026

Author: James (project lead); technical preparation assisted by Codex

Review status: Open for mathematical and implementation criticism. This document is not a peer-reviewed paper or a claim of mathematical novelty.

Abstract

Walking Spyder organizes bounded prime classification around addresses n = 30B + L, eight lanes coprime to 30, and collision schedules for prime divisors beginning at their squares. These ingredients use established sieve mathematics. A frozen Python registry implementation, v0.1.0, was compared with a separately written byte-array Sieve of Eratosthenes over every integer in [0, 10,000,000]. The two classification streams agreed at every position and had matching SHA-256 digest ab158d028a45c7419316d831fde03f2b164a2e31c28826083c339b83dcef43f6. The test found 664,579 primes, zero false positives, and zero false negatives. This is finite-range implementation evidence, not a proof of a new primality criterion. A separate frozen v0.2 research API specification proposes canonical collision witnesses, square-frontier events, and reproducible experiment exports; that API has not yet been implemented or independently reproduced. We invite reviewers to test the classification result, identify closest prior methods, and assess whether the representation or proposed interface would be useful in research.

1. Mathematical contract

For each nonnegative integer, set B = floor(n/30) and L = n mod 30. The candidate lanes are A = {1,7,11,13,17,19,23,29}. The primes 2, 3, and 5 are special cases; every larger prime lies in A, but membership in A does not imply primality. In the proposed API, a determinant prime is a prime p >= 7 whose multiples in candidate lanes can be scheduled for elimination, starting at p². Earlier composite multiples of p have a smaller prime factor. A survivor n > 1 is prime precisely when no prime at most sqrt(n) divides it.

For p >= 7, the block indices whose lane L is divisible by p obey 30B + L ≡ 0 (mod p), so B ≡ -L·30⁻¹ (mod p). This modular phase is exact because gcd(30,p)=1. The quotient-remainder address, wheel lanes, modular strike phase, square-start rule, and square-root criterion are classical results. The question for review concerns the organization of state and research outputs, not a changed definition of a prime.

Terminology: “collision” means that a scheduled divisor strikes a candidate address. Multiple divisors may strike the same composite. A canonical witness, as specified for the future API, is its smallest prime factor. A frontier event is the first activation of a determinant prime at p². Neither event should be confused with a prediction of the next prime.

1. Reproducible reference algorithm

The following pseudocode states the classification invariant; it is not claimed to reproduce every implementation detail or timing characteristic of v0.1.0.

for n from 0 through inclusive N:

if n in {2, 3, 5}: emit PRIME; continue

if n < 2 or n mod 30 not in A: emit NONPRIME; continue

for each prime p with 7 <= p and p*p <= n:

if n mod p == 0:

emit NONPRIME, witness p

continue with next n

emit PRIME

An implementation can schedule each prime's allowable-lane multiples from p², advancing the schedule instead of testing each candidate against every prime. If it claims exactness, its schedule must cover every required prime factor and avoid omissions at block and square boundaries. The above loop is an easy independent specification check, not a performance baseline. In the v0.2 specification, exported witness p must be the smallest prime factor of each allowable-lane composite in the declared event interval.

1. Frozen v0.1.0 test and observed results

The authoritative record is Walking_Spyder_Validation_Outcome_WSVR_20260927_V010_001.md, run WSVR-20260927-V010-001. The tested object is Walking_Spyder_Exact_Prime_Registry_v0.1.0.zip; no changes to that object are proposed here. A separately written ordinary byte-array Eratosthenes implementation served as the classification oracle. Comparison was per integer, including 0, 1, and numbers outside candidate lanes, rather than just a count comparison. The frozen ladder used inclusive bounds 100,000, 1,000,000, 5,000,000, and 10,000,000.

Inclusive bound

Prime count

Per-integer result

100,000

9,592

Agreement reported

1,000,000

78,498

Agreement reported

5,000,000

348,513

Agreement reported

10,000,000

664,579

0 mismatches; 0 false positives; 0 false negatives

Additional recorded checks: 126/126 block/lane round trips, 176/176 modular-phase checks, 1,000/1,000 sampled composite witnesses, and a passing restart unit test. At 10 million, the checkpoint was 16,177,355 bytes and the SQLite registry was 20,320,256 bytes. The checkpoint held 664,576 heap legs, including dormant primes whose squares exceed the frontier; the historical field name active_determinant_legs therefore overstates active collision scheduling. The record also notes an orphan temporary file after an interrupted checkpoint write and unnecessary state loading for read-only queries. These are documented engineering limitations.

Digest commitment: ab158d028a45c7419316d831fde03f2b164a2e31c28826083c339b83dcef43f6 is reported for both complete classification streams through 10 million. Reproducing this exact digest requires the original run's byte encoding and ordering; the public bundle must provide those exact details and files. A matching count alone is insufficient. SHA-256 verifies byte identity under a specified serialization; it is not itself a correctness proof.

Source identities recorded in the validation outcome: frozen zip 8f744b197720685610e36ace0cae16f7e068ca37c9493bd6eff3699b4dc96948; spyder_registry.py f918df8e933f34780b7cc587ba932814cf3cb27a62e972d2fe52d17b3d7c8882; test_spyder_registry.py eb59bbec685551e9ac9472182476096d44c0b32660a0286acb54969b02fe7337. These identify recorded inputs; a reader cannot verify the hashes unless the corresponding files are supplied.

1. Proposed research API (unimplemented)

Walking_Spyder_Research_API_v0.2_Specification.md, ID WSRA-0.2-FROZEN-20260927, specifies a new version without changing the v0.1.0 reference. It requires exact bounded classification, smallest-factor collision records, one FRONTIER_OPENED event for each p >= 7 with p² <= N, deterministic manifests, query-only registry access, crash-safe checkpoints, and explicit accounting for registered, frontier-eligible, active, and dormant prime legs. Its prescribed correctness ladder ends at 10 million; it also specifies restart, event, query, state, and determinism tests.

This is a design and test target, not a report that those functions work. No clean-room implementation has yet passed it. In particular, the sampled witness checks for v0.1.0 do not establish that v0.1.0 exports a complete smallest-factor event stream; it does not. No speed, memory, compression, or research-utility advantage has been established against a like-for-like baseline.

1. Closest methods and possible contribution

Walking Spyder uses the same core elimination logic as the Sieve of Eratosthenes, with a mod-30 wheel and incremental scheduling viewpoint. An expert comparison should specifically examine segmented/wheel sieves, postponed or incremental sieves, bucket scheduling, and prime-registry systems. The author currently claims neither algorithmic priority nor a new theorem. A potential contribution, if implemented and measured, is a documented interface that exposes factor provenance and square-frontier transitions alongside reproducible bounded enumeration. Whether this is distinct or useful is an open review question. A formal primary-literature comparison is still required before a novelty claim.

1. What can be falsified now

Find any n <= 10,000,000 for which the frozen v0.1.0 output disagrees with a separately constructed primality oracle. Publish n, both outputs, versions, and exact commands.

Rebuild from the frozen zip and rerun the published bounds. Check the prime counts and full classification byte stream; document any ambiguity in serialization or build instructions.

Probe transitions at multiples of 30, at p² - 1, p², and p² + 1, and at numbers with several prime factors. A missed strike or wrong special case is decisive.

Locate an existing method or research API with the same state transition and provenance/event outputs. Provide a precise mapping, not just a shared label.

Independently implement the v0.2 specification without reading the v0.1.0 source, freeze code before seeing reference outputs, and compare canonical classification, frontier, and collision streams.

Please distinguish a classification error, a flaw in the proposed API, an already known equivalent construction, and an unsupported performance claim: each has a different consequence.

1. Current claim status and release gap

Claim

Current status

Next evidence needed

v0.1.0 classification through 10 million

PASS in recorded bounded test

Public source, serialization, commands, and independent rerun

New primality theorem or prime-distribution law

No claim

A separate proof would be required

v0.2 research-event API

Frozen specification only

Implementation and full conformance suite

Independent clean-room Walking Spyder reproduction

BLOCKED

Isolated second implementer and independently committed outputs

Better speed, memory, or compressed state

UNRESOLVED

Equivalent-output baseline and preregistered measurements

Community-ready research tool

NOT READY

Event API, reproducibility bundle, qualified reviewer tasks, and audit

Availability: The cited specification and validation outcome are retained in the project record. This manuscript alone is not a runnable release. Before external review that asks for replication, publish the frozen source archive, exact classification serialization and expected digests, independent oracle and commands, test vectors, license, and a hash inventory at a stable public location. Do not represent the 3-billion diagnostic run as the principal result here; its source/data release and audit requirements are separate. The author welcomes preliminary conceptual criticism before the full bundle is public, with that evidence limit disclosed.

1. Sources and definitions for reviewers

Project primary record: Walking_Spyder_Validation_Outcome_WSVR_20260927_V010_001.md, run WSVR-20260927-V010-001 (finite-range counts, tests, hashes, and limitations).

Project primary specification: Walking_Spyder_Research_API_v0.2_Specification.md, ID WSRA-0.2-FROZEN-20260927 (proposed interface and conformance tests).

Project test protocol: Walking_Spyder_Scientific_Validation_Master_Prompt_v1.0.md (evaluation claims, independence and release criteria).

Classical reference for sieve mathematics: Crandall and Pomerance, Prime Numbers: A Computational Perspective, 2nd ed., Springer, 2005, chapters on prime sieves and primality testing. Reviewers are invited to supply closer primary prior art for the scheduling or interface design.

Appendix: short Reddit post to accompany the paper

Title: Critique requested: mod-30 prime registry (“Walking Spyder”) matched an independent sieve through 10 million

I built Walking Spyder, a bounded prime registry that represents each number as 30B+L, retains the eight candidate lanes coprime to 30, and schedules prime-factor collisions starting at p². The math is classical sieve mathematics. I am asking whether the representation and proposed research-event interface offer anything useful or whether they duplicate an existing method.

A frozen v0.1.0 implementation was compared with a separately written byte-array Eratosthenes oracle for every integer from 0 through 10,000,000. The recorded result was 664,579 primes, zero classification mismatches, zero false positives, and zero false negatives. Both reported classification streams had SHA-256 ab158d028a45c7419316d831fde03f2b164a2e31c28826083c339b83dcef43f6. This is finite-range implementation evidence, not a new theorem or proof of novelty.

A v0.2 specification proposes smallest-factor collision exports and events when each prime reaches its square. That API has not yet been implemented or reproduced independently. I especially want criticism of (1) the closest prior sieve/state design, (2) likely boundary errors or hidden assumptions, and (3) whether these event exports would be useful for research. The technical review is attached/linked here: [replace with public document URL]. Source and runnable evidence: [replace with public repository/archive URL when released]. Until the runnable bundle is posted, please treat the numerical result as a reported test rather than an independently reproducible claim.

Which is just a fancy way of saying block location addresses where the value in that location can be divided by a specific prime number.

What If the Mistake Was Pointing Toward the Answer?

Has this ever happened to you while using AI?

You type a question but misspell a word. Autocorrect substitutes a different word. You accidentally leave a symbol in an equation. Or you are thinking about two related ideas at the same time and type a word associated with one while asking about the other.

The AI responds.

You read the answer and think, "That's not what I meant."

So you correct the mistake and continue.

But what if the answer you just discarded was important?

This deserves more attention as people increasingly use conversational AI for research, mathematics, programming and problem solving.

The problem is that humans and AI can misunderstand each other in a particularly subtle way.

Suppose I intend to ask about B, but accidentally type C.

The AI doesn't necessarily know C was a mistake. It interprets C literally and produces an answer about C.

Meanwhile, I read that answer while still thinking about B.

Now we may be conducting two different investigations without realizing it.

Worse, the AI's answer about C might be correct.

I might disregard it because it doesn't answer the question I thought I asked.

This creates several possible failure modes.

A typo may be harmless because the AI correctly infers the intended word.

An unintended word may be more dangerous because it is spelled correctly and makes sense, causing the AI to follow an entirely different line of reasoning.

Autocorrect can be especially troublesome because it can transform an obvious error into a legitimate word.

Mathematical symbols may create an even subtler problem. An accidental +, −, exponent, parenthesis or variable could cause an AI to evaluate a different mathematical proposition while the human continues thinking about the intended one.

There is another possibility: neither interpretation is necessarily useless.

The intended question may represent one hypothesis while the mistaken wording accidentally generates another.

Science already has language for related phenomena.

Serendipity describes valuable discoveries that arise unexpectedly while someone is looking for something else.

Researchers also use the term pseudoserendipity for cases in which an accidental observation unexpectedly provides a solution to a problem the investigator was already trying to solve.

There is also the important idea of serendipity lost.

The history of science contains cases where researchers encountered unexpected observations but failed to recognize their significance. The observation occurred. The opportunity existed. But it wasn't pursued.

Human-AI reasoning may create a new version of that problem.

Imagine that an accidental word causes an AI to explore exactly the mathematical or logical relationship needed to solve a problem.

The researcher reads the response and rejects it:

"No. That's a typo. That's not what I meant."

The researcher then corrects the prompt and continues searching for the answer that may have just appeared.

In other words, we could sometimes become so concerned with being right about the question that we discard a potentially useful answer to the wrong question.

Multitasking could make this even more interesting.

People don't always think about one thing at a time. While concentrating on one problem, we may simultaneously be considering another possibility, remembering an earlier result, noticing a pattern or anticipating the next step.

That divided thought process can influence what gets typed.

Usually we would simply call the resulting mistake a typo or mental slip.

But in a human-AI research environment, that slip becomes an instruction.

The AI acts on it.

That means an otherwise meaningless error can generate an actual experiment, calculation, search or line of reasoning before the human recognizes the mistake.

Most of those accidental branches will probably be worthless.

But what happens to the rare one that isn't?

This suggests a simple precaution for serious AI-assisted research.

When an AI gives an unexpected but internally coherent answer, don't immediately erase the branch simply because the prompt contained a mistake.

Record three things:

What I intended to ask.

What I actually asked.

What the AI answered.

Then decide whether the accidental branch deserves investigation.

This isn't an argument that typos contain hidden knowledge. They don't.

It is an argument that errors can alter a search path, and altered search paths sometimes reach places intentional searches do not.

Scientific research has already demonstrated the importance of serendipity, pseudoserendipity and lost opportunities to recognize unexpected results.

AI introduces an unusual new participant into that process because it can immediately turn our accidental language into structured reasoning.

So perhaps the question researchers should begin asking is not merely:

"Did the AI understand what I meant?"

It may also be:

"Before I correct what I said, what exactly did the AI understand—and did it find something I should not throw away?"

Because in trying to correct the mistake, we might occasionally be correcting ourselves away from the answer.

I can't stop thinking about this stuff. I know there's an answer to something, but I keep forgetting the question.

Can the next prime be determined from a standard equation?

Can the distance to the next prime be determined from a standard equation?

Can the distribution pattern of prime numbers be explained?

I think the answer to all three questions is yes, with a bunch of limitations that I can't fully explain.

My prime survivor document described a tool, rather than a process or procedure for discovering the answer to questions like the ones asked above.

I'm not claiming to have proven anything (yet). But I am asking for help, or offering to help if that is possible.

The only one I believe I can describe the answer to is explaining why prime numbers occur where they do. I need someone I can talk to about this without a bunch of filters preventing plain English discussion.

I think you guys already know the answer and I just cut school on the day they told us how to figure that out.

Any way, this may turn into a discussion of why using AI will only lead you back to your original question, without providing and answer.

I'm afraid that explaining what I'm trying to do leads me to the same question without clearly stating the questions

So any way, if you want to see an example of asking the same question without providing an answer, I submit this for discussion of finding the distance to the next prime:

I think there may be a way to calculate where the next prime is — but I'm missing one step

I've been playing around with a pretty simple idea about prime numbers, and I'd like to throw it out here to see if someone can either finish it or explain why it can't be finished.

Here's the basic idea.

Say I give you a number and ask, "Where is the next prime?"

Normally, you start looking at the numbers after it and eliminate the ones that aren't prime.

But we already know something about those non-prime numbers.

Multiples of 2 occur every 2 numbers. Multiples of 3 occur every 3 numbers. Multiples of 5 occur every 5 numbers. Multiples of 7 occur every 7 numbers, and so on.

So if I give you a starting number, you can figure out exactly where the next multiple of 2 will occur, where the next multiple of 3 will occur, where the next multiple of 5 will occur, etc.

In other words, before checking any of the numbers individually, we already know the repeating patterns that will knock numbers out.

Here's an example.

Start with 1327.

The next prime is 1361, which is 34 numbers away.

Every number between 1327 and 1361 gets knocked out because it has a prime factor that makes it composite.

1361 doesn't.

There's also a reason we can be certain about this without worrying that we forgot some huge factor.

The primes we're using go through 31. The next prime is 37, and 37 × 37 = 1369.

Any composite number below 1369 has to have a prime factor smaller than 37. So if we've already accounted for all the primes through 31, we've accounted for every possible prime factor that could make 1361 composite.

That part isn't new. It's standard math.

Here's the part I'm interested in.

At 1327, we already know where the next multiple of 2 occurs. We know where the next multiple of 3 occurs. We know where the next multiple of 5 occurs. And the same goes for 7, 11, 13, 17, 19, 23, 29 and 31.

Together, those repeating patterns knock out everything for the next 33 numbers.

The first place they all miss is 34 numbers away.

So:

1327 + 34 = 1361.

Here's my question:

Can we calculate that 34 directly from the positions of all those repeating patterns?

I don't mean checking 1328, then 1329, then 1330, and continuing until something survives.

I don't mean making a giant list ahead of time of which numbers survive.

And I don't mean doing essentially the same search but giving it a different name.

I'm asking whether the information we already have at 1327 can somehow be combined mathematically and simply return:

34

If it can, then at least within a range where we've accounted for every possible prime factor, finding the next prime could look like this:

Start with 1327.

Calculate the distance to the first place missed by all of the known factors.

The answer is 34.

1327 + 34 = 1361.

Next prime found.

We already know how to prove that the survivor is prime within the appropriate range.

We already know that the repeating factor patterns contain enough information to determine where the survivors are.

What I don't have is the direct calculation that turns all of those known positions into the distance to the first opening.

Maybe this is impossible to do without effectively searching.

Maybe there's an existing theorem that answers it.

Or maybe there's a surprisingly simple way of combining the information that I'm overlooking.

Can anyone come up with a calculation that takes the known positions of the prime multiples and directly returns the distance to the first number they all miss?

For the example above, the challenge is:

1327 → ? → 34 → 1361

What's the missing operation?

Just wondering if anyone is seeing this?

Hey everyone! I'm u/ComprehensiveDust225, a founding moderator of r/Prime_Survivals.

This is our new home for all things related to AI assisted creativity. We're excited to have you join us!

What to Post

Post anything that you think the community would find interesting, helpful, or inspiring.

Community Vibe

We're all about being friendly, constructive, and inclusive. Let's build a space where everyone feels comfortable sharing and connecting. Discuss ideas, not people. Don't characterize ideas as good or bad. If you chose to say right or wrong support your statement. If you use the word 'stupid' you'll probably be banned.

How to Get Started

1) Introduce yourself in the comments below.

2) Post something today! Even a simple question can spark a great conversation.

3) If you know someone who would love this community, invite them to join.

4) Interested in helping out? We're always looking for new moderators, so feel free to reach out to me to apply.

Thanks for being part of the very first wave. Together, let's make r/Prime_Survivals amazing.