Datasets:
File size: 12,488 Bytes
06c7e2f | 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 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | """Logical operators — elemental reasoning primitives.
Tests the model's capacity for basic logical operations in text form:
- negation: Verify whether a candidate is a correct logical negation
- conjunction: Evaluate conjunction/disjunction statements from text facts
- conditional: Decide whether a conclusion follows from a rule + fact
These are building blocks for reasoning-heavy benchmarks.
Format (ICL):
Input: [text logic problem]
Output: True or False
(varies by category — see demos)
"""
import random
from typing import Dict, List, Any
from tasks.base_task import BaseTask, TaskConfig
class LogicalOpsTask(BaseTask):
"""Elemental logical-operators task."""
TASK_NAME = "logical_ops"
CATEGORY_DATA: Dict[str, List[Dict[str, str]]] = {
"negation": [
{"input": "Statement: All robots can move.\nCandidate negation: Some robots cannot move.\nIs the candidate a correct logical negation?", "output": "True"},
{"input": "Statement: All apples are red.\nCandidate negation: No apples are red.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: Some birds can swim.\nCandidate negation: No birds can swim.\nIs the candidate a correct logical negation?", "output": "True"},
{"input": "Statement: Some books are heavy.\nCandidate negation: Some books are not heavy.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: The lamp is on.\nCandidate negation: The lamp is not on.\nIs the candidate a correct logical negation?", "output": "True"},
{"input": "Statement: The lamp is on.\nCandidate negation: The lamp is off and broken.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: Everyone passed the test.\nCandidate negation: Not everyone passed the test.\nIs the candidate a correct logical negation?", "output": "True"},
{"input": "Statement: Everyone passed the test.\nCandidate negation: No one passed the test.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: No cars are electric.\nCandidate negation: Some cars are electric.\nIs the candidate a correct logical negation?", "output": "True"},
{"input": "Statement: No cars are electric.\nCandidate negation: All cars are electric.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: The gate is closed.\nCandidate negation: The gate is open.\nIs the candidate a correct logical negation?", "output": "False"},
{"input": "Statement: The gate is closed.\nCandidate negation: The gate is not closed.\nIs the candidate a correct logical negation?", "output": "True"},
],
"conjunction": [
{"input": "Fact A is True. Fact B is True.\nClaim: A AND B.\nIs the claim true?", "output": "True"},
{"input": "Fact A is True. Fact B is False.\nClaim: A AND B.\nIs the claim true?", "output": "False"},
{"input": "Fact A is False. Fact B is True.\nClaim: A OR B.\nIs the claim true?", "output": "True"},
{"input": "Fact A is False. Fact B is False.\nClaim: A OR B.\nIs the claim true?", "output": "False"},
{"input": "Fact A is True. Fact B is False.\nClaim: NOT B.\nIs the claim true?", "output": "True"},
{"input": "Fact A is True. Fact B is False.\nClaim: NOT A.\nIs the claim true?", "output": "False"},
{"input": "Fact A is True. Fact B is True. Fact C is False.\nClaim: A AND B AND C.\nIs the claim true?", "output": "False"},
{"input": "Fact A is True. Fact B is True. Fact C is False.\nClaim: A AND (B OR C).\nIs the claim true?", "output": "True"},
{"input": "Fact A is False. Fact B is False. Fact C is True.\nClaim: (A OR B) AND C.\nIs the claim true?", "output": "False"},
{"input": "Fact A is False. Fact B is False. Fact C is True.\nClaim: A OR (B OR C).\nIs the claim true?", "output": "True"},
{"input": "Fact A is True. Fact B is False.\nClaim: (A AND B) OR A.\nIs the claim true?", "output": "True"},
{"input": "Fact A is True. Fact B is False.\nClaim: (A OR B) AND B.\nIs the claim true?", "output": "False"},
],
"conditional": [
{"input": 'Rule: If it rains, the ground gets wet.\nFact: It rains.\nConclusion: The ground gets wet.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If it rains, the ground gets wet.\nFact: It does not rain.\nConclusion: The ground gets wet.\nDoes the conclusion logically follow?', "output": "False"},
{"input": 'Rule: If the switch is on, the lamp lights up.\nFact: The switch is on.\nConclusion: The lamp lights up.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If the switch is on, the lamp lights up.\nFact: The lamp lights up.\nConclusion: The switch is on.\nDoes the conclusion logically follow?', "output": "False"},
{"input": 'Rule: If a number is even, it is divisible by 2.\nFact: 14 is even.\nConclusion: 14 is divisible by 2.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If a number is even, it is divisible by 2.\nFact: 15 is not even.\nConclusion: 15 is not divisible by 2.\nDoes the conclusion logically follow?', "output": "False"},
{"input": 'Rule: If a file is deleted, it is unavailable.\nFact: The file is deleted.\nConclusion: The file is unavailable.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If a file is deleted, it is unavailable.\nFact: The file is unavailable.\nConclusion: The file is deleted.\nDoes the conclusion logically follow?', "output": "False"},
{"input": 'Rule: If a student studies, they pass this quiz.\nFact: Mina studies.\nConclusion: Mina passes this quiz.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If a student studies, they pass this quiz.\nFact: Leo does not pass this quiz.\nConclusion: Leo did not study.\nDoes the conclusion logically follow?', "output": "False"},
{"input": 'Rule: If the alarm rings, everyone evacuates.\nFact: The alarm rings.\nConclusion: Everyone evacuates.\nDoes the conclusion logically follow?', "output": "True"},
{"input": 'Rule: If the alarm rings, everyone evacuates.\nFact: Everyone evacuates.\nConclusion: The alarm rings.\nDoes the conclusion logically follow?', "output": "False"},
],
}
CATEGORY_DEMOS: Dict[str, List[str]] = {
"negation": [
"Input: Statement: All chairs are wooden.\nCandidate negation: Some chairs are not wooden.\nIs the candidate a correct logical negation?\nOutput: True",
"Input: Statement: Some cups are clean.\nCandidate negation: No cups are clean.\nIs the candidate a correct logical negation?\nOutput: True",
"Input: Statement: The window is open.\nCandidate negation: The window is not open.\nIs the candidate a correct logical negation?\nOutput: True",
"Input: Statement: Everyone arrived early.\nCandidate negation: No one arrived early.\nIs the candidate a correct logical negation?\nOutput: False",
"Input: Statement: The road is clear.\nCandidate negation: The road is blocked.\nIs the candidate a correct logical negation?\nOutput: False",
],
"conjunction": [
"Input: Fact A is True. Fact B is True.\nClaim: A AND B.\nIs the claim true?\nOutput: True",
"Input: Fact A is True. Fact B is False.\nClaim: A AND B.\nIs the claim true?\nOutput: False",
"Input: Fact A is False. Fact B is True.\nClaim: A OR B.\nIs the claim true?\nOutput: True",
"Input: Fact A is True. Fact B is False.\nClaim: NOT B.\nIs the claim true?\nOutput: True",
"Input: Fact A is False. Fact B is False.\nClaim: A OR B.\nIs the claim true?\nOutput: False",
],
"conditional": [
"Input: Rule: If the bell rings, class starts.\nFact: The bell rings.\nConclusion: Class starts.\nDoes the conclusion logically follow?\nOutput: True",
"Input: Rule: If traffic is heavy, travel time increases.\nFact: Travel time increased.\nConclusion: Traffic was heavy.\nDoes the conclusion logically follow?\nOutput: False",
"Input: Rule: If the key fits, the lock opens.\nFact: The key fits.\nConclusion: The lock opens.\nDoes the conclusion logically follow?\nOutput: True",
"Input: Rule: If a file is saved, it can be reopened.\nFact: The file can be reopened.\nConclusion: The file was saved.\nDoes the conclusion logically follow?\nOutput: False",
"Input: Rule: If the sensor triggers, the alarm sounds.\nFact: The sensor triggers.\nConclusion: The alarm sounds.\nDoes the conclusion logically follow?\nOutput: True",
],
}
def __init__(self, config: TaskConfig):
super().__init__(config)
def _load_data(self):
import pandas as pd
if self.config.in_memory_data:
self.data = pd.DataFrame(self.config.in_memory_data)
return
rows: List[Dict[str, str]] = []
for category, examples in self.CATEGORY_DATA.items():
for ex in examples:
rows.append({
"input": ex["input"],
"output": ex["output"],
"category_name": category,
})
self.data = pd.DataFrame(rows)
def build_prompt(self, instance: Dict[str, Any], num_shots: int = 5) -> str:
category = instance.get("category_name", "negation")
demos = self.CATEGORY_DEMOS.get(category, [])
inst_input = instance.get("input", "")
demos = [d for d in demos if inst_input not in d][:num_shots]
prompt = ""
for d in demos:
prompt += d + "\n\n"
if category == "conditional":
prompt += f"Input: {inst_input}\nOutput:"
else:
prompt += f"Input: {inst_input}\nOutput:"
return prompt
def evaluate(self, predictions: List[str], split: str = "test", **kwargs) -> Dict[str, float]:
ground_truth = self.get_ground_truth(split)
task_data = self.get_split(split)
if len(predictions) != len(ground_truth):
raise ValueError(
f"Prediction count ({len(predictions)}) != ground truth ({len(ground_truth)})"
)
processed = [self.preprocess_prediction(p) for p in predictions]
correct = sum(
1 for p, g in zip(processed, ground_truth)
if p.lower().strip() == g.lower().strip()
)
results: Dict[str, Any] = {
"accuracy": correct / len(ground_truth),
"correct": correct,
"total": len(ground_truth),
}
cat_stats: Dict[str, Dict[str, int]] = {}
for p, g, item in zip(processed, ground_truth, task_data):
cat = item.get("category_name", "unknown")
cat_stats.setdefault(cat, {"correct": 0, "total": 0})
cat_stats[cat]["total"] += 1
if p.lower().strip() == g.lower().strip():
cat_stats[cat]["correct"] += 1
for cat, s in cat_stats.items():
results[f"accuracy_{cat}"] = s["correct"] / s["total"]
return results
def get_ground_truth(self, split: str = "test") -> List[str]:
rows = self.get_split(split)
return [str(r.get("output", "")) for r in rows]
def create_logical_ops_task(
category: str = None,
name: str = "logical_ops",
) -> LogicalOpsTask:
"""Create a LogicalOpsTask, optionally filtered to one category."""
data = None
if category and category in LogicalOpsTask.CATEGORY_DATA:
data = [
{**ex, "category_name": category}
for ex in LogicalOpsTask.CATEGORY_DATA[category]
]
name = f"logical_ops:{category}"
config = TaskConfig(
name=name,
description="Logical operators (negation, conjunction, conditional)",
data_format="memory",
in_memory_data=data,
input_column="input",
output_column="output",
evaluation_metrics=["accuracy"],
metadata={"task_type": "logical_ops", "category": category},
)
return LogicalOpsTask(config)
|