polyblocks 0.1.0__py3-none-any.whl

polyblocks/__init__.py

@@ -0,0 +1,5 @@
+from .abstract import ABPolyblock, Solution
+from .naive import BalancedPOA, BasePOA
+from .tree import TreePOA
+
+__all__ = ["ABPolyblock", "BalancedPOA", "BasePOA", "Solution", "TreePOA"]

polyblocks/abstract.py

@@ -0,0 +1,301 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from functools import partial
+from time import perf_counter
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from .utils import monotone_proj, print_row, tighten
+
+
+@dataclass
+class Solution:
+    """
+    The result returned by `ABPolyblock.solve`.
+
+    Attributes:
+        x: Optimal (or best attained) solution.
+        obj: Optimal (or best attained) objective value.
+        best_bound: Best upper-bound on the optimal objective.
+        success: Whether the solver returned an optimal solution.
+        status: Description of the termination status.
+        n_iter: Number of iterations executed.
+    """
+
+    x: NDArray | None = None
+    obj: float = -np.inf
+    best_bound: float = np.inf
+    success: bool = False
+    status: str = "Maximum iterations reached"
+    n_iter: int = 0
+
+
+class ABPolyblock(ABC):
+    """
+    An abstract class for custom implementations of the Polyblock Outer-approximation (POA) algorithm.
+
+    POA maximises an increasing objective over `G ∩ H ∩ [x_l, x_u]`, where `G` is a normal set given by `ub_oracle` and `H` a co-normal set given by `lb_oracle`.
+    It does so by maintaining a *polyblock*: a finite vertex set `V` whose union of boxes `(-inf, v]` contains every feasible point which could still improve the incumbent.
+    Each iteration projects vertices of `V` onto the boundary of `G` and cuts the
+    infeasible cone strictly above each projection out of the polyblock, so the outer-approximation tightens until `V` empties and the incumbent is certified optimal.
+
+    Child classes choose how that vertex set is stored and refined, and `solve` drives the representation through one cycle per iteration:
+
+    1. `projection_pairs` selects the vertices to refine, each paired with a feasible anchor below it.
+    2. `solve` projects each vertex towards its anchor onto the boundary of the eroded set `G_delta`, giving `proj`, and takes the shifted candidates `min(proj + delta, x_u)` as feasible solutions.
+    3. `set_min_obj` is called with a new objective cut-off, but only when a candidate improves the incumbent.
+    4. `new_vertices` cuts the cones above `proj` out of the polyblock and returns the replacement vertices.
+    5. `solve` evaluates the objective on those vertices and passes a feasibility mask to `update`, which reports whether the vertex set is now exhausted.
+
+    Implementing `__init__`, `projection_pairs`, `set_min_obj`, `new_vertices`, and  `update` is therefore enough to define a solver.
+    The `size` property is used for limiting memory usage, while the `best_bound` property is optional and only used for progress reporting.
+
+    Attributes:
+        POLYBLOCK_LIMIT: Maximum permitted `size` of the polyblock container.
+    """
+
+    POLYBLOCK_LIMIT = 2 * int(1e8)
+
+    @abstractmethod
+    def __init__(self, lower: NDArray, upper: NDArray) -> None:
+        """
+        Initialises polyblock representation using lower and upper points which define the feasible rectangle.
+
+        Both points have already been tightened against the oracles by `solve`, so the initial polyblock is the single vertex `upper`.
+
+        Args:
+            lower: Lower point of the feasible rectangle, of shape `(dim,)`.
+            upper: Upper point of the feasible rectangle, of shape `(dim,)`.
+        """
+
+    @abstractmethod
+    def projection_pairs(self) -> tuple[NDArray, NDArray]:
+        """
+        Returns pairs of anchors and vertices for computing monotone projections.
+
+        Called once at the start of each iteration to choose which vertices to refine.
+        The selection policy is free, subject only to the requirement that the *maximal* vertex, the one of greatest objective value in the polyblock, is always among those returned; convergence rests on it.
+        Returning several pairs cuts several cones per iteration, where downstream routines apply in a vectorised fashion.
+
+        Each anchor need only lie in `G` and strictly below its vertex; the `delta` shift keeping it feasible for the eroded set is applied downstream.
+
+        Returns:
+            A tuple `(anchors, vertices)`, each of shape `(num_pairs, dim)`:
+                anchors: Feasible points which project their paired vertex.
+                vertices: Polyblock vertices to project onto their paired anchor.
+        """
+
+    @abstractmethod
+    def set_min_obj(self, obj: float) -> None:
+        """
+        Update minimum objective value of future candidate solutions, discarding those which fall below it.
+
+        The polyblock only has to cover feasible points which beat the incumbent by the optimality tolerance, so a vertex falling below `obj` may be dropped: its objective bounds the whole box below it.
+        Called only when the incumbent improves, so `obj` increases monotonically over a solve.
+
+        Args:
+            obj: Objective cut-off for retained vertices.
+        """
+
+    @abstractmethod
+    def new_vertices(self, proj: NDArray, delta: float) -> NDArray:
+        """
+        Returns refined polyblock vertices to be checked for feasibility.
+
+        Cuts the cones above `proj` out of the polyblock, returning the vertices which replace those they remove.
+        A vertex lying above a projection is refined by reducing each of its components in turn to the matching component of that projection, giving up to `dim` replacements.
+        The choice of which vertices are refined, a vertex lying above several projections is handled is left to the implementation.
+        The implementation decides which vertices are refined, the projections used to refine them, and how redundancy checking is handled.
+
+        New vertiecs are internally retained, since `update` reports feasibility against it positionally.
+
+        Args:
+            proj: Monotone projections of this iteration's vertices, of shape `(num_pairs, dim)`.
+            delta: Erosion factor, giving the margin within which a vertex need not be refined for partial refinements.
+
+        Returns:
+            Candidate vertices of shape `(num_new, dim)`, pending the feasibility check in `update`.
+            All vertices should lie within the feasible box.
+        """
+
+    @abstractmethod
+    def update(self, new_mask: NDArray[np.bool], new_obj: NDArray) -> bool:
+        """
+        Updates internal polyblock representation after checking new vertex feasibility.
+
+        `new_mask` indexes the array returned by `new_vertices` in the same order, while `new_obj` holds objective values for the masked entries alone.
+        Masked-out vertices either violate the co-normal constraints or fall below the objective cut-off, and should be discarded rather than stored.
+
+        Args:
+            new_mask: Refined vertex feasibility, of shape `(num_new,)`.
+            new_obj: Objective values of feasible refined vertices, of shape `(new_mask.sum(),)`.
+
+        Returns:
+            True once the vertex set is exhausted, which terminates `solve` and certifies the incumbent as optimal, or the problem as infeasible if no candidate was ever found.
+        """
+
+    @property
+    @abstractmethod
+    def size(self) -> int:
+        """
+        Size of the container used to store polyblocks. Used for limiting memory usage.
+
+        Polled every iteration, and `solve` gives up once it exceeds `POLYBLOCK_LIMIT`.
+        Units are left to the implementation, as the limit is only ever compared against this property.
+        """
+
+    @property
+    def best_bound(self) -> float:
+        """
+        Best upper-bound on optimal objective value (optional).
+
+        Defaults to `nan` for implementations which do not track a bound.
+        This property is only used for reporting purposes and does not affect the solve.
+        """
+        return np.nan
+
+    @classmethod
+    def solve(
+        cls,
+        obj: Callable[[NDArray[np.floating]], NDArray[np.floating]],
+        x_l: ArrayLike,
+        x_u: ArrayLike,
+        ub_oracle: Callable[[NDArray[np.floating]], NDArray[np.bool]],
+        lb_oracle: Callable[[NDArray[np.floating]], NDArray[np.bool]] | None = None,
+        eps_obj_abs: float = 1e-6,
+        eps_obj_rel: float = 1e-2,
+        eps_ls: float = 1e-3,
+        delta: float = 1e-3,
+        verbose_gap: int | None = None,
+        time_limit: int = 3600,
+        iteration_limit: int = int(1e8),
+    ) -> Solution:
+        """
+        A template for the Polyblock Outer-approximation algorithm.
+
+        Maximises `obj` over the points of `[x_l, x_u]` accepted by both oracles.
+        The objective must be non-decreasing in every coordinate, while `ub_oracle` and `lb_oracle` should be boolean-valued functions querying upper- and lower-bound constraints, respectively.
+        All three functions are called with 2D arrays batching points along the first axis.
+
+        A returned solution is always feasible, and no feasible point beats it by more than the objective tolerances, except possibly points lying within `delta` of the upper-bound constraint boundary.
+
+        Args:
+            obj: Non-decreasing objective function.
+            x_l: Lower point defining feasible rectangle [x_l, x_u], must broadcast with `x_u` to a valid input for the objective and oracles.
+            x_u: Upper point defining feasible rectangle [x_l, x_u], must broadcast with `x_l` to a valid input for the objective and oracles.
+            ub_oracle: Oracle querying upper-bound (normal) constraints.
+            lb_oracle: Oracle querying lower-bound (co-normal) constraints (optional).
+            eps_obj_abs: Absolute tolerance between incumbent objective and upper-bound.
+            eps_obj_rel: Relative tolerance between incumbent objective and upper-bound.
+            eps_ls: Line-search tolerance.
+            delta: Optimality relaxation for upper-bound constraints. The objective is optimised only over the `delta` eroded normal set.
+            verbose_gap: Number of iterations between printout (optional).
+            iteration_limit: Maximum number of POA iterations before the solver gives up.
+            time_limit: Maximum solver runtime in seconds.
+
+        Returns:
+            The best solution found, see `Solution`. Note that `success` reports whether the solver terminated on its own certificate rather than a limit, so it is also set when the problem is proven infeasible.
+
+        Raises:
+            ValueError: If `x_u` is smaller than `x_l` in any coordinate.
+        """
+
+        lb_exists = lb_oracle is not None
+        verbose = verbose_gap is not None
+
+        ## returned solution
+        sol = Solution()
+
+        ## initial checks
+        x_l, x_u = np.broadcast_arrays(x_l, x_u)
+        if (x_u - x_l < 0).any():
+            raise ValueError("`x_u` must be no smaller than `x_l` element-wise.")
+        elif not ub_oracle(x_l[None]):
+            sol.success = True
+            sol.status = "Problem Infeasible since `x_l` not in normal set."
+            if verbose:
+                print(sol.status)
+            return sol
+
+        ## tighten initial box
+        x_u = tighten(x_l, x_u, oracle=ub_oracle)
+        x_l = tighten(x_u, x_l, oracle=lb_oracle) if lb_exists else x_l.copy()
+
+        mono_proj = partial(monotone_proj, oracle=ub_oracle, eps=eps_ls, delta=delta)
+        polyblock = cls(x_l, x_u)
+        min_obj = -np.inf
+
+        ## main loop
+        i = -1
+        start_time = perf_counter()
+        for i in range(iteration_limit):
+            ## compute projections from lower and upper points
+            lower_data, upper_data = polyblock.projection_pairs()
+            proj = mono_proj(lower_data, upper_data)
+            candidates = (proj + delta).clip(max=x_u)
+
+            ## find feasible candidates
+            feas_mask = (candidates >= x_l).all(-1)
+            if lb_exists:
+                feas_mask &= lb_oracle(candidates)
+
+            ## update best solution
+            if feas_mask.any():
+                cand_feas = candidates[feas_mask]
+                cand_obj = obj(cand_feas)
+                best_cand = cand_obj.argmax()
+                best_obj_cand = cand_obj[best_cand]
+                if best_obj_cand > sol.obj:
+                    sol.obj = best_obj_cand.item()
+                    sol.x = cand_feas[best_cand].copy()
+                    min_obj = eps_obj_abs + sol.obj * (eps_obj_rel + 1)
+                    polyblock.set_min_obj(min_obj)
+
+            ## update polyblock representation
+            new = polyblock.new_vertices(proj, delta=delta)
+            new_obj = obj(new).flatten()
+            new_mask = new_obj >= min_obj
+            if lb_exists:
+                new_mask &= lb_oracle(new)
+            new_obj = new_obj[new_mask]
+            empty = polyblock.update(new_mask, new_obj)
+
+            ## check termination
+            if empty:
+                sol.success = True
+                if sol.x is not None:
+                    sol.status = "Optimal!"
+                else:
+                    sol.status = "Infeasible under current relaxation."
+                break
+            elif polyblock.size > cls.POLYBLOCK_LIMIT:
+                sol.status = "Maximum polyblock size exceeded."
+                break
+            elif perf_counter() - start_time > time_limit:
+                sol.status = "Time limit exceeded."
+                break
+
+            if verbose and i % verbose_gap == 0:
+                header = i % (verbose_gap * 50) == 0
+                print_row(
+                    header=header,
+                    iter=i,
+                    obj=sol.obj,
+                    best_bound=polyblock.best_bound,
+                    poly_size=polyblock.size,
+                    dist_to_boundary=(upper_data - proj).mean().item(),
+                )
+
+        sol.n_iter = i + 1
+        sol.best_bound = polyblock.best_bound
+        if verbose:
+            print(
+                f"{sol.status}, "
+                f"itr: {sol.n_iter}, "
+                f"Best solution: {sol.x}, "
+                f"Obj: {sol.obj:.3f}"
+            )
+
+        return sol

polyblocks/containers.py

@@ -0,0 +1,179 @@
+import numpy as np
+from numpy.typing import ArrayLike, DTypeLike, NDArray
+
+from .jit_funcs import delete, find_best, query_multi, rebuild, update_obj
+
+
+class DynamicArray:
+    """
+    A 2D numpy array with over-allocated memory to improve append performance along first axis.
+
+    Data range is not checked when indexing array.
+    """
+
+    __slots__ = ("data", "length")
+
+    def __init__(self, dim=1, dtype: DTypeLike = float, start_sz=100):
+        """Initialise dynamic container consisting of `dim` dimensional vectors of type `dtype`"""
+
+        size = (start_sz,) if dim == 1 else (start_sz, dim)
+        self.data = np.empty(size, dtype=dtype)
+        self.length = 0
+
+    def append(self, new: ArrayLike) -> None:
+        """Append vectors in `new` to the end of the array."""
+
+        data = self.data
+        row_shape = data.shape[1:]
+        new = np.asarray(new, dtype=data.dtype).reshape(-1, *row_shape)
+
+        max_size = data.shape[0]
+        length = self.length
+        new_len = length + new.shape[0]
+        if new_len > max_size:
+            new_size = max(max_size * 2, new_len)
+            new_data = np.empty((new_size, *row_shape), dtype=data.dtype)
+            new_data[:length] = data[:length]
+            self.data = data = new_data
+        data[length:new_len] = new
+        self.length = new_len
+
+    @property
+    def array(self):
+        return self.data[: self.length]
+
+    @property
+    def dtype(self):
+        return self.data.dtype
+
+    def __getitem__(self, index):
+        return self.data[index]
+
+    def __setitem__(self, index, val):
+        self.data[index] = val
+
+    def delete(self, removed_idx: NDArray[np.intp]) -> None:
+        """Deletes elements at `removed_idx` by shifting remaining elements down."""
+
+        delete(self.array, removed_idx)
+        self.length -= removed_idx.shape[0]
+
+
+class Tree:
+    """Maintains a tree-representation of polyblock vertices."""
+
+    IDX_TYPE = np.int32
+    COMPONENT_TYPE = np.int8
+
+    def __init__(self, first: NDArray[np.float32 | np.float64]):
+        """Initialise tree using the root node vertex."""
+
+        self.first = first
+
+        ## tree representation
+        float_type = first.dtype
+        cvo_type = np.dtype(
+            [("comp", self.COMPONENT_TYPE), ("value", float_type), ("obj", float_type)]
+        )
+        self.cvo = DynamicArray(dim=1, dtype=cvo_type)
+        self.idx_range = DynamicArray(dim=2, dtype=self.IDX_TYPE)
+        self.parent = DynamicArray(dim=1, dtype=self.IDX_TYPE)
+
+        ## add first points
+        self.idx_range.append([-1, -1])
+        self.cvo.append((-1, -1, np.inf))
+        self.parent.append(-1)
+
+    def query(self, x: NDArray, lower: NDArray, min_obj=-np.inf, delta=1e-3) -> tuple:
+        """
+        Find and expand all leaf nodes which lie in the upper orthant of points `x`.
+
+        If a leaf node lies in more than one orthant, it is expanded using only the first valid point in `x`.
+
+        Args:
+            x: Array of shape `(num_points, dim)` containing points to query.
+            lower: Component-wise lower-bounds on tree vertices.
+            min_obj: Lower-bound on leaf objective permitted.
+            delta: Minimum distance from `x` required to expand a leaf.
+
+        Returns:
+            A tuple `(values, indices, vect, comp, cval)`:
+                values: Expanded leaf values.
+                indices: Indices of expanded leaves in the tree.
+                vect: Indices into `values` giving the parent leaf of each new node.
+                comp: Reduced component of each new node.
+                cval: New component values.
+        """
+
+        return query_multi(
+            x,
+            self.cvo.array,
+            self.idx_range.array,
+            self.first,
+            lower,
+            min_obj=min_obj,
+            delta=delta,
+        )
+
+    def find_best(self, num=1) -> NDArray:
+        """Find up to `num` different leaf node values, the first of which has the best objective."""
+
+        return find_best(self.cvo.array, self.idx_range.array, self.first, num=num)
+
+    def add(
+        self,
+        expanded: NDArray[np.intp],
+        exp_idx: NDArray[np.intp],
+        comp_idx: NDArray[np.intp],
+        comp_vals: NDArray[np.float32 | np.float64],
+        new_obj: NDArray[np.float32 | np.float64],
+    ) -> None:
+        """
+        Update internal tree representation by expanding leaf nodes.
+
+        Args:
+            expanded: Indices of expanded nodes.
+            exp_idx: Indices in `expanded` for parents of new nodes.
+            comp_idx: New expanded components.
+            comp_vals: New expanded component values.
+            new_obj: New objective values
+
+        """
+
+        cvo = self.cvo
+        parents = self.parent
+        idx_range = self.idx_range
+
+        ## collect new data
+        new_cvo = np.empty(comp_vals.shape[0], dtype=self.cvo.dtype)
+        new_cvo["comp"] = comp_idx
+        new_cvo["value"] = comp_vals
+        new_cvo["obj"] = new_obj
+
+        ## update parent neighbour ranges
+        num_expand = np.bincount(exp_idx, minlength=expanded.shape[0])
+        cumsum_expand = np.cumulative_sum(num_expand, include_initial=True)
+        cs_offset = cumsum_expand + cvo.length
+        par_ranges = np.column_stack((cs_offset[:-1], cs_offset[1:]))
+        idx_range[expanded] = par_ranges
+
+        ## append to tree
+        cvo.append(new_cvo)
+        parent_idx = expanded[exp_idx]  # exp_idx is assumed sorted
+        parents.append(parent_idx)
+        added_len = exp_idx.shape[0]
+        idx_range.append(np.full((added_len, 2), -1, dtype=idx_range.dtype))
+
+        ## backtrack obj values
+        update_obj(expanded, parents.array, cvo.array, idx_range.array)
+
+    def rebuild(self, min_obj: float) -> None:
+        """Remove childless nodes and nodes with objectives below `min_obj`."""
+
+        parent = self.parent
+        idx_range = self.idx_range
+        cvo = self.cvo
+
+        n_removed = rebuild(cvo.array, idx_range.array, parent.array, min_obj)
+        for arr in (cvo, parent, idx_range):
+            arr.length -= n_removed

polyblocks/jit_funcs.py

@@ -0,0 +1,406 @@
+"""A collection of functions which are jit compiled using numba."""
+
+import numpy as np
+from numba import njit, prange
+
+
+@njit(parallel=True, nogil=True, cache=True)
+def rebuild(cvo, idx_range, parents, min_obj) -> int:
+    """
+    Remove nodes whose objective falls to `min_obj` or below, and repair the indices of those remaining.
+
+    Surviving nodes are shifted down in-place, so the caller must reduce its own record of the array lengths by the returned count.
+
+    Args:
+        cvo: Node data of shape `(num_nodes,)` with `comp`, `value` and `obj` fields. Modified in-place.
+        idx_range: Child index ranges of shape `(num_nodes, 2)`. Modified in-place.
+        parents: Parent node indices of shape `(num_nodes,)`. Modified in-place.
+        min_obj: Nodes whose objective does not exceed this value are removed.
+
+    Returns:
+        Number of nodes removed.
+    """
+
+    ## find indices to remove
+    o = cvo["obj"]
+    removed_idx = (o <= min_obj).nonzero()[0]
+
+    ## prune tree
+    delete(cvo, removed_idx)
+    delete(parents, removed_idx)
+    delete(idx_range, removed_idx)
+
+    ## shift index values down
+    for i in prange(cvo.shape[0] - removed_idx.shape[0]):
+        p_offset = np.searchsorted(removed_idx, parents[i])
+        parents[i] -= p_offset
+
+        st, end = idx_range[i]
+        if st == end:
+            continue
+        else:
+            st_offset = np.searchsorted(removed_idx, st)
+            end_offset = np.searchsorted(removed_idx[st_offset:], end)
+        idx_range[i] = st - st_offset, end - end_offset - st_offset
+
+    return removed_idx.shape[0]
+
+
+@njit(nogil=True, cache=True)
+def query(x, cvo, idx_range, first, min_obj=-np.inf):
+    """
+    Query polyblock tree for all vertices `v` such that `v >= x` and `obj[v] >= min_obj`.
+
+    Args:
+        x: Query point of shape `(dim,)`.
+        cvo: Node data with `comp`, `value` and `obj` fields.
+        idx_range: Child index ranges of shape `(num_nodes, 2)`.
+        first: Root vertex value of shape `(dim,)`.
+        min_obj: Subtrees whose objective falls below this value are not descended into.
+
+    Returns:
+        A tuple `(values, indices)`:
+            values: Matching leaf vertices of shape `(num_leaves, dim)`.
+            indices: Indices of those leaves in `cvo`, of shape `(num_leaves,)`.
+    """
+
+    idx_type = idx_range.dtype.type
+    node_stack = [
+        (idx_type(0), first),
+    ]
+    leaf_idx = []
+    leaf_values = []
+
+    while node_stack:
+        ## search top node
+        node_idx, node_val = node_stack.pop()
+        st, end = idx_range[node_idx]
+
+        if st == -1:
+            node_idx = idx_range.dtype.type(node_idx)
+            leaf_idx.append(node_idx)
+            leaf_values.append(node_val)
+
+        for i in range(st, end):
+            ci = cvo[i]
+            if ci["obj"] >= min_obj and x[ci["comp"]] <= ci["value"]:
+                child_val = node_val.copy()
+                child_val[ci["comp"]] = ci["value"]
+                node_stack.append((i, child_val))
+
+    ## collect leaf values
+    l_idx = np.array(leaf_idx, dtype=idx_type)
+    n_leaves = l_idx.shape[0]
+    l_vals = np.empty((n_leaves, x.shape[0]), dtype=x.dtype)
+    for i in range(n_leaves):
+        l_vals[i] = leaf_values[i]
+
+    return l_vals, l_idx
+
+
+@njit(parallel=True, nogil=True, cache=True)
+def query_multi(x_batch, cvo, idx_range, first, lower, min_obj=-np.inf, delta=1e-3):
+    """
+    Query and refine a polyblock tree using a batch of points `x_batch`.
+
+    Each point is queried independently, and the leaves it matches are refined along every component which yields a non-redundant vertex.
+    A leaf matching more than one query point is refined against only the first of them.
+
+    Args:
+        x_batch: Query points of shape `(num_points, dim)`.
+        cvo: Node data with `comp`, `value` and `obj` fields.
+        idx_range: Child index ranges of shape `(num_nodes, 2)`.
+        first: Root vertex value of shape `(dim,)`.
+        lower: Component-wise lower-bounds on tree vertices, of shape `(dim,)`.
+        min_obj: Subtrees whose objective falls below this value are not descended into.
+        delta: Minimum separation from the query point required to refine a leaf.
+
+    Returns:
+        A tuple `(values, indices, vect, comp, cval)`:
+            values: Refined leaf vertices of shape `(num_refined, dim)`.
+            indices: Indices of those leaves in `cvo`, of shape `(num_refined,)`.
+            vect: Index into `values` of the parent leaf of each new node.
+            comp: Component reduced by each new node.
+            cval: New value taken by that component.
+    """
+
+    b = x_batch.shape[0]
+    idx_dtype = idx_range.dtype
+    float_dtype = x_batch.dtype
+    x_batch_delta = x_batch + delta
+
+    indices = [np.empty(0, dtype=idx_dtype) for _ in range(b)]
+    values = [np.empty((0, 0), dtype=float_dtype) for _ in range(b)]
+    vects = [np.empty((0), dtype=np.int64) for _ in range(b)]
+    comps = [np.empty((0), dtype=np.int64) for _ in range(b)]
+    comp_val = [np.empty((0), dtype=float_dtype) for _ in range(b)]
+
+    ## parallel queries and redundancy checks
+    for i in prange(b):
+        x = x_batch[i]
+        x_delta = x_batch_delta[i]
+        value, index = query(x, cvo, idx_range, first, min_obj)
+
+        ## only explore vertices further than delta and break ties
+        refine_mask = all_row(value > x_delta)
+        if i > 0:
+            for idx in range(value.shape[0]):
+                if refine_mask[idx]:
+                    v_idx = value[idx]
+                    for j in range(i):
+                        x_delta_j = x_batch_delta[j]
+                        feas_j = (v_idx > x_delta_j).all()
+                        if feas_j:
+                            refine_mask[idx] = False
+                            break
+
+        idx_mask = x >= lower
+        vect, comp = find_redundant(value, idx_mask, refine_mask)
+
+        indices[i] = index[refine_mask]
+        values[i] = value[refine_mask]
+        vects[i] = vect
+        comps[i] = comp
+        comp_val[i] = x[comp]
+
+    ## merge all data while shifting indices
+    v_full = cat(values)
+    ind_full = cat(indices)
+
+    cumsum = len(indices[0])
+    for i in range(1, b):
+        vects[i] += cumsum
+        cumsum += len(indices[i])
+
+    vect_full = cat(vects)
+    comp_full = cat(comps)
+    cval_full = cat(comp_val)
+
+    return v_full, ind_full, vect_full, comp_full, cval_full
+
+
+@njit(nogil=True, cache=True)
+def cat(list_of_arrays):
+    """Concatenate list of arrays along first axis."""
+
+    size = sum([arr.shape[0] for arr in list_of_arrays])
+    ar0 = list_of_arrays[0]
+    combined = np.empty((size,) + ar0.shape[1:], dtype=ar0.dtype)
+    init_pos = 0
+    for arr in list_of_arrays:
+        combined[init_pos : init_pos + len(arr)] = arr
+        init_pos += len(arr)
+    return combined
+
+
+@njit(nogil=True, cache=True, parallel=True, inline="always")
+def all_row(arr):
+    """Equivalent to `np.all(arr, axis=1)`"""
+    rows = arr.shape[0]
+    mask = np.empty(rows, dtype=np.bool)
+    for i in prange(rows):
+        mask[i] = arr[i].all()
+    return mask
+
+
+@njit(parallel=True, nogil=True, cache=True)
+def find_best(cvo, idx_range, first, num=1):
+    """
+    Find up to `num` distinct leaf vertices, the first of which has the best objective.
+
+    Attempts to find distinct leaves by performing `num` tree descents.
+    Descent `i` carries an offset of `i` which diverts its path: at a node with `n` children it steps up to `n - 1` ranks below the best child, taking as many as the remaining offset allows and deducting them from it.
+    Once the offset reaches zero the descent follows best children the rest of the way down.
+    Descent `0` is never diverted and so reaches the best leaf, while larger offsets are spent as high in the tree as possible, giving paths that diverge earlier and hence distinct leaves.
+    A descent `i` still holding offset when it reaches a leaf is discarded as its path is identical to that of a descent with a smaller index `j < i`, so fewer than `num` vertices may be returned.
+
+    Args:
+        cvo: Node data with `comp`, `value` and `obj` fields.
+        idx_range: Child index ranges of shape `(num_nodes, 2)`.
+        first: Root vertex value of shape `(dim,)`.
+        num: Number of descents to attempt.
+
+    Returns:
+        Leaf vertices of shape `(num_found, dim)`, where `num_found <= num`.
+        The first leaf has the best objective.
+    """
+
+    dim = first.shape[0]
+    values = np.empty((num, dim), dtype=first.dtype)
+    for i in range(num):
+        values[i] = first
+
+    curr_idx = np.zeros(num, dtype=idx_range.dtype)
+    skipped_mask = np.zeros(num, dtype=np.bool)
+    for i in prange(num):
+        skip = np.int32(i)
+        while True:
+            st, end = idx_range[curr_idx[i]]
+            if st == end:
+                if skip == 0:
+                    skipped_mask[i] = True
+                break
+            order = end - st - 1
+            if skip > 0:
+                less = min(skip, end - st - 1)
+                order -= less
+                skip -= less
+
+            o = cvo[st:end]["obj"]
+            chosen_child = np.argpartition(o, order)[order] + st
+            child_cvo = cvo[chosen_child]
+            values[i][child_cvo["comp"]] = child_cvo["value"]
+            curr_idx[i] = chosen_child
+
+    return values[skipped_mask]
+
+
+@njit(parallel=True, nogil=True, cache=True)
+def new_block(block, added, idx_mask, delta=1e-3):
+    """
+    Remove infeasible cone given by `added` from `block`.
+
+    Args:
+        block: Current polyblock vertices of shape `(num_vertices, dim)`.
+        added: Vertex of the cone to remove, of shape `(dim,)`.
+        idx_mask: Components eligible for reduction, of shape `(dim,)`.
+        delta: Minimum separation from `added` required for a vertex to be cut.
+
+    Returns:
+        A tuple `(removed_idx, new_vertices)`:
+            removed_idx: Indices of vertices in `block` refined by the cut.
+            new_vertices: New vertices generated by the cut.
+    """
+
+    ## perform range query
+    vertex_idx = []
+    old_size, dims = block.shape
+    for i in range(old_size):
+        row = block[i]
+        inside = True
+        for d in range(dims):
+            if added[d] > row[d]:
+                inside = False
+                break
+        if inside:
+            vertex_idx.append(i)
+
+    vertex_idx = np.array(vertex_idx, dtype=np.int64)
+    vertices = block[vertex_idx]
+    removed_mask = all_row(vertices > added + delta)
+
+    ## compute new vertices
+    vect, comp = find_redundant(vertices, idx_mask, removed_mask)
+    apen = vertices[removed_mask][vect]
+    for i in prange(apen.shape[0]):
+        c_comp = comp[i]
+        apen[i, c_comp] = added[c_comp]
+
+    return vertex_idx[removed_mask], apen
+
+
+@njit(nogil=True, cache=True)
+def delete(array, removed_idx):
+    """Delete indices in-place by shifting remaining elements down. This function also sorts removed_idx."""
+
+    ## check if removed_idx is sorted
+    r_prev = -np.inf
+    for r in removed_idx:
+        if r >= r_prev:
+            r_prev = r
+        else:
+            removed_idx.sort()
+            break
+
+    ## shift down
+    n_removed = removed_idx.shape[0]
+    old_size = array.shape[0]
+    for down_shift in range(n_removed + 1):
+        st = removed_idx[down_shift - 1] + 1 if down_shift > 0 else 0
+        end = removed_idx[down_shift] if down_shift < n_removed else old_size
+        for j in range(st, end):
+            array[j - down_shift] = array[j]
+
+
+@njit(parallel=True, nogil=True, inline="always", cache=True)
+def find_redundant(arr, idx_mask, eps_mask=None):
+    """
+    Find the vertex refinements which are dominated by another vertex in `arr`.
+
+    Reducing component `d` of vertex `arr[i]` is redundant when some other vertex `arr[j]` already dominates the result, which happens exactly when `arr[i]` exceeds `arr[j]` in dimension `d` alone.
+
+    Args:
+        arr: Candidate vertices of shape `(num_vertices, dim)`.
+        idx_mask: Components eligible for reduction, of shape `(dim,)`.
+        eps_mask: Optional mask of shape `(num_vertices,)` selecting the vertices to refine. All vertices are refined when omitted.
+
+    Returns:
+        A tuple `(vect, comp)` of equal length, holding one entry per non-redundant refinement:
+            vect: Index of the vertex to refine, relative to the rows selected by `eps_mask`.
+            comp: Component of that vertex to reduce.
+    """
+
+    if eps_mask is None:
+        eps_idx = np.arange(arr.shape[0])
+    else:
+        eps_idx = eps_mask.nonzero()[0]
+
+    n_exp = eps_idx.shape[0]
+    dims = arr.shape[1]
+    mask = np.empty((n_exp, dims), dtype=np.bool)
+    for i in prange(n_exp):
+        mask[i] = idx_mask
+
+    for i in prange(n_exp):
+        ai = arr[eps_idx[i]]
+        for aj in arr:
+            fail_i = -1
+            nfail_i = 0
+
+            for d in range(dims):
+                dom_ij = ai[d] > aj[d]
+
+                if dom_ij:
+                    nfail_i += 1
+                    fail_i = d
+                    if nfail_i > 1:
+                        break
+
+            if nfail_i == 1:
+                mask[i, fail_i] = False
+
+    vect, comp = mask.nonzero()
+    return vect, comp
+
+
+@njit(nogil=True, cache=True)
+def update_obj(expanded, parents, cvo, idx_range):
+    """
+    Update the objective attribute of polyblock tree by propagating the maximum objective value from children to parents.
+
+    Args:
+        expanded: Indices of the nodes whose children have changed.
+        parents: Parent node indices of shape `(num_nodes,)`.
+        cvo: Node data with `comp`, `value` and `obj` fields. The `obj` field is modified in-place.
+        idx_range: Child index ranges of shape `(num_nodes, 2)`.
+    """
+
+    curr_layer = expanded
+    while curr_layer.shape[0] > 0:
+        layer_mask = np.zeros_like(curr_layer, dtype=np.bool)
+
+        for i in range(curr_layer.shape[0]):
+            ## get child data
+            curr_idx = curr_layer[i]
+            st, end = idx_range[curr_idx]
+
+            ## update self if best obj changes
+            best_obj = cvo[st:end]["obj"].max() if st != end else -np.inf
+            if best_obj < cvo[curr_idx]["obj"]:
+                cvo[curr_idx]["obj"] = best_obj
+                if curr_idx > 0:
+                    layer_mask[i] = True
+
+        ## find unique set of parents
+        curr_layer = parents[curr_layer[layer_mask]]
+        curr_layer = np.unique(curr_layer)

polyblocks/naive.py

@@ -0,0 +1,65 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from .abstract import ABPolyblock
+from .containers import DynamicArray
+from .jit_funcs import new_block
+
+
+class BasePOA(ABPolyblock):
+    """A naive implementation of POA which directly stores polyblock vertices in dynamic arrays."""
+
+    POLYBLOCK_LIMIT = 3 * int(1e6)
+    RHO = 0.2
+
+    def __init__(self, lower, upper):
+        self.lower = lower
+        const = self.RHO / (1 - self.RHO)
+        self.lower_offset = lower - const * (upper - lower).max()
+        self.lower_offset = self.lower_offset[None]
+        self.new: NDArray
+
+        self.vertices = DynamicArray(dim=lower.shape[0], dtype=lower.dtype)
+        self.obj_vals = DynamicArray(dim=1, dtype=lower.dtype)
+        self.vertices.append(upper)
+        self.obj_vals.append(np.inf)
+
+    def projection_pairs(self) -> tuple[NDArray, NDArray]:
+        best_vtx = self.obj_vals.array.argmax()
+        return self.lower_offset, self.vertices[None, best_vtx].copy()
+
+    def set_min_obj(self, obj) -> None:
+        removed_idx = (self.obj_vals.array < obj).nonzero()[0]
+        self.vertices.delete(removed_idx)
+        self.obj_vals.delete(removed_idx)
+
+    def new_vertices(self, proj, delta) -> NDArray:
+        proj = proj.flatten()
+        idx_mask = proj >= self.lower
+        vertices = self.vertices
+        obj_vals = self.obj_vals
+
+        removed_idx, self.new = new_block(vertices.array, proj, idx_mask, delta)
+        vertices.delete(removed_idx)
+        obj_vals.delete(removed_idx)
+        return self.new
+
+    def update(self, new_mask, new_obj) -> bool:
+        new = self.new[new_mask]
+        self.vertices.append(new)
+        self.obj_vals.append(new_obj)
+        return self.vertices.length == 0
+
+    @property
+    def size(self):
+        return self.vertices.length
+
+
+class BalancedPOA(BasePOA):
+    """A variant of the naive POA implementation which uses balanced anchors."""
+
+    def projection_pairs(self) -> tuple[NDArray, NDArray]:
+        blk_best = self.obj_vals.array.argmax()
+        best_upper = self.vertices[None, blk_best]
+        best_lower = best_upper - (best_upper - self.lower).max()
+        return best_lower, best_upper.copy()

polyblocks/tree.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+from .abstract import ABPolyblock
+from .containers import Tree
+
+
+class TreePOA(ABPolyblock):
+    """
+    An implementation of POA which stores polyblock vertices in a tree.
+
+    Rather than storing the current vertices `V` alone, this solver keeps the whole tree of refinements the search has produced, with `V` as its leaves.
+    The representation is compressed: a cut replaces a vertex by copies differing from it in one component, so a node need only record the component its cut modified and that component's new value, with the root holding the initial upper point.
+    A vertex is recovered by descending from the root and tracing these modifications at each node.
+
+    In return, each node bounds both the region and objective of its subtree, so a search can rule out the whole subtree without visiting its leaves. POA's searches over `V` thus become descents rather than scans:
+
+    - `projection_pairs` finds the maximal vertex by descending through the highest-objective child at each
+      step, using descents diverted into lower-ranked children to return up to `PROJECTED_VERTICES`
+      distinct leaves
+    - `new_vertices` collects the vertices above a projection by recursing from the root, entering a child
+      only when its component clears the projection and its objective attribute clears the incumbent.
+    - `best_bound` is read off the root, whose objective attribute is the maximum over all vertices.
+
+    Under a positive `delta` the depth of the tree is bounded independently of how many vertices it holds, so a descent costs `O(dim * depth)` against the `O(len(V))` of a flat array.
+
+    Pruned nodes are not removed eagerly, as repairing every index is expensive for large trees.
+    Instead, their objective attributes are used to keep them out of both tree traversals for free.
+    `update` rebuilds the tree every `REBUILD_GAP` updates, removing childless nodes and those which can no longer improve the incumbent.
+
+    Attributes:
+        REBUILD_GAP: Number of updates between tree rebuilds, which prunes redundant nodes.
+        PROJECTED_VERTICES: Maximum number of vertices projected per iteration.
+    """
+
+    REBUILD_GAP: int = 10000
+    PROJECTED_VERTICES: int = 8
+
+    def __init__(self, lower, upper) -> None:
+        self.lower = lower
+        self.tree = Tree(upper)
+        self.best_obj = -np.inf
+        self.clean_counter = 0
+
+        self.expanded_idx: np.ndarray
+        self.vect: np.ndarray
+        self.comp: np.ndarray
+        self.cval: np.ndarray
+
+    def projection_pairs(self) -> tuple[np.ndarray, np.ndarray]:
+        vertices = self.tree.find_best(self.PROJECTED_VERTICES)
+        anchors = vertices - (vertices - self.lower).max(-1, keepdims=True)
+        return anchors, vertices
+
+    def set_min_obj(self, obj) -> None:
+        self.best_obj = obj
+
+    def new_vertices(self, proj, delta) -> np.ndarray:
+        ## query range using tree search
+        (expanded_data, self.expanded_idx, vect, comp, cval) = self.tree.query(
+            proj, self.lower, min_obj=self.best_obj, delta=delta
+        )
+
+        ## compute new vertices
+        new_data = expanded_data[vect]
+        np.put_along_axis(new_data, comp[:, None], cval[:, None], axis=1)
+
+        self.vect, self.comp = vect, comp
+        self.cval = cval
+        return new_data
+
+    def update(self, new_mask, new_obj) -> bool:
+        vect, comp = self.vect[new_mask], self.comp[new_mask]
+        cval = self.cval[new_mask]
+        self.tree.add(self.expanded_idx, vect, comp, cval, new_obj)
+
+        ## rebuild tree periodically
+        if self.clean_counter == self.REBUILD_GAP:
+            self.tree.rebuild(self.best_obj)
+            self.clean_counter = 0
+        else:
+            self.clean_counter += 1
+
+        return self.best_bound <= self.best_obj
+
+    @property
+    def size(self):
+        return self.tree.cvo.length
+
+    @property
+    def best_bound(self) -> float:
+        return self.tree.cvo[0]["obj"].item()

polyblocks/utils.py

@@ -0,0 +1,101 @@
+from collections.abc import Callable
+
+import numpy as np
+from numpy.linalg import norm
+from numpy.typing import NDArray
+
+
+def monotone_proj(
+    vertices: NDArray,
+    anchors: NDArray,
+    oracle: Callable,
+    eps=1e-4,
+    delta=0.0,
+):
+    """
+    Perform a vectorised bisection search to compute monotone projections onto the `delta`-eroded normal set corresponding to the given oracle.
+
+    Args:
+        vertices: Vertices to project using paired anchors, of shape `(num_pairs, dim)`.
+        anchors: Feasible anchor points for projecting paired vertex, of shape `(num_pairs, dim)`. Shifted by `delta` to account for erosion.
+        oracle: An oracle for querying normal set feasibility.
+        eps: The numerical tolerance for the line search.
+        delta: The erosion factor for the normal set.
+
+    Returns:
+        Batched monotone projections of shape `(num_pairs, dim)`.
+    """
+
+    ## resolve erosion
+    vert_offset = vertices + delta
+    anchors = anchors - delta
+
+    ## scale epsilon
+    diff = anchors - vertices
+    eps = eps / norm(diff, ord=2, axis=-1, keepdims=True)
+
+    ub = np.ones_like(eps)
+    lb = -eps
+    x = np.full_like(eps, 0.5)
+
+    while (ub - lb > eps).any():
+        mask = oracle(diff * x + vert_offset)
+        n_mask = ~mask
+        ub[n_mask] = x[n_mask]
+        lb[mask] = x[mask]
+        x = (ub + lb) / 2
+
+    return lb * diff + vertices
+
+
+def tighten(root: NDArray, reduced: NDArray, oracle: Callable, eps=1e-4):
+    """Tighten the box anchored at `root` using a monotone oracle."""
+
+    reduced = reduced.copy()
+    for ind in range(reduced.shape[-1]):
+        c_end = root.copy()
+        c_end[ind] = reduced[ind]
+        reduced[ind] = monotone_proj(root[None], c_end[None], oracle, eps=eps)[0, ind]
+    return reduced
+
+
+def _center(s: str, width: int) -> str:
+    pad = max(width - len(s), 0)
+    left = pad - pad // 2
+    return " " * left + s + " " * (pad - left)
+
+
+def print_row(*, header: bool = True, **columns):
+    """
+    Print a row of a progress table, drawing a header/rule above it if `header` is set.
+
+    Args:
+        header: Whether to (re)print the column header and box rules before the row.
+        **columns: Column name -> value. Column names are converted to title case for display,
+            and the column width is derived from the label length so header and rows always align.
+    """
+
+    labels = {name: name.replace("_", " ").title() for name in columns}
+    widths = {name: max(len(label) + 2, 8) for name, label in labels.items()}
+
+    if header:
+        print("┌" + "┬".join("─" * w for w in widths.values()) + "┐")
+        print(
+            "│"
+            + "│".join(_center(label, widths[name]) for name, label in labels.items())
+            + "│"
+        )
+        print("├" + "┼".join("─" * w for w in widths.values()) + "┤")
+
+    cells = []
+    for name, value in columns.items():
+        if isinstance(value, int):
+            value = f"{value:#.2g}"
+        elif isinstance(value, float):
+            value = f"{value:#.4g}"
+        else:
+            value = str(value)
+
+        cells.append(_center(value, widths[name]))
+
+    print("│" + "│".join(cells) + "│")

polyblocks-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: polyblocks
+Version: 0.1.0
+Summary: Solvers for global monotonic optimisation problems
+Author: Ahmed Rashwan
+Author-email: Ahmed Rashwan <ar3009@bath.ac.uk>
+License-Expression: MIT
+Requires-Dist: numba>=0.65.1
+Requires-Dist: numpy>=2.2.6
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/RashwanA/polyblocks
+Description-Content-Type: text/markdown
+
+Polyblocks
+=============
+
+This package provides a set of solvers for monotonic optimisation problems, which take the general form:
+
+$$
+\begin{aligned}
+\max_{x \in \mathbb{R}^n} \quad & f(x) \\
+\text{s.t.} \ \quad & x_l \le x \le x_u \\
+& g(x) \le 0 \\
+& h(x) \ge 0
+\end{aligned}
+$$
+
+where $f$, $g$, and $h$ are non-decreasing in each coordinate.
+This covers a broad class of non-convex problems, including polynomial programming along with many radio resource allocation problems in communications.
+
+Solvers are built around the **Polyblock Outer-approximation (POA)** algorithm: a branch-and-bound algorithm which iteratively refines a rectangular outer-approximation of the solution space.
+Full details are available in the accompanying paper: **LINK**
+
+## Installation
+
+```bash
+pip install polyblocks
+```
+
+or, for local development:
+
+```bash
+git clone https://github.com/RashwanA/polyblocks.git
+cd polyblocks
+pip install .
+```
+
+## Solvers
+
+The package includes three built-in solvers: `BasePOA`, `BalancedPOA`, and `TreePOA`.
+Of these `TreePOA` typically has the best empirical performance as it uses an efficient tree-based representation of the solution space.
+All solvers implement the common `ABPolyblock` interface, which exposes a set of subroutines used by the POA algorithm.
+Users may also define custom solvers by implementing this interface.
+
+## Usage
+
+Each solver is called via its `solve` classmethod, which takes the objective, the bounding box, and oracles for querying feasibility.
+
+Ball optimisation example:
+
+```python
+from polyblocks import TreePOA
+
+# maximise 3x + 4y
+# subject to x^2 + y^2 <= 1
+
+def obj(x):
+    return x @ [3, 4]
+
+def ub_oracle(x):
+    return (x ** 2).sum(-1) <= 1
+
+sol = TreePOA.solve(
+    obj=obj,
+    ub_oracle=ub_oracle,
+    x_l=(0., 0.),
+    x_u=(1., 1.),
+)
+
+print(f"status={sol.status}, obj={sol.obj:.2f}, x={sol.x.round(2)}")
+```
+
+Geometric programming example:
+
+```python
+from polyblocks import TreePOA
+
+# maximise x y z
+# subject to x (y + z) <= 4,
+#            y z <= 4,
+#            x, y, z ∈ [0, 4]
+
+def obj(x):
+    return x.prod(1)
+
+def ub_oracle(x):
+    cons1 = x[:,0] * (x[:,1:].sum(1)) <= 4.
+    cons2 = x[:,1:].prod(1) <= 4.
+    return cons1 * cons2
+
+sol = TreePOA.solve(
+    obj=obj,
+    ub_oracle=ub_oracle,
+    x_l=(0., 0., 0.),
+    x_u=4.,             # bounds are broadcast
+    verbose_gap=10,     # print progress every 10 iterations
+)
+print(f"status={sol.status}, obj={sol.obj:.2f}, x={sol.x.round(2)}")
+```
+
+Objectives and oracles are expected to accept batched inputs of shape `(num_points, dim)`.

polyblocks-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+polyblocks/__init__.py,sha256=5DkiX8mAIV99j_XIC_0dxP9FiHOexVIaDgDuLitOcQM,186
+polyblocks/abstract.py,sha256=cBUIBB9RVHLCtAnnPkNSTmqcMEsS0pjRueFLHVrIWIM,14050
+polyblocks/containers.py,sha256=1kr-g5_Jb36nv9KcFCN_58GjERNo_iBa7gM7aNacs2Y,6081
+polyblocks/jit_funcs.py,sha256=qKyre3qkSSGw8DKfl2NS7yqdQXQoWlC0dvF1bvTWuKQ,14422
+polyblocks/naive.py,sha256=2oxsMOd7PPt_o3Wgwc5cnM_kAyifSl1nYCrHnVHjBYM,2184
+polyblocks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polyblocks/tree.py,sha256=lSXF9iUjfGDGEm0-Cpx2SlmaeuTn8Z6_drBeIBcPY9Q,3974
+polyblocks/utils.py,sha256=hndB92ZppZoA9R7gdM5fDyMm8f47KnvQ-H3xps0lJ8s,3188
+polyblocks-0.1.0.dist-info/WHEEL,sha256=EmLkUISDECbcUx3FMCYOqokNOJqNp2r0d4mJzjErvvs,80
+polyblocks-0.1.0.dist-info/METADATA,sha256=3C9mNfVLah1-EUrpdHpjDXR387fHAmkIXQmnwegdiCQ,2958
+polyblocks-0.1.0.dist-info/RECORD,,

polyblocks-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.3
+Root-Is-Purelib: true
+Tag: py3-none-any