README.md

metadata

license: mit
language:
  - en
pretty_name: ThinkProbe
size_categories:
  - 100K<n<1M
task_categories:
  - text-generation
  - text-classification
  - graph-ml
tags:
  - reasoning
  - reasoning-graphs
  - thought-graphs
  - llm-evaluation
  - discourse-segmentation
  - open-ended-questions
  - arxiv:2606.29067
configs:
  - config_name: graphs
    default: true
    data_files:
      - split: test
        path: data/graphs/test.parquet
  - config_name: questions
    data_files:
      - split: test
        path: data/questions/test.parquet
  - config_name: thought_units
    data_files:
      - split: test
        path: data/thought_units/test.parquet
  - config_name: segmentation_verification
    data_files:
      - split: test
        path: data/segmentation_verification/test.parquet

ThinkProbe: Thought Graphs of Open-Ended LLM Reasoning

This is the companion dataset for ThinkProbe: Beyond Accuracy — Structural Profiling of Open-Ended LLM Reasoning Traces via Non-Generative Thought Graphs (Kerkouri et al., 2026). The code is at github.com/kmamine/ThinkProb.

ThinkProbe turns each LLM reasoning trace into a Thought Graph: a directed graph, which can contain cycles, whose nodes are typed thought units (TUs) and whose edges are typed reasoning links. The pipeline does not use a generative model at any step. It combines rule-based segmentation, MiniLM-based TextTiling, and linking based on embedding similarity.

The dataset contains the Thought Graphs for 7 open-weight LLMs answering 200 open-ended questions in 10 domains, with 3 runs per (model, question) pair. It also includes the 50-trace human segmentation validation set used in the paper.

Questions	200 (10 domains × 20)
Models	7 open-weight LLMs
Runs per (model, question)	3
Thought Graphs	4,200
Thought units (nodes)	154,840 (mean 36.9 per graph)
Edges	478,273
Human segmentation validation traces	50 (2 annotators)

Quick start

from datasets import load_dataset

graphs    = load_dataset("Amine-CV/thinkprob", "graphs", split="test")         # default config
questions = load_dataset("Amine-CV/thinkprob", "questions", split="test")
units     = load_dataset("Amine-CV/thinkprob", "thought_units", split="test")
seg       = load_dataset("Amine-CV/thinkprob", "segmentation_verification", split="test")

# Node-type distribution per model
df = units.to_pandas()
print(df.groupby("model")["node_type"].value_counts(normalize=True).unstack())

# Build a networkx graph for one trace
import networkx as nx
g = graphs[0]
G = nx.MultiDiGraph()
G.add_nodes_from((n["tu_id"], n) for n in g["nodes"])
G.add_edges_from((e["source"], e["target"], e) for e in g["edges"])

Configs

All configs have one test split.

graphs (default) — 4,200 rows

One row per model response (trace) with its full Thought Graph.

Field	Type	Description
trace_id	string	Unique trace identifier (UUID)
model	string	Hugging Face model id that generated the response
question_id	string	Key into questions.id (e.g. D1_001)
domain	string	Question domain
question	string	Question text (copied from questions for convenience)
run	int8	Independent sampling run (1–3)
token_count	int32	Response length in tokens
n_nodes, n_edges	int32	Graph size
nodes	list[struct]	Thought units; see thought_units for the fields
edges	list[struct]	source, target (node tu_ids), edge_type, confidence (float), is_sequential (bool)

The same node pair can be joined by several edges with different types. For example, a SEQ edge and an ELAB edge can both connect nodes 0 → 1.

questions — 200 rows

Field	Type	Description
id	string	D<domain#>_<nnn>
domain	string	One of the 10 domains below
text	string	The question prompt
expected_angles	list[string]	Perspectives a thorough answer would be expected to consider
difficulty	string	medium (57) or hard (143)

thought_units — 154,840 rows

The nodes of graphs flattened to one row per node. Use it for tabular analysis.

Field	Type	Description
trace_id, model, question_id, domain, run		Trace keys (join to graphs)
tu_id	int32	Node index within the trace (0..n-1, in reading order)
text	string	Thought-unit text
start_char, end_char	int32	Character span in the original response
token_count	int32	Tokens in the unit
boundary_class	string	Class of the boundary that opens the unit (see below)
node_type	string	Reasoning-move type (see below)
node_family	string	Family of node_type
classification_confidence	float32	Boundary-detection confidence: 1.0 when the unit opens on a cue-based boundary, 0.5 when it opens on an untyped (NONE) break. It is not a probability for node_type; node typing is deterministic.

segmentation_verification — 50 rows

The human validation set for TU segmentation. Two expert annotators (EA1, EA2) segmented each trace independently, and their segmentations sit next to the pipeline output.

Field	Type	Description
sample_id	int32	Index of the validation sample (0–49)
trace_id, model, question_id	string	Trace keys (join to graphs)
ea1_segments, ea2_segments	list[struct]	Annotator segmentations: start_sent (index of the sentence where the segment starts), boundary_class
pipeline_n_tus	int32	Number of TUs found by the pipeline
pipeline_boundary_classes, pipeline_node_types	list[string]	Pipeline labels per TU
pipeline_tu_texts	list[string]	Pipeline TU texts, cut off at 120 characters

start_sent indexes sentences produced by punctuation-based splitting (a period followed by an uppercase letter). These sentence lists are not part of this release.

Label definitions

Definitions are quoted from the paper (Table 1 and Appendix B). The counts are computed from this dataset.

Node types

Code	Family	Definition	Count
HYP	Exploration	A new hypothesis, conjecture, or initial framing of the problem	16,138
RFR	Exploration	Restates the problem from a different conceptual starting point	32,859
SPC	Elaboration	Narrows or specifies a prior idea with detail or constraint	50,597
JUS	Elaboration	Provides evidence, justification, or reasoning support for a prior claim	0
CRT	Evaluation	Identifies a flaw, limitation, or counter-argument in prior reasoning	10,021
CMP	Evaluation	Contrasts two ideas, framings, or positions against each other	0
MET	Evaluation	Reflects on the quality or direction of the reasoning process itself	347
SYN	Convergence	Integrates multiple prior threads into a unified position or conclusion	44,878

The taxonomy defines 8 types, but JUS and CMP are never assigned in this release.

Boundary classes

Class	Triggered by	Count
NONE	Untyped paragraph break (default)	55,338
BRANCH	Explicit section break (markdown header, bold line)	49,311
ELABORATION	Cue phrases signalling that detail is being expanded	27,717
CONVERGENCE	Convergence cues (e.g. "putting this together", "in summary")	21,895
BACKTRACK	Backtracking cues (e.g. "wait", "but actually", "on second thought")	579
META	Process-reflection cues (e.g. "let me step back"); annotator labels only	—
CONTRAST	Contrastive connectives; annotator labels only	—

Edge types

Code	Definition	How it is assigned	Count
SEQ	Default sequential flow between adjacent TUs	Default; is_sequential = true, confidence = 1.0	150,640
BRCH	A new reasoning branch diverges from the current thread	BRANCH boundary, or a semantic shift below the trace's 25th-percentile similarity	71,612
ELAB	The target TU elaborates or extends the source	Embedding similarity ≥ the trace's 65th percentile	38,892
BACK	The target TU revises or corrects a non-adjacent prior TU	Backward arc from a BACKTRACK-class TU spanning more than 1 segment	30,371
SYNT	The target TU synthesises content from multiple source TUs	CONVERGENCE boundary with linking to several parents	186,758

For non-SEQ edges, confidence is a continuous score between −0.04 and 1.0. Its values match similarities computed with all-MiniLM-L6-v2, but treat this as an observation from the data, not a definition from the paper.

Models

Model	Graphs	Mean tokens / response
google/gemma-4-31B-it	600	654.8
microsoft/Phi-4-reasoning	600	1,704.2
mistralai/Mistral-Medium-3.5-128B	600	985.6
nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4	600	1,631.4
openai/gpt-oss-120b	600	2,194.9
Qwen/Qwen3.5-35B-A3B	600	1,017.7
zai-org/GLM-4.7-Flash	600	1,691.5

Domains

There are 20 questions per domain: Ethical Dilemmas, Policy Design, Strategic Planning, Scientific Speculation, Creative Problem Solving, Interpersonal Reasoning, Economics & Markets, Geopolitics, Environmental Ethics, Philosophy & Metaphysics.

Dataset creation

1. Questions. The authors wrote seed questions for each domain by hand, then expanded them to 20 per domain with LLM assistance while keeping the topics diverse. Two expert annotators reviewed all 200 questions independently against one criterion: the question must be truly open-ended, with no single correct answer.
2. Generation. Locally hosted models were served with vLLM behind an OpenAI-compatible endpoint. Settings: temperature 0.7, max 20,000 tokens, no system prompt, 3 independent runs per question. Degenerate loops were caught by hashing repeated normalised lines, with up to 3 retries.
3. Segmentation (Layer 1). Rule-based splitting on markdown headers, bold lines, blank lines, and sentence boundaries. Spans shorter than 3 sentences or 50 tokens are merged.
4. Soft boundaries (Layer 2). TextTiling over all-MiniLM-L6-v2 sentence embeddings (window width 3). Local minima below the trace's 30th-percentile similarity become boundaries.
5. Linking. Typed edges are added using cue-phrase boundary classes and similarity thresholds computed per trace (see Edge types).
6. Node typing. A deterministic priority hierarchy assigns node types. It looks at synthesis and backtracking edges, then boundary class, then similarity and edge patterns.
7. Validation. Two annotators segmented 50 traces independently (the segmentation_verification config). The paper reports that the pipeline matches or exceeds inter-annotator agreement on major cognitive transitions; see the paper for the Krippendorff's α values.

Limitations

• The full raw responses are not included. Only the segmented TU texts are released. Joining the text values in tu_id order gives an approximation of the response, but whitespace and formatting between units (see the gaps between end_char and the next start_char) are lost.
• The sentence lists that annotator start_sent indices refer to are not included.
• pipeline_tu_texts are cut off at 120 characters, as in the source files.
• All graph labels come from an automatic, rule- and similarity-based pipeline, so they contain noise. Only the EA1/EA2 segmentations are human annotations.
• Questions and responses are in English only.

License

The dataset is released under the MIT license. The model outputs are also subject to the license and terms of use of the model that generated them (see the Models table).

Citation

@misc{kerkouri2026thinkprobeaccuracystructural,
      title={ThinkProbe: Beyond Accuracy -- Structural Profiling of Open-Ended LLM Reasoning Traces via Non-Generative Thought Graphs},
      author={Mohamed Amine Kerkouri and Simon D. Hernandez and Marouane Tliba and Yann Dauxais and Maha Ben-Fares and Pierre Holat},
      year={2026},
      eprint={2606.29067},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2606.29067},
}