sofic 0.1.0__py3-none-any.whl

sofic/automata/idfa.py

@@ -0,0 +1,363 @@
+"""Enumeration of incomplete accessible DFA structures (IDFA∅).
+
+Extends the complete ICDFA string representation of Almeida, Moreira, and Reis
+(2007) with ``-1`` for missing transitions, following the accessible-DFA
+generation and rank function ``B¹_{n,k}`` used by Johnson et al. (2010),
+*Enumerating Finitary Processes* (arXiv:1011.0036).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from functools import cache
+
+from sofic.automata.icdfa import (
+    _upper_bound_at,
+    _validate_flags,
+    next_flags,
+)
+from sofic.exceptions import SoficValidationError
+
+__all__ = [
+    "MISSING_TRANSITION",
+    "count_accessible_idfa",
+    "count_idfa_strings_for_flags",
+    "extended_flags",
+    "first_idfa_string",
+    "idfa_string_to_topological_graph",
+    "iter_idfa_strings",
+    "last_idfa_string",
+    "next_idfa_string",
+    "rank_idfa_string",
+    "transition_count",
+    "unrank_idfa_string",
+    "validate_idfa_string",
+]
+
+MISSING_TRANSITION = -1
+
+
+class IDFAEnumerationError(SoficValidationError):
+    """Raised when incomplete accessible DFA enumeration fails."""
+
+
+def extended_flags(flags: Sequence[int], *, n: int, k: int) -> tuple[int, ...]:
+    """Return ``(f_0, …, f_n)`` with ``f_0 = -1`` and ``f_n = nk``."""
+    return (MISSING_TRANSITION,) + tuple(flags) + (n * k,)
+
+
+def validate_idfa_string(
+    transitions: Sequence[int],
+    *,
+    n: int,
+    k: int,
+) -> None:
+    """Validate an incomplete accessible DFA string (rules R1 and R2)."""
+    length = k * n
+    if len(transitions) != length:
+        raise IDFAEnumerationError(f"expected length {length}, got {len(transitions)}")
+    for value in transitions:
+        if value != MISSING_TRANSITION and not 0 <= value < n:
+            raise IDFAEnumerationError(f"transition value {value!r} not in [-1, {n - 1}]")
+
+    for index, value in enumerate(transitions):
+        if value == MISSING_TRANSITION or value <= 1:
+            continue
+        if not any(transitions[j] == value - 1 for j in range(index) if transitions[j] != MISSING_TRANSITION):
+            raise IDFAEnumerationError(f"state {value} at index {index} appears before state {value - 1}")
+
+    for state in range(1, n):
+        if state not in transitions[: k * state]:
+            raise IDFAEnumerationError(f"state {state} does not appear in the first {k * state} symbols")
+
+
+def transition_count(transitions: Sequence[int]) -> int:
+    """Return the number of defined transitions in ``transitions``."""
+    return sum(1 for value in transitions if value != MISSING_TRANSITION)
+
+
+def string_from_flags(
+    flags: Sequence[int],
+    *,
+    n: int,
+    k: int,
+    filler: int = MISSING_TRANSITION,
+) -> tuple[int, ...]:
+    """Build the first IDFA∅ string for a valid flag sequence."""
+    _validate_flags(flags, n=n, k=k)
+    transitions = [filler] * (k * n)
+    for state, flag in enumerate(flags, start=1):
+        transitions[flag] = state
+    for index in range(flags[0]):
+        transitions[index] = 0
+    return tuple(transitions)
+
+
+def first_idfa_string(*, n: int, k: int) -> tuple[int, ...]:
+    """Return the first incomplete accessible DFA string in generation order."""
+    if n == 1:
+        return (MISSING_TRANSITION,) * k
+    flags = tuple(k * state - 1 for state in range(1, n))
+    return string_from_flags(flags, n=n, k=k)
+
+
+def last_idfa_string(*, n: int, k: int) -> tuple[int, ...]:
+    """Return the last incomplete accessible DFA string for the last flag sequence."""
+    if n == 1:
+        return (n - 1,) * k
+    flags = list(range(n - 1))
+    transitions = list(string_from_flags(flags, n=n, k=k))
+    flag_set = set(flags)
+    for index in range(k * n):
+        if index in flag_set:
+            continue
+        transitions[index] = _upper_bound_at(index, transitions, flags)
+    return tuple(transitions)
+
+
+def _is_last_idfa_string(
+    transitions: Sequence[int],
+    flags: Sequence[int],
+    *,
+    n: int,
+) -> bool:
+    for index, value in enumerate(transitions):
+        if index in flags:
+            continue
+        if value < _upper_bound_at(index, transitions, flags):
+            return False
+    return True
+
+
+def _advance_idfa_value(current: int, upper: int) -> tuple[int, bool]:
+    """Advance one position; return ``(new_value, carry)``."""
+    if current < upper:
+        if current == MISSING_TRANSITION and upper < 0:
+            return MISSING_TRANSITION, True
+        if current == MISSING_TRANSITION:
+            return 0, False
+        return current + 1, False
+    if current == upper:
+        return MISSING_TRANSITION, True
+    raise IDFAEnumerationError(f"invalid transition value {current!r} with upper bound {upper}")
+
+
+def next_idfa_string(
+    transitions: list[int],
+    flags: Sequence[int],
+    *,
+    n: int,
+    k: int,
+) -> None:
+    """Advance ``transitions`` in-place to the next string for fixed ``flags``."""
+    if _is_last_idfa_string(transitions, flags, n=n):
+        raise StopIteration
+
+    flag_set = set(flags)
+
+    def nextidfa(state: int, symbol: int) -> None:
+        index = state * k + symbol
+        while index in flag_set:
+            for tail in range(index + 1, k * n):
+                if tail not in flag_set:
+                    transitions[tail] = MISSING_TRANSITION
+            symbol -= 1
+            if symbol < 0:
+                if state == 0:
+                    raise IDFAEnumerationError("cannot advance past first IDFA string for flags")
+                nextidfa(state - 1, k - 1)
+                return
+            index -= 1
+
+        upper = _upper_bound_at(index, transitions, flags)
+        new_value, carry = _advance_idfa_value(transitions[index], upper)
+        transitions[index] = new_value
+        if carry:
+            if symbol == 0:
+                if state == 0:
+                    raise IDFAEnumerationError("cannot advance past first IDFA string for flags")
+                nextidfa(state - 1, k - 1)
+            else:
+                nextidfa(state, symbol - 1)
+
+    nextidfa(n - 1, k - 1)
+
+
+def count_idfa_strings_for_flags(flags: Sequence[int], *, n: int, k: int) -> int:
+    """Return the number of IDFA∅ strings with the given flag sequence."""
+    ext = extended_flags(flags, n=n, k=k)
+    product = 1
+    for segment_index in range(n):
+        segment = ext[segment_index + 1] - ext[segment_index] - 1
+        if segment == 0:
+            continue
+        if segment_index == 0:
+            continue
+        product *= (segment_index + 2) ** segment
+    return product
+
+
+def count_accessible_idfa(k: int, n: int) -> int:
+    """Return ``B¹_{k,n}``, the number of incomplete accessible DFA∅ structures."""
+    if n == 1:
+        return 2**k
+
+    total = 0
+
+    def visit(prefix: list[int]) -> None:
+        nonlocal total
+        depth = len(prefix)
+        if depth == n - 1:
+            total += count_idfa_strings_for_flags(prefix, n=n, k=k)
+            return
+
+        lower = 0 if depth == 0 else prefix[-1] + 1
+        upper = k * (depth + 1)
+        for value in range(lower, upper):
+            prefix.append(value)
+            visit(prefix)
+            prefix.pop()
+
+    visit([])
+    return total
+
+
+@cache
+def _enumeration_index(k: int, n: int) -> dict[tuple[int, ...], int]:
+    return {candidate: rank for rank, candidate in enumerate(_iter_idfa_strings_impl(k, n))}
+
+
+def rank_idfa_string(transitions: Sequence[int], *, n: int, k: int) -> int:
+    """Return ``B¹_{n,k}(S)``, the rank of ``transitions`` in generation order."""
+    validate_idfa_string(transitions, n=n, k=k)
+    try:
+        return _enumeration_index(k, n)[tuple(transitions)]
+    except KeyError as exc:
+        raise IDFAEnumerationError("string is not in the accessible DFA enumeration") from exc
+
+
+def unrank_idfa_string(rank: int, *, n: int, k: int) -> tuple[int, ...]:
+    """Return the IDFA∅ string with rank ``rank`` in ``[0, B¹_{n,k})``."""
+    if rank < 0:
+        raise IDFAEnumerationError("rank must be nonnegative")
+    if n == 1:
+        if rank >= 2**k:
+            raise IDFAEnumerationError("rank out of range")
+        transitions: list[int] = []
+        for index in range(k):
+            mask = 2 ** (k - 1 - index)
+            transitions.append(0 if rank & mask else MISSING_TRANSITION)
+        return tuple(transitions)
+    for index, candidate in enumerate(_iter_idfa_strings_impl(k, n)):
+        if index == rank:
+            return candidate
+    raise IDFAEnumerationError("rank out of range")
+
+
+def _iter_idfa_strings_impl(k: int, n: int) -> Iterator[tuple[int, ...]]:
+    if n == 1:
+        for rank in range(2**k):
+            yield unrank_idfa_string(rank, n=n, k=k)
+        return
+
+    flags = [k * state - 1 for state in range(1, n)]
+    transitions = list(string_from_flags(flags, n=n, k=k))
+    while True:
+        yield tuple(transitions)
+        try:
+            next_idfa_string(transitions, flags, n=n, k=k)
+        except StopIteration:
+            try:
+                next_flags(flags, k=k)
+            except StopIteration:
+                break
+            transitions[:] = list(string_from_flags(flags, n=n, k=k))
+
+
+def iter_idfa_strings(k: int, n: int) -> Iterator[tuple[int, ...]]:
+    """Yield all incomplete accessible DFA∅ strings in generation order."""
+    yield from _iter_idfa_strings_impl(k, n)
+
+
+def idfa_string_to_topological_graph(
+    transitions: Sequence[int],
+    *,
+    n: int,
+    k: int,
+    alphabet: Sequence[object] | None = None,
+):
+    """Decode an IDFA string into a :class:`~sofic.generators.synchronization.TopologicalUnifilarGraph`."""
+    from sofic.generators.synchronization import TopologicalUnifilarGraph
+
+    validate_idfa_string(transitions, n=n, k=k)
+    if alphabet is None:
+        symbols = tuple(range(k))
+    else:
+        if len(alphabet) != k:
+            raise IDFAEnumerationError("alphabet length must equal k")
+        symbols = tuple(alphabet)
+
+    states = frozenset(range(n))
+    edges: dict[tuple[int, object], int] = {}
+    for index, target in enumerate(transitions):
+        if target == MISSING_TRANSITION:
+            continue
+        source = index // k
+        symbol = symbols[index % k]
+        edges[(source, symbol)] = target
+    return TopologicalUnifilarGraph(states=states, alphabet=frozenset(symbols), transitions=edges)
+
+
+def _delta_table(transitions: Sequence[int], *, n: int, k: int) -> list[list[int | None]]:
+    table: list[list[int | None]] = [[None] * k for _ in range(n)]
+    for index, target in enumerate(transitions):
+        if target == MISSING_TRANSITION:
+            continue
+        table[index // k][index % k] = target
+    return table
+
+
+def reroot_idfa_string(
+    transitions: Sequence[int],
+    *,
+    new_root: int,
+    n: int,
+    k: int,
+) -> tuple[int, ...] | None:
+    """Relabel with ``new_root`` as state ``0``; return ``None`` if labeling fails."""
+    validate_idfa_string(transitions, n=n, k=k)
+    table = _delta_table(transitions, n=n, k=k)
+    old_to_new: dict[int, int] = {new_root: 0}
+    new_to_old: list[int] = [new_root]
+    next_label = 1
+
+    while True:
+        progressed = False
+        for new_source in range(len(new_to_old)):
+            old_source = new_to_old[new_source]
+            for symbol in range(k):
+                target = table[old_source][symbol]
+                if target is None or target in old_to_new:
+                    continue
+                old_to_new[target] = next_label
+                new_to_old.append(target)
+                next_label += 1
+                progressed = True
+        if not progressed:
+            break
+
+    if len(new_to_old) != n:
+        return None
+
+    rebuilt = [MISSING_TRANSITION] * (k * n)
+    for new_source, old_source in enumerate(new_to_old):
+        for symbol in range(k):
+            target = table[old_source][symbol]
+            if target is None:
+                continue
+            rebuilt[new_source * k + symbol] = old_to_new[target]
+    try:
+        validate_idfa_string(rebuilt, n=n, k=k)
+    except IDFAEnumerationError:
+        return None
+    return tuple(rebuilt)

sofic/automata/languages/__init__.py

@@ -0,0 +1,39 @@
+"""Regular-language algebra for automata constructions."""
+
+from sofic.automata.languages.atoms import atoms, is_prime_atom, prime_atoms
+from sofic.automata.languages.base import AutomatonLanguage, ExplicitLanguage, RegularLanguage
+from sofic.automata.languages.operations import (
+    complement,
+    concat,
+    difference,
+    intersection,
+    kleene_star,
+    product,
+    reverse,
+    union,
+)
+from sofic.automata.languages.quotients import left_quotient, left_quotients, residuals, right_quotient
+from sofic.automata.languages.residuals import is_composed_residual, prime_residuals
+
+__all__ = [
+    "AutomatonLanguage",
+    "ExplicitLanguage",
+    "RegularLanguage",
+    "atoms",
+    "complement",
+    "concat",
+    "difference",
+    "intersection",
+    "is_composed_residual",
+    "is_prime_atom",
+    "kleene_star",
+    "left_quotient",
+    "left_quotients",
+    "prime_atoms",
+    "prime_residuals",
+    "product",
+    "residuals",
+    "reverse",
+    "right_quotient",
+    "union",
+]

sofic/automata/languages/_quotient_utils.py

@@ -0,0 +1,64 @@
+"""Shared helpers for quotient and atom computations."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from sofic.automata.languages.automaton_ops import minimal_dfa_from_language
+from sofic.automata.languages.base import AutomatonLanguage, ExplicitLanguage, RegularLanguage, as_language
+
+
+def _words_up_to(length: int, alphabet: frozenset[Any]) -> list[tuple[Any, ...]]:
+    if length < 0:
+        return []
+    if length == 0:
+        return [()]
+    shorter = _words_up_to(length - 1, alphabet)
+    return [word + (symbol,) for word in shorter for symbol in alphabet]
+
+
+def _languages_equal(left: RegularLanguage, right: RegularLanguage, alphabet: frozenset[Any], max_len: int = 6) -> bool:
+    for length in range(max_len + 1):
+        for word in _words_up_to(length, alphabet):
+            if (word in left) != (word in right):
+                return False
+    return True
+
+
+def _residual_from_state(aut: AutomatonLanguage, state) -> AutomatonLanguage:
+    sub = aut.automaton.copy()
+    sub.initial_states = frozenset({state})
+    return AutomatonLanguage(minimal_dfa_from_language(sub))
+
+
+def _alphabet_of(language: RegularLanguage) -> frozenset[Any]:
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, ExplicitLanguage):
+        return lang.alphabet
+    if isinstance(lang, AutomatonLanguage):
+        return lang.automaton.input_alphabet
+    return frozenset()
+
+
+def _suffixes_if_prefix(word: tuple[Any, ...], prefix: Sequence[Any]) -> set[tuple[Any, ...]]:
+    p = tuple(prefix)
+    if word[: len(p)] == p:
+        return {word[len(p) :]}
+    return set()
+
+
+def _prefixes_if_suffix(word: tuple[Any, ...], suffix: Sequence[Any]) -> set[tuple[Any, ...]]:
+    s = tuple(suffix)
+    if len(word) >= len(s) and word[-len(s) :] == s:
+        return {word[: len(word) - len(s)]}
+    return set()
+
+
+def _is_union_of_others(target: ExplicitLanguage, others: list[ExplicitLanguage]) -> bool:
+    union_pos: set[tuple] = set()
+    union_neg: set[tuple] = set()
+    for lang in others:
+        union_pos |= lang._positive
+        union_neg |= lang._negative
+    return target._positive == union_pos and target._negative == union_neg

sofic/automata/languages/atoms.py

@@ -0,0 +1,31 @@
+"""Atoms and prime atoms of regular languages."""
+
+from __future__ import annotations
+
+from sofic.automata.languages._quotient_utils import _alphabet_of, _languages_equal, _residual_from_state
+from sofic.automata.languages.automaton_ops import minimal_dfa_from_language
+from sofic.automata.languages.base import AutomatonLanguage, RegularLanguage, as_language
+from sofic.automata.languages.quotients import left_quotients
+
+
+def atoms(language: RegularLanguage) -> frozenset[RegularLanguage]:
+    lang = as_language(language)  # type: ignore[arg-type]
+    result: set[RegularLanguage] = set(left_quotients(language))
+    if isinstance(lang, AutomatonLanguage) and not result:
+        dfa = minimal_dfa_from_language(lang.automaton)
+        for state in dfa.states():
+            result.add(_residual_from_state(AutomatonLanguage(dfa), state))
+    return frozenset(result)
+
+
+def prime_atoms(language: RegularLanguage) -> frozenset[RegularLanguage]:
+    all_atoms = atoms(language)
+    return frozenset(atom for atom in all_atoms if is_prime_atom(atom, all_atoms))
+
+
+def is_prime_atom(atom: RegularLanguage, all_atoms: frozenset[RegularLanguage]) -> bool:
+    others = [candidate for candidate in all_atoms if candidate is not atom]
+    if not others:
+        return True
+    alphabet = _alphabet_of(atom)
+    return all(not _languages_equal(atom, other, alphabet) for other in others)