simplex-tree-classifier 0.1.0__py3-none-any.whl

simplex_tree_classifier/simplex_tree.py

@@ -0,0 +1,319 @@
+"""Hierarchical tree of N-dimensional simplices.
+
+A ``SimplexTree`` is a ``Simplex`` that can subdivide itself. Two subdivision
+schemes are supported through this class:
+
+* barycentric - recursively split every simplex at its barycenter
+  (``_add_barycentric_centers_recursively``), producing a uniform tree;
+* data-driven - split only chosen leaves at their barycenter
+  (``subdivide_leaf``), driven externally by classification error.
+
+The tree also answers geometric queries used by the classifier:
+``find_containing_simplex`` and ``find_adjacent_simplexes``.
+"""
+
+import numpy as np
+from typing import List, Optional, Iterator, Tuple
+from collections import deque
+
+from .simplex import Simplex
+from .vertex_registry import VertexRegistry
+
+
+def make_enclosing_simplex(dimension: int, scale: Optional[float] = None,
+                           margin: float = 0.05) -> List[Tuple[float, ...]]:
+    """Build vertices of a d-simplex that encloses the unit hypercube ``[0, 1]^d``.
+
+    The simplex has one vertex at the origin and one vertex ``scale * e_i`` along
+    each axis, i.e. the region ``{x_i >= 0, sum_i x_i <= scale}``. Choosing
+    ``scale > d`` guarantees the whole closed unit cube (whose farthest corner has
+    coordinate sum ``d``) lies strictly inside.
+
+    For ``d == 2`` and ``margin == 0`` this reproduces the classic base triangle
+    ``[(0, 0), (2, 0), (0, 2)]``.
+
+    Args:
+        dimension: Number of features ``d``.
+        scale: Axis intercept of the enclosing simplex. Defaults to
+            ``d * (1 + margin)``.
+        margin: Relative slack beyond the unit cube when ``scale`` is not given.
+
+    Returns:
+        List of ``d + 1`` coordinate tuples.
+    """
+    if dimension < 1:
+        raise ValueError("dimension must be >= 1")
+    if scale is None:
+        scale = dimension * (1.0 + margin)
+    origin = tuple(0.0 for _ in range(dimension))
+    vertices = [origin]
+    for axis in range(dimension):
+        vertex = [0.0] * dimension
+        vertex[axis] = float(scale)
+        vertices.append(tuple(vertex))
+    return vertices
+
+
+class SimplexTree(Simplex):
+    def __init__(self, vertices: List[Tuple[float, ...]], tolerance: float = 1e-10,
+                 registry: Optional[VertexRegistry] = None, _is_child: bool = False):
+        if registry is None:
+            reg = VertexRegistry(tolerance)
+            self._is_root = True
+            self._split_counter = [0]
+        else:
+            reg = registry
+            self._is_root = not _is_child
+            self._split_counter = None
+
+        vertex_indices = reg.register_vertices(vertices)
+        super().__init__(vertex_indices, reg, tolerance)
+
+        self.children: List[Optional['SimplexTree']] = []
+        self.parent: Optional['SimplexTree'] = None
+        self.depth: int = 0
+        self._node_count = 1
+        self.splitting_point_index: Optional[int] = None
+        self.splitting_point_vertex_index: Optional[int] = None
+
+    def _get_root(self) -> 'SimplexTree':
+        node = self
+        while node.parent is not None:
+            node = node.parent
+        return node
+
+    def _get_next_split_index(self) -> int:
+        root = self._get_root()
+        idx = root._split_counter[0]
+        root._split_counter[0] += 1
+        return idx
+
+    def _add_child(self, child_vertices: List[Tuple[float, ...]]) -> 'SimplexTree':
+        child = SimplexTree(child_vertices, self.tolerance, self.registry, _is_child=True)
+        child.parent = self
+        child.depth = self.depth + 1
+        self.children.append(child)
+        return child
+
+    def _is_leaf(self) -> bool:
+        return len(self.children) == 0
+
+    def _get_children(self) -> List['SimplexTree']:
+        return self.children.copy()
+
+    def _remove_splitting_point(self, splitting_point_index: int) -> bool:
+        """Remove a splitting point by clearing its children and resetting to a leaf."""
+        for node in self._traverse_breadth_first():
+            if node.splitting_point_index == splitting_point_index:
+                for child in node.children:
+                    if len(child.children) > 0:
+                        return False
+                node.children.clear()
+                node.splitting_point_index = None
+                node.splitting_point_vertex_index = None
+                return True
+        return False
+
+    def remove_by_leaf_key(self, vertex_key: frozenset) -> bool:
+        """Removes a leaf simplex by undoing its parent's split.
+
+        Clears the parent's splitting point and removes all sibling children,
+        restoring the parent to a leaf state.
+
+        Args:
+            vertex_key: Frozenset of vertex indices identifying the leaf to remove
+
+        Returns:
+            True if removal succeeded, False if leaf not found or has children
+        """
+        for node in self._traverse_breadth_first():
+            if frozenset(node.vertex_indices) == vertex_key:
+                parent = node.parent
+                if parent is not None and parent.splitting_point_index is not None:
+                    return self._remove_splitting_point(parent.splitting_point_index)
+                return False
+        return False
+
+    def _traverse_breadth_first(self) -> Iterator['SimplexTree']:
+        queue = deque([self])
+        while queue:
+            node = queue.popleft()
+            yield node
+            for child in node._get_children():
+                queue.append(child)
+
+    def get_leaves(self) -> List['SimplexTree']:
+        """Returns all leaf nodes (simplices with no children) in the tree."""
+        leaves = []
+        for node in self._traverse_breadth_first():
+            if node._is_leaf():
+                leaves.append(node)
+        return leaves
+
+    def find_adjacent_simplexes(self, leaf: 'SimplexTree') -> List['SimplexTree']:
+        """Finds all leaf simplexes adjacent to the given leaf.
+
+        Two leaf simplexes are adjacent if they share at least ``d`` vertices
+        (a ``(d-1)``-dimensional face), where ``d`` is the dimension of the space.
+
+        Walks up the tree level by level - at each ancestor, checks the sibling
+        subtrees for adjacent leaves (siblings, cousins, second cousins, etc.).
+
+        Args:
+            leaf: A leaf SimplexTree node
+
+        Returns:
+            List of adjacent leaf SimplexTree nodes
+        """
+        leaf_vertex_set = set(leaf.vertex_indices)
+        min_shared = leaf.dimension
+        adjacent = []
+        seen = set()
+
+        current = leaf
+        while current.parent is not None:
+            parent = current.parent
+            for sibling in parent.children:
+                if sibling is current:
+                    continue
+                candidates = [sibling] if sibling._is_leaf() else sibling.get_leaves()
+                for candidate in candidates:
+                    if id(candidate) not in seen:
+                        if len(leaf_vertex_set.intersection(candidate.vertex_indices)) >= min_shared:
+                            adjacent.append(candidate)
+                            seen.add(id(candidate))
+                            if len(adjacent) == leaf.dimension + 1:
+                                return adjacent
+            current = parent
+
+        return adjacent
+
+    def find_containing_simplex(self, point: Tuple[float, ...]) -> Optional['SimplexTree']:
+        """Finds the leaf simplex containing the given point.
+
+        Recursively searches the tree to find the smallest (deepest) simplex
+        that contains the point.
+
+        Args:
+            point: Coordinates to locate
+
+        Returns:
+            The leaf SimplexTree containing the point, or None if outside tree
+        """
+        if not self._point_inside_simplex(point):
+            return None
+
+        if self._is_leaf():
+            return self
+
+        for child in self._get_children():
+            result = child.find_containing_simplex(point)
+            if result is not None:
+                return result
+
+        return self
+
+    def __repr__(self):
+        vertices = self.get_vertices_as_tuples()
+        vertex_str = str(vertices)
+        return (f"{self.__class__.__name__}(vertices={vertex_str}, "
+                f"children={len(self.children)}, depth={self.depth})")
+
+    def _add_splitting_point(self, point: Tuple[float, ...]) -> List['SimplexTree']:
+        if not self._is_leaf():
+            for child in self.children:
+                if child._point_inside_simplex(point):
+                    return child._add_splitting_point(point)
+
+        if not self._point_inside_simplex(point):
+            raise ValueError(f"Splitting point {point} is not inside this simplex")
+
+        self.splitting_point_index = self._get_next_split_index()
+        vertex_indices = self.registry.register_vertices([tuple(point)])
+        self.splitting_point_vertex_index = vertex_indices[0]
+
+        vertices = self.get_vertices_as_tuples()
+        n_vertices = len(vertices)
+
+        children = []
+        for i in range(n_vertices):
+            child_vertices = [v for j, v in enumerate(vertices) if j != i] + [tuple(point)]
+            child = self._add_child(child_vertices)
+            children.append(child)
+        return children
+
+    def _compute_barycentric_center(self) -> Tuple[float, ...]:
+        vertices = self.vertices
+        center = np.mean(vertices, axis=0)
+        return tuple(float(x) for x in center)
+
+    def subdivide_leaf(self, leaf: 'SimplexTree') -> List['SimplexTree']:
+        """Split a single leaf at its barycenter (used by data-driven subdivision).
+
+        Args:
+            leaf: A leaf node of this tree.
+
+        Returns:
+            The list of freshly created child simplices.
+        """
+        if not leaf._is_leaf():
+            raise ValueError("subdivide_leaf expects a leaf node")
+        barycenter = leaf._compute_barycentric_center()
+        return leaf._add_splitting_point(barycenter)
+
+    def _add_barycentric_centers_recursively(self, levels: int) -> None:
+        if levels <= 0:
+            return
+
+        if self._is_leaf():
+            barycenter = self._compute_barycentric_center()
+            self._add_splitting_point(barycenter)
+
+        for child in self.children:
+            child._add_barycentric_centers_recursively(levels - 1)
+
+    def print_tree(self, show_only_splitting_points: bool = False) -> None:
+        """Prints the tree structure to console.
+
+        Args:
+            show_only_splitting_points: If True, shows only splitting point indices.
+                If False, shows all nodes with vertex indices.
+        """
+        def _print(node, prefix: str = "", is_last: bool = True):
+            connector = "└── " if is_last else "├── "
+            if show_only_splitting_points:
+                if node.splitting_point_index is not None:
+                    print(f"{prefix}{connector}[{node.splitting_point_index}] "
+                          f"(vertex {node.splitting_point_vertex_index})")
+                    new_prefix = prefix + ("    " if is_last else "│   ")
+                    child_count = len(node.children)
+                    for idx, child in enumerate(node.children):
+                        _print(child, new_prefix, idx == child_count - 1)
+            else:
+                if node.splitting_point_index is not None:
+                    label = f"[{node.splitting_point_index}] vertices: {node.vertex_indices}"
+                else:
+                    label = f"vertices: {node.vertex_indices}"
+                print(f"{prefix}{connector}{label}")
+            new_prefix = prefix + ("    " if is_last else "│   ")
+            child_count = len(node.children)
+            for idx, child in enumerate(node.children):
+                _print(child, new_prefix, idx == child_count - 1)
+
+        _print(self)
+
+    def get_splitting_points(self) -> List[Tuple[int, Tuple[float, ...]]]:
+        """Returns all splitting points currently in the tree.
+
+        Each splitting point is the center used to subdivide a simplex into
+        children.
+
+        Returns:
+            List of ``(split_index, coords)`` tuples for each splitting point
+        """
+        splitting_points = []
+        for node in self._traverse_breadth_first():
+            if node.splitting_point_index is not None:
+                coords = tuple(self.registry._get_vertex(node.splitting_point_vertex_index))
+                splitting_points.append((node.splitting_point_index, coords))
+        return splitting_points

simplex_tree_classifier/vertex_registry.py

@@ -0,0 +1,70 @@
+"""Global registry that de-duplicates vertices shared across a simplex tree.
+
+Every unique coordinate tuple is stored once and referenced everywhere by an
+integer index. This keeps barycentric feature columns consistent: a given
+column always maps to the same point in space.
+"""
+
+import numpy as np
+from typing import List, Tuple, Dict
+
+
+class VertexRegistry:
+    def __init__(self, tolerance: float = 1e-10):
+        self.vertices: List[np.ndarray] = []
+        self.vertex_to_index: Dict[Tuple, int] = {}
+        self.tolerance = tolerance
+
+    def _register_vertex(self, vertex: Tuple[float, ...]) -> int:
+        vertex_tuple = tuple(float(x) for x in vertex)
+        if vertex_tuple in self.vertex_to_index:
+            return self.vertex_to_index[vertex_tuple]
+        idx = len(self.vertices)
+        self.vertices.append(np.array(vertex_tuple))
+        self.vertex_to_index[vertex_tuple] = idx
+        return idx
+
+    def register_vertices(self, vertices: List[Tuple[float, ...]]) -> List[int]:
+        """Registers multiple vertices and returns their indices.
+
+        Existing vertices return their existing index (no duplicates created).
+
+        Args:
+            vertices: List of coordinate tuples to register
+
+        Returns:
+            List of integer indices corresponding to each vertex
+        """
+        return [self._register_vertex(v) for v in vertices]
+
+    def _get_vertex(self, idx: int) -> np.ndarray:
+        return self.vertices[idx]
+
+    def _get_vertices(self, indices: List[int]) -> List[np.ndarray]:
+        return [self.vertices[idx] for idx in indices]
+
+    def _get_vertex_as_tuple(self, idx: int) -> Tuple[float, ...]:
+        return tuple(float(x) for x in self.vertices[idx])
+
+    def get_vertices_as_tuples(self, indices: List[int]) -> List[Tuple[float, ...]]:
+        """Returns coordinates as tuples for the given vertex indices.
+
+        Args:
+            indices: List of vertex indices to look up
+
+        Returns:
+            List of coordinate tuples
+        """
+        return [self._get_vertex_as_tuple(idx) for idx in indices]
+
+    def as_matrix(self) -> np.ndarray:
+        """Returns all registered vertices stacked into an (n_vertices, dim) array."""
+        if not self.vertices:
+            return np.empty((0, 0))
+        return np.vstack(self.vertices)
+
+    def __len__(self) -> int:
+        return len(self.vertices)
+
+    def __repr__(self) -> str:
+        return f"VertexRegistry(num_vertices={len(self.vertices)})"

simplex_tree_classifier/visualization.py

@@ -0,0 +1,102 @@
+"""Optional 2-D visualization helpers (requires the ``viz`` extra: matplotlib).
+
+These only make sense for 2-dimensional data. Import lazily so the core package
+works without matplotlib installed.
+"""
+
+from typing import List, Optional, Tuple
+
+
+def _require_matplotlib():
+    try:
+        import matplotlib.pyplot as plt  # noqa: F401
+        import matplotlib.patches as patches  # noqa: F401
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "Visualization requires matplotlib. Install the extra with "
+            "`pip install simplex-tree-classifier[viz]`."
+        ) from exc
+    return plt, patches
+
+
+def _draw_2d_simplex(vertices, ax, color, alpha=0.3, linewidth=1, s=50, label=None):
+    import matplotlib.patches as patches
+    n = len(vertices)
+    if n == 0:
+        return
+    if n == 1:
+        x, y = vertices[0]
+        ax.scatter([x], [y], color=color, s=s * 2, label=label)
+    elif n == 2:
+        x, y = zip(*vertices)
+        ax.plot(x, y, color=color, linewidth=linewidth * 2, alpha=alpha, label=label)
+        ax.scatter(x, y, color=color, s=s, alpha=alpha)
+    elif n == 3:
+        triangle = patches.Polygon(vertices, facecolor=color, alpha=alpha,
+                                   edgecolor="black", linewidth=linewidth)
+        ax.add_patch(triangle)
+        x, y = zip(*vertices)
+        ax.scatter(x, y, color=color, s=s, alpha=alpha, label=label)
+    else:
+        x, y = zip(*vertices)
+        ax.scatter(x, y, color=color, s=s, alpha=alpha, label=label)
+        for i in range(n):
+            for j in range(i + 1, n):
+                ax.plot([vertices[i][0], vertices[j][0]],
+                        [vertices[i][1], vertices[j][1]],
+                        color=color, linewidth=linewidth, alpha=alpha)
+
+
+def _draw_children_recursive(node, ax, colors, depth=0):
+    for i, child in enumerate(node._get_children()):
+        color = colors[(depth + i) % len(colors)]
+        _draw_2d_simplex(child.get_vertices_as_tuples(), ax, color,
+                         alpha=0.2, linewidth=1, s=30)
+        _draw_children_recursive(child, ax, colors, depth + 1)
+
+
+def visualize_simplex_tree(tree, data_points=None,
+                           title: str = "Simplex Tree",
+                           figsize: Tuple[int, int] = (10, 8)):
+    """Plot a 2-D simplex tree and (optionally) overlaid data points."""
+    plt, _ = _require_matplotlib()
+    fig, ax = plt.subplots(figsize=figsize)
+    colors = ["red", "blue", "green", "orange", "purple", "brown",
+              "pink", "gray", "cyan", "magenta"]
+
+    _draw_2d_simplex(tree.get_vertices_as_tuples(), ax, "red", alpha=0.3,
+                     linewidth=2, s=20, label="Root simplex")
+    _draw_children_recursive(tree, ax, colors, depth=0)
+
+    if data_points is not None and len(data_points) > 0:
+        xs = [p[0] for p in data_points]
+        ys = [p[1] for p in data_points]
+        ax.scatter(xs, ys, color="black", s=40, alpha=0.8,
+                   edgecolors="white", linewidth=1, label="Data", zorder=10)
+
+    ax.set_xlabel("x1")
+    ax.set_ylabel("x2")
+    ax.set_title(title)
+    ax.set_aspect("equal")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    return fig, ax
+
+
+def plot_leaf_boundaries(classifier, ax=None,
+                         color: str = "red", linewidth: float = 0.5):
+    """Draw the edges of every leaf simplex of a fitted 2-D classifier."""
+    plt, _ = _require_matplotlib()
+    if classifier.dimension != 2:
+        raise ValueError("plot_leaf_boundaries only supports 2-D classifiers.")
+    if ax is None:
+        _, ax = plt.subplots(figsize=(8, 8))
+    for boundary in classifier.get_simplex_vertices():
+        if len(boundary) >= 3:
+            closed = list(boundary) + [boundary[0]]
+            xs = [p[0] for p in closed]
+            ys = [p[1] for p in closed]
+            ax.plot(xs, ys, color=color, linewidth=linewidth, alpha=0.6)
+    ax.set_aspect("equal")
+    return ax

simplex_tree_classifier-0.1.0.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: simplex-tree-classifier
+Version: 0.1.0
+Summary: Hierarchical simplex-tree classifier with barycentric embedding, GPU-accelerated transform, and non-convex boundary pruning.
+Author: Yasmin
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yasmin/SimplexTreeClassifier
+Project-URL: Repository, https://github.com/yasmin/SimplexTreeClassifier
+Keywords: machine-learning,classifier,simplex,barycentric,interpretability,surrogate-model
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: torch>=1.12
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.4; extra == "viz"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# simplex-tree-classifier
+
+A hierarchical **simplex-tree classifier**. It embeds points into the barycentric
+coordinates of a subdivided simplex, then trains any scikit-learn estimator on
+that sparse, geometry-aware feature space. The barycentric `transform` is
+accelerated with **PyTorch** and runs on the GPU when one is available.
+
+It works in two ways:
+
+- **Dataset mode** - train directly on your data `(X, y)`.
+- **Surrogate mode** - imitate an existing `model` (e.g. a neural network) to
+produce an interpretable, piecewise-linear geometric surrogate.
+
+Everything is **N-dimensional**.
+
+## Installation
+
+```bash
+pip install simplex-tree-classifier          # core (numpy, scipy, scikit-learn, torch)
+pip install simplex-tree-classifier[viz]      # + matplotlib for 2-D plots
+```
+
+From source:
+
+```bash
+cd simplex_tree_package
+pip install -e .
+```
+
+
+
+## Quickstart
+
+
+
+### Dataset mode
+
+```python
+import numpy as np
+from simplex_tree_classifier import SimplexTreeClassifier
+
+X = np.random.uniform(0, 1, size=(500, 4))
+y = (X.sum(axis=1) > 2.0).astype(int)
+
+clf = SimplexTreeClassifier(subdivision_levels=2)   # default classifier: LinearSVC
+clf.fit(X, y)
+print(clf.predict(X[:5]))
+```
+
+
+
+### Surrogate mode (imitate a model)
+
+Pass any object with `.predict(X)` or any callable `X -> labels`, plus the input
+dimensionality. Fill points are sampled in `[0, 1]^d` and labeled by the model.
+
+```python
+def black_box(X):                      # e.g. a wrapped PyTorch model
+    X = np.atleast_2d(X)
+    return (X[:, 0] + X[:, 1] > 1.0).astype(int)
+
+surrogate = SimplexTreeClassifier(
+    model=black_box,
+    n_features=2,
+    subdivision_levels=4,
+    n_fill=5000,
+)
+surrogate.fit()                        # samples + labels internally
+```
+
+
+
+### Data-driven subdivision
+
+Instead of uniform (barycentric) subdivision, split only where the classifier is
+still wrong:
+
+```python
+clf = SimplexTreeClassifier(
+    subdivision_strategy="data_driven",
+    subdivision_levels=6,     # here: maximum tree depth
+    max_leaves=500,
+)
+clf.fit(X, y)
+```
+
+
+
+## API overview
+
+Constructor: `SimplexTreeClassifier(classifier=None, model=None, n_features=None, subdivision_levels=1, subdivision_strategy="barycentric", n_fill=5000, max_leaves=None, normalize=None, margin=0.05, device=None, tolerance=1e-10, random_state=None, data_driven_max_iter=50)`
+
+Core methods:
+
+- `transform(X)` - sparse barycentric embedding (GPU-accelerated); rows sum to 1.
+- `fit(X=None, y=None)` - trains the classifier. In surrogate mode `X`/`y` are
+optional. Automatically records same-side simplices afterward (linear only).
+- `predict(X)` - predicted labels.
+
+Geometry queries:
+
+- `find_containing_simplex(point)` - the leaf simplex a point falls in.
+- `find_adjacent_simplexes(simplex)` - leaves sharing a `(d-1)`-face.
+- `get_simplex_vertices()` - vertices of every leaf simplex (renamed from
+`get_simplex_boundaries`).
+- `is_in_simplex(point, simplex)` - boolean containment test.
+
+Decision-boundary analysis (linear classifiers, multiclass-aware):
+
+- `identify_crossing_simplices()` - leaves crossed by the decision boundary.
+- `remove_nonconvex_leaves(criterion="distance"|"convexity_sign", removal_factor=0.15, epsilon=None, keep_frac=None, min_depth=0.0, max_remove_frac=0.25, max_iter=10, refit=True)` - iteratively prune leaves whose
+boundary bends non-convexly.
+- `find_same_side_simplices()` - subdivisions that don't touch the boundary (also
+run automatically at the end of `fit`, stored in `same_side_keys_`).
+- `compute_plane_equations()` - the boundary hyperplane within each crossing leaf.
+
+Helpers: `SimplexTree`, `Simplex`, `VertexRegistry`, `make_enclosing_simplex(d)`,
+`get_device()`.
+
+## GPU acceleration
+
+`transform` stacks each leaf's inverse edge matrix into tensors and embeds an
+entire batch of points against all leaves at once. The device is auto-detected
+(CUDA if present); override with `device="cpu"` / `device="cuda"`. Points outside
+every leaf (or inside a degenerate one) fall back to an exact per-point search.
+
+## TODO
+
+- [ ] **Overleaf cross-check.** Reconcile this package's operations against the
+  list of supported operations in the paper (Overleaf) and add anything missing.
+

simplex_tree_classifier-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+simplex_tree_classifier/__init__.py,sha256=I7M12scTJVYBzkZfoYw4Rv_Wh4aOJvUC6GsURd66s_I,888
+simplex_tree_classifier/backend.py,sha256=zSS6rZu-3ys5VGraLWMR03za_udmgOBkX-DFM7Yyaiw,7137
+simplex_tree_classifier/classifier.py,sha256=tY-aWwtO_EWkCF6d3Bo3fV5_xc6L5NoTiQdEdI2X6CY,33016
+simplex_tree_classifier/convexity.py,sha256=skg3iYo14iMo5_-6USeVUcLIhU9_bNvPRoPEcAmcuNs,8508
+simplex_tree_classifier/plane_equation.py,sha256=JNfwlLKmYB4tZHRhs4Ly5Hyf074FT2LkBafjHtc7i1I,2481
+simplex_tree_classifier/simplex.py,sha256=SwiM7_ay3DA5kMPKtS7UsF5m1uIkX8ca8JFa2dDg7yg,6208
+simplex_tree_classifier/simplex_tree.py,sha256=Qc8gZUYuYnEloEiRIBpb_FZb3PYSQKjkgpVHZYw6Kto,12762
+simplex_tree_classifier/vertex_registry.py,sha256=UzkgeHaXIm15ZCmglWsKuMKU5lpwJxKEA60ZNwDs3iU,2548
+simplex_tree_classifier/visualization.py,sha256=NvSETvHRQb3S8MWOLyPUKMvFeTebec2TU1MazWzlIUk,4064
+simplex_tree_classifier-0.1.0.dist-info/licenses/LICENSE,sha256=00sYuqcAxSjdor89Kd8thtcvK-xhUXf-fsBR1oTeC14,1084
+simplex_tree_classifier-0.1.0.dist-info/METADATA,sha256=Ky0YZjSiGiD5lGPCqTpO2RwbymHcYanjWlPNeg13mB0,5227
+simplex_tree_classifier-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+simplex_tree_classifier-0.1.0.dist-info/top_level.txt,sha256=PO4kiKAZRtkgzHgHtzufjkEL55mkhqvsTtF2hK4Wtdc,24
+simplex_tree_classifier-0.1.0.dist-info/RECORD,,

simplex_tree_classifier-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simplex_tree_classifier-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yasmin
+
+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.