pythonic-peano-arithmetic 0.3.0__py3-none-any.whl

peano/rational.py

@@ -0,0 +1,295 @@
+"""Construct rational numbers as equivalence classes of integer ratios."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import total_ordering
+from typing import cast
+
+from .integer import Z_ONE, Z_ZERO, Integer, integer, n2z
+from .natural_number import N_ONE, N_ZERO, NaturalNumber
+from .utils import LogMessage, log
+
+
+@total_ordering
+@dataclass(frozen=True, slots=True, eq=False, repr=False)
+class Rational:
+    """Represent a rational number as an integer ratio ``p / q``, ``q != 0``.
+
+    ``p/q ~ r/s`` is defined by the cross products ``p*s = q*r``. Input
+    representatives are preserved; ``reduction`` normalizes the denominator
+    and reduces the ratio only when explicitly requested.
+    """
+
+    p: Integer
+    q: Integer
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.p, Integer) or not isinstance(self.q, Integer):
+            raise TypeError("Rational.p and Rational.q must be Integer values")
+        if self.q == Z_ZERO:
+            raise ZeroDivisionError("the denominator cannot be zero")
+
+    def __repr__(self) -> str:
+        return f"<Q({self})>"
+
+    def __str__(self) -> str:
+        return f"{self.p}/{self.q}"
+
+    @log(log_level=21)
+    def __eq__(self, other: object) -> tuple[bool, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(bool, NotImplemented),
+                lambda: f"{self!r} == {other!r} = NotImplemented",
+            )
+        result = self.p * converted.q == self.q * converted.p
+        return (
+            result,
+            lambda: (
+                f"{self!r} == {converted!r} ⇔ "
+                f"{self.p!r} * {converted.q!r} == "
+                f"{self.q!r} * {converted.p!r}"
+            ),
+        )
+
+    @log(log_level=22)
+    def __lt__(self, other: object) -> tuple[bool, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(bool, NotImplemented),
+                lambda: f"{self!r} < {other!r} = NotImplemented",
+            )
+        left = self.p * converted.q
+        right = self.q * converted.p
+        denominators_have_different_signs = (self.q < Z_ZERO) != (converted.q < Z_ZERO)
+        result = left > right if denominators_have_different_signs else left < right
+        operator = ">" if denominators_have_different_signs else "<"
+        return (
+            result,
+            lambda: f"{self!r} < {converted!r} ⇔ {left!r} {operator} {right!r}",
+        )
+
+    @log(log_level=22)
+    def __le__(self, other: object) -> tuple[bool, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(bool, NotImplemented),
+                lambda: f"{self!r} <= {other!r} = NotImplemented",
+            )
+        left = self.p * converted.q
+        right = self.q * converted.p
+        denominators_have_different_signs = (self.q < Z_ZERO) != (converted.q < Z_ZERO)
+        result = left >= right if denominators_have_different_signs else left <= right
+        operator = ">=" if denominators_have_different_signs else "<="
+        return (
+            result,
+            lambda: f"{self!r} <= {converted!r} ⇔ {left!r} {operator} {right!r}",
+        )
+
+    @log(log_level=24)
+    def __add__(self, other: object) -> tuple[Rational, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(Rational, NotImplemented),
+                lambda: f"{self!r} + {other!r} = NotImplemented",
+            )
+        result = Rational(
+            self.p * converted.q + self.q * converted.p,
+            self.q * converted.q,
+        )
+        return (
+            result,
+            lambda: (
+                f"{self!r} + {converted!r} = "
+                f"({self.p!r} * {converted.q!r} + "
+                f"{self.q!r} * {converted.p!r}) / "
+                f"({self.q!r} * {converted.q!r})"
+            ),
+        )
+
+    def __radd__(self, other: object) -> Rational:
+        return self + other
+
+    @log(log_level=24)
+    def __neg__(self) -> tuple[Rational, LogMessage]:
+        result = Rational(-self.p, self.q)
+        return result, lambda: f"-{self!r} = (-{self.p!r}) / {self.q!r}"
+
+    @log(log_level=24)
+    def __sub__(self, other: object) -> tuple[Rational, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(Rational, NotImplemented),
+                lambda: f"{self!r} - {other!r} = NotImplemented",
+            )
+        return (
+            self + -converted,
+            lambda: f"{self!r} - {converted!r} = {self!r} + (-{converted!r})",
+        )
+
+    def __rsub__(self, other: object) -> Rational:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return cast(Rational, NotImplemented)
+        return converted - self
+
+    @log(log_level=25)
+    def __mul__(self, other: object) -> tuple[Rational, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(Rational, NotImplemented),
+                lambda: f"{self!r} * {other!r} = NotImplemented",
+            )
+        result = Rational(self.p * converted.p, self.q * converted.q)
+        return (
+            result,
+            lambda: (
+                f"{self!r} * {converted!r} = "
+                f"({self.p!r} * {converted.p!r}) / "
+                f"({self.q!r} * {converted.q!r})"
+            ),
+        )
+
+    def __rmul__(self, other: object) -> Rational:
+        return self * other
+
+    @log(log_level=25)
+    def __truediv__(self, other: object) -> tuple[Rational, LogMessage]:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return (
+                cast(Rational, NotImplemented),
+                lambda: f"{self!r} / {other!r} = NotImplemented",
+            )
+        if not converted:
+            raise ZeroDivisionError("division by zero")
+        result = Rational(self.p * converted.q, self.q * converted.p)
+        return (
+            result,
+            lambda: (
+                f"{self!r} / {converted!r} = "
+                f"({self.p!r} * {converted.q!r}) / "
+                f"({self.q!r} * {converted.p!r})"
+            ),
+        )
+
+    def __rtruediv__(self, other: object) -> Rational:
+        converted = _coerce_rational(other)
+        if converted is None:
+            return cast(Rational, NotImplemented)
+        return converted / self
+
+    @log(log_level=26)
+    def __pow__(self, exponent: object) -> tuple[Rational, LogMessage]:
+        if not isinstance(exponent, NaturalNumber):
+            return (
+                cast(Rational, NotImplemented),
+                lambda: f"{self!r} ** {exponent!r} = NotImplemented",
+            )
+        if exponent == N_ZERO:
+            return Q_ONE, lambda: f"{self!r} ** {exponent!r} = {Q_ONE!r}"
+        return (
+            (self ** (exponent - N_ONE)) * self,
+            lambda: (
+                f"{self!r} ** {exponent!r} = "
+                f"({self!r} ** ({exponent!r} - {N_ONE!r})) * {self!r}"
+            ),
+        )
+
+    def __bool__(self) -> bool:
+        return self.p != Z_ZERO
+
+    def __hash__(self) -> int:
+        reduced = self.reduction()
+        if reduced.q == Z_ONE:
+            # Equal NaturalNumber and Integer values must share the same hash.
+            return hash(reduced.p)
+        return hash(("Rational", int(reduced.p), int(reduced.q)))
+
+    def __pos__(self) -> Rational:
+        return self
+
+    def __abs__(self) -> Rational:
+        return Rational(Integer(abs(self.p), N_ZERO), Integer(abs(self.q), N_ZERO))
+
+    def as_integer_ratio(self) -> tuple[int, int]:
+        """Return a reduced Python integer ratio with a positive denominator.
+
+        This boundary API avoids constructing equivalent but enormous Peano
+        intermediates when displaying or validating large rational values.
+        """
+
+        from math import gcd
+
+        numerator, denominator = int(self.p), int(self.q)
+        if denominator < 0:
+            numerator, denominator = -numerator, -denominator
+        divisor = gcd(abs(numerator), denominator)
+        return numerator // divisor, denominator // divisor
+
+    def reduction(self) -> Rational:
+        """Return a reduced representative with a positive denominator."""
+
+        numerator = self.p.normalize()
+        denominator = self.q.normalize()
+        if denominator < Z_ZERO:
+            numerator, denominator = -numerator, -denominator
+
+        a, b = abs(numerator), abs(denominator)
+        while b:
+            a, b = b, a % b
+        divisor = Integer(a, N_ZERO)
+        return Rational(numerator // divisor, denominator // divisor)
+
+
+def rational(numerator: int, denominator: int) -> Rational:
+    """Construct a rational number from two Python integers."""
+
+    return Rational(integer(numerator), integer(denominator))
+
+
+def n2r(value: NaturalNumber) -> Rational:
+    """Embed a natural number into the rationals."""
+
+    if not isinstance(value, NaturalNumber):
+        raise TypeError("n2r expects a NaturalNumber")
+    return Rational(n2z(value), Z_ONE)
+
+
+def z2r(value: Integer) -> Rational:
+    """Embed an integer into the rationals."""
+
+    if not isinstance(value, Integer):
+        raise TypeError("z2r expects an Integer")
+    return Rational(value, Z_ONE)
+
+
+def _coerce_rational(value: object) -> Rational | None:
+    if isinstance(value, NaturalNumber):
+        return n2r(value)
+    if isinstance(value, Integer):
+        return z2r(value)
+    if isinstance(value, Rational):
+        return value
+    return None
+
+
+def cast2r(value: object) -> Rational:
+    """Coerce a supported numeric value to ``Rational``."""
+
+    converted = _coerce_rational(value)
+    if converted is None:
+        raise TypeError(f"{value!r} is not a Rational")
+    return converted
+
+
+Q_ZERO = Rational(Z_ZERO, Z_ONE)
+Q_ONE = Rational(Z_ONE, Z_ONE)
+Q_MINUS_ONE = Rational(-Z_ONE, Z_ONE)

peano/utils.py

@@ -0,0 +1,189 @@
+"""Lightweight logging support for observing symbolic evaluation."""
+
+from copy import copy
+from functools import wraps
+from inspect import signature
+from logging import (
+    Filter,
+    Formatter,
+    Logger,
+    LogRecord,
+    NullHandler,
+    StreamHandler,
+    getLogger,
+)
+from typing import Callable, Literal, ParamSpec, TypeVar, get_args, get_origin
+
+logger = getLogger(__name__)
+logger.addHandler(NullHandler())
+logger.propagate = False
+logger.disabled = True
+
+P = ParamSpec("P")
+T = TypeVar("T")
+LogMessage = str | Callable[[], str]
+_PEANO_HANDLER_MARKER = "_peano_handler"
+_LOG_LIMIT_NOTICE = "_peano_log_limit_notice"
+_locale: Literal["en", "ja"] = "en"
+
+
+def localized(english: str, japanese: str) -> str:
+    """Return a localized runtime message."""
+
+    return japanese if _locale == "ja" else english
+
+
+class _LineLimitFormatter(Formatter):
+    """Format a copied record when emitting the truncation notice."""
+
+    def format(self, record: LogRecord) -> str:
+        max_lines = getattr(record, _LOG_LIMIT_NOTICE, None)
+        if not isinstance(max_lines, int):
+            return super().format(record)
+        notice = copy(record)
+        notice.msg = localized(
+            f"…Log output was truncated after {max_lines} lines. "
+            "Use smaller inputs and run the cell again.",
+            f"…ログは{max_lines}行で省略しました。入力を小さくして再実行してください。",
+        )
+        notice.args = ()
+        return super().format(notice)
+
+
+class _LineLimitFilter(Filter):
+    """Emit at most ``max_lines`` messages plus one truncation notice."""
+
+    def __init__(self, max_lines: int | None) -> None:
+        super().__init__(__name__)
+        self.max_lines = max_lines
+        self.emitted_lines = 0
+
+    def filter(self, record: LogRecord) -> bool:
+        if not super().filter(record):
+            return False
+        if self.max_lines is None:
+            return True
+        if self.emitted_lines < self.max_lines:
+            self.emitted_lines += 1
+            return True
+        if self.emitted_lines == self.max_lines:
+            self.emitted_lines += 1
+            setattr(record, _LOG_LIMIT_NOTICE, self.max_lines)
+            return True
+        return False
+
+
+def log(
+    log_level: int,
+) -> Callable[[Callable[P, tuple[T, LogMessage]]], Callable[P, T]]:
+    """Turn an operation returning a result and message into a public operation.
+
+    The implementation returns ``(result, formula)``. Callers receive only
+    ``result`` while ``formula`` is logged at the requested level. Callable
+    messages are evaluated lazily only when logging is enabled.
+    """
+
+    def outer(func: Callable[P, tuple[T, LogMessage]]) -> Callable[P, T]:
+        @wraps(func)
+        def inner(*args: P.args, **kwargs: P.kwargs) -> T:
+            result, message = func(*args, **kwargs)
+            if logger.isEnabledFor(log_level):
+                logger.log(
+                    log_level, message if isinstance(message, str) else message()
+                )
+            return result
+
+        public_return = _public_return_annotation(
+            signature(func, follow_wrapped=False).return_annotation
+        )
+        inner.__annotations__ = {
+            **func.__annotations__,
+            "return": public_return,
+        }
+        setattr(
+            inner,
+            "__signature__",
+            signature(func, follow_wrapped=False).replace(
+                return_annotation=public_return
+            ),
+        )
+        return inner
+
+    return outer
+
+
+def _public_return_annotation(annotation: object) -> object:
+    """Extract the public result type from the internal tuple annotation."""
+
+    if isinstance(annotation, str):
+        prefix = "tuple["
+        for suffix in (", str]", ", LogMessage]"):
+            if annotation.startswith(prefix) and annotation.endswith(suffix):
+                return annotation[len(prefix) : -len(suffix)]
+    elif get_origin(annotation) is tuple:
+        arguments = get_args(annotation)
+        if len(arguments) == 2 and arguments[1] in (str, LogMessage):
+            return arguments[0]
+    raise TypeError("functions decorated with log must return (result, LogMessage)")
+
+
+def _remove_peano_handlers(*loggers: Logger) -> None:
+    """Remove only handlers installed by this module."""
+
+    for target in loggers:
+        for handler in tuple(target.handlers):
+            if getattr(handler, _PEANO_HANDLER_MARKER, False):
+                target.removeHandler(handler)
+                handler.close()
+
+
+def config_log(
+    log_level: int = 0,
+    root: bool = False,
+    fmt: str = "%(message)s",
+    clear_handlers: bool = True,
+    max_lines: int | None = None,
+    locale: Literal["en", "ja"] = "en",
+) -> None:
+    """Write symbolic evaluation logs to standard error.
+
+    By default, only the library logger is configured. ``root=True`` preserves
+    existing root handlers and manages only the handler installed here.
+    ``max_lines`` emits one truncation notice after the limit. Pass
+    ``"Level %(levelno)s: %(message)s"`` as ``fmt`` to expose internal levels.
+    Runtime labels are English by default; ``locale="ja"`` selects Japanese.
+    """
+
+    global _locale
+    if max_lines is not None and (
+        isinstance(max_lines, bool) or not isinstance(max_lines, int) or max_lines < 1
+    ):
+        raise ValueError("max_lines must be a positive integer or None")
+    if locale not in ("en", "ja"):
+        raise ValueError("locale must be 'en' or 'ja'")
+    _locale = locale
+
+    root_logger = getLogger()
+    if clear_handlers:
+        _remove_peano_handlers(logger, root_logger)
+
+    handler = StreamHandler()
+    handler.setFormatter(_LineLimitFormatter(fmt))
+    handler.setLevel(log_level)
+    handler.addFilter(_LineLimitFilter(max_lines))
+    setattr(handler, _PEANO_HANDLER_MARKER, True)
+
+    logger.setLevel(log_level)
+    logger.disabled = False
+    if root:
+        logger.propagate = True
+        root_logger.addHandler(handler)
+    else:
+        logger.propagate = False
+        logger.addHandler(handler)
+
+
+def explain(value: object) -> str:
+    """Render a value consistently inside symbolic log messages."""
+
+    return repr(value)