The Greek alphabet table

The Greek Letter Generator draws from one data table: 24 letters, alpha through omega, each with an uppercase form, a lowercase form and a name. This guide prints that table from the engine’s own data, explains what each column means to the sampler, and shows — with real engine calls run at build time — how it behaves under case expansion, vowel and consonant filters, include and exclude lists, and draws without repeats. Nothing here is typed by hand: if the table changed, the page would change with it, or the build would fail.

The table, from the engine’s data

The 24 rows below are the engine’s table itself, read at build time from the exported constant the generator draws from and the tests check. The index column is the number the sampler must produce to land on that row: index 0 is Alpha, index 23 is Omega. The code-point column records which Unicode character each glyph is. The pool-flag column shows how the data marks each letter for the filters: 7 rows are vowels (α ε η ι ο υ ω) and the other 17 are consonants.

The 24-row Greek alphabet table, rendered from the engine’s data.
Index	Name	Upper	Lower	Code points	Pool flag
0	Alpha	Α	α	U+0391 / U+03B1	Vowel
1	Beta	Β	β	U+0392 / U+03B2	Consonant
2	Gamma	Γ	γ	U+0393 / U+03B3	Consonant
3	Delta	Δ	δ	U+0394 / U+03B4	Consonant
4	Epsilon	Ε	ε	U+0395 / U+03B5	Vowel
5	Zeta	Ζ	ζ	U+0396 / U+03B6	Consonant
6	Eta	Η	η	U+0397 / U+03B7	Vowel
7	Theta	Θ	θ	U+0398 / U+03B8	Consonant
8	Iota	Ι	ι	U+0399 / U+03B9	Vowel
9	Kappa	Κ	κ	U+039A / U+03BA	Consonant
10	Lambda	Λ	λ	U+039B / U+03BB	Consonant
11	Mu	Μ	μ	U+039C / U+03BC	Consonant
12	Nu	Ν	ν	U+039D / U+03BD	Consonant
13	Xi	Ξ	ξ	U+039E / U+03BE	Consonant
14	Omicron	Ο	ο	U+039F / U+03BF	Vowel
15	Pi	Π	π	U+03A0 / U+03C0	Consonant
16	Rho	Ρ	ρ	U+03A1 / U+03C1	Consonant
17	Sigma	Σ	σ	U+03A3 / U+03C3	Consonant
18	Tau	Τ	τ	U+03A4 / U+03C4	Consonant
19	Upsilon	Υ	υ	U+03A5 / U+03C5	Vowel
20	Phi	Φ	φ	U+03A6 / U+03C6	Consonant
21	Chi	Χ	χ	U+03A7 / U+03C7	Consonant
22	Psi	Ψ	ψ	U+03A8 / U+03C8	Consonant
23	Omega	Ω	ω	U+03A9 / U+03C9	Vowel

Reading the index column: how a byte picks a row

Each draw starts with one random byte from crypto.getRandomValues, a value from 0 to 255. The engine keeps only the lowest 5 bits — the fewest that cover the last index, 23 — leaving a candidate from 0 to 31. A candidate below 24 is the row to draw; one from 24 to 31 — 8 of the 32 possible values — is thrown away and a fresh byte drawn. Nothing is folded back onto the table, which is why every row keeps exactly probability 1/24.

Three scripted draws make this concrete; they use a fixed byte script for illustration, while live draws use crypto.getRandomValues. Bytes 7, 17, 23 are all below 24, so they select rows 7, 17, 23 directly: Θ Σ Ω — Theta, Sigma, Omega. Byte 27 masks to 27, at or beyond 24, so it is discarded and the next scripted byte, 3, selects row 3: Δ (Delta). A byte far above the table, such as 200, is not an error: its lowest 5 bits are 8, so it selects Ι (Iota). The full walk-through is in how a random letter is drawn; the arithmetic behind the discarded band is in rejection sampling, explained.

The sigma row

Row 17 is Sigma, and its lowercase glyph is the medial form σ, not the final form ς. The final form ς appears only at word ends, and the generator draws letters, not words, so σ is the form a drawn letter takes: a scripted lowercase draw of byte 17 returns exactly σ (Sigma). The tests pin this.

The final form is still understood as input. Type ς into an include or exclude list on the main generator with the Greek alphabet selected and the parser reads it as Sigma: a build-time call with the include list “ς” gives a pool of 1: Σ (Sigma). Excluding “σ” leaves a pool of 23, and Sigma is not among them.

Upper, lower, and both

The case control decides which column the pool is built from. Upper builds a 24-entry pool from the uppercase column, lower a 24-entry pool from the lowercase column, and both builds one pool from both columns in a fixed order — all 24 uppercase forms, Α through Ω, then all 24 lowercase forms, α through ω — for 48 entries.

That order shows in the indices: index 0 is still Α and index 24 is the first lowercase entry, α, so a scripted mixed-case draw of bytes 0 and 24 returns Α α — Alpha, Alpha. The wider pool needs 6 bits (values 0 to 63), of which 16 are discarded. Each of the 48 entries has probability exactly 1/48: mixed case is a genuine 48-entry pool, not an uppercase draw followed by a coin flip. With “no repeats” on, Α and α count as different entries, so a mixed-case draw can return both forms of the same letter.

Vowels and consonants in the table

The pool-flag column is the data behind the vowel and consonant filters. The vowel filter keeps the 7 flagged rows — Α Ε Η Ι Ο Υ Ω — a pool of 7; the consonant filter keeps everything else, a pool of 17. The flags live in the same tested table (the suite asserts exactly these 7 names are flagged), so the filters cannot disagree with the rows above. The Greek Letter Generator page draws from the full table; the filters and the include and exclude lists are on the main generator.

Typing Greek into include and exclude lists

Include and exclude lists are parsed against the selected alphabet. Spaces, commas and semicolons are separators and are ignored. Letters match case-insensitively — α and Α both mean Alpha — and ς is read as Sigma. Anything else is an error, reported rather than skipped. The build-time call with the include list “α, β; Γ” gives a pool of 3: Α Β Γ (Alpha, Beta, Gamma).

The validation is strict about alphabets. A Latin B in a Greek exclude list is refused with the engine’s exact message: “The exclude list contains “B”, which is not a letter of the selected alphabet.” The reverse fails the same way — an Ω in an English include list produces “The include list contains “Ω”, which is not a letter of the selected alphabet.” And because the include list is applied after the vowel or consonant filter, the two can cancel out: including only α with the consonant filter on leaves nothing, and the engine says so — “The selected filters leave no letters to draw from — relax the filters.” — instead of drawing from an empty pool. The order of filters, lists and case expansion is the subject of how letter pools are built.

What the tests pin

The automated test suite locks this table in several ways. It asserts exactly 24 entries; the full canonical name sequence, Alpha to Omega, in order; 24 distinct uppercase and 24 distinct lowercase glyphs; that no glyph is a Latin look-alike — none matches A–Z or a–z; and that every glyph’s code point lies inside a single Greek range of the Unicode table. The rows above span U+0391 to U+03C9, and none falls outside it.

The look-alike test matters because a Latin capital can be mistaken for a Greek one in source code: Α is U+0391, while A is U+0041. A table that quietly held the Latin character where Alpha belongs would draw one letter while appearing to show another. The suite also pins behavior on the table: byte 0 draws Alpha with its name attached, byte 23 draws Omega, a lowercase draw of byte 17 is σ, and the mixed-case pool has 48 entries.

Drawing the whole table without repeats

With “no repeats” on, drawn letters leave the pool, so a draw of 24 unique letters from the uppercase table is a random ordering of the whole alphabet — every ordering equally likely. A scripted draw of all 24, run on the fixed byte script 23, 0, 11, 2, 7, 0, 5, 1, 3, 0, 9, 4, 1, 0, 6, 2, 0, 3, 1, 0, 2, 1, 0, 0 — for illustration; live draws use crypto.getRandomValues — gives Ω Β Ξ Ζ Μ Δ Ε Ι Η Κ Υ Π Γ Ν Φ Σ Ρ Ο Λ Τ Ψ Θ Χ Α. Asking for one more is refused with the engine’s actual limit: “Cannot draw 25 letters without repeats from a pool of only 24 — allow repeats, lower the count, or widen the pool.” The ceiling is per case — 48 in mixed case — and counts on every generator run from 1 to 100, so above 24 on this table you must allow repeats. The mechanics — a partial Fisher–Yates shuffle — are in drawing without repeats.

Uniform only, including this table

Every letter in the active pool is exactly equally likely — the engine never weights draws by English text frequency or any other distribution.

That sentence is exported from the engine and rendered here verbatim. Applied to this table it means every row is drawn with probability 1/24 in either single case and every entry with probability 1/48 in mixed case — no row is favored for any reason. The flip side is that uniform draws are streaky: 3 draws in a row can all come up Alpha at odds of exactly 1 in 24³ = 1 in 13,824. That is pool arithmetic: 3 independent choices from a 24-row pool, so any one fixed run of 3 — all Alpha, or any other named sequence — has probability (1/24)³. A short run that never repeats is not evidence of anything either. More of the pool arithmetic behind streaks is in uniform randomness and streaks.

What the table does not cover

This page documents a data table, not a language. The table holds the modern 24-letter alphabet in its two plain cases; no other Greek character — accented forms included — is in it, and none can be drawn. The table is the whole of what the Greek tool can produce: a draw is always one of these 24 rows — or one of 48 entries in mixed case — and every result reports the pool size it came from.

Frequently asked questions

How many letters are in the Greek alphabet table?

Exactly 24, Alpha through Omega, each with an uppercase form, a lowercase form and a name. 7 rows are flagged as vowels (α ε η ι ο υ ω) and the other 17 as consonants.

Why is lowercase sigma shown as σ and not ς?

Because the generator draws letters, not words. The final form ς appears only at word ends, so row 17 carries the medial form σ, and a lowercase draw of that row returns σ. The tests pin this, and typing ς into an include or exclude list is still understood as Sigma.

Can I type Greek letters into the include and exclude lists?

Yes — on the main generator with the Greek alphabet selected. Spaces, commas and semicolons are ignored, matching is case-insensitive, and ς is read as Sigma. Anything that is not a letter of the selected alphabet is an error, never silently dropped: a Latin B in a Greek exclude list produces “The exclude list contains “B”, which is not a letter of the selected alphabet.”

What does “both cases” do to the Greek pool?

It builds one pool of 48 entries — all 24 uppercase forms followed by all 24 lowercase forms — and draws from it directly, so each entry has probability exactly 1/48. It is not an uppercase draw with a coin flip afterwards.

Is every Greek letter equally likely?

Yes, at exactly 1/24 per draw in a single case. The engine keeps the lowest 5 bits of each random byte (values 0 to 31), uses a value below 24 as the row index, and discards the 8 values from 24 to 31 rather than folding them back onto the table. Uniform draws are streaky: 3 draws in a row can all come up Alpha at odds of exactly 1 in 24^3 = 1 in 13,824 — pool arithmetic: 3 independent choices from a 24-row pool, so any one fixed run of 3 has probability (1/24)^3.

What do the automated tests check about this table?

That it has exactly 24 entries in canonical name order from Alpha to Omega; that its 24 uppercase and 24 lowercase glyphs are all distinct; that no glyph is a Latin letter standing in for a Greek one; that every glyph falls inside a single Greek range of the Unicode table; and that byte 0 draws Alpha and byte 23 draws Omega.