JigSawPT/ptpt-failure-set-gate

Where a local 27B actually breaks against a frontier model — a European-Portuguese failure-set gate

On broad everyday tasks, a clean local 27B is near-indistinguishable from a frontier model under blind judging. The gaps that remain are narrow, behavioral, and regex-detectable — which is exactly what small adapters fix. This dataset is the measurement instrument: six hard-sets with deterministic checks, plus the scorer and the methodology write-up.

Dataset summary

Six workload-flavoured hard-sets of European-Portuguese (PT-PT) tasks (≈240 items across code, clinical, reasoning, shopping-math, and long-document reading), each item shipping an objective, machine-checkable verification — required/forbidden regex and/or an expected FINAL= value computed by executing a reference solution. Ships with the deterministic, domain-agnostic scorer (hardset_score.py) and the methodology summaries. Built to answer one question precisely: where does a clean dense local 27B actually fall short of a frontier model, so I can decide whether training small domain adapters is worth it? All student measurements are on a single consumer PC (RTX 5090 + Ryzen 9950X3D + 64 GB DDR5, temp 0).

TL;DR: A blind rubric gate on broad PT-PT tasks could not separate the local 27B from a frontier teacher (rubric means 4.2–4.9 both sides; the student even out-scored the teacher on reasoning). Switching to this deterministic failure-set gate surfaced the real gaps: inconsistent European-Portuguese orthography under load, Brazilian-lexicon bleed, exact-format compliance, and code that ends print(f"FINAL={var}") without stating the value. The frontier teacher passes 9/9 (clinical) and 15/15 (code) of the student's failures under identical checks. The deltas are behavioral — the profile small adapters correct best.

The question

I run a clean dense Qwen3.6-27B (Q4_K_P) as a daily driver, and I wanted to know — precisely, not by vibes — where it actually falls short of a frontier model, so I could decide whether training small domain adapters was worth the effort. I expected to find knowledge gaps. I found something narrower, more behavioral, and more useful. All student measurements are on my own hardware (temp 0); the frontier teacher answers were generated by a frontier model (Claude), which is also why the whole method rests on objective, reference-executed checks rather than any model's opinion.

Part 1 — broad tasks are near-indistinguishable

I first ran a blind cheap-gate: 30 realistic European-Portuguese prompts per domain across three domains (code, clinical-PT, reasoning), teacher and student answers shuffled and scored 1–5 by a blind LLM arbiter. I ran it twice — once with local teachers, once with a frontier model as the teacher pool — to test whether a stronger teacher would open a gap. Rubric means with the frontier teacher:

Domain	Frontier teacher	Local 27B student	Delta
code-PT	4.90	4.27	+0.63
clinical-PT	4.57	4.20	+0.37
reasoning	4.70	4.83	−0.13

Every domain came in under my +0.7 "teacher meaningfully better" threshold; on reasoning the student out-scored the frontier teacher. Deterministic anchors corroborated the rubric: on reasoning, the frontier model scored 30/30 on the ground-truth FINAL= values and the student scored 26/26 on the items it completed (the 4 raw misses were max_tokens truncations on the longest derivations — a generation-config artifact, not a reasoning error). On clinical dosage arithmetic, both sides were correct on every anchor item.

The rubric-saturation lesson

This is the methodological finding I would most want another practitioner to take away. With the student sitting at 4.2–4.8/5 on these broad, easy prompts, a "+0.7 mean delta" gate is arithmetically impossible to pass — the available headroom in reasoning was only 0.17 (5.0 − 4.83). Two consecutive teacher pools "failed" a gate that could not mathematically pass at these student baselines.

Rule promoted: before gating on a bounded-rubric mean delta, verify headroom (rubric_max − student_mean) ≥ threshold. If the headroom is below the threshold, the mean delta is uninformative — gate on failure-set pass rates instead. This is the pivot that produced everything below, and the failure-sets in this dataset are the instrument it produced.

Part 2 — where the 27B actually breaks

I replaced the saturated rubric gate with a failure-set gate. I authored hard, workload-flavoured prompts (40 per domain across five domains), each shipping an objective, machine-checkable verification where the expected value is computed by executing a reference solution, never hand-derived. The student answers at temperature 0, and the "failure set" is precisely the items it fails under deterministic scoring. Four gaps surfaced, all behavioral rather than knowledge-based:

1. Inconsistent pre-AO90 European-Portuguese orthography under load. On 6 of 8 pre-AO90 rewrite items, the student converted the easy acção/infecção family but left actual, directo, óptima, recepção, director unconverted. Partial conversion under load is a real, checkable break.
2. Brazilian-lexicon bleed. Under load the student slips into infarto (European PT: enfarte), estresse, caminhão (camião), equipe (equipa), isquêmico (isquémico). A variety-default failure, not a knowledge failure — and it matches external evidence (see disclosure).
3. Exact-format compliance. Instructed "exactly these headers, each on its own line," it wraps them in markdown bold (**Motivo:**), breaking anchored header checks. Instructed to emit FINAL=3,1,2,4,5, it emits 3, 1, 2, 4, 5 — correct answer, wrong format.
4. The "unexecuted program" failure. Asked to apply code to a given input and state the resulting value, the student writes a correct script ending print(f"FINAL={resultado}") and never runs it — the value appears nowhere in the answer. 7 of 13 code failures in one wave were this exact pattern. The dominant code gap is execution discipline, not algorithmic knowledge.

The gaps are narrow. Two whole domains produced almost no signal at realistic-hard difficulty: online-shopping math (0/40) and long-document extraction (2/40).

Dataset structure

Each hardset_*.jsonl file is one JSON object per line: the task prompt (PT-PT) plus a checks block — required/forbidden regex lists and/or an expected_final value (reference-executed). The scorer's contract: every required regex must match, no forbidden regex may match, and the last FINAL=... occurrence must equal expected_final under tolerant normalization (accents, case, comma/point decimals, unit-stripping, multi-part).

File	Items	Domain	Gate verdict
hardset_codigo.jsonl	40	code-PT (base)	viable (combined 15/80; teacher 15/15)
hardset_codigo_ext.jsonl	40	code-PT (extension)	↑ same combined domain
hardset_clinico.jsonl	40	clinical-PT	viable (9/40; teacher 9/9)
hardset_raciocinio.jsonl	40	reasoning	not viable (6/40, below ≥8 bar)
hardset_compras.jsonl	40	shopping-math	not viable (0/40)
hardset_docslongos.jsonl	40	long-document reading	not viable (2/40)
hardset_score.py	—	deterministic scorer (all domains)	runs a self-test before scoring

Methodology & outcome tables (Markdown): 13_deltamoe_runbook.md (read first — the full narrative and every gate-stage table), hardset_phase2_summary.md, hardset_phase2b_summary.md, cheapgate2_summary.md, cheapgate_raciocinio_regen.md.

Not included (available on request): the raw student/teacher/judge answer JSONLs and raw server logs — large and mechanical (model completions + deterministic scores); every specific claim above is already quoted in the summaries.

The failure-set gate methodology

• Objective checks only, with expected values reference-executed. No LLM opinion enters the score.
• Teacher answers the failure set only, from prompts alone (the checks are never shown to the teacher), scored by the same unmodified checker. Any item the teacher also fails does not count toward viability — prompt-author bias cannot inflate the result.
• Instrument audits with exact-flip verification. I revised the scorer across three versions (v2→v4) as I found check-authoring bugs; each revision was required to flip only the flagged items and move no other verdict (e.g. v2 fixed four clinical check-narrowness bugs — a ml/min unit-strip gap, a too-literal diabetes tipo 2 — and the re-score flipped exactly those four, nothing else).
• Viability criterion (per domain): ≥ 8/40 student failures AND the teacher passes ≥ 70% of the student-failed items under the identical checks.

On the two viable domains, the frontier teacher passed 9/9 (clinical) and 15/15 (code) of the student's failures — confirming the gap is genuine and learnable, not a scorer artifact.

Takeaways

• Local models are already frontier-class for everyday broad use. On saturated broad tasks, blind judging plus deterministic anchors could not separate a clean 27B from a frontier model.
• The deltas that remain are narrow, behavioral, and regex-detectable — orthography drift under load, Brazilian-variety default, exact-format compliance, unexecuted-value discipline. Not knowledge holes.
• That profile is exactly what small adapters fix best. The adapter program is frozen at the ready-to-train stage: both viable domains cleared the gate, the training pipeline (QLoRA → GGUF adapter → served with MTP at ~118 tok/s) is proven end-to-end, and I paused before committing teacher-generation budget.

Disclosure

This work was built with heavy AI assistance (Anthropic's Claude), including as one of the frontier teachers and prompt-authors in these experiments — which is exactly why every claim rests on an objective, reference-executed check rather than any model's opinion, and why teacher-authored items the teacher itself fails are discarded from viability. All student measurements ran on my own hardware; all direction, thresholds and decisions are mine.

The Brazilian-Portuguese-default failure mode is not idiosyncratic to my setup: it aligns with the P3B3 variety-bias benchmark (arxiv.org/pdf/2606.16753), which finds that strong LLMs systematically default to Brazilian Portuguese even when European context is set — across lexical choice, orthography (AO90 compliance), verbal morphology, syntax, and register.

The broader project (a hot/cold MoE expert cache that lets a consumer PC punch above its weight on large MoE models) is here: https://github.com/JigSawPT/moe-autopilot