sofic 0.1.0__tar.gz → 0.2.0__tar.gz

{sofic-0.1.0 → sofic-0.2.0}/.gitignore

@@ -37,6 +37,9 @@ coverage_html_report/
 # Documentation
 docs/_build/
 
+# macOS
+.DS_Store
+
 # Misc
 .cache/
 .pypirc

{sofic-0.1.0 → sofic-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sofic
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python package for hidden Markov models, symbolic dynamics, finite state machines, and stochastic symbol generators.
 Project-URL: Homepage, https://github.com/dit/sofic
 Project-URL: Repository, https://github.com/dit/sofic

{sofic-0.1.0 → sofic-0.2.0}/sofic/__init__.py

@@ -33,17 +33,23 @@ from sofic.automata import (
     UnifilarAutomaton,
     VisiblyPushdownAutomaton,
     WeightedFiniteStateTransducer,
+    WheelerError,
+    WheelerIndex,
+    WheelerOrder,
     automaton_to_regex,
     cartesian_product_gg,
     cartesian_product_tt,
+    colex_width,
     complete,
     compose_tg,
     compose_tt,
     determinize,
     equivalent,
+    is_wheeler,
     minimize,
     transduce_generator,
     trim,
+    wheeler_order,
 )
 from sofic.core import EPSILON, StateIndex, StateMachine, Transition, TransitionGraph
 from sofic.generators import (
@@ -75,6 +81,8 @@ from sofic.generators import (
     is_lumpable,
     lump,
     minimal_generative_model,
+    wheeler_presentation,
+    wheeler_statistical_complexity,
     wyner_generative_model,
 )
 from sofic.operations import reverse
@@ -93,6 +101,8 @@ from sofic.shifts import (
     SymbolicModel,
     TextileSystem,
     TopologicalMarkovChain,
+    WheelerCover,
+    wheeler_cover,
 )
 
 __all__ = [
@@ -158,15 +168,21 @@ __all__ = [
     "UnifilarAutomaton",
     "VisiblyPushdownAutomaton",
     "WeightedFiniteStateTransducer",
+    "WheelerCover",
+    "WheelerError",
+    "WheelerIndex",
+    "WheelerOrder",
     "WynerGenerativeModel",
     "automaton_to_regex",
     "cartesian_product_gg",
     "cartesian_product_tt",
+    "colex_width",
     "complete",
     "compose_tg",
     "compose_tt",
     "determinize",
     "equivalent",
+    "is_wheeler",
     "minimize",
     "from_yaml",
     "functional_generative_model",
@@ -180,6 +196,10 @@ __all__ = [
     "reverse",
     "transduce_generator",
     "trim",
+    "wheeler_cover",
+    "wheeler_order",
+    "wheeler_presentation",
+    "wheeler_statistical_complexity",
     "wyner_generative_model",
     "__version__",
 ]

{sofic-0.1.0 → sofic-0.2.0}/sofic/automata/__init__.py

@@ -106,6 +106,21 @@ from sofic.automata.vpa import (
     kleene_star_vpa,
     union_vpa,
 )
+from sofic.automata.wheeler import (
+    WheelerError,
+    WheelerOrder,
+    colex_width,
+    is_input_consistent,
+    is_wheeler,
+    maximum_colex_relation,
+    minimum_wdfa,
+    wheeler_canonical_form,
+    wheeler_isomorphic,
+    wheeler_order,
+    wheeler_state_index,
+    wnfa_to_wdfa,
+)
+from sofic.automata.wheeler_index import WheelerIndex, wheeler_index
 
 __all__ = [
     "Atomaton",
@@ -150,8 +165,12 @@ __all__ = [
     "Transducer",
     "UnifilarAutomaton",
     "WeightedFiniteStateTransducer",
+    "WheelerError",
+    "WheelerIndex",
+    "WheelerOrder",
     "VisiblyPushdownAutomaton",
     "automaton_to_regex",
+    "colex_width",
     "cartesian_product_gg",
     "cartesian_product_tt",
     "complement_vpa",
@@ -172,7 +191,9 @@ __all__ = [
     "flags_from_string",
     "icdfa_string_to_dfa",
     "intersection_vpa",
+    "is_input_consistent",
     "is_well_matched",
+    "is_wheeler",
     "iter_icdfa",
     "iter_icdfa_empty_strings",
     "iter_idfa_strings",
@@ -189,7 +210,9 @@ __all__ = [
     "learn_mealy_lstar",
     "learn_pfa_alergia",
     "learn_sofic_dyck_shift_papni",
+    "maximum_colex_relation",
     "minimize",
+    "minimum_wdfa",
     "next_flags",
     "next_icdfa_empty_string",
     "papni_encode",
@@ -204,4 +227,10 @@ __all__ = [
     "union_vpa",
     "validate_idfa_string",
     "validate_icdfa_empty_string",
+    "wheeler_canonical_form",
+    "wheeler_index",
+    "wheeler_isomorphic",
+    "wheeler_order",
+    "wheeler_state_index",
+    "wnfa_to_wdfa",
 ]

{sofic-0.1.0 → sofic-0.2.0}/sofic/automata/algorithms.py

@@ -134,7 +134,42 @@ def minimize_moore(dfa: DFA, *, alphabet: frozenset[Any] | None = None) -> DFA:
     if not states:
         return work
 
-    partition = _initial_partition(states, work.accepting_states)
+    partition = _moore_refine(work, states, symbols)
+    return _quotient_from_partition(work, partition, symbols)
+
+
+def nerode_partition(
+    dfa: DFA,
+    *,
+    alphabet: frozenset[Any] | None = None,
+) -> tuple[frozenset[Hashable], ...]:
+    """Return the Nerode classes of ``dfa``: states grouped by right language.
+
+    The DFA is completed with a trap state so that missing transitions compare
+    correctly, and the trap is dropped from the result.  Unlike
+    :func:`minimize_moore`, states are *not* trimmed first, so states with an
+    empty right language survive as their own class.  Callers that reason about
+    every state of a given DFA -- rather than about the language it recognizes
+    -- need that distinction.
+    """
+    symbols = alphabet if alphabet is not None else _effective_alphabet(dfa)
+    work = complete(dfa, symbols)
+    states = sorted(work.states(), key=repr)
+    if not states:
+        return ()
+
+    partition = _moore_refine(work, states, symbols)
+    blocks = (frozenset(block) - {_TRAP} for block in partition)
+    return tuple(block for block in blocks if block)
+
+
+def _moore_refine(
+    dfa: DFA,
+    states: Sequence[Hashable],
+    symbols: frozenset[Any],
+) -> list[set[Hashable]]:
+    """Refine the accepting/non-accepting split until it is stable."""
+    partition = _initial_partition(states, dfa.accepting_states)
     changed = True
     while changed:
         changed = False
@@ -146,7 +181,7 @@ def minimize_moore(dfa: DFA, *, alphabet: frozenset[Any] | None = None) -> DFA:
                 for piece in refined:
                     groups: dict[int, set[Hashable]] = {}
                     for state in piece:
-                        successor = _dfa_successor(work, state, symbol)
+                        successor = _dfa_successor(dfa, state, symbol)
                         index = -1 if successor is None else _block_index(partition, successor)
                         groups.setdefault(index, set()).add(state)
                     next_refined.extend(groups.values())
@@ -155,8 +190,7 @@ def minimize_moore(dfa: DFA, *, alphabet: frozenset[Any] | None = None) -> DFA:
                 changed = True
             new_partition.extend(refined)
         partition = new_partition
-
-    return _quotient_from_partition(work, partition, symbols)
+    return partition
 
 
 def minimize_hopcroft(dfa: DFA, *, alphabet: frozenset[Any] | None = None) -> DFA:

sofic-0.2.0/sofic/automata/atomaton.py

@@ -0,0 +1,102 @@
+"""Atomic and átomaton NFA presentations."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable
+from typing import TYPE_CHECKING, Any, cast
+
+from sofic.automata.dfa import DFA
+from sofic.automata.languages.base import RegularLanguage
+from sofic.automata.nfa import NFA
+from sofic.exceptions import SoficValidationError
+
+if TYPE_CHECKING:
+    from sofic.automata.observation import ObservationTable
+    from sofic.automata.rfsa import CanonicalRFSA
+
+
+def atomic_states(nfa: NFA, *, alphabet: frozenset[Any] | None = None) -> frozenset[Hashable]:
+    r"""Return the states of ``nfa`` whose right language is a union of atoms.
+
+    An *atom* of a regular language is a non-empty intersection of complemented
+    or uncomplemented left quotients; the atoms partition :math:`\Sigma^*` and
+    every quotient is a union of them.  A state is *atomic* when its right
+    language is such a union.
+
+    Implements Theorem 4 of :cite:`BrzozowskiTamm2014`: a state :math:`q` is
+    atomic if and only if :math:`\{s \in N^{RD} : q \in s\}` is a union of
+    Nerode classes of :math:`N^{RD}`, the subset construction applied to the
+    reversal of ``nfa``.
+    """
+    from sofic.automata.algorithms import _effective_alphabet, nerode_partition
+
+    symbols = alphabet if alphabet is not None else _effective_alphabet(nfa)
+    reverse_subsets = nfa.reverse().determinize(alphabet=symbols)
+    blocks = nerode_partition(reverse_subsets, alphabet=symbols)
+    # Subset-construction states are frozensets of the original NFA's states.
+    subsets = cast("list[frozenset[Hashable]]", list(reverse_subsets.states()))
+
+    atomic = set()
+    for state in nfa.states():
+        containing = {subset for subset in subsets if state in subset}
+        if all(block <= containing or block.isdisjoint(containing) for block in blocks):
+            atomic.add(state)
+    return frozenset(atomic)
+
+
+def is_atomic(nfa: NFA, *, alphabet: frozenset[Any] | None = None) -> bool:
+    """Return whether every state of ``nfa`` has a right language of atoms.
+
+    Equivalently -- Corollary 2 of :cite:`BrzozowskiTamm2014` -- whether
+    :math:`N^{RD}` is minimal, which is exactly the condition under which the
+    subset construction applied to :math:`N^R` yields a minimal DFA.
+    """
+    return atomic_states(nfa, alphabet=alphabet) == frozenset(nfa.states())
+
+
+class AtomicAutomaton(NFA):
+    """NFA whose states accept unions of atoms."""
+
+    def validate(self) -> None:
+        super().validate()
+        non_atomic = frozenset(self.states()) - atomic_states(self)
+        if non_atomic:
+            listed = ", ".join(sorted(map(repr, non_atomic)))
+            raise SoficValidationError(f"right language is not a union of atoms for state(s) {listed}")
+
+
+class Atomaton(AtomicAutomaton):
+    """Canonical átomaton whose states are all atoms of L."""
+
+    @classmethod
+    def from_language(cls, language: RegularLanguage | NFA, **kwargs: Any) -> Atomaton:
+        from sofic.automata.canonical_extraction import atomaton_from_language
+
+        return atomaton_from_language(language)
+
+    def to_minimal_dfa_via_double_reversal(self) -> DFA:
+        from sofic.automata.algorithms import minimize
+
+        return minimize(self, algorithm="brzozowski")
+
+
+class MaximizedPrimeAtomaton(AtomicAutomaton):
+    """Maximized prime átomaton — dual of the canonical RFSA."""
+
+    @classmethod
+    def from_language(cls, language: RegularLanguage | NFA, **kwargs: Any) -> MaximizedPrimeAtomaton:
+        from sofic.automata.canonical_extraction import maximized_prime_atomaton_from_language
+
+        return maximized_prime_atomaton_from_language(language)
+
+    @classmethod
+    def from_observation_table(cls, table: ObservationTable, **kwargs: Any) -> MaximizedPrimeAtomaton:
+        from sofic.automata.canonical_extraction import observation_to_maximized_prime_atomaton
+
+        return observation_to_maximized_prime_atomaton(table)
+
+    @classmethod
+    def from_canonical_rfsa(cls, rfsa: CanonicalRFSA, **kwargs: Any) -> MaximizedPrimeAtomaton:
+        from sofic.automata.canonical_dual import dual_atomaton_from_rfsa
+
+        return dual_atomaton_from_rfsa(rfsa)

{sofic-0.1.0 → sofic-0.2.0}/sofic/automata/canonical_extraction.py

@@ -40,11 +40,18 @@ def canonical_rfsa_from_language(language: RegularLanguage | NFA | DFA) -> Canon
 
 
 def atomaton_from_language(language: RegularLanguage | NFA | DFA) -> Atomaton:
-    """Build átomaton via double-reversal pipeline."""
+    """Build átomaton via double-reversal pipeline.
+
+    The átomaton is the *reverse of the minimal DFA of the reverse language*
+    (:cite:`BrzozowskiTamm2014`, Theorem 2), so the pipeline must stop at the
+    reversal: determinizing once more would collapse it back to the minimal DFA
+    of ``language``, which is Brzozowski's minimization rather than the
+    átomaton.
+    """
     aut = _language_automaton(language)
     dfa = minimal_dfa_from_language(aut)
     rev = dfa.reverse().determinize().minimize()
-    atom = rev.reverse().determinize()
+    atom = rev.reverse()
     return Atomaton(
         input_alphabet=atom.input_alphabet,
         initial_states=atom.initial_states,