mathematicskit 0.1.0__py3-none-any.whl

mathkit/abstract_algebra/__init__.py

@@ -0,0 +1,43 @@
+"""mathkit.abstract_algebra: group, ring, and field theory made computational.
+
+Every algorithm here is hand-rolled from its textbook definition --
+finite group/ring/field theory has no ``numpy``/``scipy`` equivalent.
+Cyclic and permutation group implementations with Cayley table
+generation; group-property checks (order, identity, inverses, abelian,
+cyclicity); subgroup and coset enumeration for small groups; finite
+field arithmetic (``GF(p)`` and ``GF(p^n)`` via irreducible polynomials
+over ``GF(p)``); and polynomial ring arithmetic (addition,
+multiplication, division with remainder, gcd) over :math:`\\mathbb{Z}`,
+:math:`\\mathbb{Q}`, and finite fields.
+"""
+
+from mathkit.abstract_algebra.core.base import FiniteGroup, GroupPropertiesResult, Polynomial
+from mathkit.abstract_algebra.systems.finite_fields import GF, find_irreducible_polynomial, is_irreducible
+from mathkit.abstract_algebra.systems.groups import CyclicGroup, PermutationGroup, group_properties
+from mathkit.abstract_algebra.systems.polynomial_ring import poly_add, poly_divmod, poly_gcd, poly_mul, poly_sub
+from mathkit.abstract_algebra.systems.subgroups import all_subgroups, cyclic_subgroup, left_cosets
+from mathkit.abstract_algebra.utils.checks import is_cyclic
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "FiniteGroup",
+    "GroupPropertiesResult",
+    "Polynomial",
+    "CyclicGroup",
+    "PermutationGroup",
+    "group_properties",
+    "is_cyclic",
+    "cyclic_subgroup",
+    "all_subgroups",
+    "left_cosets",
+    "GF",
+    "is_irreducible",
+    "find_irreducible_polynomial",
+    "poly_add",
+    "poly_sub",
+    "poly_mul",
+    "poly_divmod",
+    "poly_gcd",
+]

mathkit/abstract_algebra/core/base.py

@@ -0,0 +1,253 @@
+r"""Abstract base class for finite groups, and a coefficient-generic
+polynomial class, shared across mathkit.abstract_algebra's systems/
+modules.
+
+Every algorithm in this domain is hand-rolled from its textbook
+definition -- group/ring/field theory over finite structures has no
+``numpy``/``scipy`` equivalent at all. See Dummit & Foote, *Abstract
+Algebra*, 3rd ed., throughout.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from fractions import Fraction
+from typing import Optional
+
+import numpy as np
+
+__all__ = ["FiniteGroup", "GroupPropertiesResult", "Polynomial"]
+
+
+class FiniteGroup(ABC):
+    r"""Common interface for a finite group :math:`(G, \cdot)`.
+
+    Concrete subclasses (:class:`~mathkit.abstract_algebra.systems.groups.CyclicGroup`,
+    :class:`~mathkit.abstract_algebra.systems.groups.PermutationGroup`)
+    provide the element set and the group operation; this base class
+    derives the Cayley table, abelian check, and element orders purely
+    from those. See Dummit & Foote, *Abstract Algebra*, 3rd ed., Ch. 1.
+
+    Examples
+    --------
+    >>> from mathkit.abstract_algebra.systems.groups import CyclicGroup
+    >>> g = CyclicGroup(4)
+    >>> g.order
+    4
+    >>> g.is_abelian()
+    True
+    """
+
+    @property
+    @abstractmethod
+    def elements(self) -> list:
+        """list: Every group element, in a fixed (implementation-defined) order."""
+
+    @abstractmethod
+    def identity(self):
+        """The group's identity element."""
+
+    @abstractmethod
+    def operate(self, a, b):
+        """The group operation, :math:`a \\cdot b`."""
+
+    @abstractmethod
+    def inverse(self, a):
+        """The inverse of ``a``."""
+
+    @property
+    def order(self) -> int:
+        """int: :math:`|G|`, the number of elements."""
+        return len(self.elements)
+
+    def cayley_table(self) -> np.ndarray:
+        r"""The Cayley (multiplication) table, as element indices.
+
+        Row ``i``, column ``j`` holds the index (into :attr:`elements`)
+        of ``elements[i] . elements[j]``. See Dummit & Foote, *Abstract
+        Algebra*, 3rd ed., Sec. 1.7.
+
+        Returns
+        -------
+        ndarray, shape (n, n), int
+        """
+        els = self.elements
+        index = {e: i for i, e in enumerate(els)}
+        n = len(els)
+        table = np.zeros((n, n), dtype=np.int64)
+        for i, a in enumerate(els):
+            for j, b in enumerate(els):
+                table[i, j] = index[self.operate(a, b)]
+        return table
+
+    def is_abelian(self) -> bool:
+        """Whether the group operation is commutative for every pair of elements.
+
+        Returns
+        -------
+        bool
+        """
+        els = self.elements
+        return all(self.operate(a, b) == self.operate(b, a) for a in els for b in els)
+
+    def element_order(self, a) -> int:
+        r"""The order of element ``a``: the smallest :math:`k>0` with :math:`a^k = e`.
+
+        Parameters
+        ----------
+        a
+
+        Returns
+        -------
+        int
+        """
+        e = self.identity()
+        x = a
+        k = 1
+        while x != e:
+            x = self.operate(x, a)
+            k += 1
+            if k > self.order:
+                raise RuntimeError("element does not appear to have finite order within |G| steps")
+        return k
+
+
+@dataclass
+class GroupPropertiesResult:
+    """Container for a finite group's summary properties."""
+
+    order: int
+    is_abelian: bool
+    identity: object
+    element_orders: dict = field(default_factory=dict)
+    """dict: ``{element: order}`` for every element."""
+
+
+class Polynomial:
+    r"""A polynomial with coefficients over :math:`\mathbb{Q}` (``modulus=None``,
+    stored as exact :class:`fractions.Fraction`) or :math:`\mathrm{GF}(p)`
+    (``modulus=p``, coefficients reduced mod ``p``).
+
+    Coefficients are stored lowest-degree first: ``coeffs[k]`` is the
+    coefficient of :math:`x^k`. Integer (``Z``) and rational (``Q``)
+    coefficients are both represented exactly as ``Fraction`` (``Z`` is
+    simply the sub-case where every coefficient happens to have
+    denominator 1); this is what makes polynomial *division* with
+    remainder always well-defined (needs the divisor's leading
+    coefficient to be invertible, which holds automatically in a field
+    but not in :math:`\mathbb{Z}` itself). See Dummit & Foote, *Abstract
+    Algebra*, 3rd ed., Ch. 9.
+
+    Parameters
+    ----------
+    coeffs : sequence
+        Coefficients, lowest degree first.
+    modulus : int, optional
+        A prime ``p``, for coefficients in :math:`\mathrm{GF}(p)`;
+        ``None`` (the default) for :math:`\mathbb{Q}` coefficients.
+
+    Examples
+    --------
+    >>> p = Polynomial([1, 2, 1])  # 1 + 2x + x^2 = (1+x)^2
+    >>> q = Polynomial([1, 1])  # 1 + x
+    >>> quotient, remainder = divmod(p, q)
+    >>> quotient.coeffs, remainder.coeffs
+    ([Fraction(1, 1), Fraction(1, 1)], [Fraction(0, 1)])
+    """
+
+    def __init__(self, coeffs, modulus: Optional[int] = None):
+        self.modulus = modulus
+        if modulus is None:
+            raw = [Fraction(c) for c in coeffs]
+        else:
+            raw = [int(c) % modulus for c in coeffs]
+        self.coeffs = self._trim(raw)
+
+    def _trim(self, coeffs: list) -> list:
+        coeffs = list(coeffs)
+        zero = Fraction(0) if self.modulus is None else 0
+        while len(coeffs) > 1 and coeffs[-1] == zero:
+            coeffs.pop()
+        if not coeffs:
+            coeffs = [zero]
+        return coeffs
+
+    def _reduce(self, c):
+        return c if self.modulus is None else c % self.modulus
+
+    def _wrap(self, coeffs: list) -> Polynomial:
+        result = Polynomial.__new__(Polynomial)
+        result.modulus = self.modulus
+        result.coeffs = result._trim(coeffs)
+        return result
+
+    @property
+    def degree(self) -> int:
+        """int: The polynomial's degree (``-1`` for the zero polynomial, by convention)."""
+        if len(self.coeffs) == 1 and self.coeffs[0] == (Fraction(0) if self.modulus is None else 0):
+            return -1
+        return len(self.coeffs) - 1
+
+    def _pad(self, n: int) -> list:
+        zero = Fraction(0) if self.modulus is None else 0
+        return self.coeffs + [zero] * (n - len(self.coeffs))
+
+    def __add__(self, other: Polynomial) -> Polynomial:
+        n = max(len(self.coeffs), len(other.coeffs))
+        return self._wrap([self._reduce(a + b) for a, b in zip(self._pad(n), other._pad(n))])
+
+    def __sub__(self, other: Polynomial) -> Polynomial:
+        n = max(len(self.coeffs), len(other.coeffs))
+        return self._wrap([self._reduce(a - b) for a, b in zip(self._pad(n), other._pad(n))])
+
+    def __mul__(self, other: Polynomial) -> Polynomial:
+        result = [Fraction(0) if self.modulus is None else 0] * (len(self.coeffs) + len(other.coeffs) - 1)
+        for i, a in enumerate(self.coeffs):
+            for j, b in enumerate(other.coeffs):
+                result[i + j] = self._reduce(result[i + j] + a * b)
+        return self._wrap(result)
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, Polynomial) and self.modulus == other.modulus and self.coeffs == other.coeffs
+
+    def __hash__(self) -> int:
+        return hash((self.modulus, tuple(self.coeffs)))
+
+    def __divmod__(self, other: Polynomial):
+        r"""Polynomial long division: ``self = quotient * other + remainder``, ``deg(remainder) < deg(other)``."""
+        if other.degree == -1:
+            raise ZeroDivisionError("division by the zero polynomial")
+        remainder = self._wrap(list(self.coeffs))
+        quotient_degree = max(self.degree - other.degree, -1)
+        zero = Fraction(0) if self.modulus is None else 0
+        quotient_coeffs = [zero] * (quotient_degree + 1) if quotient_degree >= 0 else [zero]
+        lead_other = other.coeffs[other.degree]
+        lead_inv = (1 / lead_other) if self.modulus is None else pow(int(lead_other), self.modulus - 2, self.modulus)
+        while remainder.degree >= other.degree and remainder.degree >= 0:
+            shift = remainder.degree - other.degree
+            factor = self._reduce(remainder.coeffs[remainder.degree] * lead_inv)
+            quotient_coeffs[shift] = self._reduce(quotient_coeffs[shift] + factor)
+            subtrahend_coeffs = [zero] * shift + [self._reduce(factor * c) for c in other.coeffs]
+            remainder = remainder - self._wrap(subtrahend_coeffs)
+        return self._wrap(quotient_coeffs), remainder
+
+    def evaluate(self, x):
+        """Evaluate the polynomial at ``x``, via Horner's method.
+
+        Parameters
+        ----------
+        x
+
+        Returns
+        -------
+        The same type as the polynomial's coefficients.
+        """
+        result = Fraction(0) if self.modulus is None else 0
+        for c in reversed(self.coeffs):
+            result = self._reduce(result * x + c)
+        return result
+
+    def __repr__(self) -> str:
+        terms = [f"{c}*x^{k}" for k, c in enumerate(self.coeffs) if c != (Fraction(0) if self.modulus is None else 0)]
+        return " + ".join(terms) if terms else "0"

mathkit/abstract_algebra/systems/__init__.py

@@ -0,0 +1,23 @@
+"""Concrete group, ring, and field algorithms."""
+
+from mathkit.abstract_algebra.systems.finite_fields import GF, find_irreducible_polynomial, is_irreducible
+from mathkit.abstract_algebra.systems.groups import CyclicGroup, PermutationGroup, group_properties
+from mathkit.abstract_algebra.systems.polynomial_ring import poly_add, poly_divmod, poly_gcd, poly_mul, poly_sub
+from mathkit.abstract_algebra.systems.subgroups import all_subgroups, cyclic_subgroup, left_cosets
+
+__all__ = [
+    "CyclicGroup",
+    "PermutationGroup",
+    "group_properties",
+    "cyclic_subgroup",
+    "all_subgroups",
+    "left_cosets",
+    "GF",
+    "is_irreducible",
+    "find_irreducible_polynomial",
+    "poly_add",
+    "poly_sub",
+    "poly_mul",
+    "poly_divmod",
+    "poly_gcd",
+]

mathkit/abstract_algebra/systems/finite_fields.py

@@ -0,0 +1,201 @@
+r"""Finite field arithmetic: :math:`\mathrm{GF}(p)` and
+:math:`\mathrm{GF}(p^n)` via irreducible polynomials over :math:`\mathrm{GF}(p)`.
+
+No numpy/scipy equivalent. See Dummit & Foote, *Abstract Algebra*, 3rd
+ed., Sec. 13.5 (finite fields) and Lidl & Niederreiter, *Introduction to
+Finite Fields and Their Applications*, Ch. 2-3.
+"""
+
+from __future__ import annotations
+
+import itertools
+from typing import Optional
+
+from mathkit.abstract_algebra.core.base import Polynomial
+
+__all__ = ["GF", "is_irreducible", "find_irreducible_polynomial"]
+
+
+def is_irreducible(poly: Polynomial) -> bool:
+    r"""Whether `poly` is irreducible over :math:`\mathrm{GF}(p)`: has no polynomial factor of degree :math:`1 \leq d \leq \deg(\text{poly})/2`.
+
+    Checked by trial division against every monic polynomial of degree
+    ``1`` through ``deg(poly) // 2`` (degree-1 divisors are equivalent
+    to checking for a root in :math:`\mathrm{GF}(p)`). Feasible for the
+    small ``p``, small degree cases this domain's examples use. See
+    Lidl & Niederreiter, *Introduction to Finite Fields*, Sec. 3.1.
+
+    Parameters
+    ----------
+    poly : Polynomial
+        With ``modulus`` set (coefficients in :math:`\mathrm{GF}(p)`).
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> is_irreducible(Polynomial([1, 1, 1], modulus=2))  # x^2+x+1 over GF(2)
+    True
+    >>> is_irreducible(Polynomial([0, 1, 1], modulus=2))  # x^2+x = x(x+1): reducible
+    False
+    """
+    p = poly.modulus
+    n = poly.degree
+    if n <= 1:
+        return True
+    for d in range(1, n // 2 + 1):
+        for candidate_coeffs in _monic_polynomials_of_degree(p, d):
+            candidate = Polynomial(candidate_coeffs, modulus=p)
+            _, remainder = divmod(poly, candidate)
+            if remainder.degree == -1:
+                return False
+    return True
+
+
+def _monic_polynomials_of_degree(p: int, d: int):
+    """Every monic polynomial of degree `d` over GF(p), lowest coefficient first."""
+    if d == 0:
+        yield [1]
+        return
+    for lower_coeffs in itertools.product(range(p), repeat=d):
+        yield list(lower_coeffs) + [1]
+
+
+def find_irreducible_polynomial(p: int, n: int) -> Polynomial:
+    r"""Find a monic irreducible polynomial of degree ``n`` over :math:`\mathrm{GF}(p)`, by brute-force search.
+
+    An irreducible polynomial of every degree exists over every finite
+    field (Dummit & Foote, *Abstract Algebra*, 3rd ed., Corollary 13.24
+    -- via counting arguments), so this search always terminates. See
+    Lidl & Niederreiter, *Introduction to Finite Fields*, Sec. 3.1-3.3.
+
+    Parameters
+    ----------
+    p : int
+        Prime.
+    n : int
+        Degree, ``n >= 1``.
+
+    Returns
+    -------
+    Polynomial
+
+    Examples
+    --------
+    >>> poly = find_irreducible_polynomial(2, 3)
+    >>> poly.degree
+    3
+    >>> is_irreducible(poly)
+    True
+    """
+    if n == 1:
+        return Polynomial([0, 1], modulus=p)
+    for coeffs in _monic_polynomials_of_degree(p, n):
+        candidate = Polynomial(coeffs, modulus=p)
+        if is_irreducible(candidate):
+            return candidate
+    raise RuntimeError(f"no irreducible polynomial of degree {n} found over GF({p})")
+
+
+class GF:
+    r"""The finite field :math:`\mathrm{GF}(p^n)`.
+
+    ``n=1`` (the default) is the prime field :math:`\mathrm{GF}(p) =
+    \mathbb{Z}/p\mathbb{Z}`, with elements plain integers ``0, ..., p-1``.
+    ``n>1`` represents elements as polynomials of degree ``< n`` over
+    :math:`\mathrm{GF}(p)`, with multiplication reduced modulo a fixed
+    irreducible polynomial (found via :func:`find_irreducible_polynomial`
+    if not supplied) -- :math:`\mathrm{GF}(p)[x]/(f(x))` is a field
+    exactly when ``f`` is irreducible. See Dummit & Foote, *Abstract
+    Algebra*, 3rd ed., Sec. 13.5.
+
+    Parameters
+    ----------
+    p : int
+        Prime.
+    n : int
+        Extension degree, ``n >= 1``.
+    irreducible : Polynomial, optional
+        A degree-``n`` irreducible polynomial over :math:`\mathrm{GF}(p)`;
+        found automatically if omitted.
+
+    Examples
+    --------
+    >>> field = GF(2, 3)  # GF(8)
+    >>> field.order
+    8
+    >>> a = Polynomial([1, 1, 0], modulus=2)  # 1 + x
+    >>> b = Polynomial([0, 1, 1], modulus=2)  # x + x^2
+    >>> field.multiply(a, b).degree <= 2  # result stays reduced mod the irreducible polynomial
+    True
+    """
+
+    def __init__(self, p: int, n: int = 1, irreducible: Optional[Polynomial] = None):
+        self.p = int(p)
+        self.n = int(n)
+        self.irreducible = irreducible if irreducible is not None else (find_irreducible_polynomial(p, n) if n > 1 else None)
+
+    @property
+    def order(self) -> int:
+        """int: :math:`|\\mathrm{GF}(p^n)| = p^n`."""
+        return self.p**self.n
+
+    def elements(self) -> list:
+        """Every field element.
+
+        Returns
+        -------
+        list of int (if ``n == 1``) or list of Polynomial (if ``n > 1``)
+        """
+        if self.n == 1:
+            return list(range(self.p))
+        return [Polynomial(list(coeffs), modulus=self.p) for coeffs in itertools.product(range(self.p), repeat=self.n)]
+
+    def add(self, a, b):
+        """Field addition."""
+        if self.n == 1:
+            return (a + b) % self.p
+        return a + b
+
+    def multiply(self, a, b):
+        """Field multiplication, reduced modulo the extension's irreducible polynomial when ``n > 1``."""
+        if self.n == 1:
+            return (a * b) % self.p
+        product = a * b
+        _, remainder = divmod(product, self.irreducible)
+        return remainder
+
+    def inverse(self, a):
+        r"""Multiplicative inverse of a nonzero element.
+
+        ``n == 1``: via Fermat's little theorem, :math:`a^{-1} \equiv
+        a^{p-2} \pmod p`. ``n > 1``: via the polynomial extended
+        Euclidean algorithm (finding :math:`u, v` with :math:`ua +
+        v \cdot \text{irreducible} = \gcd = 1`).
+        """
+        if self.n == 1:
+            if a % self.p == 0:
+                raise ZeroDivisionError("0 has no multiplicative inverse")
+            return pow(a, self.p - 2, self.p)
+        if a.degree == -1:
+            raise ZeroDivisionError("0 has no multiplicative inverse")
+        return _poly_extended_gcd_inverse(a, self.irreducible, self.p)
+
+
+def _poly_extended_gcd_inverse(a: Polynomial, modulus_poly: Polynomial, p: int) -> Polynomial:
+    """Find a's inverse mod modulus_poly via the polynomial extended Euclidean algorithm."""
+    zero = Polynomial([0], modulus=p)
+    one = Polynomial([1], modulus=p)
+    old_r, r = a, modulus_poly
+    old_s, s = one, zero
+    while r.degree != -1:
+        q, remainder = divmod(old_r, r)
+        old_r, r = r, remainder
+        old_s, s = s, old_s - q * s
+    # old_r is now gcd(a, modulus_poly), which must be a nonzero constant
+    # since modulus_poly is irreducible; normalize to exactly 1.
+    lead = old_r.coeffs[old_r.degree]
+    lead_inv = pow(int(lead), p - 2, p)
+    return Polynomial([c * lead_inv for c in old_s.coeffs], modulus=p)

mathkit/abstract_algebra/systems/groups.py

@@ -0,0 +1,162 @@
+r"""Cyclic and permutation groups, with Cayley table generation and
+group-property checks (order, identity, inverses, abelian).
+
+Every construction here is hand-rolled from the textbook definitions --
+finite group theory has no ``numpy``/``scipy`` equivalent. See Dummit &
+Foote, *Abstract Algebra*, 3rd ed., Ch. 1-4.
+"""
+
+from __future__ import annotations
+
+from mathkit.abstract_algebra.core.base import FiniteGroup, GroupPropertiesResult
+
+__all__ = ["CyclicGroup", "PermutationGroup", "group_properties"]
+
+
+class CyclicGroup(FiniteGroup):
+    r"""The cyclic group :math:`\mathbb{Z}_n = \{0, 1, \dots, n-1\}` under addition mod ``n``.
+
+    Generated by a single element (e.g. ``1``); every finite cyclic
+    group of order ``n`` is isomorphic to this one. See Dummit & Foote,
+    *Abstract Algebra*, 3rd ed., Sec. 1.3, 2.3.
+
+    Parameters
+    ----------
+    n : int
+        Group order, ``n >= 1``.
+
+    Examples
+    --------
+    >>> g = CyclicGroup(5)
+    >>> g.operate(3, 4)
+    2
+    >>> g.inverse(3)
+    2
+    >>> g.is_abelian()
+    True
+    """
+
+    def __init__(self, n: int):
+        if n < 1:
+            raise ValueError("n must be >= 1")
+        self.n = int(n)
+
+    @property
+    def elements(self) -> list:
+        return list(range(self.n))
+
+    def identity(self) -> int:
+        return 0
+
+    def operate(self, a: int, b: int) -> int:
+        return (a + b) % self.n
+
+    def inverse(self, a: int) -> int:
+        return (-a) % self.n
+
+
+class PermutationGroup(FiniteGroup):
+    r"""The group generated by a set of permutations, under composition.
+
+    Elements are tuples ``p`` with ``p[i]`` = the image of ``i`` under
+    the permutation; the full element set is found by closing the
+    generators under composition (a breadth-first search from the
+    identity). ``generators=None`` builds the full symmetric group
+    :math:`S_n` (generated by an adjacent transposition and the full
+    n-cycle). See Dummit & Foote, *Abstract Algebra*, 3rd ed., Sec. 1.3,
+    1.6.
+
+    Parameters
+    ----------
+    degree : int
+        The permutations act on ``{0, ..., degree - 1}``.
+    generators : list of tuple, optional
+        Generating permutations; defaults to generators of the full
+        symmetric group :math:`S_{\text{degree}}`.
+
+    Examples
+    --------
+    >>> # S_3, the symmetric group on 3 elements: order 6, non-abelian.
+    >>> g = PermutationGroup(3)
+    >>> g.order
+    6
+    >>> g.is_abelian()
+    False
+    >>> # A cyclic subgroup: generated by the 3-cycle (0 1 2).
+    >>> g3 = PermutationGroup(3, generators=[(1, 2, 0)])
+    >>> g3.order
+    3
+    """
+
+    def __init__(self, degree: int, generators=None):
+        self.degree = int(degree)
+        if generators is None:
+            if self.degree < 2:
+                generators = [tuple(range(self.degree))]
+            else:
+                transposition = list(range(self.degree))
+                transposition[0], transposition[1] = transposition[1], transposition[0]
+                cycle = list(range(1, self.degree)) + [0]
+                generators = [tuple(transposition), tuple(cycle)]
+        self.generators = [tuple(g) for g in generators]
+        self._elements = self._generate_closure()
+
+    def _compose(self, p, q) -> tuple:
+        """(p . q)(i) = p(q(i)): apply q first, then p."""
+        return tuple(p[q[i]] for i in range(self.degree))
+
+    def _generate_closure(self) -> list:
+        identity = tuple(range(self.degree))
+        elements = {identity}
+        frontier = [identity]
+        while frontier:
+            new_frontier = []
+            for elem in frontier:
+                for g in self.generators:
+                    composed = self._compose(elem, g)
+                    if composed not in elements:
+                        elements.add(composed)
+                        new_frontier.append(composed)
+            frontier = new_frontier
+        return sorted(elements)
+
+    @property
+    def elements(self) -> list:
+        return self._elements
+
+    def identity(self) -> tuple:
+        return tuple(range(self.degree))
+
+    def operate(self, a: tuple, b: tuple) -> tuple:
+        return self._compose(a, b)
+
+    def inverse(self, a: tuple) -> tuple:
+        inv = [0] * self.degree
+        for i, v in enumerate(a):
+            inv[v] = i
+        return tuple(inv)
+
+
+def group_properties(group: FiniteGroup) -> GroupPropertiesResult:
+    """Summarize a finite group's order, abelian-ness, and every element's order.
+
+    Parameters
+    ----------
+    group : FiniteGroup
+
+    Returns
+    -------
+    GroupPropertiesResult
+
+    Examples
+    --------
+    >>> result = group_properties(CyclicGroup(4))
+    >>> result.order
+    4
+    >>> result.is_abelian
+    True
+    >>> result.element_orders
+    {0: 1, 1: 4, 2: 2, 3: 4}
+    """
+    orders = {e: group.element_order(e) for e in group.elements}
+    return GroupPropertiesResult(order=group.order, is_abelian=group.is_abelian(), identity=group.identity(), element_orders=orders)