Pick a mode with the four tabs across the top of the card: List first N, List a – b, Test a number or Lookup by index; the ? beside each tab describes it. Learn more about the modes
In List first N, type how many terms to show in Show first and click Update; the cards give the count, the largest term and the sum, and the tiles list every term. Learn more about listing terms
In List a – b, type the From index and the To index and click List range; a red box explains a bad range. Learn more about ranges
In Test a number, type a positive integer in Test number and click Check; a green box names the index, a red box says it is not prime. Learn more about the test
The panel on the right explains the current mode and walks through the arithmetic with your own numbers; it changes with every tab and click. Learn more about the panel
The explorer opens on the List first N tab, one of four tabs across the top of the card; the small ? beside each tab shows what the mode does. Type how many terms you want in the Show first box and click Update or press Enter. Three cards answer at once: Showing gives the count, Largest the last term with its index, and Sum the total of the listed terms, the sum of the first N primes. Under the cards every term is laid out as a tile with its index above its value, so p1=2 to pN can be read in order.
The box accepts 1 to 1,000: 10 gives p10=29 with the sum 129, 30 gives p30=113 with the sum 1,593, and 1,100 is capped at 1,000 terms, ending at p1,000=7,919 with the sum 3,682,913; a single term gives p1=2. Large values are printed with thousands separators. A count of 0, a decimal or an empty box is refused with "Enter a positive integer." There is no Reset button: type a new count and click Update again. The panel on the right, List first N, states the rule the tiles come from, and its walkthrough repeats the last term and the sum with your own N. What the terms are is explained in what is a prime number.
Listing a Range of Indexes
DemoThe range tab, a new range, two bad ranges
Step 0 of 4
Click the List a – b tab to list the terms between two positions instead of starting from 1. Type the From index and the To index and click List range or press Enter. The cards give the Countb−a+1, the Smallest term pa and the Largest term pb, and the tiles below list every term in between with its index. The tab opens with 10 to 30, 21 terms from p10=29 to p30=113; indexes 40 to 60 give 21 terms from 173 to 281.
Both boxes must hold positive integers, the first no larger than the second, and the range may hold at most 1,000 terms; otherwise a red box explains: "Enter two positive integer indexes", "From-index must be less than or equal to to-index", or "Range too wide — cap is 1,000 terms". The panel on the right, List a – b, explains the mode, and its walkthrough names the smallest and largest term of your range. The rule each tile uses is explained in the fundamental theorem of arithmetic.
Testing a Number
DemoThe test tab, a non-member, a member, 0
Step 0 of 4
Click the Test a number tab to ask whether a given positive integer is prime. Type it in the Test number box and click Check or press Enter. A green box with a tick answers yes and names the index, as for the opening value 97, which is p25; a red box with a cross answers no, as for 91, and the walkthrough on the right then shows the two nearest prime numbers, p24=89 and p25=97. A large value is handled the same way: 7,919 is p1000.
The box takes positive integers only; 0, a negative number or a decimal is refused with "Enter a positive integer". The test behind the answer is exact: the explorer looks the number up in its precomputed list of the first 1,000 primes (up to 7,919); a hit gives the index, a miss shows the two nearest primes, and a number above 7,919 is reported as not prime. The panel on the right, Test a number, states this rule, and its walkthrough carries out the arithmetic for your number. The rule itself is explained in primality testing — how the explorer decides.
Looking Up a Term by Index
DemoThe lookup tab, two indexes, n = 0
Step 0 of 4
Click the Lookup by index tab to compute one term directly. Type the position in the Index n box and click Get term or press Enter. Two cards answer: Index repeats n and Value gives pn with its index as a subscript. The tab opens with n=100, which gives p100=541; n=500 gives 3,571 and n=1000 gives 7,919. The box takes positive integers only; 0 is refused with "Enter a positive integer index".
The panel on the right has two parts in every mode. How it works names the rule the mode uses, here pn, the n-th prime, and links to the section of this page that explains it; Walkthrough applies the rule to the numbers you typed, so for the lookup it shows the arithmetic with your n filled in. Both change as soon as you switch tabs or click a button. The rule and where it comes from are in the fundamental theorem of arithmetic.
What is a Prime Number?
A prime number is a positive integer greater than 1 whose only positive divisors are 1 and itself. The first few primes:
Why 1 is not prime. The convention excludes 1 to make the fundamental theorem of arithmetic clean: every integer >1 factors uniquely into primes. If 1 were prime, 6=2⋅3=1⋅2⋅3=1⋅1⋅2⋅3 would have multiple representations.
Why 2 is the only even prime. Every other even number is divisible by 2, so cannot be prime. Both being even and being greater than 2 implies non-prime.
Composite numbers. Integers >1 that are not prime are composite. Examples: 4=2⋅2, 6=2⋅3, 8=23, 9=32, 10=2⋅5.
Scope of this explorer. This tool uses a precomputed list of the first 10,000 primes, with maximum value 104,729 (the 10,000th prime). Lookups and membership tests within this range are constant-time. For larger numbers, dedicated primality-testing tools are needed.
For deeper coverage see prime number, fundamental theorem of arithmetic, and primality test.
Statement. Every integer greater than 1 either is prime or can be written uniquely (up to ordering) as a product of primes.
For example:
12=22⋅3,100=22⋅52,420=22⋅3⋅5⋅7,1000000=26⋅56
Why uniqueness matters. Unique factorization is what makes primes "atoms" of arithmetic. The integers have a structure as a unique factorization domain — properties like greatest common divisor, least common multiple, modular arithmetic, and modular inverses all rest on this structure.
Why it's a theorem, not a definition. It's not obvious that factorization is unique. Consider analogous systems where it fails: in Z[−5], we have 6=2⋅3=(1+−5)(1−−5) — two different factorizations into irreducibles. The integers Z have unique factorization; this is a deep property requiring proof.
Proof sketch. Standard proofs use the Euclidean algorithm: if a prime p divides a product ab, then p divides a or p divides b. This "prime property" plus induction gives unique factorization.
Practical consequence. All number-theoretic algorithms (GCD computation, modular inverse, RSA, primality testing) rest on the structure that the fundamental theorem provides. Disrupt unique factorization and most of cryptography breaks down.
Primality Testing — How the Explorer Decides
This explorer uses a precomputed list of the first 10,000 primes (up to 104,729). Three modes interact with the list:
• Browse the first N primes — direct array access, O(N) time. • List a range — direct slice, O(b−a) time. • Membership test — hash-set lookup, O(1) time. • n-th prime lookup — direct array access, O(1) time.
Out-of-range behavior. For inputs m>104,729, the explorer reports the value as out of range rather than guessing. To test primality of larger numbers, use dedicated primality-testing tools or libraries.
Why precomputed. Storing the first 10,000 primes costs only a few kilobytes of memory and gives constant-time answers for the common range of educational and recreational queries. Naive trial division for m≈105 would require dozens of divisions per query — not slow, but slower than a lookup.
General-case primality tests (for context, not used here):
• Trial division: divide m by all primes up to m. Slow but exact. Practical up to ∼1012. • Miller-Rabin: probabilistic test, fast and very reliable. Practical for thousands of digits. • AKS primality test: deterministic polynomial-time test (2002). Theoretically important but slower than Miller-Rabin in practice. • Lucas-Lehmer: specialized test for Mersenne primes (2p−1). Used by GIMPS to find the largest known primes.
The largest known prime (as of recent record): 282,589,933−1, a Mersenne prime with over 24 million digits. Found via GIMPS in 2018.
The Prime Counting Function and Distribution
Let π(x) denote the number of primes less than or equal to x. Examples:
Equivalently, the density of primes near x is approximately 1/lnx. So:
• Near x=1000, about 1 in 7 numbers is prime. • Near x=106, about 1 in 14 numbers is prime. • Near x=10100, about 1 in 230 numbers is prime.
Primes become sparser as numbers grow, but never disappear (Euclid's theorem).
Better approximations. The logarithmic integral Li(x)=∫2xdt/lnt approximates π(x) more accurately than x/lnx. For x=1015, Li(x) matches π(x) to within about 107 (out of ∼3⋅1013 primes).
The Riemann hypothesis. The conjecture that all non-trivial zeros of the Riemann zeta function ζ(s) lie on the line Re(s)=1/2 would give very precise error bounds on π(x)−Li(x), namely O(xlnx). This is the most famous open problem in mathematics.
Inverse: the n-th prime.pn∼nlnn. Examples: p100=541≈100⋅ln100=460; p1000=7919≈1000⋅ln1000=6908. The approximation improves for large n and can be refined using pn≈n(lnn+lnlnn−1).
Famous Conjectures and Open Problems
Despite their elementary definition, primes harbor some of the deepest open problems in mathematics.
Twin prime conjecture. Twin primes are pairs (p,p+2) both prime: (3,5),(5,7),(11,13),(17,19),(29,31),…. Open question: are there infinitely many twin primes? Likely yes; proof remains elusive. The Polymath project and Yitang Zhang's 2013 breakthrough proved infinitely many primes differ by at most some bounded amount; the bound has been reduced to 246 (and conditionally to 6 under stronger hypotheses).
Goldbach conjecture. Every even integer greater than 2 is a sum of two primes. Verified computationally up to 4⋅1018; no proof. Examples: 4=2+2, 6=3+3, 8=3+5, 10=3+7=5+5, 100=3+97=11+89=….
Riemann hypothesis. All non-trivial zeros of ζ(s) have real part 1/2. Equivalent to precise error bounds on the distribution of primes. One of the Millennium Prize Problems (\1$ million for a proof).
Mersenne primes. Primes of the form 2p−1 where p is prime: 3,7,31,127,8191,…. Open: are there infinitely many? GIMPS finds new ones occasionally; only 51 known.
Fermat primes. Primes of the form 22n+1: 3,5,17,257,65537. Only these five known; conjectured to be the only ones.
Sophie Germain primes. Primes p such that 2p+1 is also prime. 2,3,5,11,23,29,41,…. Open: infinitely many?
Bertrand's postulate (proved): for every n≥1, there is a prime p with n<p<2n. Erdős gave an elegant proof at age 19.
Green-Tao theorem (2004): the primes contain arbitrarily long arithmetic progressions. A landmark result with surprising structural depth.
Primes in Cryptography
Primes are the foundation of modern public-key cryptography. Two prominent schemes:
RSA encryption. A user picks two large primes p and q (each typically 1024 bits). Their product N=pq is the public modulus. The security of RSA rests on the difficulty of factoring N back into p and q when only N is given.
• Encryption: given a message m and a public key (N,e), compute c=memodN. • Decryption: with the private key d (derived from ϕ(N)=(p−1)(q−1)), compute m=cdmodN.
Breaking RSA is equivalent to factoring large semi-primes. The best classical algorithms (general number field sieve) are sub-exponential; quantum computers running Shor's algorithm could factor in polynomial time, motivating post-quantum cryptography.
Diffie-Hellman key exchange. Uses a large prime p and a generator g of the multiplicative group modulo p. Two parties exchange gamodp and gbmodp publicly; both can compute the shared secret gabmodp but an eavesdropper cannot (under the discrete log assumption).
Why primality matters. Both schemes require generating large primes quickly. Probabilistic primality tests (Miller-Rabin) verify candidate primes in milliseconds; the prime number theorem says about 1 in ln(N)≈1000 random 1000-bit numbers is prime, so a few thousand candidates produce a usable prime.
Why primality is necessary. The mathematical structure (cyclic groups, modular inverses, Fermat's little theorem) requires primes or carefully chosen prime-related moduli. Replacing p with a composite breaks the algorithms in subtle but devastating ways.
Post-quantum cryptography. Lattice-based, code-based, and hash-based schemes aim to replace RSA and Diffie-Hellman without relying on factoring or discrete logs. Active area of standardization (NIST).
• Calling 1 a prime. By modern convention, 1 is neither prime nor composite. Historical mathematicians sometimes called it prime, but the convention shifted in the 19th-20th century for clarity of unique factorization.
• Calling 2 not prime because it's even. 2 is the unique even prime. Its evenness is a quirk, not a disqualifier.
• Thinking primes thin out predictably. While density decreases (∼1/lnx), the distribution is irregular: prime gaps can be small (twin primes) or large (gaps growing as logpn on average, but with occasional very large gaps).
• Conflating prime with irreducible. In the integers Z, prime and irreducible are equivalent. In more general algebraic settings, they can differ. Always specify "in Z" when needed.
• Over-trusting trial division for large numbers. Trial division up to N is exact but slow for N above ∼1012. Use Miller-Rabin or AKS for larger inputs.
• Forgetting Wilson's theorem subtleties.(p−1)!≡−1(modp) for prime p is a beautiful characterization but impractical as a primality test (the factorial grows too fast).
• Misremembering Goldbach. Goldbach's conjecture is about even integers, not all integers. The corresponding statement for odd integers — every odd ≥7 is a sum of three primes — was settled (Helfgott 2013, building on Vinogradov).
• Mersenne-Fermat prime confusion. Mersenne: 2p−1. Fermat: 22n+1. Different forms, different open problems.