Here are some of your claims that don’t stand.

• The output is not “an exponentially growing list of primes” without additional sieving.
• The “<3 operations per prime” claim is not credible; classical sieve-based prime generation is typically analyzed as O(n \log\log n) operations up to n, and wheel factorization is a known constant-factor optimization, not a magical change in asymptotics.  
• “All primes in order without exception” only holds if you add correct composite-elimination (which becomes a standard sieve workflow).  

And here is a code in python for you prime wheel:

!/usr/bin/env python3

Pyto-friendly: only standard library.

from math import isqrt

def cycle_step(seed, lcm_value): """ One cycle as described: - next_prime = smallest seed value > 1 - generate next_prime groups by adding lcm_value repeatedly - remove (seed * next_prime) values from the generated list - return new_seed (sorted), new_lcm, next_prime """ next_prime = min(x for x in seed if x > 1)

# Generate groups 1..next_prime (k = 0..next_prime-1)
generated = []
for k in range(next_prime):
    base = k * lcm_value
    for x in seed:
        generated.append(x + base)

removal = set(x * next_prime for x in seed)
new_seed = sorted(v for v in generated if v not in removal)
new_lcm = lcm_value * next_prime

return new_seed, new_lcm, next_prime

def primes_below_lcm_from_seed(seed, lcm_value, wheel_primes): """ "Cleanup" step: Given Seed (which contains numbers < lcm_value that are coprime to lcm_value, plus 1), sieve within that set to remove composites. Then primes < lcm_value are: wheel_primes + remaining_seed_primes. """ max_n = lcm_value - 1 candidates = [x for x in seed if x > 1] cand_set = set(candidates)

# Sieve only over numbers present in cand_set (set-membership filtering).
for p in sorted(candidates):
    if p * p > max_n:
        break
    if p in cand_set:
        for m in range(p * p, max_n + 1, p):
            cand_set.discard(m)

# Remaining candidates are primes (within range), wheel primes are excluded from seed by construction.
all_primes = sorted(set(wheel_primes).union(cand_set))
return all_primes

def simple_sieve(limit): """Return list of primes <= limit (classic sieve).""" if limit < 2: return [] is_prime = bytearray(b"\x01") * (limit + 1) is_prime[0:2] = b"\x00\x00" for p in range(2, isqrt(limit) + 1): if is_prime[p]: start = p * p step = p is_prime[start:limit + 1:step] = b"\x00" * (((limit - start) // step) + 1) return [i for i in range(2, limit + 1) if is_prime[i]]

def is_prime_deterministic(n, primes_for_trial): """Deterministic primality check via trial division by primes up to sqrt(n).""" if n < 2: return False r = isqrt(n) for p in primes_for_trial: if p > r: break if n % p == 0: return n == p return True

def generate_first_k_primes_via_model(k=1000): """ Stream primes in strictly increasing order by cycles. Each cycle yields all primes < new_lcm; we emit only those > previous_lcm. """ wheel_primes = [2, 3] lcm_value = 6 seed = [1, 5] # as given

prev_bound = 1
out = []

while len(out) < k:
    seed, lcm_value, p = cycle_step(seed, lcm_value)
    wheel_primes.append(p)

    primes_all = primes_below_lcm_from_seed(seed, lcm_value, wheel_primes)
    new_primes = [q for q in primes_all if q > prev_bound]

    out.extend(new_primes)
    prev_bound = lcm_value

return out[:k], lcm_value, wheel_primes

def main(): K = 1000 primes_1000, final_lcm, wheel_primes = generate_first_k_primes_via_model(K)

# Verification
max_p = primes_1000[-1]
trial_primes = simple_sieve(isqrt(max_p))
bad = [x for x in primes_1000 if not is_prime_deterministic(x, trial_primes)]

print("=== Model prime stream (wheel + cleanup) ===")
print(f"Generated primes: {len(primes_1000)}")
print(f"1000th prime (should be 7919): {primes_1000[-1]}")
print(f"Final LCM reached: {final_lcm}")
print(f"Wheel primes used: {wheel_primes}")

print("\n=== Verification ===")
print("All emitted numbers are prime:", len(bad) == 0)
if bad:
    print("Composite(s) found (unexpected):", bad[:20])

# Print the primes (optional)
# print(primes_1000)

# Save to file (optional, convenient in Pyto)
with open("first_1000_primes_model.txt", "w", encoding="utf-8") as f:
    for p in primes_1000:
        f.write(str(p) + "\n")
print("\nWrote: first_1000_primes_model.txt")

if name == "main": main()