sofic 0.1.0__py3-none-any.whl

sofic/automata/languages/automaton_ops.py

@@ -0,0 +1,243 @@
+"""Automaton constructions for regular-language algebra."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable, Hashable, Sequence
+from typing import Any
+
+from sofic.automata.algorithms import complete, determinize, minimize, trim
+from sofic.automata.base import LabeledAutomaton
+from sofic.automata.dfa import DFA
+from sofic.automata.nfa import NFA
+from sofic.graph import ATTR_SYMBOL, EPSILON, TransitionGraph
+
+_LEFT = object()
+_RIGHT = object()
+_START = object()
+_STAR_START = object()
+
+
+def _to_nfa(aut: LabeledAutomaton) -> NFA:
+    if isinstance(aut, NFA):
+        return trim(aut)
+    nfa = NFA(
+        input_alphabet=aut.input_alphabet,
+        initial_states=aut.initial_states,
+        accepting_states=aut.accepting_states,
+        graph=aut.graph.copy(),
+    )
+    return trim(nfa)
+
+
+def _to_dfa(aut: LabeledAutomaton, alphabet: frozenset[Any] | None = None) -> DFA:
+    if isinstance(aut, DFA):
+        return trim(aut)
+    return trim(determinize(_to_nfa(aut), alphabet=alphabet))
+
+
+def union_nfa(left: LabeledAutomaton, right: LabeledAutomaton) -> NFA:
+    left_nfa = _to_nfa(left)
+    right_nfa = _to_nfa(right)
+    alphabet = left_nfa.input_alphabet | right_nfa.input_alphabet
+    graph = TransitionGraph()
+    start = (_START,)
+    graph.add_state(start)
+    for state in left_nfa.states():
+        graph.add_state((_LEFT, state))
+    for state in right_nfa.states():
+        graph.add_state((_RIGHT, state))
+    for initial in left_nfa.initial_states:
+        graph.add_transition(start, (_LEFT, initial), **{ATTR_SYMBOL: EPSILON})
+    for initial in right_nfa.initial_states:
+        graph.add_transition(start, (_RIGHT, initial), **{ATTR_SYMBOL: EPSILON})
+    for transition in left_nfa.transitions():
+        graph.add_transition(
+            (_LEFT, transition.source),
+            (_LEFT, transition.target),
+            **transition.data,
+        )
+    for transition in right_nfa.transitions():
+        graph.add_transition(
+            (_RIGHT, transition.source),
+            (_RIGHT, transition.target),
+            **transition.data,
+        )
+    accepting = {(_LEFT, s) for s in left_nfa.accepting_states} | {(_RIGHT, s) for s in right_nfa.accepting_states}
+    return NFA(
+        input_alphabet=alphabet,
+        initial_states=frozenset({start}),
+        accepting_states=frozenset(accepting),
+        graph=graph,
+    )
+
+
+def _product_dfa(
+    left_dfa: DFA,
+    right_dfa: DFA,
+    alphabet: frozenset[Any],
+    accept_pred: Callable[[Hashable, Hashable], bool],
+    *,
+    complete_inputs: bool,
+) -> DFA:
+    """Product-construction BFS over ``left_dfa`` x ``right_dfa``.
+
+    When ``complete_inputs`` is ``False`` (intersection semantics) transitions
+    with a missing successor in either factor are skipped, yielding a sparse
+    product. When ``True`` (difference semantics) both factors are assumed total
+    so every symbol produces a successor and traps contribute to the language.
+    ``accept_pred`` decides acceptance from the two component states.
+    """
+    graph = TransitionGraph()
+    initial = (next(iter(left_dfa.initial_states)), next(iter(right_dfa.initial_states)))
+    graph.add_state(initial)
+    queue: deque[tuple[Hashable, Hashable]] = deque([initial])
+    seen = {initial}
+    while queue:
+        pair = queue.popleft()
+        for symbol in alphabet:
+            left_next = left_dfa.delta(pair[0], symbol)
+            right_next = right_dfa.delta(pair[1], symbol)
+            if not complete_inputs and (len(left_next) != 1 or len(right_next) != 1):
+                continue
+            target = (next(iter(left_next)), next(iter(right_next)))
+            if target not in seen:
+                seen.add(target)
+                graph.add_state(target)
+                queue.append(target)
+            graph.add_transition(pair, target, **{ATTR_SYMBOL: symbol})
+    accepting = {pair for pair in seen if accept_pred(pair[0], pair[1])}
+    return DFA(
+        input_alphabet=alphabet,
+        initial_states=frozenset({initial}),
+        accepting_states=frozenset(accepting),
+        graph=graph,
+    )
+
+
+def intersection_dfa(left: LabeledAutomaton, right: LabeledAutomaton) -> DFA:
+    left_dfa = _to_dfa(left)
+    right_dfa = _to_dfa(right)
+    alphabet = left_dfa.input_alphabet | right_dfa.input_alphabet
+    return _product_dfa(
+        left_dfa,
+        right_dfa,
+        alphabet,
+        lambda ls, rs: ls in left_dfa.accepting_states and rs in right_dfa.accepting_states,
+        complete_inputs=False,
+    )
+
+
+def complement_dfa(dfa: LabeledAutomaton, alphabet: frozenset[Any] | None = None) -> DFA:
+    symbols = _effective_alphabet(dfa) if alphabet is None else alphabet
+    complete_dfa = complete(_to_dfa(dfa, alphabet=symbols), alphabet=symbols)
+    all_states = set(complete_dfa.states())
+    accepting = all_states - set(complete_dfa.accepting_states)
+    result = complete_dfa.copy()
+    result.accepting_states = frozenset(accepting)
+    return result
+
+
+def difference_dfa(
+    left: LabeledAutomaton,
+    right: LabeledAutomaton,
+    alphabet: frozenset[Any] | None = None,
+) -> DFA:
+    """Return a DFA recognizing ``left`` minus ``right`` over ``alphabet``."""
+    symbols = alphabet if alphabet is not None else _effective_alphabet(left) | _effective_alphabet(right)
+    left_dfa = complete(_to_dfa(left, alphabet=symbols), alphabet=symbols)
+    right_dfa = complete(_to_dfa(right, alphabet=symbols), alphabet=symbols)
+    return _product_dfa(
+        left_dfa,
+        right_dfa,
+        symbols,
+        lambda ls, rs: ls in left_dfa.accepting_states and rs not in right_dfa.accepting_states,
+        complete_inputs=True,
+    )
+
+
+def concat_nfa(left: LabeledAutomaton, right: LabeledAutomaton) -> NFA:
+    left_nfa = _to_nfa(left)
+    right_nfa = _to_nfa(right)
+    alphabet = left_nfa.input_alphabet | right_nfa.input_alphabet
+    graph = left_nfa.graph.copy()
+    for state in right_nfa.states():
+        graph.add_state((_RIGHT, state))
+    for transition in right_nfa.transitions():
+        graph.add_transition(
+            (_RIGHT, transition.source),
+            (_RIGHT, transition.target),
+            **transition.data,
+        )
+    for accept in left_nfa.accepting_states:
+        for initial in right_nfa.initial_states:
+            graph.add_transition(accept, (_RIGHT, initial), **{ATTR_SYMBOL: EPSILON})
+    accepting = {(_RIGHT, s) for s in right_nfa.accepting_states}
+    return NFA(
+        input_alphabet=alphabet,
+        initial_states=left_nfa.initial_states,
+        accepting_states=frozenset(accepting),
+        graph=graph,
+    )
+
+
+def kleene_star_nfa(aut: LabeledAutomaton) -> NFA:
+    nfa = _to_nfa(aut)
+    graph = nfa.graph.copy()
+    start = (_STAR_START,)
+    graph.add_state(start)
+    for initial in nfa.initial_states:
+        graph.add_transition(start, initial, **{ATTR_SYMBOL: EPSILON})
+    for accept in nfa.accepting_states:
+        for initial in nfa.initial_states:
+            graph.add_transition(accept, initial, **{ATTR_SYMBOL: EPSILON})
+    accepting = set(nfa.accepting_states) | {start}
+    return NFA(
+        input_alphabet=nfa.input_alphabet,
+        initial_states=frozenset({start}),
+        accepting_states=frozenset(accepting),
+        graph=graph,
+    )
+
+
+def left_quotient_automaton(u: Sequence[Any], aut: LabeledAutomaton) -> NFA:
+    nfa = _to_nfa(aut)
+    current = nfa.epsilon_closure(set(nfa.initial_states))
+    for symbol in u:
+        next_states: set[Hashable] = set()
+        for state in current:
+            next_states.update(nfa.delta(state, symbol))
+        current = nfa.epsilon_closure(next_states)
+    return NFA(
+        input_alphabet=nfa.input_alphabet,
+        initial_states=frozenset(current),
+        accepting_states=nfa.accepting_states,
+        graph=nfa.graph.copy(),
+    )
+
+
+def right_quotient_automaton(aut: LabeledAutomaton, u: Sequence[Any]) -> NFA:
+    reversed_u = tuple(reversed(u))
+    rev = _to_nfa(aut).reverse()
+    return left_quotient_automaton(reversed_u, rev).reverse()
+
+
+def minimal_dfa_from_language(aut: LabeledAutomaton) -> DFA:
+    return minimize(_to_dfa(aut))
+
+
+def state_residual_languages(dfa: DFA) -> dict[Hashable, DFA]:
+    """Map each state to the DFA for its left-quotient (right-language) residual."""
+    residuals: dict[Hashable, DFA] = {}
+    for state in dfa.states():
+        sub = dfa.copy()
+        sub.initial_states = frozenset({state})
+        sub.accepting_states = dfa.accepting_states
+        residuals[state] = minimize(_to_dfa(sub))
+    return residuals
+
+
+def _effective_alphabet(aut: LabeledAutomaton) -> frozenset[Any]:
+    from sofic.automata.algorithms import _effective_alphabet as _shared
+
+    return _shared(aut)

sofic/automata/languages/base.py

@@ -0,0 +1,67 @@
+"""Regular language protocol and concrete wrappers."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Protocol, runtime_checkable
+
+from sofic.automata.base import LabeledAutomaton
+
+
+@runtime_checkable
+class RegularLanguage(Protocol):
+    """Membership oracle for a regular (or finitely specified) language."""
+
+    def __contains__(self, word: Sequence[Any]) -> bool: ...
+
+
+class ExplicitLanguage:
+    """Language given by explicit positive/negative word sets."""
+
+    __slots__ = ("_positive", "_negative", "_alphabet")
+
+    def __init__(
+        self,
+        positive: set[tuple[Any, ...]] | None = None,
+        negative: set[tuple[Any, ...]] | None = None,
+        alphabet: frozenset[Any] | None = None,
+    ) -> None:
+        self._positive = positive if positive is not None else set()
+        self._negative = negative if negative is not None else set()
+        self._alphabet = alphabet if alphabet is not None else frozenset()
+
+    def __contains__(self, word: Sequence[Any]) -> bool:
+        key = tuple(word)
+        if key in self._negative:
+            return False
+        return key in self._positive
+
+    @property
+    def alphabet(self) -> frozenset[Any]:
+        return self._alphabet
+
+
+class AutomatonLanguage:
+    """Language recognized by a :class:`LabeledAutomaton`."""
+
+    __slots__ = ("_automaton",)
+
+    def __init__(self, automaton: LabeledAutomaton) -> None:
+        self._automaton = automaton
+
+    def __contains__(self, word: Sequence[Any]) -> bool:
+        return self._automaton.recognizes(word)
+
+    @property
+    def automaton(self) -> LabeledAutomaton:
+        return self._automaton
+
+    @classmethod
+    def from_automaton(cls, aut: LabeledAutomaton) -> AutomatonLanguage:
+        return cls(aut)
+
+
+def as_language(language: RegularLanguage | LabeledAutomaton) -> RegularLanguage:
+    if isinstance(language, LabeledAutomaton):
+        return AutomatonLanguage.from_automaton(language)
+    return language

sofic/automata/languages/operations.py

@@ -0,0 +1,78 @@
+"""Boolean and structural regular-language operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sofic.automata.languages.automaton_ops import (
+    complement_dfa,
+    concat_nfa,
+    difference_dfa,
+    intersection_dfa,
+    kleene_star_nfa,
+    union_nfa,
+)
+from sofic.automata.languages.base import AutomatonLanguage, ExplicitLanguage, RegularLanguage, as_language
+
+
+def union(left: RegularLanguage, right: RegularLanguage) -> RegularLanguage:
+    left_lang = as_language(left)  # type: ignore[arg-type]
+    right_lang = as_language(right)  # type: ignore[arg-type]
+    if isinstance(left_lang, AutomatonLanguage) and isinstance(right_lang, AutomatonLanguage):
+        return AutomatonLanguage(union_nfa(left_lang.automaton, right_lang.automaton))
+    raise TypeError("union requires automaton-backed languages")
+
+
+def intersection(left: RegularLanguage, right: RegularLanguage) -> RegularLanguage:
+    left_lang = as_language(left)  # type: ignore[arg-type]
+    right_lang = as_language(right)  # type: ignore[arg-type]
+    if isinstance(left_lang, AutomatonLanguage) and isinstance(right_lang, AutomatonLanguage):
+        return AutomatonLanguage(intersection_dfa(left_lang.automaton, right_lang.automaton))
+    raise TypeError("intersection requires automaton-backed languages")
+
+
+def complement(language: RegularLanguage, alphabet: frozenset[Any]) -> RegularLanguage:
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, AutomatonLanguage):
+        return AutomatonLanguage(complement_dfa(lang.automaton, alphabet))
+    raise TypeError("complement requires automaton-backed languages")
+
+
+def difference(
+    left: RegularLanguage, right: RegularLanguage, alphabet: frozenset[Any] | None = None
+) -> RegularLanguage:
+    left_lang = as_language(left)  # type: ignore[arg-type]
+    right_lang = as_language(right)  # type: ignore[arg-type]
+    if isinstance(left_lang, AutomatonLanguage) and isinstance(right_lang, AutomatonLanguage):
+        return AutomatonLanguage(difference_dfa(left_lang.automaton, right_lang.automaton, alphabet=alphabet))
+    raise TypeError("difference requires automaton-backed languages")
+
+
+def reverse(language: RegularLanguage) -> RegularLanguage:
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, ExplicitLanguage):
+        positive = {tuple(reversed(word)) for word in lang._positive}
+        negative = {tuple(reversed(word)) for word in lang._negative}
+        return ExplicitLanguage(positive=positive, negative=negative, alphabet=lang.alphabet)
+    if isinstance(lang, AutomatonLanguage):
+        return AutomatonLanguage.from_automaton(lang.automaton.reverse())
+    raise TypeError(f"unsupported language type {type(lang)!r}")
+
+
+def concat(left: RegularLanguage, right: RegularLanguage) -> RegularLanguage:
+    left_lang = as_language(left)  # type: ignore[arg-type]
+    right_lang = as_language(right)  # type: ignore[arg-type]
+    if isinstance(left_lang, AutomatonLanguage) and isinstance(right_lang, AutomatonLanguage):
+        return AutomatonLanguage(concat_nfa(left_lang.automaton, right_lang.automaton))
+    raise TypeError("concat requires automaton-backed languages")
+
+
+def kleene_star(language: RegularLanguage) -> RegularLanguage:
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, AutomatonLanguage):
+        return AutomatonLanguage(kleene_star_nfa(lang.automaton))
+    raise TypeError("kleene_star requires automaton-backed languages")
+
+
+def product(left: RegularLanguage, right: RegularLanguage) -> RegularLanguage:
+    return intersection(left, right)

sofic/automata/languages/quotients.py

@@ -0,0 +1,66 @@
+"""Left and right quotients of regular languages."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from sofic.automata.languages._quotient_utils import (
+    _prefixes_if_suffix,
+    _residual_from_state,
+    _suffixes_if_prefix,
+    _words_up_to,
+)
+from sofic.automata.languages.automaton_ops import (
+    left_quotient_automaton,
+    minimal_dfa_from_language,
+    right_quotient_automaton,
+)
+from sofic.automata.languages.base import AutomatonLanguage, ExplicitLanguage, RegularLanguage, as_language
+
+
+def left_quotient(u: Sequence[Any], language: RegularLanguage) -> RegularLanguage:
+    """Return u^{-1} L = {w | uw in L}."""
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, ExplicitLanguage):
+        positive = {w for uw in lang._positive for w in _suffixes_if_prefix(uw, u)}
+        negative = {w for uw in lang._negative for w in _suffixes_if_prefix(uw, u)}
+        return ExplicitLanguage(positive=positive, negative=negative, alphabet=lang.alphabet)
+    if isinstance(lang, AutomatonLanguage):
+        return AutomatonLanguage(left_quotient_automaton(u, lang.automaton))
+    raise TypeError(f"unsupported language type {type(lang)!r}")
+
+
+def right_quotient(language: RegularLanguage, u: Sequence[Any]) -> RegularLanguage:
+    """Return L u^{-1} = {w | wu in L}."""
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, ExplicitLanguage):
+        positive = {w for wu in lang._positive for w in _prefixes_if_suffix(wu, u)}
+        negative = {w for wu in lang._negative for w in _prefixes_if_suffix(wu, u)}
+        return ExplicitLanguage(positive=positive, negative=negative, alphabet=lang.alphabet)
+    if isinstance(lang, AutomatonLanguage):
+        return AutomatonLanguage(right_quotient_automaton(lang.automaton, u))
+    raise TypeError(f"unsupported language type {type(lang)!r}")
+
+
+def left_quotients(language: RegularLanguage) -> frozenset[RegularLanguage]:
+    lang = as_language(language)  # type: ignore[arg-type]
+    if isinstance(lang, AutomatonLanguage):
+        dfa = minimal_dfa_from_language(lang.automaton)
+        quotients: set[RegularLanguage] = set()
+        for state in dfa.states():
+            quotients.add(_residual_from_state(AutomatonLanguage(dfa), state))
+        return frozenset(quotients)
+    if isinstance(lang, ExplicitLanguage):
+        alphabet = lang.alphabet
+        quotients: set[RegularLanguage] = set()
+        for length in range(4):
+            for word in _words_up_to(length, alphabet):
+                quotients.add(left_quotient(word, lang))
+        return frozenset(quotients)
+    raise TypeError(f"unsupported language type {type(lang)!r}")
+
+
+def residuals(language: RegularLanguage) -> frozenset[RegularLanguage]:
+    """Residual languages Res(L) = {u^{-1}L | u in Sigma*}."""
+    return left_quotients(language)

sofic/automata/languages/residuals.py

@@ -0,0 +1,25 @@
+"""Prime and composed residual languages."""
+
+from __future__ import annotations
+
+from sofic.automata.languages._quotient_utils import (
+    _alphabet_of,
+    _is_union_of_others,
+    _languages_equal,
+)
+from sofic.automata.languages.base import ExplicitLanguage, RegularLanguage
+from sofic.automata.languages.quotients import left_quotients
+
+
+def prime_residuals(language: RegularLanguage) -> frozenset[RegularLanguage]:
+    all_residuals = left_quotients(language)
+    return frozenset(r for r in all_residuals if not is_composed_residual(r, all_residuals))
+
+
+def is_composed_residual(residual: RegularLanguage, all_residuals: frozenset[RegularLanguage]) -> bool:
+    if isinstance(residual, ExplicitLanguage):
+        others = [r for r in all_residuals if r is not residual and isinstance(r, ExplicitLanguage)]
+        return _is_union_of_others(residual, others)
+    others = [r for r in all_residuals if r is not residual]
+    alphabet = _alphabet_of(residual)
+    return any(_languages_equal(residual, other, alphabet) for other in others)

sofic/automata/learning.py

@@ -0,0 +1,79 @@
+"""NL* active learning for maximized prime átomata."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from sofic.automata.atomaton import MaximizedPrimeAtomaton
+from sofic.automata.languages.base import RegularLanguage
+from sofic.automata.observation import ObservationTable
+
+
+def learn_maximized_prime_atomaton(
+    teacher: RegularLanguage,
+    alphabet: frozenset[Any],
+    max_rounds: int = 32,
+) -> MaximizedPrimeAtomaton:
+    """Simulated NL* teacher loop using membership queries."""
+    access_words: set[tuple[Any, ...]] = {()}
+    experiments: set[tuple[Any, ...]] = {()}
+
+    def membership(word: Sequence[Any]) -> bool:
+        return tuple(word) in teacher
+
+    def close_table(max_depth: int = 6) -> None:
+        changed = True
+        while changed:
+            changed = False
+            for word in list(access_words):
+                if len(word) >= max_depth:
+                    continue
+                for symbol in alphabet:
+                    successor = word + (symbol,)
+                    if successor not in access_words:
+                        access_words.add(successor)
+                        changed = True
+
+    for _ in range(max_rounds):
+        close_table()
+        table = _build_table(access_words, experiments, membership)
+        hypothesis = table.to_maximized_prime_atomaton()
+        counterexample = _find_counterexample(teacher, hypothesis, alphabet)
+        if counterexample is None:
+            return hypothesis
+        for length in range(len(counterexample) + 1):
+            experiments.add(counterexample[length:])
+
+    return _build_table(access_words, experiments, membership).to_maximized_prime_atomaton()
+
+
+def _build_table(
+    access_words: set[tuple[Any, ...]],
+    experiments: set[tuple[Any, ...]],
+    membership,
+) -> ObservationTable:
+    membership_map: dict[tuple[Any, ...], bool] = {}
+    for prefix in access_words:
+        for suffix in experiments:
+            membership_map[prefix + suffix] = membership(prefix + suffix)
+    return ObservationTable(
+        access_words=frozenset(access_words),
+        experiments=frozenset(experiments),
+        membership=membership_map,
+    )
+
+
+def _find_counterexample(
+    teacher: RegularLanguage,
+    hypothesis: MaximizedPrimeAtomaton,
+    alphabet: frozenset[Any],
+    max_len: int = 8,
+) -> tuple[Any, ...] | None:
+    from sofic.automata.languages._quotient_utils import _words_up_to
+
+    for length in range(max_len + 1):
+        for word in _words_up_to(length, alphabet):
+            if (word in teacher) != hypothesis.recognizes(word):
+                return word
+    return None

sofic/automata/nfa.py

@@ -0,0 +1,39 @@
+"""Nondeterministic finite automata."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Sequence
+from typing import TYPE_CHECKING, Any
+
+from sofic.automata.base import LabeledAutomaton
+from sofic.graph import ATTR_SYMBOL, EPSILON
+
+if TYPE_CHECKING:
+    from sofic.automata.algorithms import MinimizationAlgorithm
+    from sofic.automata.dfa import DFA
+
+
+class NFA(LabeledAutomaton):
+    """Nondeterministic finite automaton with first-class epsilon transitions."""
+
+    def add_transition(self, source: Hashable, target: Hashable, symbol: Any = EPSILON, **attrs: Any) -> int:
+        return self.graph.add_transition(source, target, **{ATTR_SYMBOL: symbol, **attrs})
+
+    def recognizes(self, word: Sequence[Any]) -> bool:
+        final = self._run_nfa(word)
+        return bool(final & self.accepting_states)
+
+    def determinize(self, *, alphabet: frozenset[Any] | None = None) -> DFA:
+        from sofic.automata.algorithms import determinize
+
+        return determinize(self, alphabet=alphabet)
+
+    def minimize(
+        self,
+        algorithm: MinimizationAlgorithm = "hopcroft",
+        *,
+        alphabet: frozenset[Any] | None = None,
+    ) -> DFA:
+        from sofic.automata.algorithms import minimize
+
+        return minimize(self, algorithm=algorithm, alphabet=alphabet)