This dataset holds ICPC World Finals and NWERC 2024 problem statements, editorials and reference solutions. The World Finals material is © ICPC Foundation and carries no open licence; the community editorials and the alternative reference solutions belong to their authors. It is shared only with collaborators of the insight-generation research project, for research use, and requests are reviewed by hand.

ICPC insight bank — v0.2

An insight is a short hint that lets an open model solve a competitive-programming problem it otherwise struggles with. The model being taught (the learner) is Nemotron-Cascade-2-30B-A3B.

This repository builds on Peiyang Xu's harness and his 24-problem set. This card covers three things:

what is his;
what this repository adds;
what his published 9/28 records show on a second look.

Duy Nguyen assembled it with Claude Code and Codex.

Peiyang's work, which this builds on

what	where
The harness. The learner solves a problem under a judge that returns ICPC verdicts: on its own (`LLM/`), or with tools over its own past submissions (`agent/`).	github.com/xupy2003/InsightGeneration
The insight engine. GPT-6-Astra writes a hint for one problem, over 10 rounds; each round is scored on 5 learner runs (`InsightGen/`).	same repository
24 World Finals problems from 2021–2025 (22 distinct), with tests, judges and editorials	xupy21/ICPC_Data
The 9/28 runs: no hint, the editorial, and every GPT insight, 5 seeds each	`runs/` in xupy21/ICPC_Data

The 9/28 headline:

The shortest successful insights average 84 tokens. The editorials average 1,229.
They solve 118 of 120 runs. The editorial solves 117, and no hint 103.

On 10/1 he re-ran the four problems that the checker-message leak affected (issue 2), with the fix. Counting those runs, the insights average 86 tokens and no hint solves 104; the other numbers are unchanged.

What this adds

	Peiyang's set	this repository
problems	24 entries (22 distinct), World Finals 2021–2025	198 distinct: every World Finals problem from 2010–2025 (185) and NWERC 2024 (13). The 24 are included, with statement and editorial byte-identical to his.
checked with the harness's own judge	—	133 distinct problems validated on the official tests with a passing reference solution (at 3× the time limit, with a 64 MB stack)
solution texts	one editorial per problem	186 editorials (78 community write-ups, 95 judges' sketches, 13 NWERC slide decks), 134 judges' sketches and 164 reference solutions
which problems need the same idea	—	technique labels from two labellers; 34 technique families; 13 idea families covering 27 problems; 375 problem pairs for transfer tests
training-data contamination	—	every problem flagged high (14), medium (172) or low (12) risk
a test of whether one problem's insight helps on another	—	the hint-transfer experiment, set up on Farmshare with the team's own model; not yet run
harness issues	—	8 found, each with its file and line; one fixed upstream since
the 9/28 records	published	re-read in section 4

1. The problem bank

bank/problems/ uses the layout the harness already reads, so WF_ARCHIVE can point straight at it. bank/tables/bank.jsonl has one row per problem directory: 203 rows, i.e. the 198 distinct problems plus second copies of the five problems the 2022 and 2023 Finals shared. Start there.

Judging. A problem is harness_ready when all of these hold:
- its official tests installed and validated;
- its time limit is known;
- it needs no checker or interactor that is missing;
- a reference solution passed the harness's own judge.
133 distinct problems qualify: 132 under their main id, plus Riddle of the Sphinx, which can be judged only under its 2023 id. Validation allowed 3× the official time limit and a 64 MB stack (issue 3).
Validation failures. 8 reference solutions fail, each for a known reason. Two of them, 2013/D and 2015/D, are correct programs that the harness itself breaks (issue 5 below).
Relations. Two models (Claude and Codex) label every problem's techniques and key observation independently. They name the same main family for 79% of problems (Cohen's κ 0.73).
- Technique families group problems that both labellers tagged alike.
- Idea families group problems that both models, reading every key observation, said need the same idea.
Idea families are small: 12 pairs and one triple.
Pairs for transfer tests (bank/tables/edges.jsonl):

edge count

D3_idea: same idea family 15

D3_technique: same technique family 166

D4: a control of similar difficulty sharing neither 194
Contamination. The learner was fine-tuned on OpenCodeReasoning. 14 problems appear in it. 172 were public before its base model's cutoff (2025-06-25). The 12 from 2025 came after it.

code/README.md documents every column, the sources and how to rebuild the bank.

2. The hint-transfer experiment (set up, not run)

The question. Does a key idea taken from a different problem help the learner solve a target that needs the same idea, once the hint says where it comes from? It is asked twice: with the idea alone, and with the other problem's whole worked solution. Two neighbouring questions have already been tested, so they are not asked again. In the Generalization Spectrum study (arXiv 2606.25450), measuring a 4B thinking model's pass@1:

a worked example transferred to a retelling of the same problem: 0.29 → 0.63 (level D2);
it did not transfer to a different problem that only shares an algorithm family (level D3): with the pair hand-picked, 0.24 → 0.17. In a separate test, a sentence naming the relation did not help at D3 either, and an 8B model showed no gain there.

The pairs here sit between the two: their shared lemma is the target's crux.

arm	what the learner is shown
`none`	no hint section
`idea`	"This idea comes from a different problem that needs the same key idea as this one:" and the source's key observation
`idea_placebo`	the same sentence and an unrelated problem's key observation, within 10% of its length
`worked`	"Below is a different problem that needs the same key idea as this one, with its solution:" and the source's statement, editorial and passing program
`worked_placebo`	the same sentence and an unrelated problem's statement, editorial and program: the closest in length, within 25%
`empty`	the hint section holding `(none)`

The learner. Cascade-2 itself, the team's model. vLLM 0.18.1, the team's version, serves it in BF16 on Stanford's Farmshare, on two L40S GPUs per server. The engine settings are the team's, except four that the hardware forces; hint_transfer/learners/nemotron-cascade-2-30b-a3b/learner.json records them. The same GPU node runs the team's harness unmodified and judges.
Speed. A contest generates about 84 tokens/s there, against about 295 on the team's GPUs. On the team's problems whose editorial runs all solved, the budget was 10k–150k tokens, so most runs should reach it well inside the hour. The slower GPU can still end a contest before a solution that would have been within budget, so every run's tokens and time are kept, and screening shows how much room the hour leaves.
Candidates. There are 32 directions (source → target). Two models drafted each one's shared lemma.
- Where both call it the target's crux and a quote of that crux is found word for word in the target's editorial or sketch, the direction was admitted automatically: 15 directions.
- Where neither does, it was rejected: 12.
- Duy decides the 5 split ones (hint_transfer/review.txt). Admitting one still needs the crux quote found in the target's files.
Stages.
1. Screening, seeds 1–5: every problem with no hint and with its editorial. A run's cost is the completion tokens it spends up to its first accepted submission. Each problem's budget is 1.5× the mean cost of its editorial runs that solved. A target is kept if, within that budget, it solves at most 3 times in 5 without a hint and at least 4 times with the editorial.
2. Stage A, seeds 6–25: each source's own key observation must work on the source itself, within budget in at least 14 of 20 runs and no less often than with no hint in screening.
3. Stage B, seeds 6–25: the six arms on each qualifying target.
Decisions. There are two, one per real arm: idea and worked, each against none, its placebo and empty. The unit is the family of problems joined by admitted pairs.
- GO needs every one-sided 95% lower bound above zero.
- NO-GO: the upper bound against none is below 0.3.
- Otherwise INCONCLUSIVE, and WAIT below 6 families.
- In simulation at 20 seeds, a +0.15 effect is found about 59%, 71% and 80% of the time at 8, 10 and 12 families. With no effect, each decision says GO about 1% of the time.
Checks already done.
- Judging. All 25 problems in the candidate directions pass at the official time limits on Farmshare's own CPUs (Xeon Gold 6426Y, GCC 13.3), with a 2 GB stack, as ICPC's judges set it. At 64 MB, 2022/R's own reference overflowed. Each check covers five things:
  - the reference passes;
  - an empty program gets WA;
  - perturbed outputs are rejected;
  - every official answer is accepted;
  - the verdict the learner sees carries no checker message (issue 2).
- Serving. On every request, a prompt rendered locally and the server's count of it agree, including after tool turns and after older turns are dropped. The model's own reasoning and tool-call text come back unchanged.
- The whole path. On Farmshare, with the real model, a test design's screening ran end to end four times, through the job that will run the real stages: 8 of 8 contests finished each time. Submitting it again submitted nothing.
- Tokenizer. The local tokenizer reproduces all 48 token counts the cluster recorded.
Freezing. Once Duy's calls are in and the checks pass, freezing records hashes of every hint, test archive, harness file, the serving setup and the judging processor. The job submitter then refuses to run if anything differs. Nothing is frozen yet.
What it needs. Duy's 5 calls. Then about three days on four Farmshare GPUs, at no cost. The code is code/hint_transfer*.py and code/api_learner/; the files are in hint_transfer/.

3. Harness issues found

The locations refer to github.com/xupy2003/InsightGeneration at 25b9344.

#	where	what happens	status
1	`agent/run.py:349-351`	An older turn's shortened copy takes its text from `content`, which the tool loop has already set to the last tool result. The learner sees that result, clipped to 400 characters, where its own words should be. Confirmed with a stubbed-vLLM run.	open
2	`judge.py:313-315, 386-395`	A checker's or interactor's message is appended to WA and reached the learner, e.g. "WA (the tower is 9006 cm tall, not 1001 cm)" in 2025/J. This affects 2021/H, 2023/A, 2024/F and 2025/J.	fixed 9/30 by Abhiram Kadiyala's PR #1 in `agent/prompt.py` and `agent/store.py`. `LLM/prompt.py` and the insight engine's view (`InsightGen/*/history.py`) still show the full message.
3	`judge.py:_limits`	The stack limit is never raised, so correct deep recursion crashes at the usual 8 MB. 7 of the 11 accepted jury solutions for NWERC 2024 G failed this way.	open
4	`_verify/judging.json`	2022/Y accepts any shortest answer, but has no checker, so answers are compared exactly.	open
5	`run.py:patch_includes`	Adding `#include <bits/stdc++.h>` alongside the program's own `using namespace std;` makes `exp` and `slice` clash with the program's own names. The correct references for 2013/D and 2015/D fail to compile.	open
6	`agent/run.py:annotate_summary`	The contest clock is not recorded. Reference arms default to 7200 s and insight evaluations to 3600 s.	open
7	`problems.txt`	It lists two problems twice (2022/P = 2023/G, 2022/T = 2023/D), so 22 are distinct.	note
8	`LLM/sweep.sh`, `LLM/run.py:grade`, `agent/sweep.sh`	The `LLM/sweep.sh` header and the `grade` comment still describe the 9/21 run (53 problems). Separately, `agent/sweep.sh -h` prints only 17 lines of its 19-line header.	open

4. A second look at the 9/28 results

Everything below comes from the published reference.json, insights.jsonl and best.json of each problem in xupy21/ICPC_Data at revision 372ef6c (10/1), which includes the rerun of four problems; the tool-call counts come from its no-hint and editorial transcripts. GPT-6-Astra checked every number independently.

Most problems were already solved.
- 16 of the 24 entries (14 of 22 distinct problems) are solved 5/5 with no hint.
- The 14 extra solves come from 7 problems. 11 of them come from 2021/L, 2024/I, 2025/J and 2025/K, which went from 8/20 to 19/20; the editorial also gets 19/20.
- So on most problems an insight saves tokens rather than making the problem solvable.
"Shortest successful" is a minimum over noisy tests. Each problem's winner is the shortest of its 10 insights that passed, and every insight was scored on the same 5 seeds.
- Token counts swing a lot between runs. In the 217 rounds where all five runs solved, the median coefficient of variation is 0.52, so a 5-run mean carries about 23% standard error. The success bar rests on the editorial's own 5-run mean, so it is exposed to the same noise.
- Mosaic Browsing: versions of one sentence at 15, 16 and 12 tokens scored 58.0k (fail), 29.9k (pass) and 49.3k (fail), against a 36.8k bar.
- Splitstream: a 7-token and the 10-token winner say the same thing. The 7-token one failed because two of its five runs took 93.0k and 64.2k tokens.
- One-word winners. Two winners are a single word:
  - "mod" for 2024/C, where no hint at all already clears the bar;
  - "DP" for 2025/D, where no hint misses the bar by 10%.
Some winners also instruct the agent's behaviour. Alongside the algorithm, 6 of the 24 winners, and 29 of the 138 successful rounds, tell the agent to submit at once or to skip testing. For example, the 2025/K winner opens "Spend <1000 reasoning tokens; no rederivation/testing. Immediately CALL the submit tool". A line like that could save tokens on any problem.
- It targets a real habit. Without a hint, the learner calls a tool the harness does not have in 357 of 1,890 rounds (19%), and in 122 of 134 on 2025/K. Usually that is a Python sandbox (stateful_python and variants). With the editorial it does so in 23 of 382 rounds (6%).
- The harness answers that there is no such tool (agent/tools.py), and none of those rounds submits anything.
There is no placebo. Nothing measures what an unrelated hint of the same length does. In one small study (Qwen2.5-3B, arXiv 2609.01106), unrelated hints rescued 19 failures where real hints rescued 36.
The teacher's cost is not counted. Each problem cost 10 GPT-6-Astra rounds at effort xhigh plus 50 learner runs. That pays off only if an insight is reused many times.
Rerunning the four leak problems changed little. 2021/H, 2023/A, 2024/F and 2025/J (Stacking Cups) first ran with checker messages visible to the learner (issue 2). On 10/1 Peiyang re-ran their no-hint and editorial runs and their insight loops with the fix.
- No hint now solves 16 of 20 runs instead of 15: 2025/J went from 0/5 to 1/5.
- The editorial still solves 20 of 20, and each problem again has a winner that solves 5/5.
- The winners changed, e.g. 2021/H from 65 to 17 tokens and 2024/F from 89 to 200. But every round's insight is new, so the leak's part in that cannot be told apart from the loop's own variation.

What would settle it cheaply:

Re-run the other 20 entries' reference arms on the fixed harness. The fix also shortens verdicts on every problem (RTE (killed by SIGSEGV) becomes RTE), so their 9/28 thresholds no longer match it.
In the same batch, re-score the winning insights on new seeds 6–10 (110 runs for the 22 distinct problems).
Add a length-matched unrelated hint and a "submit directly" line on its own, for a few problems.

What the literature already says:

Hints mostly help where the learner is already close.
- For a 1.5B model, a quarter of the solution sketch left almost as many problems unsolved as no hint (3,155 against 3,812), while half the sketch left 143 (QuestA, arXiv 2507.13266).
- Accuracy stays flat, then jumps once the key step is included (KnowRL, arXiv 2604.12627).
- Human tutoring took GPT-4 from 0 to 13 of 15 unsolved USACO problems and left GPT-3.5 at 0 (arXiv 2404.10952).
Closest prior work on carrying insights across problems:
- ExpeL (arXiv 2308.10144): GPT-4 writes insights that GPT-3.5 uses. Near transfer gained 63 → 70, after the insights were rewritten with target examples.
- Buffer of Thoughts (arXiv 2406.04271): templates for whole problem families lift Llama3-8B on puzzles.
- The USACO study: retrieving similar problems' solutions raised GPT-4 from 8.7 to 14.3 pass@1.
- Dynamic Cheatsheet (arXiv 2504.07952): mixed results on small models.
- Decocted Experience (arXiv 2604.04373): a model reusing its own experience within one task.
Not covered by any of these: a placebo-controlled test of one hard problem's insight on a different hard problem, for a small learner.

The records at revision 372ef6c, per problem

Pass counts and mean tokens per run come from reference.json and best.json. An unsolved run counts as 3,000,000 tokens. The bar is the editorial's pass count, with at most 1.5× its mean tokens.

problem	no hint	editorial	success bar	shortest successful insight	its runs
`2021/A-crystal-crosswind`	5/5, 54.8k	5/5, 21.3k	≥5/5, ≤31.9k	236 tokens: “Use byte boundary tables B[w][p]; read each wx wy b and i…”	5/5, 27.6k
`2021/C-fair-division`	5/5, 95.6k	5/5, 27.3k	≥5/5, ≤40.9k	131 tokens: “Implement and call `submit` this turn; no code blocks or…”	5/5, 28.5k
`2021/E-hand-of-the-free-marked`	4/5, 1,357.7k	5/5, 15.1k	≥5/5, ≤22.6k	87 tokens: “Next tool call: submit. Implement this proven formula wit…”	5/5, 20.7k
`2021/G-mosaic-browsing`	4/5, 651.1k	5/5, 24.5k	≥5/5, ≤36.8k	16 tokens: “1D FFT masked squared-error correlations; flatten both gr…”	5/5, 29.9k
`2021/H-prehistoric-programs`	5/5, 29.0k	5/5, 15.8k	≥5/5, ≤23.7k	17 tokens: “Nonnegatives: decreasing minimum prefix; then negatives:…”	5/5, 22.2k
`2021/J-splitstream`	5/5, 31.4k	5/5, 26.2k	≥5/5, ≤39.2k	10 tokens: “Cache lengths; backtrack indices O(nq).”	5/5, 32.8k
`2021/L-where-am-i`	3/5, 1,567.9k	5/5, 49.1k	≥5/5, ≤73.6k	113 tokens: “Simulate 39601 spiral visits: T(0,0)=0; cyclic directions…”	5/5, 59.4k
`2022/P-turning-red`	5/5, 82.4k	5/5, 32.8k	≥5/5, ≤49.2k	80 tokens: “Press targets R=0,G=2,B=1. BFS button components via shar…”	5/5, 33.7k
`2022/T-carls-vacation`	5/5, 58.2k	5/5, 16.3k	≥5/5, ≤24.5k	111 tokens: “With v=b-a,w=(-v.y,v.x), use cyclic corners a,b,b+w,a+w.…”	5/5, 16.5k
`2022/Y-compression`	5/5, 35.9k	5/5, 6.6k	≥5/5, ≤9.8k	23 tokens: “Print: uniform input → its bit; different endpoints → fir…”	5/5, 9.5k
`2023/A-riddle-of-the-sphinx`	5/5, 36.5k	5/5, 15.2k	≥5/5, ≤22.8k	28 tokens: “Query x,y,z,x+y+z,x+2y+3z: any three independent. Solve t…”	5/5, 21.7k
`2023/D-carls-vacation`	5/5, 40.4k	5/5, 13.8k	≥5/5, ≤20.7k	128 tokens: “For all 16 base-edge pairs interpolate p(t),q(u). With ba…”	5/5, 19.5k
`2023/G-turning-red`	5/5, 52.5k	5/5, 31.6k	≥5/5, ≤47.4k	66 tokens: “Submit C++17 directly. Buttons are vertices; lights impos…”	5/5, 40.0k
`2023/K-alea-iacta-est`	5/5, 543.0k	5/5, 98.7k	≥5/5, ≤148.0k	256 tokens: “Use stochastic Dijkstra, not locked-count DP. Call submit…”	5/5, 88.0k
`2024/C-citizenship`	5/5, 219.9k	4/5, 749.1k	≥4/5, ≤1,123.7k	1 token: “mod”	5/5, 132.4k
`2024/F-friendly-rivalry`	5/5, 50.1k	5/5, 18.4k	≥5/5, ≤27.6k	200 tokens: “Implement this plan directly: brief analysis, then make y…”	5/5, 25.7k
`2024/I-steppe-on-it`	1/5, 2,509.6k	4/5, 854.2k	≥4/5, ≤1,281.2k	34 tokens: “Postorder: nearest center C, farthest uncovered D includi…”	4/5, 978.2k
`2025/C-bride-of-pipe-stream`	4/5, 1,204.5k	5/5, 58.8k	≥5/5, ≤88.1k	97 tokens: “Minimax gives 100 min H(w) over simplex weights, where H…”	5/5, 80.0k
`2025/D-buggy-rover`	5/5, 33.7k	5/5, 20.4k	≥5/5, ≤30.6k	1 token: “DP”	5/5, 26.9k
`2025/E-delivery-service`	4/5, 1,101.8k	4/5, 701.6k	≥4/5, ≤1,052.4k	38 tokens: “Union home(a),destination(b). Count Σ choose(cities touch…”	4/5, 843.3k
`2025/F-herding-cats`	5/5, 132.6k	5/5, 33.7k	≥5/5, ≤50.5k	38 tokens: “L[v]=max target of cats liking v (default 0). Feasible if…”	5/5, 45.7k
`2025/J-stacking-cups`	1/5, 2,702.1k	5/5, 65.1k	≥5/5, ≤97.6k	56 tokens: “For h=2n+1,n≥4 output tallest,3,unused descending. Otherw…”	5/5, 48.2k
`2025/K-treasure-map`	3/5, 1,833.6k	5/5, 38.2k	≥5/5, ≤57.2k	200 tokens: “Spend <1000 reasoning tokens; no rederivation/testing. Im…”	5/5, 50.4k
`2025/L-walking-on-sunshine`	5/5, 19.5k	5/5, 7.1k	≥5/5, ≤10.6k	93 tokens: “Horizontal travel is free: switch rectangles at any share…”	5/5, 9.4k

Layout

bank/
  problems/<year>/<L>-<slug>/      statement.txt, solution.tex, sketch.txt, solution.cpp, meta.json
  problems/nwerc2024/<L>-<slug>/   the same, plus statement.pdf (tests not included)
  problems/_verify/                judging.json, checkers/, interactors/ (the harness reads these)
  tables/bank.jsonl                one row per problem directory: start here
  tables/                          edges, families, contamination, validation results, test-archive checksums
  labels/{claude,codex}.jsonl      each labeller's techniques and key observations
  families/{claude,codex}_groups.json   each model's proposed idea groups
hint_transfer/                     candidate pairs, lemma drafts, review.txt, approvals.jsonl,
                                   hints/, hints.jsonl, judge checks, token counts, the tokenizer pin
  learners/<learner>/learner.json  each learner's model, revision and serving settings
code/                              the scripts that build the bank and run the experiment;
                                   code/README.md documents them
  api_learner/                     the learner client and the Farmshare stage job

Not included, and how to get them:

Tests.
- World Finals: import_wf_tests.py reinstalls them, and refuses any archive whose checksum differs from the one recorded in tables/wf_tests.jsonl.
- NWERC 2024: import_kattis.py --contests nwerc2024.
The reference lists used for the contamination flags: import_refs.py.
The math set: it is on the Hub as jasonlwd/HM-ReasoningBench.
The tokenizer: pinned by hash in hint_transfer/tokenizer/pin.json and fetched from nvidia/Nemotron-Cascade-2-30B-A3B.
Each learner's tokenizer, chat template and configs: NVIDIA's files, fetched from the repository and revision in its learner.json.

Using it

The scripts expect to sit in the harness repository as dataset/, with the data under data/:

git clone https://github.com/xupy2003/InsightGeneration && cd InsightGeneration
hf download yudduy/icpc-bank --repo-type dataset --local-dir ../icpc-bank      # after access is granted
mkdir -p data && cp -r ../icpc-bank/bank data/bank && cp -r ../icpc-bank/hint_transfer data/hint_transfer
cp -r ../icpc-bank/code dataset
ulimit -s 65520                                          # room for deep recursion (issue 3)
python3 dataset/import_wf_tests.py --years 2024 2025     # the official tests for the years you need
export WF_ARCHIVE=$PWD/data/bank/problems                # what agent/ and InsightGen/ read
export MODEL_PATH=/path/to/Nemotron-Cascade-2-30B-A3B
(cd agent && python3 run.py --model "$MODEL_PATH" --problem 2025/K --seed 1)   # on a GPU node

To choose problems, filter bank/tables/bank.jsonl. For example, the judgeable members of idea families:

python3 -c "import json; [print(r['id'], r['idea_family_name']) for r in map(json.loads, open('data/bank/tables/bank.jsonl')) if r['harness_ready'] and r['idea_family']]"

Sources and rights

ICPC Foundation. World Finals statements, judges' sketches, test archives and solve counts come from the official archive and results. They are © ICPC Foundation, with no open licence, which is why access is gated.
Community editorials come from nghia03092004.github.io, where the team's 24 editorials also came from.
Alternative reference solutions come from github.com/SnapDragon64/ACMFinalsSolutions.
NWERC 2024 material comes from that contest's published packages.
All of the above belong to their authors.
The labels, families, lemma drafts and hints were generated for this project with Claude and Codex.

How this was made

Duy Nguyen built it with Claude Code and Codex between 2026-09-28 and 2026-10-02.

Codex reviewed the code over several rounds, and the Farmshare path over seven.
GPT-6-Astra checked every number in section 4 against the published records.
The literature claims were checked against the papers' own text.

v0.1 (2026-09-28) held only the team's 24 problems, repackaged with their tests: a copy of Peiyang's set. v0.2 replaces it with the bank, the experiment and this card. v0.1's folders (packages/, manifests/, metadata/, verify/) are still in the repository; nothing in v0.2 reads them.

Downloads last month: 36

Total file size:

1.04 GB

edge	count
`D3_idea`: same idea family	15
`D3_technique`: same technique family	166
`D4`: a control of similar difficulty sharing neither	194