rulerpack 0.2.1__py3-none-any.whl

rulerpack/__init__.py

@@ -0,0 +1,38 @@
+"""rulerpack: XOR rulers over the primes, and the pack that rides on them.
+
+    >>> import rulerpack as rp
+    >>> N = rp.pack(78501, 1000039)
+    >>> rp.unpack(N)
+    (78501, 1000039)
+
+Families of ruler, each a Mersenne ladder scaled by a power of two:
+
+    rp.RP(i)           (4i) ^ (4i+7)            7, 15, 7, 31, ...   the original
+    rp.ruler(i, L, c)  ((Li) ^ (Li+cL+1)) ^ 1   the general form
+    rp.R257(i)         L=4,   c=64              256 * ladder(i >> 6)
+    rp.R513(i)         L=256, c=2               512 * ladder(i >> 1)
+
+Pack family (L, c, M): K = 2p ^ ruler, X = 2p ^ Li, N = K*M + X.
+Decode is mod, div, two XORs. No search, no primality, no table.
+"""
+
+from .primes import primes_first, primes2, seeds, allowed, leftovers, isprime, wheel_pass, wheel_report
+from .rulers import v2, ladder, RP, rp_xor1, ruler, R257, R513, key, topo, R896, carry, slide512, unslide512, slide_repeats
+from .pack import (Family, F257, F513, DEFAULT, encode, decode, pack, unpack,
+                   encode_array, decode_array)
+from .build import build_kx, sweep
+from .marks import Marks, LiveMarks
+from .window import window, window_deep, residues_mod, any_prime_after, worker_pool, close_pools, ranked_window, RANK_KEYS, xor_additive, xor_additive_bits, gap_profile, squeeze_order, seeds_for, seed_depth, window_width, next_prime_after, next_prime_after_parallel, jfilter, primes_between, indexed_after, hinted_next, hint_of, hinted_family, hint_from_x, primes_from_x, hints_from_x, hint_walk
+from . import experiments
+from .count import primepi_sieve, phi, primepi_legendre, primepi_meissel, primepi, index_of, li, li_inverse, riemann_r, riemann_r_inverse, nth_prime, primepi_primecount, primepi_fastest
+
+__version__ = "0.2.1"
+__all__ = [
+    "experiments",
+    "primes_first", "primes2", "seeds", "allowed", "leftovers", "isprime", "wheel_pass", "wheel_report",
+    "v2", "ladder", "RP", "rp_xor1", "ruler", "R257", "R513", "key", "topo", "R896", "carry", "slide512", "unslide512", "slide_repeats",
+    "Family", "F257", "F513", "DEFAULT", "encode", "decode", "pack", "unpack",
+    "encode_array", "decode_array",
+    "build_kx", "sweep", "Marks", "LiveMarks", "window", "window_deep", "residues_mod", "any_prime_after", "worker_pool", "close_pools", "ranked_window", "RANK_KEYS", "xor_additive", "xor_additive_bits", "gap_profile", "squeeze_order", "seeds_for", "seed_depth", "window_width", "next_prime_after", "next_prime_after_parallel", "jfilter", "primes_between", "indexed_after", "hinted_next", "hint_of", "hinted_family", "hint_from_x", "primes_from_x", "hints_from_x", "hint_walk",
+    "primepi_sieve", "phi", "primepi_legendre", "primepi_meissel", "primepi", "index_of", "li", "li_inverse", "riemann_r", "riemann_r_inverse", "nth_prime", "primepi_primecount", "primepi_fastest",
+]

rulerpack/build.py

@@ -0,0 +1,56 @@
+"""Sequential builders and the window sweep."""
+
+import numpy as np
+
+from .primes import allowed
+from .rulers import RP
+
+
+def build_kx(n):
+    """Build (L, K, X) step by step from the seed rule, with RP and 4i.
+    K = L ^ RP ^ 1, X = L ^ 4i. Asserts K ^ X == RP ^ 1 ^ 4i at every step."""
+    L, K, X = [], [], []
+    h = 1
+    for i in range(n):
+        if i == 0:
+            c = 4
+        else:
+            while True:
+                h += 2
+                if allowed(h):
+                    break
+            c = 2 * h
+        r = RP(i)
+        ar = 4 * i
+        k = c ^ r ^ 1
+        x = c ^ ar
+        assert k ^ x == r ^ 1 ^ ar
+        L.append(c); K.append(k); X.append(x)
+    return (np.array(L, dtype=np.int64), np.array(K, dtype=np.int64),
+            np.array(X, dtype=np.int64))
+
+
+def sweep(P, step=None, use_sieve=True, prime_test=None):
+    """Walk odd candidates past the seed rule. With step, also require
+    h % step == P[i] % step (lookup mode). With prime_test (e.g. rp.isprime),
+    a candidate that fails it is rejected ("nah, next one") and counted.
+
+    Returns (index, built, true, rejected) at the first wrong-index hit,
+    or (None, rejected) if every prime in P is reproduced."""
+    h = 1
+    rejected = 0
+    for i in range(1, len(P)):
+        true = int(P[i])
+        while True:
+            h += 2
+            if not allowed(h, use_sieve):
+                continue
+            if step and h % step != true % step:
+                continue
+            if prime_test is not None and not prime_test(h):
+                rejected += 1
+                continue
+            break
+        if h != true:
+            return i, h, true, rejected
+    return None, rejected

rulerpack/cli.py

@@ -0,0 +1,68 @@
+"""rulerpack command line.
+
+    rulerpack 78501 1000039            pack a pair
+    rulerpack 8592468642374094         unpack N
+    rulerpack --check 1000000          round-trip the first n primes
+    rulerpack --ladder 32              show the ladder and both rulers
+    rulerpack --between lo hi          every prime in [lo, hi), sieve started at lo
+    rulerpack --next N                 the closest prime above N
+    options: --ruler 513|257  --shift S
+"""
+
+import sys
+
+from .pack import Family, F513, F257
+from .rulers import ladder, R257, R513, RP
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    fam = F513
+    if "--ruler" in argv:
+        k = argv.index("--ruler")
+        fam = {"513": F513, "257": F257}[argv[k + 1]]
+        del argv[k:k + 2]
+    if "--shift" in argv:
+        k = argv.index("--shift")
+        fam = Family(fam.L, fam.c, int(argv[k + 1]))
+        del argv[k:k + 2]
+    if not argv:
+        print(__doc__)
+        return 0
+    if argv[0] == "--check":
+        n = int(argv[1]) if len(argv) > 1 else 100_000
+        ok, last = fam.check(n)
+        print(f"{n:,} primes, last {last:,}, L={fam.L} c={fam.c} M=2^{fam.shift}: "
+              f"round-trip {'OK' if ok else 'FAILED'}")
+        return 0 if ok else 1
+    if argv[0] == "--between":
+        from .window import primes_between
+        P = primes_between(int(argv[1]), int(argv[2]))
+        print("\n".join(str(int(p)) for p in P))
+        return 0
+    if argv[0] == "--next":
+        from .window import next_prime_after
+        print(next_prime_after(int(argv[1])))
+        return 0
+    if argv[0] == "--ladder":
+        n = int(argv[1]) if len(argv) > 1 else 32
+        print(f"{'i':>4} {'ladder':>7} {'RP':>5} {'R257':>7} {'R513':>7}")
+        for i in range(n):
+            print(f"{i:>4} {ladder(i):>7} {RP(i):>5} {R257(i):>7} {R513(i):>7}")
+        return 0
+    if len(argv) == 2:
+        i, p = int(argv[0]), int(argv[1])
+        K, X = fam.encode(i, p)
+        N = fam.pack(i, p)
+        print(f"i={i} p={p}   (L={fam.L} c={fam.c} M=2^{fam.shift})")
+        print(f"K = {K}\nX = {X}\nN = {N}   ({N.bit_length()} bits)")
+        print(f"unpack(N) = {fam.unpack(N)}")
+        return 0
+    N = int(argv[0])
+    i, p = fam.unpack(N)
+    print(f"N -> i={i} p={p}   (L={fam.L} c={fam.c} M=2^{fam.shift})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rulerpack/count.py

@@ -0,0 +1,292 @@
+"""Prime counting, the forward map: prime in, index out.
+
+Each method is its own function so they can be compared.
+
+    primepi_sieve(x)      count by sieving to x                 O(x)
+    phi(x, a)             Legendre: how many n <= x survive the first a primes
+    primepi_legendre(x)   pi(x) = phi(x, a) + a - 1,  a = pi(sqrt x)
+    primepi_meissel(x)    Legendre with a = pi(cbrt x) and a correction sum
+    primepi(x)            the fastest exact one here (meissel)
+    index_of(p)           zero-based index of prime p, = primepi(p) - 1
+
+All exact. Pure integers plus one numpy sieve table.
+"""
+
+import sys
+from math import isqrt
+
+import numpy as np
+
+from .primes import isprime
+
+
+def _icbrt(x):
+    r = int(round(x ** (1 / 3)))
+    while r ** 3 > x:
+        r -= 1
+    while (r + 1) ** 3 <= x:
+        r += 1
+    return r
+
+
+def _sieve_table(limit):
+    """(primes, pi) with pi[n] = number of primes <= n, for n <= limit."""
+    s = np.ones(limit + 1, dtype=bool)
+    s[:2] = False
+    for q in range(2, isqrt(limit) + 1):
+        if s[q]:
+            s[q * q::q] = False
+    pi = np.cumsum(s, dtype=np.int64)
+    return np.flatnonzero(s).astype(np.int64), pi
+
+
+def primepi_sieve(x):
+    """Count primes <= x by sieving. The slow, obviously-right reference."""
+    x = int(x)
+    if x < 2:
+        return 0
+    return int(_sieve_table(x)[1][x])
+
+
+# Wheel for small a: phi(x, a) is periodic mod the product of the first a primes.
+_WHEEL_A = 7                      # 2*3*5*7*11*13*17 = 510510
+_WPRIMES = [2, 3, 5, 7, 11, 13, 17]
+_WMOD = 510510
+_wheel_mask = np.ones(_WMOD, dtype=bool)
+for _q in _WPRIMES:
+    _wheel_mask[::_q] = False
+_wheel_mask[0] = False
+_WHEEL = np.concatenate(([0], np.cumsum(_wheel_mask, dtype=np.int64)))
+_WHEEL_COUNT = int(_WHEEL[_WMOD])       # survivors per period (96 * 1430... = 92160)
+
+
+def _phi(x, a, primes):
+    if a <= _WHEEL_A:
+        # count n in [1, x] coprime to the first a primes
+        if a == _WHEEL_A:
+            return (x // _WMOD) * _WHEEL_COUNT + int(_WHEEL[x % _WMOD + 1] - _WHEEL[1]) + int(_wheel_mask[0])
+        if a == 0:
+            return x
+        if a == 1:
+            return (x + 1) // 2
+        if a == 2:
+            return (x // 6) * 2 + (1 if x % 6 >= 1 else 0) + (1 if x % 6 >= 5 else 0)
+    raise ValueError("_phi handles a in {0, 1, 2, 7} only")
+
+
+def _make_phi(primes, pi=None):
+    """Legendre recursion phi(x,a) = phi(x,a-1) - phi(x//p_a, a-1) with a memo.
+
+    With a pi table: when p_a^2 > x every survivor of the first a primes is 1 or a
+    prime, so phi(x, a) = pi(x) - a + 1 is read off instead of recursed."""
+    P = [int(p) for p in primes]
+    memo = {}
+    need = len(P) + 1000                      # recursion is one frame per prime
+    if sys.getrecursionlimit() < need:
+        sys.setrecursionlimit(need)
+    limit = len(pi) - 1 if pi is not None else -1
+    pil = pi.tolist() if pi is not None else None
+
+    def phi(x, a):
+        if a <= 2 or (a == _WHEEL_A):
+            return _phi(x, a, P)
+        pa = P[a - 1]
+        if x < pa:
+            return 1
+        if x <= limit and pa * pa > x:
+            return pil[x] - a + 1
+        key = (x, a)
+        v = memo.get(key)
+        if v is None:
+            v = phi(x, a - 1) - phi(x // pa, a - 1)
+            memo[key] = v
+        return v
+    return phi
+
+
+def phi(x, a):
+    """Legendre's phi: how many n in [1, x] have no prime factor among the first a primes."""
+    x, a = int(x), int(a)
+    primes, _ = _sieve_table(max(a * (int(np.log(a + 2)) + 3), 20))
+    while len(primes) < a:
+        primes, _ = _sieve_table(len(primes) * 4 + 100)
+    return _make_phi(primes)(x, a)
+
+
+def primepi_legendre(x):
+    """pi(x) = phi(x, a) + a - 1 with a = pi(sqrt x). Table only to sqrt x."""
+    x = int(x)
+    if x < 2:
+        return 0
+    r = isqrt(x)
+    primes, pi = _sieve_table(r)
+    a = int(pi[r])
+    return _make_phi(primes, pi)(x, a) + a - 1
+
+
+def primepi_meissel(x):
+    """Meissel: a = pi(cbrt x), b = pi(sqrt x).
+    pi(x) = phi(x, a) + a - 1 - sum_{a < i <= b} (pi(x / p_i) - i + 1).
+    Needs pi() up to x^(2/3), from one sieve table."""
+    x = int(x)
+    if x < 2:
+        return 0
+    c = _icbrt(x)
+    r = isqrt(x)
+    primes, pi = _sieve_table(max(x // max(c, 1), r) + 1)
+    a = int(pi[c])
+    b = int(pi[r])
+    ph = _make_phi(primes, pi)
+    total = ph(x, a) + a - 1
+    idx = np.arange(a + 1, b + 1, dtype=np.int64)          # 1-based i, prime p_i = primes[i-1]
+    total -= int(np.sum(pi[x // primes[a:b]] - idx + 1))
+    return total
+
+
+primepi = primepi_meissel
+
+
+def index_of(p):
+    """Zero-based index of prime p in the prime list; raises if p is not prime."""
+    p = int(p)
+    if not isprime(p):
+        raise ValueError(f"{p} is not prime")
+    return primepi(p) - 1
+
+
+# ── the inverse: index in, prime out ─────────────────────────────────────────
+
+def li(x):
+    """Logarithmic integral li(x), the classic estimate of pi(x). Series by Ramanujan."""
+    from math import log, sqrt, exp, factorial
+    x = float(x)
+    if x < 2:
+        return 0.0
+    g = 0.5772156649015329
+    lx = log(x)
+    total = 0.0
+    inner = 0.0
+    for n in range(1, 200):
+        inner += 1 / (2 * ((n - 1) // 2) + 1) if n % 2 == 1 else 0
+        k = (n - 1) // 2
+        s = sum(1 / (2 * j + 1) for j in range(0, k + 1))
+        term = ((-1) ** (n - 1)) * lx ** n / (2 ** (n - 1) * factorial(n)) * s
+        total += term
+        if abs(term) < 1e-17 * abs(total) and n > 10:
+            break
+    return g + log(lx) + sqrt(x) * total
+
+
+def li_inverse(y):
+    """x with li(x) = y, by Newton on li; derivative is 1/ln x."""
+    from math import log
+    y = float(y)
+    if y < 2:
+        return 2.0
+    x = y * log(y) if y > 3 else 3.0
+    for _ in range(60):
+        step = (li(x) - y) * log(x)
+        x -= step
+        if abs(step) < 0.5:
+            break
+    return x
+
+
+_MOBIUS = [0, 1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, 0, 1, 1, -1, 0,
+           0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, 1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0,
+           0, 1, 0, -1, 0, 1, 0, 1, 1, -1, 0]
+
+
+def riemann_r(x):
+    """Riemann's R(x) = sum mu(n)/n * li(x^(1/n)). li minus its sqrt(x) bias; much closer to pi(x)."""
+    x = float(x)
+    s = 0.0
+    for n in range(1, len(_MOBIUS)):
+        m = _MOBIUS[n]
+        if m == 0:
+            continue
+        v = x ** (1.0 / n)
+        if v < 2:
+            break
+        s += m / n * li(v)
+    return s
+
+
+def riemann_r_inverse(y):
+    """x with R(x) = y, Newton from the li inverse."""
+    from math import log
+    y = float(y)
+    if y < 2:
+        return 2.0
+    x = li_inverse(y)
+    for _ in range(50):
+        step = (riemann_r(x) - y) * log(x)
+        x -= step
+        if abs(step) < 0.5:
+            break
+    return x
+
+
+def _walk(x, k):
+    """From integer x, move k primes up (k > 0) or down (k < 0). Returns the prime landed on.
+    k == 0 means the largest prime <= x."""
+    from .primes import allowed
+    n = int(x)
+    if k >= 0:
+        if n % 2 == 0:
+            n -= 1
+        # position on the largest prime <= x first
+        while not (n >= 2 and isprime(n)):
+            n -= 1 if n > 3 else 0
+            if n < 3:
+                n = 2
+                break
+        for _ in range(k):
+            n += 1 if n == 2 else 2
+            while not isprime(n):
+                n += 2
+        return n
+    n = _walk(x, 0)
+    for _ in range(-k):
+        n -= 1 if n == 3 else 2
+        while not isprime(n):
+            n -= 2
+    return n
+
+
+def nth_prime(i, report=False, guess=None):
+    """The prime at zero-based index i, exact.
+
+    guess(y) proposes x (default riemann_r_inverse; li_inverse for comparison),
+    primepi pins pi(x) exactly, the walk closes the gap with isprime, up or down.
+    report=True also returns (guess, pi(guess), gap walked)."""
+    guess = riemann_r_inverse if guess is None else guess
+    i = int(i)
+    if i < 0:
+        raise ValueError("index must be >= 0")
+    if i < 6:
+        return [2, 3, 5, 7, 11, 13][i] if not report else ([2, 3, 5, 7, 11, 13][i], None, None, 0)
+    x = int(guess(i + 1))
+    px = primepi(x)                   # number of primes <= x
+    gap = (i + 1) - px                # how many primes past x the target is
+    p = _walk(x, gap)
+    return (p, x, px, gap) if report else p
+
+
+def primepi_primecount(x):
+    """pi(x) by Kim Walisch's primecount through its shared library, if installed
+    (Ubuntu: `sudo apt install primecount`). Raises OSError when it is not."""
+    import ctypes, ctypes.util
+    name = ctypes.util.find_library("primecount") or "libprimecount.so.8"
+    lib = ctypes.CDLL(name)
+    lib.primecount_pi.restype = ctypes.c_int64
+    lib.primecount_pi.argtypes = [ctypes.c_int64]
+    return int(lib.primecount_pi(int(x)))
+
+
+def primepi_fastest(x):
+    """primecount when present, else our Meissel."""
+    try:
+        return primepi_primecount(x)
+    except OSError:
+        return primepi_meissel(x)

rulerpack/experiments.py

@@ -0,0 +1,133 @@
+"""rulerpack.experiments: things that were fun in the session and might be more.
+
+Nothing here is used by the rest of the library. Each function reproduces an IPython moment
+exactly and names what it saw, so it can be picked up again later.
+
+    import rulerpack.experiments as rx
+
+Experiment 1, the step-10 index (In [475]-[478]):
+
+    idx = rx.stride_index(primes)            # np.arange(2, len(primes), 10)
+    rx.stripe(primes)                        # (idx ^ 2p) % 4 : 2, 0, 2, 0, ... after the first
+    rx.jumps(primes)                         # where idx ^ 2p leaps by more than 300
+    rx.block_crossings(primes)               # where 2p crosses a multiple of 256
+    rx.last_before_blocks(primes)            # 127, 251, 383, 509, ... the last prime under each 128k
+"""
+
+import numpy as np
+
+
+def stride_index(primes, start=2, step=10):
+    """`np.arange(start, len(primes), step)`: every tenth index from the third prime."""
+    return np.arange(start, len(primes), step, dtype=np.int64)
+
+
+def picked(primes, start=2, step=10):
+    """The primes the stride index picks, `primes[stride_index(primes)]`."""
+    primes = np.asarray(primes, dtype=np.int64)
+    return primes[stride_index(primes, start, step)]
+
+
+def xor_index(primes, start=2, step=10):
+    """`idx ^ (2p)` over the first len(idx) primes: the array of In [477].
+
+    XOR cancels the top bits the two sides share, so the values sit small and leap only
+    when one side crosses a power of two or a multiple of 256."""
+    primes = np.asarray(primes, dtype=np.int64)
+    idx = stride_index(primes, start, step)
+    return idx ^ (primes[: len(idx)] * 2)
+
+
+def stripe(primes, start=2, step=10):
+    """`(idx ^ 2p) % 4`: 2, then 0, 2, 0, 2, ... forever.
+
+    Bit 1 of idx alternates because the step is 2 mod 4; 2p is 2 mod 4 for every odd p; the
+    one exception is the first entry, where p = 2 and 2p = 4. That is the whole stripe."""
+    return xor_index(primes, start, step) % 4
+
+
+def jumps(primes, start=2, step=10, more_than=300):
+    """Indices of the entries where `idx ^ 2p` has just leapt by more than `more_than`.
+
+    Two kinds: 2p crossing a power of two (1024, 2048, 4096, 8192 at indices 97, 172, 309,
+    564 on the first 1000 primes) and idx crossing a multiple of 256, every 25.6 entries."""
+    x = xor_index(primes, start, step)
+    return np.flatnonzero(np.abs(np.diff(x)) > more_than) + 1
+
+
+def block_crossings(primes, block=256):
+    """`np.flatnonzero(np.diff((2p) >> 8))`: the indices where 2p steps into the next block.
+
+    With block 256 that is p crossing a multiple of 128. The spacing is the count of primes
+    in each 128-wide block, which thins as the prime number theorem says."""
+    primes = np.asarray(primes, dtype=np.int64)
+    return np.flatnonzero(np.diff((primes * 2) // block))
+
+
+def last_before_blocks(primes, width=128):
+    """The last prime under each multiple of `width`: 127, 251, 383, 509, 631, ...
+
+    The largest primes under powers of two show up here on the dot: 127, 1021, 2039, 4093,
+    and 8191 when the list reaches it."""
+    primes = np.asarray(primes, dtype=np.int64)
+    return primes[block_crossings(primes, 2 * width)]
+
+
+def gaps_to_blocks(primes, width=128):
+    """How far each `last_before_blocks` prime sits under its boundary. Always odd."""
+    last = last_before_blocks(primes, width)
+    return width * (np.arange(len(last)) + 1) - last
+
+
+# ── experiment 1, continued: the layers under the stripe (In [481]) ───────────
+
+def layers(primes, moduli=(4, 8, 16, 32), start=2, step=10, n=40):
+    """`z % m` for each modulus, z = idx ^ 2p: one more bit of the primes per row.
+
+    (a ^ b) % m == (a % m) ^ (b % m) for a power of two, so each row is the stripe with one
+    more layer on top, and the layers underneath never change. At % 8 the new bit is whether
+    the prime is 1 or 3 mod 4; at % 16 its residue mod 8; and so on."""
+    z = xor_index(primes, start, step)[:n]
+    return {m: z % m for m in moduli}
+
+
+def bit_layers(primes, bits=(1, 2, 3, 4), start=2, step=10, n=40):
+    """`(z >> bit) & 1` for each bit: the layers on their own."""
+    z = xor_index(primes, start, step)[:n]
+    return {b: (z >> b) & 1 for b in bits}
+
+
+def recover(primes, m=32, start=2, step=10):
+    """Peel the index back off a layer: `((z % m) ^ (idx % m)) >> 1 == p % (m // 2)`.
+
+    XOR is its own inverse, so no layer hides anything: the `% 32` row carries the primes'
+    residues mod 16, reversibly mixed with the index. The same fact as `rp.unslide512`."""
+    primes = np.asarray(primes, dtype=np.int64)
+    idx = stride_index(primes, start, step)
+    z = idx ^ (primes[: len(idx)] * 2)
+    return ((z % m) ^ (idx % m)) >> 1
+
+
+def side_by_side(primes, m=32, start=2, step=10, n=40):
+    """Columns `idx % m`, `2p % m`, `z % m`: where each repeated value in a layer comes from.
+
+    The runs of 28, 14, 28, 14 are the index stepping through 2, 12, 22, 32 mod 32 against
+    primes that happen to sit in the same residue class; read the rows and the run is traced."""
+    primes = np.asarray(primes, dtype=np.int64)
+    idx = stride_index(primes, start, step)[:n]
+    p2 = primes[:n] * 2
+    return np.column_stack((idx % m, p2 % m, (idx ^ p2) % m))
+
+
+def stripe_control(n=1000, start=2, step=10):
+    """The stripe over odd composites instead of primes: 0, 2, 0, 2, ... with no exception.
+
+    The primes' version opens with an extra 2 because the first prime is 2; the composites
+    have no even member, so the alternation starts clean.
+
+    The stripe is a fact about bit 1 of an index stepping by 10 and of twice an odd number.
+    Any odd sequence gives it, which is the control that says it is not about primes."""
+    odds = np.arange(9, 9 + 2 * n, 2, dtype=np.int64)
+    comps = odds[np.array([any(o % q == 0 for q in (3, 5, 7)) for o in odds])][:n]
+    idx = np.arange(start, len(comps) * step, step, dtype=np.int64)[: len(comps)]
+    return (idx ^ (comps[: len(idx)] * 2)) % 4