EvertBuzon/qwen35-2b-logic-blind-spots

Qwen3.5-2B Logic Blind Spots

This small dataset contains examples of mistakes made by the base language model Qwen/Qwen3.5-2B-Base.

The goal was to test simple reasoning situations where the model should give a short and precise answer. In several cases the model produces incorrect outputs or does not follow the format requested in the prompt.

This dataset is not intended to be a formal benchmark. It is only an exploratory collection of examples that illustrate some blind spots of current base language models.

---

Model Tested

Model tested:

https://huggingface.co/Qwen/Qwen3.5-2B-Base

Parameters: around 2B
Model type: base pretrained model (not instruction tuned)

---

Reproducibility

The experiment was executed in Google Colab.

Colab notebook:

https://colab.research.google.com/drive/1TjklzXMn13gh9sQhBCwpdGZWnB9r0P-K?usp=sharing

---

Code Used to Load the Model

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "Qwen/Qwen3.5-2B-Base"

tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto"
)

def run_prompt(prompt):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    outputs = model.generate(**inputs, max_new_tokens=20)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

---

Dataset Structure

Each row in the dataset contains four fields:

• input – the prompt given to the model
• expected_output – the correct answer
• model_output – the answer generated by the model
• error_type – the type of mistake observed

The prompts were designed to test several simple reasoning abilities.

---

Error Categories

The dataset includes several types of reasoning errors observed when interacting with the model.

Arithmetic reasoning

Some prompts test simple calculations such as addition or division.

Reasoning failures in language models on arithmetic tasks have been discussed for example in:

Wei et al. (2022)
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models

---

Counting errors

Some prompts require counting characters inside a word.

Language models often struggle with this type of task because they operate on tokens rather than individual characters.

Related discussion appears in:

Bubeck et al. (2023)
Sparks of Artificial General Intelligence

---

Constraint-following errors

Some prompts explicitly require very strict outputs, for example:

• only one word
• only one number
• exact string reproduction

In several cases the model produces additional tokens or reasoning traces instead of following the constraint.

Related issues are discussed in:

OpenAI (2023)
GPT-4 Technical Report

---

Sequence reasoning errors

Some prompts test continuation of simple numeric or alphabetic sequences.

These tasks probe pattern recognition and compositional reasoning.

---

Logical consistency

Some prompts evaluate simple logical statements.

Example:

“All squares are circles.”

These types of reasoning tests are related to work such as:

Dziri et al. (2023)
Faith and Fate: Limits of Transformers on Compositional Reasoning

---

Relational reasoning

Some prompts test basic relationships.

Example:

"If Mary is John's mother, John is Mary's what?"

Related discussions appear in work on systematic generalization such as:

Lake & Baroni (2018)
Generalization without systematicity

---

Exploratory causal reasoning

Some prompts explore simple causal logic.

Example:

"If every time A happens B happens, and B did not happen, can A have happened?"

This idea is related to classical work on causal reasoning such as:

Pearl (2009)
Causality: Models, Reasoning and Inference

---

Observed Failure Patterns

Several concrete failure patterns appear in the collected examples.

1. Failure to respect strict output constraints

In multiple prompts the model was explicitly instructed to output only one token (for example one number or one word).
However the model sometimes produced additional tokens or partial reasoning traces instead of the requested format.

Examples include:

• returning sequences such as ", 32, 64," when only one value was requested
• producing <think> instead of the final answer

This suggests the base model sometimes prioritizes internal generation patterns over strict formatting constraints.

---

2. Incorrect symbolic or relational reasoning

In some prompts involving simple relationships (for example family relations), the model either produced incorrect answers or failed to produce a final answer.

These tasks are structurally simple but require consistent symbolic reasoning rather than pattern completion.

---

3. Weak compositional reasoning

In sequence continuation tasks the model sometimes generated plausible but incorrect continuations.

For example:

expected output: 32
model output: , 32, 64,

This suggests the model is generating patterns rather than strictly solving the task requested in the prompt.

---

4. Character-level counting difficulties

Counting tasks such as counting letters inside a word sometimes fail.

This behavior has been previously observed because language models operate primarily on tokens rather than characters.

---

5. Reasoning trace leakage

In some cases the model outputs tokens such as <think> instead of the final answer.

This may indicate that internal reasoning traces are partially exposed in generation when the model is uncertain about the final output.

---

How These Errors Could Be Improved

Several works suggest that targeted fine-tuning on reasoning datasets can improve performance on structured reasoning tasks.

For example:

Wei et al. (2022) show that exposing models to structured reasoning examples can improve reasoning performance.

Similarly, instruction-tuning approaches described in:

Ouyang et al. (2022)
Training language models to follow instructions with human feedback

demonstrate that models can learn to follow strict output constraints when trained on curated instruction datasets.

Based on these findings, improving the behaviors observed in this dataset would likely require additional supervision focused on:

• strict output formatting
• symbolic reasoning
• relational reasoning
• structured reasoning tasks

---

Dataset Construction Strategy

A dataset designed to reduce these errors could combine both synthetic and curated sources.

Possible construction strategy:

1. Synthetic generation

Tasks such as arithmetic, sequence continuation, ordering and relational reasoning can be generated programmatically.
This allows creation of large numbers of controlled examples.

2. Existing reasoning benchmarks

Existing datasets could also be used, for example:

• GSM8K (Cobbe et al., 2021) for arithmetic reasoning
• reasoning tasks from BigBench

3. Symbolic reasoning templates

Structured templates could generate tasks such as:

"If A is B's parent and B is C's parent, what is A to C?"

These tasks help encourage systematic reasoning instead of pattern matching.

---

Estimated Dataset Size

Previous work on instruction tuning and reasoning datasets provides some guidance about scale.

For example:

• GSM8K (Cobbe et al., 2021) contains about 8.5k problems
• FLAN instruction tuning (Wei et al., 2022) used tens of thousands of examples
• InstructGPT training (Ouyang et al., 2022) used datasets on the order of tens of thousands of examples

Based on these precedents, a dataset intended to improve the reasoning behaviors tested here would likely require approximately:

10,000 – 50,000 examples

with diverse reasoning structures.

---

Notes

This dataset is intentionally small and exploratory. The purpose is simply to highlight concrete blind spots in a modern base language model and provide examples that could motivate further improvements.