The useful result of verigen is not that it generates brilliant puzzles. It is that it can generate ordinary candidates quickly, then reject almost all of them with explicit checks. In the author’s seed-7 run, five puzzles survived from 1,947 attempts in 84 milliseconds—an acceptance rate of 0.2568%.
That is a design argument, not a universal law: when a requirement is mechanically decidable and verification costs less than producing another candidate, a simple generator plus a strong verifier can be more reliable than continually making the generator “smarter.”
As an Amazon Associate I earn from qualifying purchases.
The design change: stop asking the generator to guarantee what the verifier can decide
Hidetzu’s verigen project separates two jobs that are often mixed together:
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitches- Generation proposes a candidate, without promising that it is valid.
- Verification checks the candidate against explicit requirements and accepts only what passes.
The author summarizes the architecture this way: “The generator guarantees nothing. Every guarantee lives in the verifier.” That sentence is the central lesson of the project, not a claim that verification is always superior. It applies most cleanly when the desired properties have a precise, executable definition and another attempt is cheap enough.
A generator-first design tends to accumulate heuristics: avoid obvious mistakes, estimate difficulty, prefer attractive shapes, and retry when something looks suspicious. Those heuristics can improve yield, but they do not establish correctness. A verifier changes the contract. The generator may be wasteful or naïve; the verifier is the authority on the properties it actually checks.
What the 99.7% rejection figure actually means
In the cited run, the program used seed 7 and produced five accepted puzzles after 1,947 attempts in 84 ms. The reported acceptance rate was 0.2568%, which means roughly 99.7% of candidates were rejected. These are project-reported results for that run, not a cross-machine benchmark or a general performance promise. The figures appear in the author’s explanation and the project README.
| Reported outcome | Attempts | Share of 1,947 attempts | What it indicates |
|---|---|---|---|
| Accepted | 5 | 0.2568% | Passed every requirement implemented by the verifier |
| Non-unique | 770 | 39.55% | Had more than one valid assignment |
| No solution | 695 | 35.70% | Had no assignment satisfying the constraints |
| More than ten distinct letters | 477 | 24.50% | Could not map every letter to a distinct decimal digit |
The categories and rounded percentages are those reported for this run. A low yield is not automatically a defect: if candidate generation is inexpensive and the accepted output meets the required standard, rejection can be the simplest path to reliability. It becomes a problem when verification is expensive, accepted candidates are still poor, or the application cannot tolerate the wasted work.
How the alphametic verifier establishes a guarantee
An alphametic replaces letters with digits so that an arithmetic expression becomes true. For example, SEND + MORE = MONEY assigns one decimal digit to each distinct letter, with the same letter always receiving the same digit.
1. Reject impossible alphametics before searching
Decimal digits provide only ten distinct values, 0 through 9. If a candidate contains eleven different letters, no one-to-one assignment can exist. The verifier therefore rejects such a candidate immediately. In the cited run, this inexpensive prefilter handled 477 attempts.
2. Disallow leading zeroes
A multi-character word cannot begin with zero. The verifier treats that as a hard constraint rather than relying on a plausibility rule. A candidate that otherwise satisfies the arithmetic still fails if a leading letter is assigned zero.
3. Search column by column with carries
The search proceeds through arithmetic columns while tracking the carry into the next column. At each step it assigns unused digits to the letters required by that column and checks the resulting sum. This prunes assignments as soon as a column becomes impossible instead of waiting until a complete mapping has been built.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstall4. Continue after finding one solution
Finding a valid assignment proves solvability, but not uniqueness. The project keeps searching after the first solution to determine whether a second assignment exists. A candidate is accepted only when exactly one solution is found. This is why the verifier can distinguish “solvable” from “uniquely solvable,” a distinction a generator heuristic cannot safely infer.
The author reports testing the verifier with known examples, including SEND + MORE = MONEY and CROSS + ROADS = DANGER, along with explicit no-solution, non-unique, and eleven-letter cases. Those are reported test designs; they are not an independent audit of the implementation.
What passing proves—and what it does not
A verifier proves only the predicates it implements. For an alphametic in this project, a passing result establishes that the arithmetic works, the digit assignments obey the distinctness rules, leading zeroes are excluded, and no second solution was found by the search.
It does not prove that the puzzle is enjoyable, elegant, educational, or appropriately difficult. The project’s difficulty label is a proxy based on the number of search branch points. Hidetzu explicitly says it has not been measured against human solvers, so it should not be presented as a validated measure of human difficulty.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The same boundary applies to any generated artifact. A program can pass unit tests and still be confusing. A text-to-structured-data pipeline can produce valid syntax while putting the wrong value in a field. A theorem prover can certify a statement relative to its formalization while the formalization omits the real-world condition a researcher cared about. Verification narrows uncertainty; it does not eliminate every kind of quality judgment.
When a generator-plus-verifier loop is the right architecture
| Question | Favorable condition | Warning sign |
|---|---|---|
| Decidability | The requirement can be tested mechanically, including uniqueness or equivalence where needed. | Success depends mainly on taste, context, or an undefined notion of “good.” |
| Verification cost | Checking is cheaper than generating another candidate. | A verifier takes longer or costs more than the generation step. |
| External judgment | A reliable reference answer, formal rule set, or grader exists. | Only a human can tell whether the result is useful, and reviewers are already overloaded. |
| Guarantee scope | You can state exactly what a pass means. | Users may mistake a narrow check for a guarantee of overall correctness. |
| Quality measurement | Requirements are objective and stable. | Interest, clarity, novelty, or difficulty are central but unmeasured. |
The economic test is especially important. The article notes that an LLM generation call can take hundreds of milliseconds to seconds. If verification is a few milliseconds and another candidate is cheap, aggressive rejection is sensible. If every verification invokes a costly model, a large solver, or a human review, increasing rejection may make the system slower and more expensive than improving generation.
Why “smarter generation” can be the wrong optimization target
Suppose a generator currently produces many invalid candidates. One response is to add more rules to its prompt, sampling strategy, or search procedure. That may raise the pass rate, but each new heuristic becomes another place where the system can be wrong or silently drift from the actual specification.
A verifier offers a different optimization target: keep the proposal mechanism simple, make the acceptance test explicit, and improve throughput only after measuring the real bottleneck. In the reported run, the overwhelming majority of attempts were rejected for concrete reasons—non-uniqueness, no solution, or too many letters—not because the program guessed that they “looked bad.”
Rank #4
This architecture also makes failures inspectable. Instead of a vague quality score, the system can report why a candidate failed. That feedback can later guide the generator, but it does not replace the final check.
How to design the loop in a new project
- Write the acceptance contract first. List every property that must hold. Separate mandatory constraints from preferences such as style or novelty.
- Implement the smallest trustworthy verifier. Prefer direct checks, exhaustive search for small spaces, or algebraic proofs where those are appropriate. Make rejection reasons observable.
- Test the verifier independently. Include known-valid examples, known-invalid examples, boundary cases, impossible inputs, and cases that are valid but non-unique.
- Keep generation disposable. Have it emit candidates in the verifier’s input format. Do not let generator assumptions count as guarantees.
- Measure the economics. Record generation time, verification time, rejection categories, memory use, and accepted-output rate. A fast verifier can justify many retries; a slow one may not.
- Define stopping and diversity rules. Decide how many accepted items are needed, how retries are bounded, and whether duplicate accepted outputs are allowed.
- Report the guarantee accurately. Document exactly what a pass establishes and identify every important quality dimension that remains outside the verifier.
Failure modes to watch for
The verifier checks too little
A syntactic check may accept malformed semantics. For example, validating that fields exist does not establish that their values are correct. Add checks for the actual invariant, not merely the shape of the output.
The verifier checks the wrong model
A formal rule can be implemented correctly and still encode the wrong requirement. Review the specification and test cases before optimizing the search.
Uniqueness is assumed instead of established
Stopping at the first solution proves existence only. If uniqueness matters, continue searching or use a mathematically justified uniqueness test.
Free tools Windows power users keep installed
One-click scans. No signup required.
Verification dominates the budget
Measure the cost of a full check, not just a prefilter. Cache reusable work, reject obvious impossibilities early, and reconsider the loop if checking costs more than producing a new candidate.
Best Value
Subjective quality is mislabeled as objective
A branch-count score may correlate with difficulty, but correlation is not validation. If human enjoyment or learning value matters, collect human evaluations or build a separate, clearly labeled quality model.
How far the pattern extends beyond puzzles
The same separation is useful for generated code, text-to-query systems, constrained structured output, and formal mathematics: generate a candidate, run a machine-checkable test, and keep only candidates that satisfy the stated contract. The article presents these as examples of the pattern, not as proof that every current product in those areas uses the same design.
The project README currently lists alphametics, polyomino tilings, Apollonian circle configurations, and Slitherlink as domains. It uses different checking methods, including exhaustive search for some domains and algebraic checks for Apollonian configurations. Because the repository can change, treat that list as a snapshot rather than a permanent feature guarantee.
Recommended Free Tools
What the IMO comparison does—and does not—show
The article contrasts mechanical verification with open-ended mathematical work, but contest results need careful interpretation. Google DeepMind reported that AlphaProof and AlphaGeometry 2 solved four of six International Mathematical Olympiad problems and scored 28 of 42 in 2024, with formalization into systems such as Lean and as much as two to three days of computation. Its 2025 report says Gemini Deep Think solved five of six problems and scored 35 of 42, with solutions graded by IMO coordinators and produced in natural language within the 4.5-hour contest limit. The official reports are DeepMind’s 2024 account and 2025 account.
Those are different systems, time limits, and evaluation settings. They do not show that verification has no role in research, nor that a generator should always be made simpler. They illustrate a boundary: when there is no compact answer key or cheap mechanical predicate for the full goal, generation and external judgment remain necessary.
The practical verdict
verigen demonstrates a disciplined trade: accept a low candidate yield in exchange for explicit, auditable guarantees. Its 0.2568% acceptance rate is acceptable only because the reported verifier completed the run quickly and because the accepted property—unique, valid solutions under defined rules—was more important than making the generator appear intelligent.
Use this architecture when you can state the requirement precisely, test it reliably, and afford rejection. Improve the generator when verification is the bottleneck or when the qualities users care about are not captured by the checker. The durable lesson is not “verification always beats smarter generation.” It is to put each guarantee in the component capable of proving it.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
