Graph-Based Inference for Feedback-Driven Word Deduction: A Scalable Framework for the Jotto Problem
Dakshi Arora, Prakhar Kumar Srivastava, Ranjib Banerjee
cs.CL
Quick verdict
Graph-pruning Jotto solver extends to variable-length, repeated-letter words; sound idea but graph is cosmetic, statistics rest on 6 points, no baselines.
Summary
The paper recasts Jotto—a two-player word game with non-positional letter-overlap feedback—as constraint propagation over a weighted lexical graph: words are nodes, edge weights count shared letters, and each feedback score F(g,s)=Σ min(counts) prunes incompatible candidates. Unlike prior fixed-length isogram treatments, the framework covers lengths 3–8 and repeated letters via 12 NLTK-derived dictionaries (Table 1) and a three-stage guessing heuristic (alphabet coverage → elimination potential → feedback variance). A Selenium-driven study of ~3,000 simulated games (250 isograms + 250 repeated-letter words per length) shows mean iterations fall monotonically from ≈11.5 (3-letter) to ≈6 (8-letter); among four fitted regressions the logarithmic model wins (R²=0.984, lowest SSE/AIC/χ²; Tables 2–3). An eight-iteration case study on 'good' (Table 4: 1,549→1 candidates) illustrates repeated-letter disambiguation, and a phase-dependent complexity analysis claims near-linear practical runtime. Main limitations: the solver never actually builds the graph (admitted in §5.3), no baselines contextualize the iteration counts, the convergence 'law' rests on six length-condition means without variance or confidence intervals, and key experimental details (sampling seeds; the 1,549-candidate start) are unreported, limiting reproducibility.
Review complete
Assessment at a glance
6
risk flags identified
● high 1
● medium 3
● low 2
4 strengths · 5 weaknesses · 5 author questions
AI text signal = Binoculars zero-shot detector score over 20 sampled passages (Fast-DetectGPT co-reported) — absence does not prove human authorship, and a flag does not imply misconduct.
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- Jotto can be modeled as iterative constraint propagation over a weighted lexical-overlap graph, generalizing prior fixed-length isogram formulations to word lengths 3–8 and repeated letters within one framework.
- Across ~3,000 simulated games, the mean number of iterations to convergence falls monotonically from ≈11.5 (3-letter words) to ≈6 (8-letter words).
- The word-length vs. iterations relationship is best described by a logarithmic decay model (R²=0.984, lowest SSE/AIC/χ² among four fitted models).
- The solver scales near-linearly in practice because the candidate pool contracts approximately geometrically, with higher-order costs localized to mid-stage discrimination.
Strengths
Genuine generalization over prior Jotto formulations
§2.1 and Table 1 build 12 dictionaries (lengths 3–8 × all-words/isogram, e.g., 9,972 five-letter words vs. 6,373 isograms), unifying variable-length and repeated-letter play that prior fixed-length isogram treatments exclude; the repeated-letter feedback function (Eq. 1, min-count multiset overlap) is correctly specified.
Interpretable three-phase guessing heuristic
§2.2.1 switches between unique-letter coverage, elimination potential S_elim=|Wt|−|Wt+1(g)|, and feedback-outcome variance as the candidate pool shrinks — an explicit, reimplementable policy rather than a black box.
Reasonable-scale empirical evaluation
Honest edge-case handling
Weaknesses
The titular graph is never computationally used
Statistical evidence is six averaged points
No baselines or comparisons
Unexplained experimental configuration
Informal complexity analysis
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
The paper addresses the Jotto word-deduction game: guess a hidden word; feedback is the non-positional count of shared letters with multiplicity (Eq. 1). Claimed contributions: (1) a graph-based constraint-propagation framework generalizing prior fixed-length isogram treatments to lengths 3–8 and repeated letters "for the first time"; (2) a three-phase adaptive guessing heuristic (§2.2.1); (3) an empirical "logarithmic convergence law" from ~3,000 simulated games (§4.1, Tables 2–3); (4) an interactive Flask implementation (§3, ref [27]); (5) a phase-dependent complexity analysis implying near-linear practical runtime (§5). The scope is narrow and recreational-mathematics flavored, positioned (§1) alongside Mastermind [3–9] and Wordle [10–12] as a testbed for feedback-driven inference.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 4 strengths & 5 weaknesses, analyzed in detail
- 6 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is the Jotto problem studied in this paper?
Jotto is a two-player word game (described 1955) where one player picks a secret word and the other guesses; after each guess the feedback is a single number — how many letters the guess shares with the secret word, counting multiplicity but ignoring letter positions. The paper treats finding the hidden word from this feedback as a constraint-elimination search problem.
What is the paper's main finding?
In about 3,000 simulated games, the average number of guesses needed falls as words get longer: roughly 11.5 guesses for 3-letter words down to about 6 for 8-letter words. The authors fit several curves and report a logarithmic relationship (R²=0.984), explaining that longer words give more informative feedback per guess.
Does the solver really use a graph?
Only for visualization. The paper's own complexity section (§5.3) states the solver does not build the graph — it just filters a candidate word list after each guess. The weighted 'lexical overlap graph' appears in figures to illustrate pruning, not in the algorithm itself.
Is code or data available for this paper?
The authors provide an interactive web demo (jottogame.vercel.app, their reference [27]) but no released solver code, test scripts, seeds, or per-run data. The dictionary comes from NLTK, and the algorithm is described in enough detail for independent reimplementation.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- Figures 1–5 are present only as captions in the extracted text; visual judgments (e.g., the shape of the Figure 2 trend) rest on the reported numbers, not the images.
- Table 4's 'Feedback' column carries a superscript marker ('Feedbacka') whose footnote text is not visible in the extraction.
- The metadata abstract cuts off mid-sentence ('as a via…'), but the complete sentence appears in the paper body, so no content was lost.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.