kauri 2.0.0__tar.gz → 2.1.0__tar.gz

{kauri-2.0.0 → kauri-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kauri
-Version: 2.0.0
+Version: 2.1.0
 Summary: Hopf algebras, B-series, and Runge-Kutta methods on rooted trees
 Author-email: Daniil Shmelev <daniil.shmelev23@imperial.ac.uk>
 License: Apache-2.0
@@ -16,14 +16,15 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: matplotlib>=3.9.2
-Requires-Dist: numpy>=1.26.4
-Requires-Dist: sympy>=1.12
-Requires-Dist: scipy>=1.13
-Requires-Dist: tqdm
+Provides-Extra: full
+Requires-Dist: matplotlib>=3.9.2; extra == "full"
+Requires-Dist: numpy>=1.26.4; extra == "full"
+Requires-Dist: sympy>=1.12; extra == "full"
+Requires-Dist: scipy>=1.13; extra == "full"
+Requires-Dist: tqdm; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.9.0; extra == "dev"
@@ -51,6 +52,14 @@ Kauri is a Python package for symbolic and algebraic manipulation of rooted tree
 pip install kauri
 ```
 
+The base install is lightweight (pure Python, no external dependencies) and provides tree algebra, enumeration, indexing, and Hopf algebraic operations.
+
+For visualization, Runge-Kutta analysis, and B-series (requires matplotlib, numpy, scipy, sympy, tqdm):
+
+```
+pip install kauri[full]
+```
+
 ## Documentation
 
 Full documentation is available at [https://kauri.readthedocs.io](https://kauri.readthedocs.io)

{kauri-2.0.0 → kauri-2.1.0}/README.md

@@ -20,6 +20,14 @@ Kauri is a Python package for symbolic and algebraic manipulation of rooted tree
 pip install kauri
 ```
 
+The base install is lightweight (pure Python, no external dependencies) and provides tree algebra, enumeration, indexing, and Hopf algebraic operations.
+
+For visualization, Runge-Kutta analysis, and B-series (requires matplotlib, numpy, scipy, sympy, tqdm):
+
+```
+pip install kauri[full]
+```
+
 ## Documentation
 
 Full documentation is available at [https://kauri.readthedocs.io](https://kauri.readthedocs.io)

{kauri-2.0.0 → kauri-2.1.0}/kauri/__init__.py

@@ -17,7 +17,7 @@
 Algebraic manipulation of rooted trees for the analysis of B-series and Runge-Kutta schemes.
 """
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 __all__ = [
     # Core types
@@ -30,6 +30,8 @@ __all__ = [
     # Tree generation
     "trees_of_order", "trees_up_to_order",
     "colored_trees_of_order", "colored_trees_up_to_order",
+    "colored_trees", "colored_tree_to_idx", "idx_to_colored_tree",
+    "canonical_to_recursive_permutation", "recursive_to_canonical_permutation",
     "planar_trees_of_order", "planar_trees_up_to_order",
     "colored_planar_trees_of_order", "colored_planar_trees_up_to_order",
     # Display
@@ -53,23 +55,23 @@ __all__ = [
 
 from .trees import (Tree, Forest, CommutativeForest, ForestSum, TensorProductSum,
                     NoncommutativeForest, PlanarTree, OrderedForest, EMPTY_PLANAR_TREE)
+from .trees import EMPTY_TREE, EMPTY_FOREST, EMPTY_ORDERED_FOREST, EMPTY_FOREST_SUM, ZERO_FOREST_SUM
 from .maps import Map, ident, sign, exact_weights, omega
 from .display import display
 from .gentrees import (trees_of_order, trees_up_to_order,
                        colored_trees_of_order, colored_trees_up_to_order,
+                       colored_trees, colored_tree_to_idx, idx_to_colored_tree,
+                       canonical_to_recursive_permutation, recursive_to_canonical_permutation,
                        planar_trees_of_order, planar_trees_up_to_order,
                        colored_planar_trees_of_order, colored_planar_trees_up_to_order)
 from .rk import RK, rk_symbolic_weight, rk_order_cond
 from .cf import CFMethod
-
 from .rk_methods import (euler, heun_rk2, midpoint, kutta_rk3, heun_rk3,
                          ralston_rk3, rk4, ralston_rk4, nystrom_rk5, backward_euler,
                          implicit_midpoint, crank_nicolson, gauss6, radau_iia, lobatto6,
                          EES25, EES27)
-
 from .bseries import BSeries, elementary_differential
-
-from .trees import EMPTY_TREE, EMPTY_FOREST, EMPTY_ORDERED_FOREST, EMPTY_FOREST_SUM, ZERO_FOREST_SUM
+from .oddeven import id_sqrt, minus, plus
 
 import kauri.bck
 import kauri.cem
@@ -77,8 +79,5 @@ import kauri.gl
 import kauri.mkw
 import kauri.nck
 import kauri.pgl
-
-from .oddeven import id_sqrt, minus, plus
-
 import kauri.oddeven
-import kauri.planar_oddeven
+import kauri.planar_oddeven

{kauri-2.0.0 → kauri-2.1.0}/kauri/bseries.py

@@ -78,15 +78,25 @@ and the symmetric-adjoint method is given by
 where `kr.sign` is the :class:`Map` sending `t` to `(-1)^|t| * t`.
 
 """
+from __future__ import annotations
 import itertools
 from functools import cache
 from typing import Union
 
-import sympy as sp
+try:
+    import sympy as sp
+except ImportError:
+    sp = None
 
 from kauri import Tree, trees_up_to_order, Map
 from kauri.trees import _is_scalar
 
+def _require_sympy():
+    if sp is None:
+        raise ImportError(
+            "B-series requires sympy. Install with: pip install kauri[full]"
+        )
+
 def _check_f_y(f, y):
     # Checks that f and y are correctly specified
 
@@ -179,6 +189,7 @@ def elementary_differential(tree : Tree,
         t = Tree([[[]],[]])
         print(elementary_differential(t, f, y))
     """
+    _require_sympy()
     if not isinstance(tree, Tree):
         raise TypeError("The argument 'tree' must be of type Tree, not " + str(type(tree)))
     if tree.colors() > 1:
@@ -227,7 +238,8 @@ class BSeries:
         print(bs([1], 0.1)) # Evaluate the B-Series at y = [1], h = 0.1
     """
 
-    def __init__(self, y : sp.Matrix, f : sp.Matrix, weights : Map, order : int):
+    def __init__(self, y, f, weights : Map, order : int):
+        _require_sympy()
         if not isinstance(weights, Map):
             raise TypeError("weights must be a Map, not " + str(type(weights)))
         if not isinstance(order, int):

{kauri-2.0.0 → kauri-2.1.0}/kauri/gentrees.py

@@ -17,10 +17,10 @@
 Functions for generating rooted trees in lexicographic order, based on the algorithms of :cite:`beyer1980constant`.
 """
 from typing import Generator
-from functools import lru_cache
+from functools import lru_cache, cache
 from itertools import product
 
-from .trees import Tree
+from .trees import Tree, EMPTY_TREE
 from .utils import _level_sequence_to_list_repr, _apply_color_sequence
 
 def trees_up_to_order(order : int) -> Generator[Tree, None, None]:
@@ -282,3 +282,188 @@ def colored_planar_trees_up_to_order(order: int, d: int):
     _validate_num_colors(d)
     for current_order in range(order + 1):
         yield from colored_planar_trees_of_order(current_order, d)
+
+
+# ---------------------------------------------------------------------------
+# Colored tree indexing
+# ---------------------------------------------------------------------------
+
+@cache
+def _colored_tree_list_cached(max_order: int, d: int) -> tuple:
+    """Cached tuple of all colored trees up to max_order with d colors."""
+    return tuple(colored_trees_up_to_order(max_order, d))
+
+
+@cache
+def _colored_tree_lookup_cached(max_order: int, d: int) -> dict:
+    """Cached dict mapping Tree -> index."""
+    trees = _colored_tree_list_cached(max_order, d)
+    return {t: i for i, t in enumerate(trees)}
+
+
+def colored_trees(d: int, max_order: int) -> list[Tree]:
+    """
+    Returns all distinct colored rooted trees up to a given order with *d* colors,
+    starting with the empty tree.
+
+    :param d: Number of colors (path dimension).
+    :type d: int
+    :param max_order: Maximum number of nodes.
+    :type max_order: int
+    :return: List of colored trees.
+    :rtype: list[Tree]
+    """
+    _validate_num_colors(d)
+    return list(_colored_tree_list_cached(max_order, d))
+
+
+def colored_tree_to_idx(tree: Tree, d: int, max_order: int) -> int:
+    """
+    Returns the index of a colored tree in the canonical enumeration.
+
+    Index 0 is the empty tree. Non-empty trees are enumerated by order,
+    then by shape, then by coloring.
+
+    :param tree: A colored rooted tree.
+    :type tree: Tree
+    :param d: Number of colors (path dimension).
+    :type d: int
+    :param max_order: Maximum number of nodes.
+    :type max_order: int
+    :return: Index in the enumeration.
+    :rtype: int
+    """
+    _validate_num_colors(d)
+    lookup = _colored_tree_lookup_cached(max_order, d)
+    if tree not in lookup:
+        raise ValueError(f"Tree {tree} not found in enumeration for d={d}, max_order={max_order}")
+    return lookup[tree]
+
+
+def idx_to_colored_tree(idx: int, d: int, max_order: int) -> Tree:
+    """
+    Returns the colored tree at a given index in the canonical enumeration.
+
+    :param idx: Index (0 = empty tree).
+    :type idx: int
+    :param d: Number of colors (path dimension).
+    :type d: int
+    :param max_order: Maximum number of nodes.
+    :type max_order: int
+    :return: The colored tree at the given index.
+    :rtype: Tree
+    """
+    _validate_num_colors(d)
+    trees = _colored_tree_list_cached(max_order, d)
+    if idx < 0 or idx >= len(trees):
+        raise ValueError(f"idx {idx} out of range [0, {len(trees)}) for d={d}, max_order={max_order}")
+    return trees[idx]
+
+
+# ---------------------------------------------------------------------------
+# Recursive tree ordering and canonical-recursive permutation
+#
+# The "recursive" ordering enumerates decorated trees by building them
+# bottom-up from child multisets, cycling root labels innermost. This
+# matches the C++ enumeration in pySigLib's cp_branched_trees.h.
+#
+# The "canonical" ordering (used by colored_trees_of_order etc.) enumerates
+# by shape first, then colorings.
+# ---------------------------------------------------------------------------
+
+def _enumerate_child_multisets(target_nodes, min_idx, tree_nodes, total_count):
+    """Enumerate multisets of tree indices whose total node count equals target_nodes."""
+    if target_nodes == 0:
+        yield ()
+        return
+    for idx in range(min_idx, total_count):
+        n = tree_nodes[idx]
+        if n > target_nodes:
+            break
+        for rest in _enumerate_child_multisets(target_nodes - n, idx, tree_nodes, total_count):
+            yield (idx,) + rest
+
+
+@cache
+def _enumerate_trees_recursive(d: int, max_order: int) -> tuple:
+    """Enumerate decorated trees in recursive ordering (child-multiset first, root label innermost)."""
+    trees = []
+    tree_nodes = []
+    for order in range(1, max_order + 1):
+        if order == 1:
+            for label in range(d):
+                trees.append((1, label, ()))
+                tree_nodes.append(1)
+        else:
+            current_count = len(trees)
+            for children in _enumerate_child_multisets(order - 1, 0, tree_nodes, current_count):
+                if not children:
+                    continue
+                for label in range(d):
+                    trees.append((order, label, children))
+                    tree_nodes.append(order)
+    return tuple(trees)
+
+
+def _recursive_tree_to_kauri(tree_idx, all_trees):
+    """Convert a recursive-order internal tree to a kauri Tree object."""
+    from .trees import Forest
+    _num_nodes, label, child_ids = all_trees[tree_idx]
+    if not child_ids:
+        return Tree([label])
+    children = [_recursive_tree_to_kauri(c, all_trees) for c in child_ids]
+    return Forest(children).join(root_color=label)
+
+
+@cache
+def canonical_to_recursive_permutation(d: int, max_order: int):
+    """
+    Compute the permutation mapping canonical tree indices to recursive tree indices.
+
+    ``perm[i] = j`` means the tree at canonical position ``i`` is at recursive
+    position ``j``. Both are 0-indexed and exclude the empty tree.
+
+    :param d: Number of colors (path dimension).
+    :type d: int
+    :param max_order: Maximum number of nodes.
+    :type max_order: int
+    :return: Permutation array of shape ``(num_trees,)``.
+    :rtype: numpy.ndarray
+    """
+    try:
+        import numpy as np
+    except ImportError:
+        raise ImportError("Permutation functions require numpy. Install with: pip install kauri[full]")
+    _validate_num_colors(d)
+    rec_trees = _enumerate_trees_recursive(d, max_order)
+    rec_kauri = [_recursive_tree_to_kauri(i, rec_trees) for i in range(len(rec_trees))]
+    rec_lookup = {t: i for i, t in enumerate(rec_kauri)}
+
+    canonical = _colored_tree_list_cached(max_order, d)
+    perm = [rec_lookup[kt] for kt in canonical[1:]]
+    return np.array(perm, dtype=np.int64)
+
+
+@cache
+def recursive_to_canonical_permutation(d: int, max_order: int):
+    """
+    Compute the permutation mapping recursive tree indices to canonical tree indices.
+
+    Inverse of :func:`canonical_to_recursive_permutation`.
+
+    :param d: Number of colors (path dimension).
+    :type d: int
+    :param max_order: Maximum number of nodes.
+    :type max_order: int
+    :return: Inverse permutation array of shape ``(num_trees,)``.
+    :rtype: numpy.ndarray
+    """
+    try:
+        import numpy as np
+    except ImportError:
+        raise ImportError("Permutation functions require numpy. Install with: pip install kauri[full]")
+    _validate_num_colors(d)
+    perm = canonical_to_recursive_permutation(d, max_order)
+    inv = np.empty_like(perm)
+    inv[perm] = np.arange(len(perm))
+    return inv

{kauri-2.0.0 → kauri-2.1.0}/kauri/rk.py

@@ -16,15 +16,26 @@
 """
 Runge-Kutta Schemes
 """
+from __future__ import annotations
 import copy
 from typing import Union, Callable, Tuple
 import warnings
 
-import numpy as np
-import sympy
-from scipy.optimize import root
-import matplotlib.pyplot as plt
-from tqdm import tqdm
+try:
+    import numpy as np
+    import sympy
+    from scipy.optimize import root as _scipy_root
+    import matplotlib.pyplot as plt
+    from tqdm import tqdm
+except ImportError:
+    np = sympy = _scipy_root = plt = tqdm = None
+
+def _require_full():
+    if np is None:
+        raise ImportError(
+            "This feature requires additional dependencies. "
+            "Install with: pip install kauri[full]"
+        )
 
 from .gentrees import trees_of_order, planar_trees_of_order
 from .trees import Tree, Forest, ForestSum, PlanarTree, _is_scalar
@@ -158,6 +169,7 @@ def rk_symbolic_weight(
     if not isinstance(rationalise, bool):
         raise TypeError("rationalise must be a bool, not " + str(type(rationalise)))
 
+    _require_full()
     t_ = t
     if _is_scalar(t):
         t_ = t * Tree(None).as_forest_sum()
@@ -214,6 +226,7 @@ def rk_order_cond(
         print(rk_order_cond(t, 2, a_mask = a_mask, b_mask = b_mask))
 
     """
+    _require_full()
     if not isinstance(t, (int, float, TreeLike, ForestLike, ForestSumLike)):
         raise TypeError("t must be a Tree, Forest, ForestSum (or planar equivalent), int or float, not " + str(type(t)))
 
@@ -237,9 +250,10 @@ class RK:
     :param b: The Runge--Kutta parameter vector :math:`b`.
     """
     def __init__(self, a, b, name = None):
-        if not isinstance(a, (list, np.ndarray)):
+        _valid_types = (list, np.ndarray) if np is not None else (list,)
+        if not isinstance(a, _valid_types):
             raise TypeError("a must be a list or array, not " + str(type(a)))
-        if not isinstance(b, (list, np.ndarray)):
+        if not isinstance(b, _valid_types):
             raise TypeError("b must be a list or array, not " + str(type(b)))
 
         self.name = name
@@ -343,7 +357,7 @@ class RK:
 
             return np.concatenate(G_vec)
 
-        sol = root(G, k0, method='hybr', tol=tol, options={'maxfev': max_iter})
+        sol = _scipy_root(G, k0, method='hybr', tol=tol, options={'maxfev': max_iter})
 
         if not sol.success:
             warnings.warn(f"Implicit RK solver failed: {sol.message}")
@@ -379,6 +393,7 @@ class RK:
         :rtype: list | array
         """
 
+        _require_full()
         if not isinstance(y0, (list, np.ndarray)):
             raise TypeError("y0 must be a list or array, not " + str(type(y0)))
         if not isinstance(t0, float):
@@ -440,6 +455,7 @@ class RK:
         :return: t_vals, y_vals - the lists of values of t and y respectively
         :rtype: tuple[list, list]
         """
+        _require_full()
 
         if not isinstance(y0, (list, np.ndarray)):
             raise TypeError("y0 must be a list or array, not " + str(type(y0)))

{kauri-2.0.0 → kauri-2.1.0}/kauri/trees.py

@@ -37,7 +37,6 @@ from functools import total_ordering
 from typing import Union
 import warnings
 
-import sympy
 
 from .utils import (_nodes, _height, _factorial, _sigma,
                     _sorted_list_repr, _list_repr_to_level_sequence,
@@ -1431,8 +1430,14 @@ class ForestSum:
 ##############################################
 ##############################################
 
+try:
+    import sympy as _sympy
+    _SCALAR_TYPES = (numbers.Real, _sympy.Expr)
+except ImportError:
+    _SCALAR_TYPES = (numbers.Real,)
+
 def _is_scalar(obj):
-    return isinstance(obj, (numbers.Real, sympy.Expr))
+    return isinstance(obj, _SCALAR_TYPES)
 
 def _is_tree_or_forest(obj):
     return isinstance(obj, (TreeLike, ForestLike))

{kauri-2.0.0 → kauri-2.1.0}/kauri/utils.py

@@ -18,7 +18,6 @@ Back-end utility functions
 """
 import math
 from functools import cache
-import sympy as sp
 
 def _to_list(obj):
     # Convert a tuple representation to a list representation
@@ -241,6 +240,7 @@ def _next_planar_layout(layout):
 
 def _rationalise(c, tol = 1e-10):
     # rationalised float
+    import sympy as sp
     return str(sp.nsimplify(c, tolerance=tol, rational = True))
 
 def _str(c, rationalise = False, tol = 1e-10):

{kauri-2.0.0 → kauri-2.1.0}/kauri.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kauri
-Version: 2.0.0
+Version: 2.1.0
 Summary: Hopf algebras, B-series, and Runge-Kutta methods on rooted trees
 Author-email: Daniil Shmelev <daniil.shmelev23@imperial.ac.uk>
 License: Apache-2.0
@@ -16,14 +16,15 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: matplotlib>=3.9.2
-Requires-Dist: numpy>=1.26.4
-Requires-Dist: sympy>=1.12
-Requires-Dist: scipy>=1.13
-Requires-Dist: tqdm
+Provides-Extra: full
+Requires-Dist: matplotlib>=3.9.2; extra == "full"
+Requires-Dist: numpy>=1.26.4; extra == "full"
+Requires-Dist: sympy>=1.12; extra == "full"
+Requires-Dist: scipy>=1.13; extra == "full"
+Requires-Dist: tqdm; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.9.0; extra == "dev"
@@ -51,6 +52,14 @@ Kauri is a Python package for symbolic and algebraic manipulation of rooted tree
 pip install kauri
 ```
 
+The base install is lightweight (pure Python, no external dependencies) and provides tree algebra, enumeration, indexing, and Hopf algebraic operations.
+
+For visualization, Runge-Kutta analysis, and B-series (requires matplotlib, numpy, scipy, sympy, tqdm):
+
+```
+pip install kauri[full]
+```
+
 ## Documentation
 
 Full documentation is available at [https://kauri.readthedocs.io](https://kauri.readthedocs.io)

{kauri-2.0.0 → kauri-2.1.0}/kauri.egg-info/requires.txt

@@ -1,9 +1,11 @@
+
+[dev]
+pytest>=8.0
+ruff>=0.9.0
+
+[full]
 matplotlib>=3.9.2
 numpy>=1.26.4
 sympy>=1.12
 scipy>=1.13
 tqdm
-
-[dev]
-pytest>=8.0
-ruff>=0.9.0

{kauri-2.0.0 → kauri-2.1.0}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kauri"
-version = "2.0.0"
+version = "2.1.0"
 description = "Hopf algebras, B-series, and Runge-Kutta methods on rooted trees"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.9"
 license = { text = "Apache-2.0" }
 authors = [
   { name = "Daniil Shmelev", email = "daniil.shmelev23@imperial.ac.uk" },
@@ -24,19 +24,20 @@ classifiers = [
   "Programming Language :: Python",
   "Topic :: Scientific/Engineering :: Mathematics",
 ]
-dependencies = [
-  "matplotlib>=3.9.2",
-  "numpy>=1.26.4",
-  "sympy>=1.12",
-  "scipy>=1.13",
-  "tqdm",
-]
+dependencies = []
 
 [project.urls]
 Homepage = "https://github.com/daniil-shmelev/kauri"
 Documentation = "https://kauri.readthedocs.io"
 
 [project.optional-dependencies]
+full = [
+  "matplotlib>=3.9.2",
+  "numpy>=1.26.4",
+  "sympy>=1.12",
+  "scipy>=1.13",
+  "tqdm",
+]
 dev = [
   "pytest>=8.0",
   "ruff>=0.9.0",
@@ -46,7 +47,7 @@ dev = [
 include = ["kauri*"]
 
 [tool.ruff]
-target-version = "py310"
+target-version = "py39"
 line-length = 100
 src = ["kauri", "unit_tests"]
 exclude = ["build", "docs/_build", ".venv"]