algobattle-problems 1.0.0__tar.gz

algobattle-problems-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Henri Lotze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

algobattle-problems-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: algobattle-problems
+Version: 1.0.0
+Author: Imogen Hergeth, Jan Dreier, Henri Lotze
+License: MIT
+Project-URL: Homepage, https://algobattle.org
+Project-URL: Documentation, https://algobattle.org/docs
+Project-URL: Repository, https://github.com/Benezivas/algobattle-problems
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: algobattle-base~=4.0.0
+Requires-Dist: networkx

algobattle-problems-1.0.0/README.md

@@ -0,0 +1,34 @@
+# Algorithmic Battle: Problems
+Collection of example problems that are ready to be used in the
+[algobattle](https://algobattle.org) project, with a strong bias towards
+problems of theoretical computer science.
+
+Each problem directory contains a `description.md` describing the problem
+and the I/O that the generator and solver use. The `generator` and `solver`
+directories contain dummy solvers that output instances which are technically
+legal, but rather unexiting. Finally, the `problem.py` implements the logic
+described in the `description.md`.
+
+# Setup and Usage
+You need the [algobattle](https://github.com/Benezivas/algobattle) tool to use
+any of the problems of this repository. Consult the
+[official documentation](https://algobattle.org/docs)
+on how to install the algobattle tool and how to use it for a given problem.
+
+If you are using the [algobattle-web framework](https://github.com/Benezivas/algobattle-web),
+you can simply import these problems in the framework. Consult the documentation
+of the `algobattle-web` framework for more details.
+
+A good and simple problem to start is the `pairsum` problem, which is well
+suited as a primer task at the start of a lab course, should you want to host
+one yourself.  For this task, a simple randomized generator and solver are
+implemented which you may use to see how the everything behaves realistically.
+
+# Compatibility
+The head of the main branch of this repository is always compatible with
+the head of the main branch of the [algobattle repository](https://github.com/Benezivas/algobattle).
+
+If you are using an older version of `algobattle`, see the releases of this
+repository in order to find versions of problems that are compatible with older
+releases. We do not actively back-port problems to older versions of
+`algobattle`.

algobattle-problems-1.0.0/algobattle_problems/biclique/generator/main.py

@@ -0,0 +1,18 @@
+"""Simple dummy generator for the BiClique problem, outputting a static instance."""
+import json
+
+with open("output/instance.json", "w+") as output:
+    json.dump(
+        {
+            "num_vertices": 4,
+            "edges": [
+                [0, 1],
+                [0, 2],
+                [0, 3],
+            ],
+        },
+        output,
+    )
+
+with open("output/solution.json", "w+") as output:
+    json.dump({"s_1": [0], "s_2": [1, 2, 3]}, output)

algobattle-problems-1.0.0/algobattle_problems/biclique/problem.py

@@ -0,0 +1,35 @@
+"""The Biclique problem class."""
+from algobattle.problem import Problem, SolutionModel, maximize
+from algobattle.util import Role, ValidationError
+from algobattle.types import UndirectedGraph, Vertex
+
+
+class Solution(SolutionModel[UndirectedGraph]):
+    """A solution to a bipartite clique problem."""
+
+    s_1: set[Vertex]
+    s_2: set[Vertex]
+
+    def validate_solution(self, instance: UndirectedGraph, role: Role) -> None:
+        super().validate_solution(instance, role)
+        edge_set = set(instance.edges) | set(edge[::-1] for edge in instance.edges)
+        if len(self.s_1.intersection(self.s_2)) != 0:
+            raise ValidationError("Solution contains vertex sets that aren't disjoint.")
+        if any((u, v) not in edge_set for u in self.s_1 for v in self.s_2):
+            raise ValidationError("The instance graph is missing an edge between the solution vertex sets.")
+        if any((u, v) in edge_set for u in self.s_1 for v in self.s_1) or any(
+            (u, v) in edge_set for u in self.s_2 for v in self.s_2
+        ):
+            raise ValidationError("The solution is not a bipartite graph.")
+
+    @maximize
+    def score(self, instance: UndirectedGraph, role: Role) -> float:
+        return len(self.s_1) + len(self.s_2)
+
+
+Biclique = Problem(
+    name="Bipartite Clique",
+    instance_cls=UndirectedGraph,
+    solution_cls=Solution,
+    min_size=5,
+)

algobattle-problems-1.0.0/algobattle_problems/biclique/solver/main.py

@@ -0,0 +1,16 @@
+"""Simple dummy solver for the BiClique problem, outputting a static solution."""
+import json
+from random import random
+
+sol = [1, 2]
+if random() <= 0.9:
+    sol.append(3)
+
+with open("output/solution.json", "w") as output:
+    json.dump(
+        {
+            "s_1": [0],
+            "s_2": sol,
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/biclique/tests.py

@@ -0,0 +1,36 @@
+"""Tests for the biclique problem."""
+import unittest
+
+from pydantic import ValidationError as PydanticValidationError
+from algobattle.util import Role
+
+from algobattle_problems.biclique.problem import UndirectedGraph, Solution, ValidationError
+
+
+class Tests(unittest.TestCase):
+    """Tests for the Biclique problem solution class."""
+
+    def test_vertices_exist(self):
+        """Tests that only valid vertex indices are allowed."""
+        graph = UndirectedGraph(num_vertices=10, edges=[(i, j) for i in range(10) for j in range(i)])
+        with self.assertRaises(PydanticValidationError):
+            sol = Solution.model_validate({"s_1": set(), "s_2": {20}}, context={"instance": graph})
+            sol.validate_solution(graph, Role.generator)
+
+    def test_edges_exist(self):
+        """Tests that solutions that arent complete bicliques are not allowed."""
+        graph = UndirectedGraph(num_vertices=10, edges=[])
+        with self.assertRaises(ValidationError):
+            sol = Solution.model_validate({"s_1": {1}, "s_2": {2}}, context={"instance": graph})
+            sol.validate_solution(graph, Role.generator)
+
+    def test_edges_missing(self):
+        """Asserts that solutions that aren't bipartite are not allowed."""
+        graph = UndirectedGraph(num_vertices=10, edges=[(i, j) for i in range(10) for j in range(i)])
+        with self.assertRaises(ValidationError):
+            sol = Solution.model_validate({"s_1": {1, 2}, "s_2": {3, 4}}, context={"instance": graph})
+            sol.validate_solution(graph, Role.generator)
+
+
+if __name__ == "__main__":
+    unittest.main()

algobattle-problems-1.0.0/algobattle_problems/c4subgraphiso/generator/main.py

@@ -0,0 +1,26 @@
+"""Simple dummy generator for the C4subgraphiso problem, outputting a static instance."""
+import json
+
+with open("output/instance.json", "w+") as output:
+    json.dump(
+        {
+            "num_vertices": 4,
+            "edges": [
+                [3, 0],
+                [0, 1],
+                [1, 2],
+                [2, 3],
+            ],
+        },
+        output,
+    )
+
+with open("output/solution.json", "w+") as output:
+    json.dump(
+        {
+            "squares": [
+                [0, 1, 2, 3],
+            ],
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/c4subgraphiso/problem.py

@@ -0,0 +1,55 @@
+"""The C4subgraphiso problem class."""
+
+from itertools import combinations, cycle, islice
+from typing import Annotated, Iterator
+from pydantic import field_validator
+
+from algobattle.problem import Problem, SolutionModel, maximize
+from algobattle.util import Role, ValidationError
+from algobattle.types import UndirectedGraph, Vertex, UniqueItems
+
+Square = Annotated[tuple[Vertex, Vertex, Vertex, Vertex], UniqueItems()]
+
+
+def edges(square: Square) -> Iterator[tuple[Vertex, Vertex]]:
+    """Returns all edges of a square."""
+    return zip(square, islice(cycle(square), 1, None))
+
+
+def diagonals(square: Square) -> Iterator[tuple[Vertex, Vertex]]:
+    """Returns the diagonals of a square."""
+    yield square[0], square[2]
+    yield square[1], square[3]
+
+
+class Solution(SolutionModel[UndirectedGraph]):
+    """A solution to a Square Subgraph Isomorphism problem."""
+
+    squares: set[Square]
+
+    @field_validator("squares", mode="after")
+    @classmethod
+    def check_squares(cls, value: set[Square]) -> set[Square]:
+        if any(set(a) & set(b) for a, b in combinations(value, 2)):
+            raise ValueError("A square in the solution is not node-disjoint to at least one other square")
+        return value
+
+    def validate_solution(self, instance: UndirectedGraph, role: Role) -> None:
+        super().validate_solution(instance, role)
+        edge_set = set(instance.edges) | {(v, u) for u, v in instance.edges}
+        if any(edge not in edge_set for square in self.squares for edge in edges(square)):
+            raise ValidationError("A square is not part of the instance.")
+        if any(edge in edge_set for square in self.squares for edge in diagonals(square)):
+            raise ValidationError("A square in the solution is not induced in the instance.")
+
+    @maximize
+    def score(self, instance: UndirectedGraph, role: Role) -> float:
+        return len(self.squares)
+
+
+C4subgraphiso = Problem(
+    name="Square Subgraph Isomorphism",
+    instance_cls=UndirectedGraph,
+    solution_cls=Solution,
+    min_size=4,
+)

algobattle-problems-1.0.0/algobattle_problems/c4subgraphiso/solver/main.py

@@ -0,0 +1,12 @@
+"""Simple dummy solver for the C4subgraphiso problem, outputting a static solution."""
+import json
+
+with open("output/solution.json", "w") as output:
+    json.dump(
+        {
+            "squares": [
+                [0, 1, 2, 3],
+            ],
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/c4subgraphiso/tests.py

@@ -0,0 +1,74 @@
+"""Tests for the c4subgraphiso problem."""
+import unittest
+
+from pydantic import ValidationError as PydanticValidationError
+
+from algobattle_problems.c4subgraphiso.problem import UndirectedGraph, Solution, ValidationError, Role
+
+
+class Tests(unittest.TestCase):
+    """Tests for the c4subgraphiso verifier."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.instance = UndirectedGraph(
+            num_vertices=10,
+            edges=[
+                (0, 1),
+                (1, 2),
+                (2, 3),
+                (2, 4),
+                (4, 5),
+                (5, 6),
+                (6, 7),
+                (7, 8),
+                (8, 9),
+                (9, 0),
+                (1, 8),
+                (4, 8),
+                (4, 7),
+                (2, 8),
+                (0, 3),
+            ],
+        )
+
+    def test_no_duplicate_squares(self):
+        with self.assertRaises(PydanticValidationError):
+            UndirectedGraph.model_validate(
+                {
+                    "squares": {
+                        (0, 1, 2, 3),
+                        (0, 1, 2, 3),
+                    }
+                }
+            )
+
+    def test_vertex_too_big(self):
+        solution = Solution(squares={(0, 1, 2, 10)})
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+    def test_edge_missing(self):
+        solution = Solution(squares={(2, 3, 4, 5)})
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+    def test_additional_edge(self):
+        solution = Solution(squares={(1, 2, 4, 8)})
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+    def test_score(self):
+        solution = Solution(squares={(0, 1, 8, 9), (4, 5, 6, 7)})
+        solution.validate_solution(self.instance, Role.generator)
+        self.assertEqual(solution.score(self.instance, Role.solver), 2)
+
+    def test_squares_disjoin(self):
+        with self.assertRaises(PydanticValidationError):
+            solution = Solution(squares={(0, 1, 2, 3), (0, 1, 8, 9)})
+            solution.validate_solution(self.instance, Role.generator)
+
+
+if __name__ == "__main__":
+    unittest.main()

algobattle-problems-1.0.0/algobattle_problems/circlecover/generator/main.py

@@ -0,0 +1,11 @@
+"""Simple dummy generator for the Circle Cover problem, outputting a static instance."""
+import json
+from pathlib import Path
+
+Path("output/instance.json").write_text(
+    json.dumps(
+        {"points": [[0, 1], [50, 50], [100, 17]]},
+    )
+)
+
+Path("/output/solution.json").write_text(json.dumps({"circles": {"10": [5, 5], "20": [60, 65], "30": [80, 10]}}))

algobattle-problems-1.0.0/algobattle_problems/circlecover/problem.py

@@ -0,0 +1,47 @@
+"""The Circle Cover problem class."""
+from math import sqrt
+from typing import Annotated, Literal
+from algobattle.problem import Problem, InstanceModel, SolutionModel, maximize
+from algobattle.util import Role
+from algobattle.types import LaxComp, Interval
+
+
+Coordinate = Annotated[float, Interval(ge=0, le=100)]
+Point = tuple[Coordinate, Coordinate]
+
+
+def distance(a: Point, b: Point) -> float:
+    """Calculates the distance between two points."""
+    return sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
+
+
+class Instance(InstanceModel):
+    """An Instance of the Circle Cover Problem."""
+
+    points: set[Point]
+
+    @property
+    def size(self) -> int:
+        return len(self.points)
+
+
+class Solution(SolutionModel[Instance]):
+    """A solution of the Circle Cover problem."""
+
+    circles: dict[Literal[10, 20, 30], Point]
+
+    @maximize
+    def score(self, instance: Instance, role: Role) -> float:
+        covered = 0
+        for size, center in self.circles.items():
+            covered += sum(distance(center, point) <= LaxComp(size, role) for point in instance.points)
+        return covered
+
+
+CircleCover = Problem(
+    name="Circle Cover",
+    instance_cls=Instance,
+    solution_cls=Solution,
+    min_size=1,
+    test_instance=Instance(points={(0, 1), (50, 50), (100, 17)}),
+)

algobattle-problems-1.0.0/algobattle_problems/circlecover/solver/main.py

@@ -0,0 +1,5 @@
+"""Simple dummy solver for the CircleCover problem, outputting a static solution."""
+import json
+from pathlib import Path
+
+Path("/output/solution.json").write_text(json.dumps({"circles": {"10": [5, 5], "20": [60, 65], "30": [80, 10]}}))

algobattle-problems-1.0.0/algobattle_problems/clusterediting/generator/main.py

@@ -0,0 +1,28 @@
+"""Simple dummy generator for the ClusterEditing problem, outputting a static instance."""
+import json
+
+with open("output/instance.json", "w+") as output:
+    json.dump(
+        {
+            "num_vertices": 4,
+            "edges": [
+                [0, 1],
+                [1, 2],
+                [0, 3],
+            ],
+        },
+        output,
+    )
+
+with open("output/solution.json", "w+") as output:
+    json.dump(
+        {
+            "add": [
+                [0, 2],
+            ],
+            "delete": [
+                [0, 3],
+            ],
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/clusterediting/problem.py

@@ -0,0 +1,52 @@
+"""The Clusterediting problem class."""
+from collections import defaultdict
+from itertools import combinations
+
+from algobattle.problem import Problem, SolutionModel, minimize
+from algobattle.util import Role, ValidationError
+from algobattle.types import Vertex, UndirectedGraph
+
+
+class Solution(SolutionModel[UndirectedGraph]):
+    """A solution to a Cluster Editing problem."""
+
+    add: set[tuple[Vertex, Vertex]]
+    delete: set[tuple[Vertex, Vertex]]
+
+    def validate_solution(self, instance: UndirectedGraph, role: Role) -> None:
+        super().validate_solution(instance, role)
+        edge_set = set(instance.edges)
+
+        # Apply modifications to graph
+        for edge in self.add:
+            if edge[::-1] not in edge_set:
+                edge_set.add(edge)
+        for edge in self.delete:
+            if edge in edge_set:
+                edge_set.remove(edge)
+            elif (edge[1], edge[0]) in edge_set:
+                edge_set.remove((edge[1], edge[0]))
+            else:
+                raise ValidationError("Solution contains edge not found in instance.")
+
+        neighbors: defaultdict[int, set[int]] = defaultdict(set)
+        for u, v in edge_set:
+            neighbors[u].add(v)
+            neighbors[v].add(u)
+
+        for u in range(instance.num_vertices):
+            for v, w in combinations(neighbors[u], 2):
+                if not (v, w) in edge_set and not (w, v) in edge_set:
+                    raise ValidationError("The solution does not transform the graph into a cluster.")
+
+    @minimize
+    def score(self, instance: UndirectedGraph, role: Role) -> float:
+        return len(self.add) + len(self.delete)
+
+
+Clusterediting = Problem(
+    name="Cluster Editing",
+    min_size=4,
+    instance_cls=UndirectedGraph,
+    solution_cls=Solution,
+)

algobattle-problems-1.0.0/algobattle_problems/clusterediting/solver/main.py

@@ -0,0 +1,15 @@
+"""Simple dummy solver for the ClusterEditing problem, outputting a static solution."""
+import json
+
+with open("output/solution.json", "w") as output:
+    json.dump(
+        {
+            "add": [
+                [1, 3],
+            ],
+            "delete": [
+                [1, 2],
+            ],
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/clusterediting/tests.py

@@ -0,0 +1,66 @@
+"""Tests for the clusterediting problem."""
+import unittest
+
+from algobattle_problems.clusterediting.problem import UndirectedGraph, Solution, ValidationError, Role
+
+
+class Tests(unittest.TestCase):
+    """Tests for the clusterediting solutions."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.instance = UndirectedGraph(
+            num_vertices=10,
+            edges=[
+                (0, 2),
+                (0, 5),
+                (0, 8),
+                (1, 5),
+                (1, 7),
+                (1, 8),
+                (2, 3),
+                (2, 5),
+                (2, 6),
+                (3, 6),
+                (4, 8),
+            ],
+        )
+
+    def test_delete_nonexisting_edge(self):
+        solution = Solution(add=set(), delete={(0, 1)})
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+    def test_delete_extra_edge(self):
+        instance = UndirectedGraph(num_vertices=4, edges=[(0, 1), (1, 2), (2, 0), (0, 3)])
+        solution = Solution(add=set(), delete={(0, 3)})
+        solution.validate_solution(instance, Role.generator)
+
+    def test_delete_and_add_edge(self):
+        instance = UndirectedGraph(num_vertices=4, edges=[(1, 2), (2, 0), (0, 3)])
+        solution = Solution(add={(0, 1)}, delete={(0, 3)})
+        solution.validate_solution(instance, Role.generator)
+
+    def test_add_edge_reverse(self):
+        solution = Solution(add={(2, 0)}, delete=set())
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+    def test_delete_edge_reverse(self):
+        instance = UndirectedGraph(num_vertices=3, edges=[(0, 1), (1, 2)])
+        solution = Solution(add=set(), delete={(1, 0)})
+        solution.validate_solution(instance, Role.generator)
+
+    def test_score(self):
+        solution = Solution(add={(0, 1), (5, 8)}, delete={(4, 8), (7, 1), (0, 2), (2, 5)})
+        solution.validate_solution(self.instance, Role.generator)
+        self.assertEqual(solution.score(self.instance, Role.solver), 1 / 6)
+
+    def test_solution_doesnt_triangulate(self):
+        solution = Solution(add={(0, 1), (5, 8)}, delete={(7, 1), (0, 2), (2, 5)})
+        with self.assertRaises(ValidationError):
+            solution.validate_solution(self.instance, Role.generator)
+
+
+if __name__ == "__main__":
+    unittest.main()

algobattle-problems-1.0.0/algobattle_problems/domset/generator/main.py

@@ -0,0 +1,21 @@
+"""Simple dummy generator for the DomSet problem, outputting a static instance."""
+import json
+
+with open("output/instance.json", "w+") as output:
+    json.dump(
+        {
+            "num_vertices": 2,
+            "edges": [
+                [0, 1],
+            ],
+        },
+        output,
+    )
+
+with open("output/solution.json", "w+") as output:
+    json.dump(
+        {
+            "domset": [0],
+        },
+        output,
+    )

algobattle-problems-1.0.0/algobattle_problems/domset/problem.py

@@ -0,0 +1,36 @@
+"""The Clusterediting problem class."""
+from algobattle.problem import Problem, SolutionModel, minimize
+from algobattle.util import Role, ValidationError
+from algobattle.types import Vertex, UndirectedGraph
+
+
+class Solution(SolutionModel[UndirectedGraph]):
+    """A solution to a Dominating Set problem."""
+
+    domset: set[Vertex]
+
+    def validate_solution(self, instance: UndirectedGraph, role: Role) -> None:
+        super().validate_solution(instance, role)
+        dominated = set(self.domset)
+        for u, v in instance.edges:
+            if u in self.domset:
+                dominated.add(v)
+            elif v in self.domset:
+                dominated.add(u)
+        if len(dominated) != instance.num_vertices:
+            raise ValidationError(
+                "Not every vertex is dominated.",
+                detail=f"{instance.num_vertices - len(dominated)} vertices are not dominated",
+            )
+
+    @minimize
+    def score(self, instance: UndirectedGraph, role: Role) -> float:
+        return len(self.domset)
+
+
+Domset = Problem(
+    name="Dominating Set",
+    min_size=2,
+    instance_cls=UndirectedGraph,
+    solution_cls=Solution,
+)

algobattle-problems-1.0.0/algobattle_problems/domset/solver/main.py

@@ -0,0 +1,10 @@
+"""Simple dummy solver for the DomSet problem, outputting a static solution."""
+import json
+
+with open("output/solution.json", "w") as output:
+    json.dump(
+        {
+            "domset": [1],
+        },
+        output,
+    )