padic-ml 0.0.1__py3-none-any.whl

padic_ml/__init__.py

@@ -0,0 +1,31 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""padic_ml: continuous p-adic optimization on Berkovich spaces."""
+
+from padic_ml import _array
+from padic_ml import ops
+
+__version__ = '0.0.1'
+
+PArray = _array.PArray
+array = _array.array
+asarray = _array.asarray
+
+__all__ = [
+    'PArray',
+    'array',
+    'asarray',
+    'ops',
+]

padic_ml/_array.py

@@ -0,0 +1,284 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data structures for Berkovich space representation and auto-diff."""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+
+import jax
+import jax.numpy as jnp
+import jaxtyping as jt
+import sympy
+
+
+@functools.cache
+def _is_prime(p: int) -> bool:
+  """Cached primality check using sympy.isprime."""
+  return bool(sympy.isprime(p))
+
+
+def _matching_float_dtype(int_dtype: jnp.dtype) -> jnp.dtype:
+  """Returns the floating-point dtype of equal bitwidth to an integer dtype."""
+  return jnp.dtype(f'float{int_dtype.itemsize * 8}')
+
+
+class IntOperand:
+  """Union type alias for int | jt.Int[jt.Array, Shape].
+
+  Usage:
+    IntOperand['*N']   -> int | jt.Int[jt.Array, '*N']
+    IntOperand['*#N']  -> int | jt.Int[jt.Array, '*#N']
+    IntOperand['...']  -> int | jt.Int[jt.Array, '...']
+  """
+
+  def __class_getitem__(cls, shape):
+    return int | jt.Int[jt.Array, shape]
+
+
+class FloatOperand:
+  """Union type alias for float | jt.Float[jt.Array, Shape].
+
+  Usage:
+    FloatOperand['*N']   -> float | jt.Float[jt.Array, '*N']
+    FloatOperand['*#N']  -> float | jt.Float[jt.Array, '*#N']
+    FloatOperand['...']  -> float | jt.Float[jt.Array, '...']
+  """
+
+  def __class_getitem__(cls, shape):
+    return float | jt.Float[jt.Array, shape]
+
+
+@functools.partial(
+    jax.tree_util.register_dataclass,
+    data_fields=('unit', 'valuation', 'log_radius'),
+    meta_fields=('p',),
+)
+@dataclasses.dataclass(eq=False, frozen=True, kw_only=True)
+class PArray:
+  """DO NOT INIT DIRECTLY; use `(as)array()`. Array of 'continuous' p-adics.
+
+  These are elements zeta_{unit * p^valuation, p^log_radius} of the p-adic
+  convex hull of Qp. In a normalized (unit, valuation) pair, unit is coprime to
+  p, or (0,0) if c = 0, such that c = unit * p^valuation. Details on this
+  representation:
+  https://doc.sagemath.org/html/en/reference/padics/sage/rings/padics/tutorial.html#terminology-and-types-of-p-adics
+  https://flintlib.org/doc/padic.html
+
+  NOTE: With integer units, we can only represent Z[1/p] in Qp exactly. However,
+  this set is dense, so for non-zero radii, we can choose the center to be in
+  Z[1/p].
+
+  Attributes:
+    unit: Integer unit representative coprime to p (or 0 if center is 0). int.
+    valuation: Exact p-adic valuation v_p(c) (or 0 if center is 0). int.
+    log_radius: Log-radius of the disk. float.
+    p: Prime base p.
+  """
+
+  unit: jt.Int[jt.Array, '*N']
+  valuation: jt.Int[jt.Array, '*N']
+  log_radius: jt.Float[jt.Array, '*N']
+  p: int
+
+  @property
+  def center(self) -> jt.Int[jt.Array, '*N']:
+    """Reconstructs the integer center u * p^v. Requires valuation >= 0."""
+    p_pow = jnp.asarray(self.p, dtype=self.unit.dtype) ** jnp.maximum(
+        0, self.valuation
+    )
+    return self.unit * p_pow
+
+  # The below two properties (shape and dtype) give a duck-typed array for JAX
+  # typing. See: https://docs.kidger.site/jaxtyping/api/array/#array
+
+  @property
+  def shape(self) -> tuple[int, ...]:
+    """Returns the shape of the array."""
+    return self.unit.shape
+
+  @property
+  def dtype(self) -> jnp.dtype:
+    """Returns the data type of the unit array."""
+    return self.unit.dtype
+
+  # Imports of ops are inside the functions to avoid circular dependency.
+  #
+  # We do not add shape annotations for these wrappers, as such annotations only
+  # get used in runtime type checking. We consolidate those in `ops`. Also see
+  # warning which discourages strings or from __future__ import annotations as
+  # array terms of the jt type annotation.
+  # https://docs.kidger.site/jaxtyping/api/runtime-type-checking/.
+  #
+  # pylint: disable=g-import-not-at-top
+
+  def __add__(self, other: PArray | IntOperand['...']) -> PArray:
+    from padic_ml import ops
+
+    return ops.add(self, other)
+
+  def __radd__(self, other: PArray | IntOperand['...']) -> PArray:
+    return self.__add__(other)
+
+  def __mul__(self, other: PArray | IntOperand['...']) -> PArray:
+    from padic_ml import ops
+
+    return ops.mul(self, other)
+
+  def __rmul__(self, other: PArray | IntOperand['...']) -> PArray:
+    return self.__mul__(other)
+
+  def __neg__(self) -> PArray:
+    from padic_ml import ops
+
+    return ops.neg(self)
+
+  def __pow__(self, power: int) -> PArray:
+    from padic_ml import ops
+
+    return ops.power(self, power)
+
+  def __sub__(self, other: PArray | IntOperand['...']) -> PArray:
+    from padic_ml import ops
+
+    return ops.sub(self, other)
+
+  def abs(self) -> jax.Array:
+    from padic_ml import ops
+
+    return ops.absolute(self)
+
+  def is_padic(self) -> jax.Array:
+    from padic_ml import ops
+
+    return ops.is_padic(self)
+
+  # pylint: enable=g-import-not-at-top
+
+
+def array(
+    center: IntOperand['*N'] | None = None,
+    radius: FloatOperand['*#N'] | None = None,
+    *,
+    p: int,
+    log_radius: FloatOperand['*#N'] | None = None,
+    unit: IntOperand['*N'] | None = None,
+    valuation: IntOperand['*#N'] | None = None,
+) -> PArray:
+  """Constructs a PArray, validating and canonicalizing its arguments.
+
+  This is the eager entry point for building a PArray, analogous to `jnp.array`.
+  All validation and casework lives here rather than in `PArray.__init__`, which
+  must stay free of logic because JAX calls it to rebuild the pytree on every
+  transformation boundary.
+
+  Supported invocation modes:
+    1. From an integer center:
+       `array(center, radius=None, *, p, log_radius=None)`
+    2. From pre-decomposed unit and valuation (e.g. elements of Z[1/p]):
+       `array(radius=None, *, p, log_radius=None, unit=..., valuation=...)`
+
+  Args:
+    center: Integer center of the disk, u * p^v. If provided, unit and valuation
+      are computed automatically via `decompose(center, p)`.
+    radius: Non-negative radius r = p^log_radius of the disk. Mutually exclusive
+      with `log_radius`. Converted internally to `log_radius`.
+    p: Prime base p (must be a prime integer >= 2).
+    log_radius: Log-radius of the disk (base p). Defaults to -inf (a strictly
+      p-adic point) if both `radius` and `log_radius` are omitted.
+    unit: Integer unit representative coprime to p (or 0 if center is 0). Must
+      be provided together with `valuation` when `center` is omitted.
+    valuation: Exact p-adic valuation v_p(c) (or 0 if center is 0). Must be
+      provided together with `unit` when `center` is omitted.
+
+  Returns:
+    A PArray in canonical (unit, valuation, log_radius) form.
+
+  Raises:
+    ValueError: If p is not prime, if both `radius` and `log_radius` are given,
+      if `radius` is negative, if the integer arguments are not of integer
+      dtype, or if neither `center` nor `(unit, valuation)` is provided.
+  """
+  if p < 2 or not _is_prime(p):
+    raise ValueError(f'Prime base p must be a prime >= 2, got {p}.')
+  if radius is not None and log_radius is not None:
+    raise ValueError('Cannot specify both radius and log_radius.')
+
+  # Resolve the canonical (unit, valuation) pair.
+  if unit is not None and valuation is not None:
+    u = jnp.asarray(unit)
+    v = jnp.asarray(valuation)
+    if not jnp.issubdtype(u.dtype, jnp.integer):
+      raise ValueError(f'unit must have integer dtype, got {u.dtype}.')
+    if not jnp.issubdtype(v.dtype, jnp.integer):
+      raise ValueError(f'valuation must have integer dtype, got {v.dtype}.')
+    # Zero has no valuation; pin it to 0 so equal values compare equal.
+    v = jnp.broadcast_to(jnp.where(u == 0, 0, v), u.shape)
+  elif center is not None:
+    c = jnp.asarray(center)
+    if not jnp.issubdtype(c.dtype, jnp.integer):
+      raise ValueError(f'center must have integer dtype, got {c.dtype}.')
+    # Deferred to break the _array <-> ops cycle, as in the PArray operator
+    # methods above.
+    from padic_ml import ops  # pylint: disable=g-import-not-at-top
+
+    u, v = ops.decompose(c, p)
+  else:
+    raise ValueError('Either center or (unit, valuation) must be provided.')
+
+  # Resolve the log-radius, matching the bitwidth of the integer payload so that
+  # 32-bit inputs do not silently incur 64-bit intermediates under jit.
+  float_dtype = _matching_float_dtype(u.dtype)
+  if log_radius is not None:
+    r = jnp.asarray(log_radius, dtype=float_dtype)
+  elif radius is not None:
+    rad = jnp.asarray(radius, dtype=float_dtype)
+    if jnp.any(rad < 0):
+      raise ValueError('Radius must be non-negative.')
+    log_p = jnp.log(jnp.asarray(p, dtype=float_dtype))
+    r = jnp.where(
+        rad == 0,
+        jnp.asarray(-jnp.inf, dtype=float_dtype),
+        jnp.log(rad) / log_p,
+    )
+  else:
+    r = jnp.full(u.shape, -jnp.inf, dtype=float_dtype)
+
+  return PArray(
+      unit=u, valuation=v, log_radius=jnp.broadcast_to(r, u.shape), p=p
+  )
+
+
+@jt.jaxtyped
+def asarray(
+    x: jt.Shaped[PArray, '*N'] | IntOperand['*N'],
+    *,
+    p: int,
+) -> jt.Shaped[PArray, '*N']:
+  """Converts an integer or integer array operand to a PArray with prime base p.
+
+  Idempotent on PArray inputs, analogous to `jnp.asarray`.
+
+  Raises:
+    ValueError: If x is a PArray whose prime base differs from p.
+  """
+  if isinstance(x, PArray):
+    if x.p != p:
+      raise ValueError(
+          f'Cannot convert PArray with prime base p={x.p} to p={p}.'
+      )
+    return x
+  return array(x, p=p)

padic_ml/_array_test.py

@@ -0,0 +1,180 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from absl.testing import absltest
+import jax
+import jax.numpy as jnp
+import numpy as np
+import padic_ml as pml
+from padic_ml import _array
+
+PArray = _array.PArray
+array = pml.array
+
+
+class PArrayTest(absltest.TestCase):
+  """PArray methods that are stubs in _array.py are tested in ops_test.py."""
+
+  def test_init(self):
+    # Default log_radius is -inf
+    arr = array(jnp.array([1, 2]), p=3)
+    np.testing.assert_array_equal(arr.center, jnp.array([1, 2]))
+    np.testing.assert_array_equal(
+        arr.log_radius, jnp.array([-jnp.inf, -jnp.inf])
+    )
+    self.assertEqual(arr.p, 3)
+
+    # Casts inputs to array
+    arr = array([1, 2], p=2)
+    self.assertIsInstance(arr.center, jax.Array)
+    np.testing.assert_array_equal(arr.center, jnp.array([1, 2]))
+
+    # Broadcasts radius inputs (r=4.0 at p=2 -> log_radius=2.0)
+    arr = array(jnp.array([1, 2]), 4.0, p=2)
+    self.assertIsInstance(arr.log_radius, jax.Array)
+    np.testing.assert_allclose(arr.log_radius, jnp.array([2.0, 2.0]))
+
+    # Radius 0.0 converts to log_radius -inf
+    arr_zero_rad = array(jnp.array([1, 2]), 0.0, p=2)
+    np.testing.assert_array_equal(
+        arr_zero_rad.log_radius, jnp.array([-jnp.inf, -jnp.inf])
+    )
+
+    # Keyword log_radius input
+    arr_log = array(jnp.array([1, 2]), log_radius=1.0, p=2)
+    np.testing.assert_array_equal(arr_log.log_radius, jnp.array([1.0, 1.0]))
+
+  def test_construction_and_properties(self):
+    x = array(jnp.array([1, 2, 3], dtype=jnp.int32), p=5)
+    self.assertEqual(x.shape, (3,))
+    self.assertEqual(x.dtype, jnp.dtype(jnp.int32))
+    self.assertEqual(x.p, 5)
+
+  def test_unit_valuation_init(self):
+    # Eager canonicalization of integer centers
+    arr = array(45, p=3)
+    np.testing.assert_array_equal(arr.unit, jnp.array(5))
+    np.testing.assert_array_equal(arr.valuation, jnp.array(2))
+    np.testing.assert_array_equal(arr.center, jnp.array(45))
+
+    # Exact zero center (u=0, v=0)
+    zero = array(0, p=3)
+    np.testing.assert_array_equal(zero.unit, jnp.array(0))
+    np.testing.assert_array_equal(zero.valuation, jnp.array(0))
+    np.testing.assert_array_equal(zero.center, jnp.array(0))
+
+    # Negative integer center
+    neg_arr = array(-12, p=3)
+    np.testing.assert_array_equal(neg_arr.unit, jnp.array(-4))
+    np.testing.assert_array_equal(neg_arr.valuation, jnp.array(1))
+    np.testing.assert_array_equal(neg_arr.center, jnp.array(-12))
+
+    # Pre-decomposed unit/valuation (Z[1/p] representation)
+    frac = array(unit=2, valuation=-3, p=3)
+    np.testing.assert_array_equal(frac.unit, jnp.array(2))
+    np.testing.assert_array_equal(frac.valuation, jnp.array(-3))
+
+    # Pre-decomposed with log-radius
+    disk = array(unit=5, valuation=2, log_radius=-1.0, p=3)
+    np.testing.assert_array_equal(disk.center, jnp.array(45))
+    np.testing.assert_array_equal(disk.log_radius, jnp.array(-1.0))
+
+  def test_center_clamps_negative_valuation(self):
+    """Documents (does not endorse) the .center precondition.
+
+    2 * 3^-3 is not an integer, so there is no correct integer to return. The
+    property clamps to p^max(0, v) and thus reports the unit. This is asserted
+    so the documented precondition stays honest rather than drifting silently;
+    exact work must use (unit, valuation).
+    """
+    frac = array(unit=2, valuation=-3, p=3)
+    np.testing.assert_array_equal(frac.center, jnp.array(2))
+
+  def test_direct_construction_accepts_float0(self):
+    """The canonical constructor must not validate dtypes.
+
+    `jax.grad(..., allow_int=True)` assigns float0 tangents to integer leaves
+    and then rebuilds the pytree by calling this constructor. A dtype assertion
+    here would reject JAX's own gradient machinery, so this must not raise.
+    """
+    float0 = jax.dtypes.float0
+    zero = np.zeros((), dtype=float0)
+    arr = PArray(
+        unit=zero,
+        valuation=zero,
+        log_radius=jnp.asarray(-jnp.inf),
+        p=3,
+    )
+    self.assertEqual(arr.unit.dtype, float0)
+
+  def test_init_error(self):
+    # Raising ValueError when neither center nor (unit, valuation) is passed
+    with self.assertRaises(ValueError):
+      array(p=3)
+    # Raising ValueError when only unit is passed
+    with self.assertRaises(ValueError):
+      array(unit=5, p=3)
+    # Raising ValueError when only valuation is passed
+    with self.assertRaises(ValueError):
+      array(valuation=2, p=3)
+    # Raising ValueError when not prime
+    with self.assertRaises(ValueError):
+      array(5, p=1)
+    with self.assertRaises(ValueError):
+      array(5, p=4)
+    with self.assertRaises(ValueError):
+      array(5, p=9)
+    # Raising ValueError when center is not integer dtype
+    with self.assertRaises(ValueError):
+      array(1.5, p=3)
+    # Raising ValueError when unit or valuation is not integer dtype
+    with self.assertRaises(ValueError):
+      array(unit=1.5, valuation=2, p=3)
+    with self.assertRaises(ValueError):
+      array(unit=1, valuation=2.5, p=3)
+    # Raising ValueError when both radius and log_radius are specified
+    with self.assertRaises(ValueError):
+      array(5, 1.0, log_radius=0.0, p=3)
+    # Raising ValueError when radius is negative
+    with self.assertRaises(ValueError):
+      array(5, -1.0, p=3)
+
+  def test_pytree_round_trip(self):
+    """register_dataclass must rebuild an identical PArray from its leaves.
+
+    This is the container contract the logic-free constructor exists to serve:
+    JAX calls it via `unflatten_func` on every transformation boundary.
+    """
+    x = array(45, log_radius=-1.0, p=3)
+    leaves, treedef = jax.tree_util.tree_flatten(x)
+    y = jax.tree_util.tree_unflatten(treedef, leaves)
+    self.assertEqual(y.unit, x.unit)
+    self.assertEqual(y.valuation, x.valuation)
+    self.assertEqual(y.log_radius, x.log_radius)
+    self.assertEqual(y.p, x.p)
+
+  def test_asarray(self):
+    # Idempotent on PArray inputs
+    x = array(45, p=3)
+    self.assertIs(pml.asarray(x, p=3), x)
+    # Converts integer operands
+    converted = pml.asarray(45, p=3)
+    np.testing.assert_array_equal(converted.unit, jnp.array(5))
+    # Rejects a prime-base mismatch
+    with self.assertRaises(ValueError):
+      pml.asarray(x, p=5)
+
+
+if __name__ == '__main__':
+  absltest.main()

padic_ml/ops.py

@@ -0,0 +1,256 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Functional arithmetic operations for PArray (Berkovich disk algebra).
+
+Architecture and Conventions:
+-----------------------------
+1. Container + Functional Math Separation:
+   - `PArray` (defined in `_array.py`) is the Berkovich disk container.
+   - It delegates to the arithmetic logic here (the functional `ops.*` API).
+
+2. Type Enforcement via jaxtyping:
+   - `ops.*` functions are decorated with `@jt.jaxtyped` to enforce dtype
+     contracts and broadcasting rules (`*#N -> *N`) across operands.
+
+3. Subclass and Custom Type Construction Contract:
+   - Each arithmetic implementation explicitly constructs and returns a base
+     `PArray(unit=..., valuation=..., log_radius=..., p=...)`. That constructor
+     is canonical-only and keyword-only; it performs no validation, because JAX
+     calls it to rebuild the pytree on every transformation boundary.
+   - To build a PArray from a center, a radius, or a plain integer operand, use
+     `_array.array(...)` or `_array.asarray(...)` instead.
+   - Subclasses (e.g. `LegacyPArray`) override the relevant operator
+     methods, call `super()` or `ops.*` for the base container, and
+     explicitly construct their own class instance.
+"""
+
+import functools
+import math
+
+import jax
+import jax.numpy as jnp
+import jaxtyping as jt
+from padic_ml import _array
+
+IntOperand = _array.IntOperand
+PArray = _array.PArray
+
+
+@jt.jaxtyped
+def absolute(x: jt.Shaped[PArray, '*N']) -> jt.Float[jax.Array, '*N']:
+  """Computes the p-adic norm |x|_p = p^{-v_p(x)} (0 if unit == 0)."""
+  # log_radius already carries the float dtype matching the integer payload.
+  float_dtype = x.log_radius.dtype
+  return jnp.where(
+      x.unit == 0,
+      jnp.asarray(0.0, dtype=float_dtype),
+      jnp.asarray(x.p, dtype=float_dtype) ** (-x.valuation),
+  )
+
+
+@jt.jaxtyped
+def is_padic(x: jt.Shaped[PArray, '*N']) -> jt.Bool[jax.Array, '*N']:
+  """Checks if the array is strictly p-adic (log_radius -inf)."""
+  return jnp.isneginf(x.log_radius)
+
+
+@jt.jaxtyped
+def add(
+    a: jt.Shaped[PArray, '*#N'],
+    b: jt.Shaped[PArray, '*#N'] | IntOperand['*#N'],
+) -> jt.Shaped[PArray, '*N']:
+  """Translates the center of a Berkovich disk."""
+
+  if isinstance(b, PArray):
+    if a.p != b.p:
+      raise ValueError(
+          f'Addition between PArrays with different primes {a.p} and {b.p} is'
+          ' not supported.'
+      )
+    if is_padic(b):
+      return add(a, b.center)
+    elif is_padic(a):
+      return add(b, a.center)
+    else:
+      raise NotImplementedError(
+          'Addition between two PArrays with positive radii is not supported'
+          ' outside computation graphs.'
+      )
+
+  return _array.array(a.center + b, log_radius=a.log_radius, p=a.p)
+
+
+@jt.jaxtyped
+def mul(
+    a: jt.Shaped[PArray, '*#N'],
+    b: jt.Shaped[PArray, '*#N'] | IntOperand['*#N'],
+) -> jt.Shaped[PArray, '*N']:
+  """Multiplicativity of seminorms on the Berkovich line."""
+  b = _array.asarray(b, p=a.p)
+  new_unit = a.unit * b.unit
+  new_valuation = jnp.where(new_unit == 0, 0, a.valuation + b.valuation)
+
+  term_one = jnp.where(
+      a.unit == 0,
+      -jnp.inf,
+      -a.valuation.astype(b.log_radius.dtype) + b.log_radius,
+  )
+  term_two = jnp.where(
+      b.unit == 0,
+      -jnp.inf,
+      -b.valuation.astype(a.log_radius.dtype) + a.log_radius,
+  )
+  term_three = a.log_radius + b.log_radius
+
+  new_log_radius = jnp.maximum(jnp.maximum(term_one, term_two), term_three)
+  return PArray(
+      unit=new_unit,
+      valuation=new_valuation,
+      log_radius=new_log_radius,
+      p=a.p,
+  )
+
+
+@jt.jaxtyped
+def neg(a: jt.Shaped[PArray, '*N']) -> jt.Shaped[PArray, '*N']:
+  """Negation on Berkovich disk."""
+  return mul(a, -1)
+
+
+@jt.jaxtyped
+def power(a: jt.Shaped[PArray, '*N'], exponent: int) -> jt.Shaped[PArray, '*N']:
+  """Integer power on the Berkovich line via binomial expansion."""
+
+  new_unit = a.unit**exponent
+  new_valuation = jnp.where(new_unit == 0, 0, a.valuation * exponent)
+
+  terms_list = []
+  for k in range(1, exponent + 1):
+    coefficient = math.comb(exponent, k)
+    _, v_comb = decompose(coefficient, a.p)
+    is_zero_term = (a.unit == 0) & (k < exponent)
+    v_term = v_comb + (exponent - k) * a.valuation
+    term_log_radius = jnp.where(
+        is_zero_term,
+        -jnp.inf,
+        -v_term.astype(a.log_radius.dtype) + k * a.log_radius,
+    )
+    terms_list.append(term_log_radius)
+
+  terms_stacked = jnp.stack(terms_list, axis=0)
+  new_log_radius = jnp.max(terms_stacked, axis=0)
+
+  return PArray(
+      unit=new_unit,
+      valuation=new_valuation,
+      log_radius=new_log_radius,
+      p=a.p,
+  )
+
+
+@jt.jaxtyped
+def sub(
+    a: jt.Shaped[PArray, '*#N'],
+    b: jt.Shaped[PArray, '*#N'] | IntOperand['*#N'],
+) -> jt.Shaped[PArray, '*N']:
+  """Subtraction on Berkovich disk."""
+  return add(a, -b)
+
+
+# ---------------------------------------------------------------------------
+# Non-PArray utility functions
+# ---------------------------------------------------------------------------
+
+
+@functools.cache
+def _max_valuation(p: int, dtype: jnp.dtype) -> int:
+  """Maximum p-adic valuation representable by an integer dtype.
+
+  Computes floor(log_p(max_val)) using integer arithmetic to avoid
+  floating-point precision issues with math.log.
+
+  Args:
+    p: Prime base.
+    dtype: Integer dtype whose range bounds the valuation.
+
+  Returns:
+    The largest v such that p^v fits within the dtype's range.
+  """
+  v, n = 0, jnp.iinfo(dtype).max
+  while n >= p:
+    n //= p
+    v += 1
+  return v
+
+
+@jt.jaxtyped
+def decompose(
+    x: IntOperand['*N'],
+    p: int,
+) -> tuple[jt.Int[jt.Array, '*N'], jt.Int[jt.Array, '*N']]:
+  """Decomposes an integer array into canonical (unit, valuation) pair.
+
+  For each element, factors x = u * p^v such that p does not divide u
+  (or u = 0, v = 0 if x = 0).
+
+  Uses fori_loop with a static bound (the maximum valuation for the input
+  dtype) instead of while_loop. This eliminates the per-iteration jnp.any()
+  global synchronization barrier that while_loop's cond_fun requires, making
+  each iteration purely element-wise.
+
+  Returns:
+    (unit, valuation): unit tensor u in Z and int valuation tensor v in Z.
+  """
+  x_arr = jnp.asarray(x)
+  abs_x = jnp.abs(x_arr)
+  is_zero = abs_x == 0
+  # Replace zeros with 1 to avoid division-by-zero in the loop body.
+  safe_x = jnp.where(is_zero, 1, abs_x)
+
+  def body_fun(_, state):
+    curr_x, val = state
+    divisible = curr_x % p == 0
+    # Only divide elements still divisible by p; others pass through.
+    next_x = jnp.where(divisible, curr_x // p, curr_x)
+    next_val = jnp.where(divisible, val + 1, val)
+    return next_x, next_val
+
+  # Upper bound on iterations: no integer of this dtype can have a p-adic
+  # valuation exceeding this, so the loop is guaranteed to finish all elements.
+  max_iters = _max_valuation(p, x_arr.dtype)
+  init_val = jnp.zeros_like(safe_x)
+  final_x, final_val = jax.lax.fori_loop(
+      0, max_iters, body_fun, (safe_x, init_val)
+  )
+
+  # Restore sign and canonicalize zeros to (u=0, v=0).
+  unit = jnp.where(is_zero, 0, jnp.sign(x_arr) * final_x)
+  valuation = jnp.where(is_zero, 0, final_val)
+  return unit, valuation
+
+
+@jt.jaxtyped
+def to_expansion(
+    value: int | jt.Int[jt.Array, ''],
+    p: int,
+    terms: int = 8,
+) -> str:
+  """Formats a standard integer into a p-adic string for representation."""
+  value_modulo = int(value) % (p**terms)
+  digits_list = []
+  for _ in range(terms):
+    digits_list.append(str(value_modulo % p))
+    value_modulo //= p
+  return '...' + ''.join(reversed(digits_list))

padic_ml/ops_test.py

@@ -0,0 +1,351 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Unit tests for PArray and p-adic operations in ops module."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import itertools
+import jax
+import jax.numpy as jnp
+import numpy as np
+import padic_ml as pml
+from padic_ml import ops
+
+PArray = pml.PArray
+array = pml.array
+
+
+class OpsTest(absltest.TestCase):
+  """Tests for PArray dataclass and p-adic operations."""
+
+  def test_absolute(self):
+    # |9|_3 = 3^{-2} = 1/9
+    nine = array(jnp.array(9), p=3)
+    self.assertAlmostEqual(nine.abs(), 1.0 / 9.0)
+    self.assertAlmostEqual(ops.absolute(nine), 1.0 / 9.0)
+
+    # |5|_3 = 3^{-0} = 1
+    five = array(jnp.array(5), p=3)
+    self.assertAlmostEqual(five.abs(), 1.0)
+    self.assertAlmostEqual(ops.absolute(five), 1.0)
+
+    # |0|_3 = 0.0
+    zero = array(jnp.array(0), p=3)
+    self.assertAlmostEqual(zero.abs(), 0.0)
+    self.assertAlmostEqual(ops.absolute(zero), 0.0)
+
+  def test_absolute_dtype_x64(self):
+    """|x|_p preserves the input bitwidth instead of upcasting to float64.
+
+    Deliberately runs under `jax.enable_x64(True)`: in JAX's default x32 mode
+    float64 is unreachable, so asserting a float32 result would be vacuous.
+    """
+    with jax.enable_x64(True):
+      arr32 = array(jnp.array([9, 0, 5], dtype=jnp.int32), p=3)
+      self.assertEqual(ops.absolute(arr32).dtype, jnp.float32)
+
+      arr64 = array(jnp.array([9, 0, 5], dtype=jnp.int64), p=3)
+      self.assertEqual(ops.absolute(arr64).dtype, jnp.float64)
+
+  def test_asarray(self):
+    # asarray now lives in _array.py and is exported as pml.asarray; ops no
+    # longer re-exports it (container/math separation).
+    self.assertFalse(hasattr(ops, 'asarray'))
+
+    # Converts int to PArray with prime p
+    arr = pml.asarray(9, p=3)
+    self.assertIsInstance(arr, PArray)
+    self.assertEqual(arr.unit, 1)
+    self.assertEqual(arr.valuation, 2)
+    self.assertEqual(arr.p, 3)
+
+    # Returns existing PArray unchanged if p matches
+    same = pml.asarray(arr, p=3)
+    self.assertIs(same, arr)
+
+    # Raises ValueError if prime p mismatches
+    with self.assertRaises(ValueError):
+      pml.asarray(arr, p=5)
+
+  def test_is_padic(self):
+    a = array(jnp.array([1, 2]), log_radius=jnp.array([-1.0, -2.0]), p=2)
+    np.testing.assert_array_equal(a.is_padic(), jnp.array([False, False]))
+    np.testing.assert_array_equal(ops.is_padic(a), jnp.array([False, False]))
+
+    b = array(jnp.array([1, 2]), log_radius=jnp.array([3.0, -jnp.inf]), p=3)
+    np.testing.assert_array_equal(b.is_padic(), jnp.array([False, True]))
+    np.testing.assert_array_equal(ops.is_padic(b), jnp.array([False, True]))
+
+    # Default log_radius is -inf, so is_padic is True.
+    c = array(jnp.array([1, 2]), p=3)
+    np.testing.assert_array_equal(c.is_padic(), jnp.array(True))
+    np.testing.assert_array_equal(ops.is_padic(c), jnp.array(True))
+
+  def test_add(self):
+    # Scalar translation: center translated, log_radius unchanged
+    a = array(5, log_radius=-2.0, p=3)
+    res_scalar = a + 4
+    self.assertEqual(res_scalar.unit, 1)
+    self.assertEqual(res_scalar.valuation, 2)
+    self.assertEqual(res_scalar.log_radius, -2.0)
+
+    res_scalar_fn = ops.add(a, 4)
+    self.assertEqual(res_scalar_fn.unit, 1)
+    self.assertEqual(res_scalar_fn.valuation, 2)
+    self.assertEqual(res_scalar_fn.log_radius, -2.0)
+
+    # Left scalar addition:
+    res_left = 4 + a
+    self.assertEqual(res_left.unit, 1)
+    self.assertEqual(res_left.valuation, 2)
+    self.assertEqual(res_left.log_radius, -2.0)
+
+    # Point + Disk translation:
+    b = array(3, log_radius=-jnp.inf, p=3)
+    res_point = a + b
+    self.assertEqual(res_point.unit, 8)
+    self.assertEqual(res_point.valuation, 0)
+    self.assertEqual(res_point.log_radius, -2.0)
+
+    # Two positive radii disks should raise NotImplementedError:
+    c = array(3, log_radius=-1.0, p=3)
+    with self.assertRaises(NotImplementedError):
+      _ = a + c
+    with self.assertRaises(NotImplementedError):
+      ops.add(a, c)
+
+  def test_commutativity(self):
+    """Addition is commutative: a+b == b+a in unit, valuation, and log_radius."""
+    a = array(5, log_radius=-2.0, p=3)
+    b = array(3, log_radius=-jnp.inf, p=3)
+    ab = a + b
+    ba = b + a
+    np.testing.assert_allclose(ab.log_radius, ba.log_radius)
+    np.testing.assert_allclose(ab.unit, ba.unit)
+    np.testing.assert_allclose(ab.valuation, ba.valuation)
+
+  def test_mul_cross_terms(self):
+    """Verify that mul accounts for cross terms in radius."""
+    x = array(1, log_radius=-2.0, p=3)
+    y = array(1, log_radius=-3.0, p=3)
+    f = x * y
+    # max(v_1*(-1)+rho_2, v_2*(-1)+rho_1, rho_1 +rho_2) = max(-3,-2,-5) = -2.0
+    self.assertAlmostEqual(f.log_radius, -2.0)
+    self.assertEqual(f.unit, 1)
+    self.assertEqual(f.valuation, 0)
+
+    # Scalar multiplication:
+    f_scalar = x * 9  # v_3(9) = 2 -> rho - v = -2 - 2 = -4.0
+    self.assertEqual(f_scalar.unit, 1)
+    self.assertEqual(f_scalar.valuation, 2)
+    self.assertAlmostEqual(f_scalar.log_radius, -4.0)
+
+    f_scalar_left = 9 * x
+    self.assertEqual(f_scalar_left.unit, 1)
+    self.assertEqual(f_scalar_left.valuation, 2)
+    self.assertAlmostEqual(f_scalar_left.log_radius, -4.0)
+
+    # Pre-decomposed Z[1/p] multiplication
+    frac_a = array(unit=2, valuation=-3, p=3)  # 2/27
+    frac_b = array(unit=5, valuation=2, p=3)  # 45
+    prod = frac_a * frac_b
+    self.assertEqual(prod.unit, 10)
+    self.assertEqual(prod.valuation, -1)
+    self.assertTrue(jnp.isneginf(prod.log_radius))
+
+  def test_power(self):
+    """Verify that pow accounts for cross terms in radius."""
+    # c=1, rho=-2.0
+    x = array(1, log_radius=-2.0, p=3)
+    f = x**2
+    # Correct radius: max(log|2c| + rho, 2*rho) = max(0 - 2, -4) = -2.0
+    self.assertAlmostEqual(f.log_radius, -2.0)
+    self.assertEqual(f.unit, 1)
+    self.assertEqual(f.valuation, 0)
+
+    # Power with non-trivial unit and valuation: 45 = 5 * 3^2
+    a = array(45, log_radius=-1.0, p=3)
+    a2 = a**2
+    self.assertEqual(a2.unit, 25)
+    self.assertEqual(a2.valuation, 4)
+
+    a3 = a**3
+    self.assertEqual(a3.unit, 125)
+    self.assertEqual(a3.valuation, 6)
+
+  def test_zero_edge_cases(self):
+    """Verify operations involving exact zeros (u=0, v=0)."""
+    zero = array(0, p=3)
+    five = array(5, p=3)
+
+    # Zero * Non-zero PArray
+    mul_zero = zero * five
+    self.assertEqual(mul_zero.unit, 0)
+    self.assertEqual(mul_zero.valuation, 0)
+    self.assertTrue(jnp.isneginf(mul_zero.log_radius))
+
+    # Non-zero * Scalar 0
+    scalar_zero = five * 0
+    self.assertEqual(scalar_zero.unit, 0)
+    self.assertEqual(scalar_zero.valuation, 0)
+    self.assertTrue(jnp.isneginf(scalar_zero.log_radius))
+
+    # Zero + Non-zero PArray
+    add_zero = zero + five
+    self.assertEqual(add_zero.unit, 5)
+    self.assertEqual(add_zero.valuation, 0)
+
+    # Power of zero
+    pow_zero = zero**2
+    self.assertEqual(pow_zero.unit, 0)
+    self.assertEqual(pow_zero.valuation, 0)
+
+  def test_cancellation_cases(self):
+    """Verify p-adic cancellation dynamics in addition and multiplication."""
+    # --- Addition Cancellation (valuation jumps) ---
+    # 1 + 2 = 3 at p=3: valuation jumps from 0 to 1
+    a = array(1, p=3)
+    b = array(2, p=3)
+    sum_ab = a + b
+    self.assertEqual(sum_ab.unit, 1)
+    self.assertEqual(sum_ab.valuation, 1)
+
+    # 5 + 4 = 9 = 1 * 3^2 at p=3: valuation jumps from 0 to 2
+    c = array(5, p=3)
+    d = array(4, p=3)
+    sum_cd = c + d
+    self.assertEqual(sum_cd.unit, 1)
+    self.assertEqual(sum_cd.valuation, 2)
+
+    # Complete cancellation to exact 0: 5 + (-5) = 0
+    neg_c = array(-5, p=3)
+    sum_zero = c + neg_c
+    self.assertEqual(sum_zero.unit, 0)
+    self.assertEqual(sum_zero.valuation, 0)
+
+    # --- Multiplication: Euclid's lemma guarantees NO cancellation ---
+    # (4 * 3^1) * (5 * 3^2) = 20 * 3^3 = 540
+    m1 = array(12, p=3)  # u=4, v=1
+    m2 = array(45, p=3)  # u=5, v=2
+    prod = m1 * m2  # u=20, v=3
+    self.assertEqual(prod.unit, 20)
+    self.assertEqual(prod.valuation, 3)
+
+  def test_neg_and_sub(self):
+    a = array(5, log_radius=-2.0, p=3)
+    neg_a = -a
+    self.assertEqual(neg_a.unit, -5)
+    self.assertEqual(neg_a.valuation, 0)
+    self.assertEqual(neg_a.log_radius, -2.0)
+    self.assertEqual(ops.neg(a).unit, -5)
+    self.assertEqual(ops.neg(a).valuation, 0)
+
+    diff = a - 2
+    self.assertEqual(diff.unit, 1)
+    self.assertEqual(diff.valuation, 1)
+    self.assertEqual(diff.log_radius, -2.0)
+
+    diff_fn = ops.sub(a, 2)
+    self.assertEqual(diff_fn.unit, 1)
+    self.assertEqual(diff_fn.valuation, 1)
+    self.assertEqual(diff_fn.log_radius, -2.0)
+
+  def test_to_expansion(self):
+    exp = ops.to_expansion(14, p=3, terms=4)
+    self.assertEqual(exp, '...0112')
+
+
+class DecomposeTest(absltest.TestCase):
+  """Tests for decompose edge cases and fori_loop bound assumptions."""
+
+  def test_max_representable_power_int32(self):
+    """Validates the fori_loop bound adapts to int32 dtype."""
+    max_v = ops._max_valuation(3, jnp.dtype(jnp.int32))
+    val = 3**max_v
+    u, v = ops.decompose(jnp.array(val, dtype=jnp.int32), p=3)
+    np.testing.assert_array_equal(u, jnp.array(1, dtype=jnp.int32))
+    np.testing.assert_array_equal(v, jnp.array(max_v, dtype=jnp.int32))
+
+  def test_max_representable_power_int64(self):
+    """Validates fori_loop bound for int64 using jax.enable_x64 context."""
+    with jax.enable_x64():
+      max_v = ops._max_valuation(3, jnp.dtype(jnp.int64))
+      val = 3**max_v
+      u, v = ops.decompose(jnp.array(val, dtype=jnp.int64), p=3)
+      np.testing.assert_array_equal(u, jnp.array(1, dtype=jnp.int64))
+      np.testing.assert_array_equal(v, jnp.array(max_v, dtype=jnp.int64))
+
+  def test_coprime_to_p(self):
+    """Value coprime to p should have valuation 0."""
+    u, v = ops.decompose(jnp.array(7), p=3)
+    np.testing.assert_array_equal(u, jnp.array(7))
+    np.testing.assert_array_equal(v, jnp.array(0))
+
+  def test_batch_mixed_valuations(self):
+    """Validates vectorized decomposition across varied elements."""
+    x = jnp.array([1, 3, 3**5, 0, -(3**3)])
+    u, v = ops.decompose(x, p=3)
+    np.testing.assert_array_equal(u, jnp.array([1, 1, 1, 0, -1]))
+    np.testing.assert_array_equal(v, jnp.array([0, 1, 5, 0, 3]))
+
+  def test_max_valuation_values(self):
+    """Verifies _max_valuation returns correct bounds for known cases."""
+    # 2^62 fits in int64 (max 2^63-1); 2^63 does not.
+    self.assertEqual(ops._max_valuation(2, jnp.dtype(jnp.int64)), 62)
+    # 2^30 fits in int32 (max 2^31-1); 2^31 does not.
+    self.assertEqual(ops._max_valuation(2, jnp.dtype(jnp.int32)), 30)
+    # 3^39 fits in int64; 3^40 does not.
+    self.assertEqual(ops._max_valuation(3, jnp.dtype(jnp.int64)), 39)
+
+
+class BitwidthTest(parameterized.TestCase):
+  """No operation may introduce a 64-bit intermediate for a 32-bit PArray.
+
+  A silent float64 upcast (classically from `jnp.float_`, which is float64
+  under x64) stays numerically correct while doubling memory traffic, and f64
+  is emulated on TPU. No correctness test would catch it, hence this
+  white-box scan of the traced jaxpr.
+
+  These run under `jax.enable_x64(True)` on purpose: in the default x32 mode
+  float64 is unreachable, so the assertion would hold vacuously.
+
+  `neg` and `sub` are omitted because they are defined as `mul(a, -1)` and
+  `add(a, -b)`, so they are covered transitively. `is_padic` returns bool and
+  `to_expansion` is pure Python.
+  """
+
+  @parameterized.named_parameters(
+      ('absolute', ops.absolute),
+      ('mul', lambda x: ops.mul(x, x)),
+      ('power', lambda x: ops.power(x, 3)),
+  )
+  def test_no_64bit_intermediates(self, op_fn):
+    with jax.enable_x64(True):
+      arr32 = array(jnp.array([9, 0, 5], dtype=jnp.int32), p=3)
+      jaxpr = jax.make_jaxpr(op_fn)(arr32)
+      eqn_vars = itertools.chain.from_iterable(
+          (*eqn.invars, *eqn.outvars) for eqn in jaxpr.jaxpr.eqns
+      )
+      eqn_dtypes = {v.aval.dtype for v in eqn_vars}
+      const_dtypes = {c.dtype for c in jaxpr.consts}
+      self.assertEmpty(
+          (eqn_dtypes | const_dtypes) & {jnp.float64, jnp.int64},
+          f'64-bit types in a 32-bit jaxpr: eqns={eqn_dtypes},'
+          f' consts={const_dtypes}',
+      )
+
+
+if __name__ == '__main__':
+  absltest.main()

padic_ml-0.0.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: padic-ml
+Version: 0.0.1
+Summary: JAX library for differentiable training of p-adic neural networks
+Author: Padic ML Authors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/google-deepmind/padic-ml
+Project-URL: Repository, https://github.com/google-deepmind/padic-ml
+Keywords: jax,p-adic,berkovich,machine learning,optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: jaxtyping
+Requires-Dist: sympy
+Provides-Extra: test
+Requires-Dist: absl-py; extra == "test"
+Requires-Dist: numpy; extra == "test"
+Dynamic: license-file
+
+# padic-ml
+
+**WORK IN PROGRESS. Paper code is being refactored into this library.
+Thanks for your patience!**
+
+This is a JAX library for differentiable training of _p_-adic neural networks,
+implementing methods described in *Continuous Optimization for p-adic Models*
+(arXiv 2026).
+
+Install with `pip install padic-ml`.
+
+**Disclaimer:** This is not an officially supported Google product.
+
+## Usage
+
+`PArray` is an array primitive for "learnable" _p_-adic numbers (points in the _p_-adic injective hull $\Gamma_p$ in Berkovich space).
+
+With radius 0 (no second argument), these become ordinary _p_-adic numbers $\mathbb{Q}_p$.
+
+```python
+>>> import padic_ml as pml
+>>> p1 = pml.array([3, 4], radius=[1, 3], p=3)
+>>> p2 = pml.array([7, 1], p=3)
+>>> p1*p2
+PArray(unit=Array([7, 4], dtype=int32), valuation=Array([1, 0], dtype=int32), log_radius=Array([0., 1.], dtype=float32), p=3)
+```

padic_ml-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+padic_ml/__init__.py,sha256=Rqkja26Jw6CbOLw_LiFvIb8Q95T1l-4-YyAjYOrwmA8,858
+padic_ml/_array.py,sha256=CUYLnUq5VEv3uYGjdh6b9givc824XezLaMThNAK7qHM,9692
+padic_ml/_array_test.py,sha256=T81P0tMXrlOLHMKVIr2cAxEN16hJjZ5uJjKYP_-bmSc,6748
+padic_ml/ops.py,sha256=WGIFxNYeo58EOHU7ZVEVJxi2M0G5H13NGX5MgyYqhLw,8058
+padic_ml/ops_test.py,sha256=7-2DyNrLsIzxMRAdOGSWwGR0B-dOPsY_vkaT87QFYDs,12709
+padic_ml-0.0.1.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+padic_ml-0.0.1.dist-info/METADATA,sha256=2S-9Ajyr80SuhxudZupYbd1lrUn7HizR-wbLUWuMyqk,1809
+padic_ml-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+padic_ml-0.0.1.dist-info/top_level.txt,sha256=92BzyjCUXoO7eBjy-dFHwZ9A2Y020GwzbWIMcN5Zk6s,9
+padic_ml-0.0.1.dist-info/RECORD,,

padic_ml-0.0.1.dist-info/WHEEL

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

padic_ml-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

padic_ml-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+padic_ml