File size: 7,279 Bytes
fb11b8a
 
08532e9
 
 
 
64ba39e
fb11b8a
 
18f6d83
 
fb11b8a
 
18f6d83
 
 
fb11b8a
 
 
 
 
e357c14
f21cb70
 
 
e357c14
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
f21cb70
fb11b8a
 
 
 
6f59da1
 
 
 
 
 
 
 
fb11b8a
 
6f59da1
 
 
 
fb11b8a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
08532e9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
---
license: apache-2.0
language:
- en
size_categories:
- 1K<n<10K
pretty_name: t
---

![Axiomic Banner](AxiomicBanner.png)

# LogicMark

A procedurally generated benchmark for evaluating symbolic logic in language models. Each problem presents a set of variable equality/inequality premises and asks the model to identify which conclusion necessarily follows.

Unlike knowledge-based benchmarks, LogicMark contains no facts a model could have memorised from pretraining. Every problem is generated fresh from abstract variable names (`a`, `b`, `c`, ...), so a model cannot pattern-match to training data - it must actually reason. This makes LogicMark a direct probe of **intrinsic reasoning capability**: the logical structure that has been built into the model's weights through training, independent of world knowledge or surface-level heuristics.

Evaluation is log-likelihood multiple-choice — no chain-of-thought, no prompting tricks. Models are scored purely on how well they assign probability to the correct completion.

---

## Benchmark Results (10000 examples)

Evaluated using average log-likelihood over ending tokens, normalised by length. Random chance = 25%.

| Company      | Model                  | Params | 1-hop      | 2-hop      | 3-hop      | 4-hop      | 5-hop      | Avg        |
| ------------ | ---------------------- | ------ | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- |
| Alibaba      | Qwen2.5-Math-1.5B      | 1.5B   | 51.10%     | 56.47%     | 50.40%     | **44.60%** | 47.40%     | **51.73%** |
| Axiomic Labs | GPT-X2-125M            | 125M   | 69.00%     | 48.98%     | **48.76%** | 41.07%     | 42.50%     | 49.09%     |
| HuggingFace  | SmolLM2-135M           | 135M   | 78.70%     | 50.72%     | 43.16%     | 38.47%     | 39.10%     | 48.6%      |
| EleutherAI   | pythia-2.8b            | 2.8B   | **79.90%** | 51.73%     | 40.56%     | 37.93%     | 37.50%     | 48.26%     |
| Alibaba      | Qwen2.5-3B             | 3.1B   | 47.10%     | **53.33%** | 47.68%     | 41.13%     | **40.80%** | **48.21%** |
| Alibaba      | Qwen2.5-1.5B           | 1.5B   | 48.30%     | 50.42%     | 46.36%     | 42.00%     | 43.00%     | 47.19%     |
| HuggingFace  | SmolLM2-1.7B           | 1.7B   | 70.50%     | 51.08%     | 37.64%     | 35.13%     | 37.10%     | 45.87%     |
| Alibaba      | Qwen2.5-Coder-1.5B     | 1.5B   | 46.70%     | 49.93%     | 43.48%     | 38.73%     | 42.60%     | 45.58%     |
| EleutherAI   | GPT-neo-125m           | 125M   | 72.10%     | 50.58%     | 36.96%     | 34.47%     | 36.00%     | 45.45%     |
| Facebook     | MobileLLM-R1-140M-base | 140M   | 68.00%     | 48.98%     | 38.96%     | 34.00%     | 38.10%     | 45.04%     |
| EleutherAI   | pythia-31m             | 30M    | 63.90%     | 49.60%     | 37.84%     | 35.40%     | 37.40%     | 44.74%     |
| OpenAI       | gpt2                   | 124M   | 56.60%     | 51.42%     | 36.88%     | 35.47%     | 37.50%     | 44.52%     |
| OpenAI       | gpt2-medium            | 355M   | 57.50%     | 51.42%     | 36.92%     | 35.47%     | 36.10%     | 44.48%     |
| OpenAI       | gpt2-xl                | 1.6B   | 58.60%     | 49.55%     | 37.76%     | 36.00%     | 38.00%     | 44.32%     |
| HuggingFace  | SmolLM-135M            | 135M   | 58.80%     | 50.28%     | 36.36%     | 34.93%     | 35.90%     | 43.91%     |
| Alibaba      | Qwen2.5-0.5B           | 494M   | 48.60%     | 49.10%     | 39.60%     | 37.53%     | 38.40%     | 43.87%     |
| Facebook     | OPT-125M               | 125M   | 59.40%     | 49.53%     | 36.68%     | 35.40%     | 36.20%     | 43.85%     |
| Axiomic Labs | GPT-X-125M             | 125M   | 57.30%     | 49.45%     | 37.16%     | 35.33%     | 37.10%     | 43.81%     |
| EleutherAI   | pythia-160m            | 162M   | 56.10%     | 41.33%     | 32.68%     | 30.93%     | 34.20%     | 38.37%     |
| EleutherAI   | pythia-70m             | 70M    | 44.00%     | 38.70%     | 30.48%     | 28.67%     | 29.90%     | 34.79%     |


## Task Format

```
If:
a = g
e != f
b != g
d = h
c = g
a != b
d = e
a = e

Then
A. c = h
B. c != h
C. c != e
D. b = h
```

The model must select the option that is logically entailed by the premises. Distractors include the flipped version of the correct answer and false statements drawn from the same variable set.

---

## Hop Depth

Each problem is tagged with a **hop depth** — the minimum number of inference steps required to derive the correct answer from the premises:

- **1-hop**: answer is directly stated as a premise
- **2-hop**: requires one transitive step (e.g. `a=b`, `b=c` → `a=c`)
- **3-hop**: requires two transitive steps
- **4-hop+**: longer inference chains

The current dataset (1000 problems) targets the following distribution:

| Hop | Target |
|-----|--------|
| 1 | 10% |
| 2 | 40% |
| 3 | 25% |
| 4 | 15% |
| 5 | 10% |

---

## Graph Styles

Premises are generated using six equality graph topologies, each producing different reasoning patterns:

| Style | Description |
|-------|-------------|
| `chain` | Variables linked in a linear sequence |
| `star` | One central variable connected to many others |
| `clusters` | Groups of variables internally linked |
| `tree` | Binary tree topology — maximises chain depth per variable |
| `bipartite` | Edges only cross between two halves — same-side equalities are structurally impossible |
| `mixed` | Random combination of the above |

---

## Generator

`baseloggen_v2.py` — full generator with hop depth control and equality type balancing.

```python
from baseloggen_v2 import Config, generate_dataset, to_benchmark_format

cfg = Config(
    limit=1000,
    min_vars=4,
    max_vars=8,
    min_eq=2,
    max_eq=5,
    min_neq=1,
    max_neq=3,
    num_choices=4,
    min_answer_hop=2,
    target_hop_dist={1: 0.10, 2: 0.40, 3: 0.25, 4: 0.15, 5: 0.10},
    styles=("chain", "star", "clusters", "tree", "bipartite", "mixed"),
    seed=42,
)

dataset = generate_dataset(cfg)
formatted = [to_benchmark_format(p, i) for i, p in enumerate(dataset)]
```

### Key Config Parameters

| Parameter | Description |
|-----------|-------------|
| `min_answer_hop` | Minimum hop depth for the correct answer (suppresses trivial problems) |
| `target_hop_dist` | Dict mapping hop depth → fraction. Generator samples each bucket exactly. |
| `styles` | Tuple of graph topologies to sample from |

### Design Decisions

**Equality type balance** — correct answers are 50/50 sampled from `=` and `!=` statements to prevent models from exploiting the observation that correct answers tend to be equality statements.

**Exact hop targeting** — when `target_hop_dist` is set, each bucket is generated with rejection sampling targeting exactly that hop depth, rather than relying on natural distribution (which heavily favours 2-hop).

**Flipped distractor** — the negation of the correct answer (e.g. `a = b` → `a != b`) is always included as a distractor to ensure the model can't win by ignoring inequality structure.

---

## Dataset Format

```json
{
  "id": "symbolic_00042",
  "domain": "Symbolic",
  "context": "If:\na = b\nb != c\na = d\n\nThen",
  "options": ["a != c", "d = c", "b = d", "a = c"],
  "answer_index": 0,
  "answer": "a != c",
  "hop_depth": 2
}
```

---