reasoning-benchmarks 0.1.0__tar.gz

reasoning_benchmarks-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include reasoning_tasks/src *.csv

reasoning_benchmarks-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: reasoning-benchmarks
+Version: 0.1.0
+Summary: Generate argumentation reasoning benchmarks and prompts.
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+
+# reasoning-benchmarks
+
+`reasoning-benchmarks` generates structured argumentation benchmarks for evaluating reasoning systems.
+
+## Features
+
+- Generate chain and star argument graphs.
+- Create prompt text for binary and multi-label reasoning tasks.
+- Export benchmark datasets directly to CSV.
+
+## Installation
+
+```bash
+pip install reasoning-benchmarks
+```
+
+## Quickstart
+
+```python
+from reasoning_benchmarks import generate_benchmark
+
+benchmark = generate_benchmark(
+	chain_range=(1, 5),
+	star_range=(3, 6),
+	shuffled="both",
+	percentage_irrelevant=0,
+	attack_words=["not credible", "unreliable", "lying"],
+	num_variations_per_graph=(1, 1),
+	seed=95,
+)
+
+print(benchmark.head())
+```
+
+## Development Build
+
+```bash
+python -m build
+```
+
+The package includes CSV resources under `reasoning_benchmarks/src` and accesses them via `importlib.resources`.

reasoning_benchmarks-0.1.0/README.md

@@ -0,0 +1,41 @@
+# reasoning-benchmarks
+
+`reasoning-benchmarks` generates structured argumentation benchmarks for evaluating reasoning systems.
+
+## Features
+
+- Generate chain and star argument graphs.
+- Create prompt text for binary and multi-label reasoning tasks.
+- Export benchmark datasets directly to CSV.
+
+## Installation
+
+```bash
+pip install reasoning-benchmarks
+```
+
+## Quickstart
+
+```python
+from reasoning_benchmarks import generate_benchmark
+
+benchmark = generate_benchmark(
+	chain_range=(1, 5),
+	star_range=(3, 6),
+	shuffled="both",
+	percentage_irrelevant=0,
+	attack_words=["not credible", "unreliable", "lying"],
+	num_variations_per_graph=(1, 1),
+	seed=95,
+)
+
+print(benchmark.head())
+```
+
+## Development Build
+
+```bash
+python -m build
+```
+
+The package includes CSV resources under `reasoning_benchmarks/src` and accesses them via `importlib.resources`.

reasoning_benchmarks-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"

reasoning_benchmarks-0.1.0/reasoning_benchmarks/__init__.py

@@ -0,0 +1 @@
+from .benchmarkgenerator import *

reasoning_benchmarks-0.1.0/reasoning_benchmarks/argumentgraph.py

@@ -0,0 +1,358 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Iterable
+
+
+@dataclass(eq=False)
+class Argument:
+    """Represents one argument node in an argumentation framework."""
+
+    ID: int
+    description: str = ""
+    value: bool | None = None
+
+
+class ArgumentGraph:
+    """Directed attack graph for abstract argumentation.
+
+    Nodes are arguments, edges are attacks (attacker -> target).
+    """
+
+    def __init__(self) -> None:
+        self.arguments: list[Argument] = []
+        self.attacks: list[tuple[Argument, Argument]] = []
+
+    def __repr__(self) -> str:
+        return f"ArgumentGraph(arguments={self.arguments}, attacks={self.attacks})"
+
+    def add_argument(self, argument: Argument) -> None:
+        """Add an argument node."""
+        if any(existing.ID == argument.ID for existing in self.arguments):
+            raise ValueError(f"Argument ID {argument.ID} already exists.")
+        self.arguments.append(argument)
+
+    def get_argument(self, argument_id: int) -> Argument:
+        """Return an argument by ID."""
+        for argument in self.arguments:
+            if argument.ID == argument_id:
+                return argument
+        raise KeyError(f"Argument ID {argument_id} does not exist.")
+
+    def add_attack(self, attacker: Argument | int, target: Argument | int) -> None:
+        """Add a directed attack edge.
+
+        Parameters can be Argument instances or argument IDs.
+        """
+        attacker_arg = self._resolve_argument(attacker)
+        target_arg = self._resolve_argument(target)
+        self.attacks.append((attacker_arg, target_arg))
+
+    def _resolve_argument(self, argument: Argument | int) -> Argument:
+        if isinstance(argument, Argument):
+            return argument
+        return self.get_argument(argument)
+
+    def solve(self) -> dict[str, list[Argument]]:
+        """Compute labels using grounded-style propagation.
+
+        Rules:
+        - Start with unattacked arguments as accepted.
+        - Arguments attacked by accepted arguments are rejected.
+        - Arguments with all attackers rejected become accepted.
+        - Remaining arguments are undecided.
+        """
+        incoming = {arg: set() for arg in self.arguments}
+        outgoing = {arg: set() for arg in self.arguments}
+
+        for attacker, target in self.attacks:
+            if attacker in outgoing and target in incoming:
+                outgoing[attacker].add(target)
+                incoming[target].add(attacker)
+
+        accepted = {arg for arg in self.arguments if len(incoming[arg]) == 0}
+        rejected: set[Argument] = set()
+
+        changed = True
+        while changed:
+            changed = False
+
+            newly_rejected = {
+                target
+                for accepted_arg in accepted
+                for target in outgoing[accepted_arg]
+            } - rejected
+            if newly_rejected:
+                rejected |= newly_rejected
+                changed = True
+
+            newly_accepted = {
+                arg
+                for arg in self.arguments
+                if arg not in accepted and arg not in rejected
+                and incoming[arg]
+                and incoming[arg].issubset(rejected)
+            }
+            if newly_accepted:
+                accepted |= newly_accepted
+                changed = True
+
+        undecided = set(self.arguments) - accepted - rejected
+
+        for arg in self.arguments:
+            if arg in accepted:
+                arg.value = True
+            elif arg in rejected:
+                arg.value = False
+            else:
+                arg.value = None
+
+        return {
+            "accepted": [arg for arg in self.arguments if arg in accepted],
+            "rejected": [arg for arg in self.arguments if arg in rejected],
+            "undecided": [arg for arg in self.arguments if arg in undecided],
+        }
+
+    def _build_degree_maps(self) -> tuple[
+        dict[Argument, list[Argument]],
+        dict[Argument, list[Argument]],
+    ]:
+        """Return (outgoing, incoming) adjacency lists for all arguments."""
+        outgoing: dict[Argument, list[Argument]] = {arg: [] for arg in self.arguments}
+        incoming: dict[Argument, list[Argument]] = {arg: [] for arg in self.arguments}
+        for attacker, target in self.attacks:
+            if attacker in outgoing and target in incoming:
+                outgoing[attacker].append(target)
+                incoming[target].append(attacker)
+        return outgoing, incoming
+
+    def is_chain(self) -> bool:
+        """Return True if the graph is a strictly linear chain.
+
+        A chain is a single directed path  a_n → a_{n-1} → … → a_1  where
+        every argument attacks exactly the preceding one and nothing else.
+
+        Requirements
+        ------------
+        - Every argument has at most one attacker  (in-degree ≤ 1).
+        - Every argument attacks at most one other  (out-degree ≤ 1).
+        - Exactly one argument is unattacked  (the chain head).
+        - Exactly one argument attacks nothing  (the chain tail).
+        - Total attacks == n − 1  (single connected path, no isolated sub-chains).
+        """
+        n = len(self.arguments)
+        if n == 0:
+            return True
+        if n == 1:
+            return len(self.attacks) == 0
+
+        outgoing, incoming = self._build_degree_maps()
+
+        if any(len(targets) > 1 for targets in outgoing.values()):
+            return False
+        if any(len(attackers) > 1 for attackers in incoming.values()):
+            return False
+
+        sources = [arg for arg in self.arguments if not incoming[arg]]
+        sinks = [arg for arg in self.arguments if not outgoing[arg]]
+        if len(sources) != 1 or len(sinks) != 1:
+            return False
+
+        # n − 1 edges guarantees a single connected path (no isolated sub-chains).
+        return len(self.attacks) == n - 1
+
+    def is_star_chain(self) -> bool:
+        """Return True if the graph is a star-chain.
+
+        A star-chain has one central argument that is attacked by multiple
+        independent chains and attacks nothing itself.
+
+        Example::
+
+            attack(b, a), attack(c, b)   # chain 1: c → b → a
+            attack(d, a)                  # chain 2: d → a
+            attack(e, a), attack(f, e)   # chain 3: f → e → a
+
+        Requirements
+        ------------
+        - Exactly one center:  out-degree = 0, in-degree ≥ 2.
+        - Every non-center argument:  out-degree = 1, in-degree ≤ 1.
+        - Every non-center argument can reach the center without cycling
+          (detects disconnected sub-cycles in the non-center subgraph).
+        """
+        n = len(self.arguments)
+        if n < 3:
+            return False
+
+        outgoing, incoming = self._build_degree_maps()
+
+        centers = [arg for arg in self.arguments if not outgoing[arg]]
+        if len(centers) != 1:
+            return False
+
+        center = centers[0]
+        if len(incoming[center]) < 2:
+            return False
+
+        non_center = [arg for arg in self.arguments if arg is not center]
+
+        if any(len(outgoing[arg]) != 1 for arg in non_center):
+            return False
+        if any(len(incoming[arg]) > 1 for arg in non_center):
+            return False
+
+        # Follow each non-center path; it must reach the center within n steps.
+        # Exceeding n steps implies a cycle that never terminates at the center.
+        for start in non_center:
+            current = start
+            for _ in range(n):
+                targets = outgoing[current]
+                if not targets:
+                    break
+                current = targets[0]
+                if current is center:
+                    break
+            else:
+                return False  # cycle detected — center never reached
+
+        return True
+
+    def _status_of(self, argument: Argument) -> str:
+        if argument.value is True:
+            return "accepted"
+        if argument.value is False:
+            return "rejected"
+        return "undecided"
+
+    def _node_label(
+        self,
+        argument: Argument,
+        *,
+        include_description: bool,
+        include_status: bool,
+        status_labels: dict[str, str],
+    ) -> str:
+        parts = [f"{argument.ID}"]
+        if include_description:
+            parts.append(argument.description)
+        if include_status:
+            parts.append(status_labels[self._status_of(argument)])
+        return " | ".join(parts)
+
+    def print_graph(
+        self,
+        style: str = "ascii",
+        include_description: bool = True,
+        include_status: bool = True,
+        status_labels: dict[str, str] | None = None,
+        sort_key: Callable[[Argument], object] | None = None,
+        only_ids: Iterable[int] | None = None,
+        return_string: bool = False,
+    ) -> str | None:
+        """Render the graph as text.
+
+        Supported styles:
+        - ascii
+        - adjacency
+        - mermaid
+        """
+        if status_labels is None:
+            status_labels = {
+                "accepted": "ACCEPTED",
+                "rejected": "REJECTED",
+                "undecided": "UNDECIDED",
+            }
+
+        allowed_styles = {"ascii", "adjacency", "mermaid"}
+        if style not in allowed_styles:
+            raise ValueError(f"style must be one of {sorted(allowed_styles)}")
+
+        selected = list(self.arguments)
+        if only_ids is not None:
+            id_filter = set(only_ids)
+            selected = [arg for arg in selected if arg.ID in id_filter]
+
+        if sort_key is None:
+            selected.sort(key=lambda arg: arg.ID)
+        else:
+            selected.sort(key=sort_key)
+
+        selected_set = set(selected)
+        selected_attacks = [
+            (attacker, target)
+            for attacker, target in self.attacks
+            if attacker in selected_set and target in selected_set
+        ]
+
+        if style == "adjacency":
+            outgoing = {arg: [] for arg in selected}
+            for attacker, target in selected_attacks:
+                outgoing[attacker].append(target)
+
+            lines: list[str] = []
+            for arg in selected:
+                node_text = self._node_label(
+                    arg,
+                    include_description=include_description,
+                    include_status=include_status,
+                    status_labels=status_labels,
+                )
+                lines.append(node_text)
+
+                targets = outgoing[arg]
+                if targets:
+                    target_ids = ", ".join(str(t.ID) for t in sorted(targets, key=lambda x: x.ID))
+                    lines.append(f"  attacks -> {target_ids}")
+                else:
+                    lines.append("  attacks -> -")
+
+            rendered = "\n".join(lines)
+
+        elif style == "mermaid":
+            lines = ["graph TD"]
+            for arg in selected:
+                label = self._node_label(
+                    arg,
+                    include_description=include_description,
+                    include_status=include_status,
+                    status_labels=status_labels,
+                )
+                safe_label = label.replace('"', "'")
+                lines.append(f"    A{arg.ID}[\"{safe_label}\"]")
+
+            for attacker, target in selected_attacks:
+                lines.append(f"    A{attacker.ID} --> A{target.ID}")
+
+            rendered = "\n".join(lines)
+
+        else:
+            lines = ["Arguments:"]
+            for arg in selected:
+                lines.append(
+                    f"  [{arg.ID}] " + self._node_label(
+                        arg,
+                        include_description=include_description,
+                        include_status=include_status,
+                        status_labels=status_labels,
+                    )
+                )
+
+            lines.append("Attacks:")
+            if selected_attacks:
+                for attacker, target in sorted(selected_attacks, key=lambda pair: (pair[0].ID, pair[1].ID)):
+                    lines.append(f"  [{attacker.ID}] -> [{target.ID}]")
+            else:
+                lines.append("  (none)")
+
+            rendered = "\n".join(lines)
+
+        if return_string:
+            return rendered
+
+        print(rendered)
+        return None
+
+
+# Backward-compatible alias
+argumentGraph = ArgumentGraph
+