sofic 0.1.0__py3-none-any.whl

sofic/__init__.py

@@ -0,0 +1,185 @@
+"""
+sofic is a Python package for hidden Markov models, symbolic dynamics,
+finite state machines, and other stochastic symbol generators.
+"""
+
+try:
+    from importlib.metadata import version
+
+    __version__ = version("sofic")
+except Exception:
+    __version__ = "0.0.0"
+
+from sofic.automata import (
+    DFA,
+    NFA,
+    Atomaton,
+    AtomicAutomaton,
+    AutomatonLanguage,
+    BuchiAutomaton,
+    CanonicalRFSA,
+    LabeledAutomaton,
+    MaximizedPrimeAtomaton,
+    MealyMachine,
+    MinimizationAlgorithm,
+    MooreMachine,
+    NestedWord,
+    NestedWordAutomaton,
+    ObservationTable,
+    RegularLanguage,
+    ResidualFiniteStateAutomaton,
+    SubsequentialTransducer,
+    Transducer,
+    UnifilarAutomaton,
+    VisiblyPushdownAutomaton,
+    WeightedFiniteStateTransducer,
+    automaton_to_regex,
+    cartesian_product_gg,
+    cartesian_product_tt,
+    complete,
+    compose_tg,
+    compose_tt,
+    determinize,
+    equivalent,
+    minimize,
+    transduce_generator,
+    trim,
+)
+from sofic.core import EPSILON, StateIndex, StateMachine, Transition, TransitionGraph
+from sofic.generators import (
+    BidirectionalEpsilonMachine,
+    BlockConvergenceDiagram,
+    BlockConvergenceEstimates,
+    BlockEntropyDiagram,
+    BlockEntropyEstimates,
+    EpsilonMachine,
+    EpsilonTransducer,
+    FunctionalGenerativeModel,
+    GacsKornerGenerativeModel,
+    HiddenMarkovModel,
+    HiddenMarkovStackModel,
+    MarkovChain,
+    MealyHMM,
+    MinimalGenerativeModel,
+    MixedState,
+    MixedStatePresentation,
+    MooreHMM,
+    NMachine,
+    ProbabilisticFiniteAutomaton,
+    QuasiRealization,
+    QuasiStochasticModel,
+    StochasticModel,
+    WynerGenerativeModel,
+    functional_generative_model,
+    gacs_korner_generative_model,
+    is_lumpable,
+    lump,
+    minimal_generative_model,
+    wyner_generative_model,
+)
+from sofic.operations import reverse
+from sofic.serialization import from_yaml, model_from_yaml, model_to_yaml, read_yaml
+from sofic.shifts import (
+    LeftFischerCover,
+    LeftKriegerCover,
+    MarkovDyckShift,
+    RightFischerCover,
+    RightKriegerCover,
+    ShiftOfFiniteType,
+    SlidingBlockCode,
+    SoficDyckShift,
+    SoficRelation,
+    SoficShift,
+    SymbolicModel,
+    TextileSystem,
+    TopologicalMarkovChain,
+)
+
+__all__ = [
+    "Atomaton",
+    "AtomicAutomaton",
+    "AutomatonLanguage",
+    "BuchiAutomaton",
+    "BidirectionalEpsilonMachine",
+    "BlockEntropyDiagram",
+    "BlockEntropyEstimates",
+    "BlockConvergenceDiagram",
+    "BlockConvergenceEstimates",
+    "CanonicalRFSA",
+    "DFA",
+    "EPSILON",
+    "EpsilonMachine",
+    "EpsilonTransducer",
+    "FunctionalGenerativeModel",
+    "GacsKornerGenerativeModel",
+    "HiddenMarkovModel",
+    "HiddenMarkovStackModel",
+    "LabeledAutomaton",
+    "LeftFischerCover",
+    "LeftKriegerCover",
+    "MarkovDyckShift",
+    "MarkovChain",
+    "MaximizedPrimeAtomaton",
+    "MealyHMM",
+    "MinimalGenerativeModel",
+    "MealyMachine",
+    "MinimizationAlgorithm",
+    "MixedState",
+    "MixedStatePresentation",
+    "MooreHMM",
+    "MooreMachine",
+    "NFA",
+    "NestedWord",
+    "NestedWordAutomaton",
+    "NMachine",
+    "ObservationTable",
+    "ProbabilisticFiniteAutomaton",
+    "QuasiRealization",
+    "QuasiStochasticModel",
+    "RegularLanguage",
+    "ResidualFiniteStateAutomaton",
+    "RightFischerCover",
+    "RightKriegerCover",
+    "ShiftOfFiniteType",
+    "SlidingBlockCode",
+    "SoficDyckShift",
+    "SoficRelation",
+    "SoficShift",
+    "StateIndex",
+    "StateMachine",
+    "StochasticModel",
+    "SubsequentialTransducer",
+    "SymbolicModel",
+    "TextileSystem",
+    "TopologicalMarkovChain",
+    "Transducer",
+    "Transition",
+    "TransitionGraph",
+    "UnifilarAutomaton",
+    "VisiblyPushdownAutomaton",
+    "WeightedFiniteStateTransducer",
+    "WynerGenerativeModel",
+    "automaton_to_regex",
+    "cartesian_product_gg",
+    "cartesian_product_tt",
+    "complete",
+    "compose_tg",
+    "compose_tt",
+    "determinize",
+    "equivalent",
+    "minimize",
+    "from_yaml",
+    "functional_generative_model",
+    "gacs_korner_generative_model",
+    "is_lumpable",
+    "lump",
+    "model_from_yaml",
+    "model_to_yaml",
+    "minimal_generative_model",
+    "read_yaml",
+    "reverse",
+    "transduce_generator",
+    "trim",
+    "wyner_generative_model",
+    "__version__",
+]

sofic/automata/__init__.py

@@ -0,0 +1,207 @@
+"""Finite automata and transducers."""
+
+# ``atomaton`` is an intentional pun on atomic automaton.
+from sofic.automata.active import (
+    EquivalenceOracle,
+    ExhaustiveEquivalenceOracle,
+    FunctionMealyOracle,
+    FunctionMembershipOracle,
+    LanguageMembershipOracle,
+    MealyEquivalenceOracle,
+    MealyExhaustiveEquivalenceOracle,
+    MealyMembershipOracle,
+    MembershipOracle,
+    RandomWalkEquivalenceOracle,
+    TransducerOutputOracle,
+    learn_dfa_from_language,
+    learn_dfa_lstar,
+    learn_dfa_ttt,
+    learn_mealy_from_transducer,
+    learn_mealy_lstar,
+)
+from sofic.automata.alergia import learn_pfa_alergia
+from sofic.automata.algorithms import (
+    MinimizationAlgorithm,
+    complete,
+    determinize,
+    equivalent,
+    minimize,
+    trim,
+)
+from sofic.automata.atomaton import Atomaton, AtomicAutomaton, MaximizedPrimeAtomaton
+from sofic.automata.base import LabeledAutomaton
+from sofic.automata.buchi import BuchiAutomaton
+from sofic.automata.dfa import DFA
+from sofic.automata.dfasat import learn_dfa_sat
+from sofic.automata.edsm import learn_dfa_edsm
+from sofic.automata.icdfa import (
+    ICDFAString,
+    count_flag_sequences,
+    count_icdfa,
+    count_icdfa_empty,
+    dfa_to_icdfa_string,
+    first_icdfa_empty_string,
+    flags_from_string,
+    icdfa_string_to_dfa,
+    iter_icdfa,
+    iter_icdfa_empty_strings,
+    last_icdfa_empty_string,
+    next_flags,
+    next_icdfa_empty_string,
+    string_from_flags,
+    validate_icdfa_empty_string,
+)
+from sofic.automata.idfa import (
+    MISSING_TRANSITION,
+    count_accessible_idfa,
+    first_idfa_string,
+    iter_idfa_strings,
+    rank_idfa_string,
+    reroot_idfa_string,
+    unrank_idfa_string,
+    validate_idfa_string,
+)
+from sofic.automata.languages import AutomatonLanguage, RegularLanguage
+from sofic.automata.nfa import NFA
+from sofic.automata.nwa import NestedWord, NestedWordAutomaton
+from sofic.automata.observation import ObservationTable
+from sofic.automata.papni import (
+    DyckAlphabet,
+    is_well_matched,
+    learn_sofic_dyck_shift_papni,
+    papni_encode,
+    papni_encode_samples,
+    sofic_dyck_shift_from_papni_dfa,
+)
+from sofic.automata.regex import automaton_to_regex
+from sofic.automata.rfsa import CanonicalRFSA, ResidualFiniteStateAutomaton
+from sofic.automata.rpni import learn_dfa_rpni
+from sofic.automata.subsequential import (
+    SubsequentialTransducer,
+    WeightedFiniteStateTransducer,
+)
+from sofic.automata.transducer_operations import (
+    ERROR_STATE,
+    ERROR_SYMBOL,
+    cartesian_product_gg,
+    cartesian_product_tt,
+    compose_tg,
+    compose_tt,
+    transduce_generator,
+)
+from sofic.automata.transducers import MealyMachine, MooreMachine, Transducer
+from sofic.automata.unifilar import UnifilarAutomaton
+from sofic.automata.vpa import (
+    CallDrivenAutomaton,
+    CanonicalVisiblyPushdownAutomaton,
+    CompositeVisiblyPushdownAutomaton,
+    DeterministicVisiblyPushdownAutomaton,
+    MultipleEntryVisiblyPushdownAutomaton,
+    SingleEntryVisiblyPushdownAutomaton,
+    VisiblyPushdownAutomaton,
+    complement_vpa,
+    concat_vpa,
+    difference_vpa,
+    intersection_vpa,
+    kleene_star_vpa,
+    union_vpa,
+)
+
+__all__ = [
+    "Atomaton",
+    "AtomicAutomaton",
+    "AutomatonLanguage",
+    "BuchiAutomaton",
+    "EquivalenceOracle",
+    "ExhaustiveEquivalenceOracle",
+    "FunctionMealyOracle",
+    "FunctionMembershipOracle",
+    "LanguageMembershipOracle",
+    "MealyEquivalenceOracle",
+    "MealyExhaustiveEquivalenceOracle",
+    "MealyMembershipOracle",
+    "MembershipOracle",
+    "RandomWalkEquivalenceOracle",
+    "TransducerOutputOracle",
+    "CallDrivenAutomaton",
+    "CanonicalVisiblyPushdownAutomaton",
+    "CanonicalRFSA",
+    "CompositeVisiblyPushdownAutomaton",
+    "DFA",
+    "DeterministicVisiblyPushdownAutomaton",
+    "DyckAlphabet",
+    "ERROR_STATE",
+    "ERROR_SYMBOL",
+    "ICDFAString",
+    "LabeledAutomaton",
+    "MaximizedPrimeAtomaton",
+    "MealyMachine",
+    "MinimizationAlgorithm",
+    "MooreMachine",
+    "MultipleEntryVisiblyPushdownAutomaton",
+    "NFA",
+    "NestedWord",
+    "NestedWordAutomaton",
+    "ObservationTable",
+    "RegularLanguage",
+    "ResidualFiniteStateAutomaton",
+    "SingleEntryVisiblyPushdownAutomaton",
+    "SubsequentialTransducer",
+    "Transducer",
+    "UnifilarAutomaton",
+    "WeightedFiniteStateTransducer",
+    "VisiblyPushdownAutomaton",
+    "automaton_to_regex",
+    "cartesian_product_gg",
+    "cartesian_product_tt",
+    "complement_vpa",
+    "compose_tg",
+    "compose_tt",
+    "concat_vpa",
+    "complete",
+    "count_accessible_idfa",
+    "count_flag_sequences",
+    "count_icdfa",
+    "count_icdfa_empty",
+    "determinize",
+    "difference_vpa",
+    "dfa_to_icdfa_string",
+    "equivalent",
+    "first_icdfa_empty_string",
+    "first_idfa_string",
+    "flags_from_string",
+    "icdfa_string_to_dfa",
+    "intersection_vpa",
+    "is_well_matched",
+    "iter_icdfa",
+    "iter_icdfa_empty_strings",
+    "iter_idfa_strings",
+    "last_icdfa_empty_string",
+    "MISSING_TRANSITION",
+    "kleene_star_vpa",
+    "learn_dfa_edsm",
+    "learn_dfa_from_language",
+    "learn_dfa_lstar",
+    "learn_dfa_rpni",
+    "learn_dfa_sat",
+    "learn_dfa_ttt",
+    "learn_mealy_from_transducer",
+    "learn_mealy_lstar",
+    "learn_pfa_alergia",
+    "learn_sofic_dyck_shift_papni",
+    "minimize",
+    "next_flags",
+    "next_icdfa_empty_string",
+    "papni_encode",
+    "papni_encode_samples",
+    "rank_idfa_string",
+    "reroot_idfa_string",
+    "sofic_dyck_shift_from_papni_dfa",
+    "string_from_flags",
+    "trim",
+    "transduce_generator",
+    "unrank_idfa_string",
+    "union_vpa",
+    "validate_idfa_string",
+    "validate_icdfa_empty_string",
+]

sofic/automata/_config_simulation.py

@@ -0,0 +1,40 @@
+"""Shared configuration-set simulation driver for stack/output machines.
+
+VPA, NWA, and transducer simulations all advance a set of ``(state, extra)``
+configurations one input step at a time, unioning the successors produced by a
+per-machine step function and stopping if the set ever empties. This captures
+that loop; the per-kind transition logic stays with each caller.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import TypeVar
+
+Config = TypeVar("Config")
+Step = TypeVar("Step")
+
+
+def simulate_configs(
+    initial: set[Config],
+    steps: Iterable[Step],
+    step_fn: Callable[[Config, Step], Iterable[Config]],
+    *,
+    closure: Callable[[set[Config]], set[Config]] | None = None,
+) -> set[Config]:
+    """Advance ``initial`` through ``steps`` via ``step_fn``.
+
+    ``step_fn(config, step)`` yields successor configurations for one input step.
+    An optional ``closure`` is applied to the seed set and after every step (used
+    by the transducer's epsilon-input closure). Returns the final configuration
+    set, which is empty if the machine had no successors at some step.
+    """
+    current = closure(initial) if closure is not None else initial
+    for step in steps:
+        nxt: set[Config] = set()
+        for config in current:
+            nxt.update(step_fn(config, step))
+        current = closure(nxt) if closure is not None else nxt
+        if not current:
+            return set()
+    return current