sofic 0.1.0__py3-none-any.whl

sofic-0.1.0.dist-info/METADATA

@@ -0,0 +1,444 @@
+Metadata-Version: 2.5
+Name: sofic
+Version: 0.1.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
+Project-URL: Documentation, https://sofic.readthedocs.io
+Author-email: chebee7i <admin@dit.io>, "Ryan G. James" <dit@autoplectic.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Requires-Dist: dit>=2.2
+Requires-Dist: networkx>=2.6
+Requires-Dist: numpy>=1.22
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: scipy>=1.7
+Provides-Extra: bayes
+Requires-Dist: arviz; extra == 'bayes'
+Requires-Dist: pymc>=5; extra == 'bayes'
+Provides-Extra: dev
+Requires-Dist: dit[symbolic]>=2.2; extra == 'dev'
+Requires-Dist: graphviz>=0.20; extra == 'dev'
+Requires-Dist: hypothesis>=6.0; extra == 'dev'
+Requires-Dist: hypothesis[numpy]; extra == 'dev'
+Requires-Dist: ipython; extra == 'dev'
+Requires-Dist: matplotlib; extra == 'dev'
+Requires-Dist: matplotlib>=3.5; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-rerunfailures; extra == 'dev'
+Requires-Dist: pytest-sugar; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: sphinx; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme; extra == 'dev'
+Requires-Dist: sphinxcontrib-bibtex; extra == 'dev'
+Requires-Dist: sympy>=1.12; extra == 'dev'
+Requires-Dist: ty; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: dit[symbolic]>=2.2; extra == 'docs'
+Requires-Dist: ipython; extra == 'docs'
+Requires-Dist: matplotlib; extra == 'docs'
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Requires-Dist: sphinxcontrib-bibtex; extra == 'docs'
+Requires-Dist: sympy>=1.12; extra == 'docs'
+Provides-Extra: sat
+Requires-Dist: python-sat>=1.8; extra == 'sat'
+Provides-Extra: symbolic
+Requires-Dist: dit[symbolic]>=2.2; extra == 'symbolic'
+Requires-Dist: sympy>=1.12; extra == 'symbolic'
+Provides-Extra: test
+Requires-Dist: graphviz>=0.20; extra == 'test'
+Requires-Dist: hypothesis>=6.0; extra == 'test'
+Requires-Dist: hypothesis[numpy]; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-rerunfailures; extra == 'test'
+Requires-Dist: pytest-sugar; extra == 'test'
+Requires-Dist: pytest-xdist; extra == 'test'
+Requires-Dist: pytest>=9.0.3; extra == 'test'
+Provides-Extra: viz
+Requires-Dist: graphviz>=0.20; extra == 'viz'
+Requires-Dist: matplotlib>=3.5; extra == 'viz'
+Description-Content-Type: text/x-rst
+
+=======
+sofic
+=======
+
+``sofic`` is a Python package for hidden Markov models, symbolic dynamics,
+finite state machines, and other stochastic symbol generators.
+
+Basic Information
+-----------------
+
+Documentation
+~~~~~~~~~~~~~~
+
+https://sofic.readthedocs.io
+
+Repository
+~~~~~~~~~~
+
+https://github.com/dit/sofic
+
+Dependencies
+~~~~~~~~~~~~
+
+* Python 3.11+
+* `networkx <https://networkx.github.io/>`_
+* `numpy <http://www.numpy.org/>`_
+* `scipy <https://www.scipy.org/>`_
+* `pyyaml <https://pyyaml.org/>`_
+* `dit <https://github.com/dit/dit>`_ (information-theoretic measures)
+
+Development
+~~~~~~~~~~~
+
+Clone the repository and install development dependencies with ``uv``:
+
+.. code-block:: bash
+
+   git clone https://github.com/dit/sofic.git
+   cd sofic
+   uv sync --extra dev
+
+Run tests with ``uv run pytest``. See the ``generalinfo`` page in the Sphinx
+docs for linting, type checking, and documentation builds.
+
+Introduction
+------------
+
+Many natural and engineered processes produce sequences of symbols whose
+statistics are governed by latent structure: hidden states, transition rules,
+or algebraic constraints on allowed paths. ``sofic`` collects algorithms and
+data structures for representing, simulating, and analyzing such generators
+behind a single, composable Python API.
+
+Every model is a graph-backed state machine, so the same objects support
+construction, validation, simulation, visualization, (de)serialization, and a
+large library of structural and information-theoretic measures. The three
+main families are:
+
+* **Stochastic generators** (``sofic.generators``) — Markov chains, hidden
+  Markov models (Moore and Mealy presentations), ε-machines, probabilistic
+  finite automata, mixed-state presentations, and quasiprobabilistic
+  generators. These assign probabilities to sequences.
+* **Finite automata** (``sofic.automata``) — DFAs, NFAs, transducers
+  (Mealy/Moore machines), regular languages, Büchi automata, visibly pushdown
+  and nested-word automata, and residual finite-state automata. These recognize
+  or transform languages.
+* **Symbolic shifts** (``sofic.shifts``) — shifts of finite type, sofic
+  shifts, topological Markov chains, and Dyck/sofic-Dyck shifts. These describe
+  the *support* (set of allowed sequences) of a process.
+
+The package builds on NumPy, SciPy, and NetworkX and is designed to sit
+alongside the `dit <https://github.com/dit/dit>`_ ecosystem for
+information-theoretic analysis of the processes these models describe.
+
+Installation
+------------
+
+.. code-block:: bash
+
+   pip install sofic
+
+Optional extras:
+
+* ``sofic[viz]`` — Graphviz diagrams in terminals and Jupyter
+* ``sofic[bayes]`` — PyMC/ArviZ backends for Bayesian inference
+* ``sofic[test]`` — pytest, hypothesis, and graphviz for the test suite
+* ``sofic[docs]`` — Sphinx, IPython, and matplotlib for the docs
+* ``sofic[dev]`` — linting, type checking, docs, and all of the above
+
+Quickstart
+----------
+
+The basic workflow is the same for every model: build (or load) a generator,
+call ``validate()``, then compute properties or convert to another
+presentation. States can be any hashable object and every model exposes
+``states()``, ``transitions()``, ``draw()``, and ``to_yaml()``.
+
+Stochastic generators
+~~~~~~~~~~~~~~~~~~~~~~~
+
+**Markov chain** — a visible-state process. Edges carry ``P(target | source)``:
+
+.. code-block:: python
+
+   from sofic import MarkovChain
+
+   mc = MarkovChain(initial_distribution={"sunny": 0.5, "rainy": 0.5})
+   mc.add_transition("sunny", "sunny", 0.9)
+   mc.add_transition("sunny", "rainy", 0.1)
+   mc.add_transition("rainy", "sunny", 0.5)
+   mc.add_transition("rainy", "rainy", 0.5)
+   mc.validate()
+
+   mc.stationary_distribution()   # array([0.8333, 0.1667])
+   mc.entropy_rate()              # 0.5575 bits/symbol
+   mc.is_deterministic()          # False
+
+**Moore HMM** — hidden states with an emission law ``P(observation | state)`` on
+states and ``P(target | source)`` on edges:
+
+.. code-block:: python
+
+   from sofic import MooreHMM
+
+   moore = MooreHMM(
+       observation_alphabet=frozenset({"H", "T"}),
+       initial_distribution={0: 0.5, 1: 0.5},
+   )
+   moore.add_transition(0, 0, 0.5)
+   moore.add_transition(0, 1, 0.5)
+   moore.add_transition(1, 0, 0.5)
+   moore.add_transition(1, 1, 0.5)
+   moore.set_emission_distribution(0, {"H": 0.9, "T": 0.1})
+   moore.set_emission_distribution(1, {"H": 0.1, "T": 0.9})
+   moore.validate()
+
+   moore.stationary_distribution()             # array([0.5, 0.5])
+   moore.log_likelihood(["H", "H", "T", "T"])  # -2.7726 (log2)
+   observations, hidden = moore.sample(6)      # simulate the process
+
+**Mealy HMM** — hidden states with a joint transition/emission law
+``P(target, symbol | source)`` on edges. Here is the golden-mean process
+(consecutive ``1``\ s are forbidden):
+
+.. code-block:: python
+
+   from sofic import MealyHMM
+
+   gm = MealyHMM(
+       observation_alphabet=frozenset({0, 1}),
+       initial_distribution={"A": 2 / 3, "B": 1 / 3},
+   )
+   gm.add_transition("A", "A", 0, 0.5)   # source, target, symbol, probability
+   gm.add_transition("A", "B", 1, 0.5)
+   gm.add_transition("B", "A", 0, 1.0)
+   gm.validate()
+
+   gm.entropy_rate()             # 0.6667 bits/symbol
+   gm.is_unifilar()              # True
+   gm.word_probability([1, 0, 1])  # 0.1667
+
+Many canonical models ship in ``sofic.examples``, so the golden mean is
+also just ``from sofic.examples import golden_mean; gm = golden_mean(0.5)``.
+
+**ε-machine** — the minimal unifilar (causal-state) presentation of a stationary
+process. Build one from any HMM, from an observed sequence, or directly, and
+read off computational-mechanics quantities:
+
+.. code-block:: python
+
+   from sofic import EpsilonMachine
+
+   eps = EpsilonMachine.from_hmm(gm)          # minimize an HMM presentation
+   # eps = EpsilonMachine.from_sequence(data, method="cssr", Lmax=4)  # infer
+   # eps = EpsilonMachine.from_sequence(data, method="spectral", prefix_length=3, rank=2)
+
+   eps.statistical_complexity()   # 0.9183 bits  (C_mu)
+   eps.entropy_rate()             # 0.6667 bits/symbol  (h_mu)
+   eps.markov_order()             # 1
+   eps.cryptic_order()            # 1
+
+Finite automata
+~~~~~~~~~~~~~~~
+
+**DFA** — a deterministic recognizer. This one accepts strings with an even
+number of ``b``\ s (states are added before their transitions so determinism can
+be checked as you go):
+
+.. code-block:: python
+
+   from sofic import DFA
+
+   dfa = DFA(
+       input_alphabet=frozenset({"a", "b"}),
+       initial_states=frozenset({"even"}),
+       accepting_states=frozenset({"even"}),
+   )
+   dfa.graph.add_state("even")
+   dfa.graph.add_state("odd")
+   dfa.add_transition("even", "even", "a")
+   dfa.add_transition("even", "odd", "b")
+   dfa.add_transition("odd", "odd", "a")
+   dfa.add_transition("odd", "even", "b")
+   dfa.validate()
+
+   dfa.recognizes("abba")   # True  (two b's)
+   dfa.recognizes("abbb")   # False (three b's)
+   dfa.minimize()           # DFA(2 states, 4 transitions)
+   dfa.to_regex()           # 'a*|a*b(?:...)*ba*'
+
+**NFA** — nondeterministic, with first-class ε-transitions. Determinize to a DFA
+when you need one:
+
+.. code-block:: python
+
+   from sofic import NFA
+
+   nfa = NFA(
+       input_alphabet=frozenset({"a", "b"}),
+       initial_states=frozenset({"q0"}),
+       accepting_states=frozenset({"q2"}),
+   )
+   nfa.add_transition("q0", "q0", "a")
+   nfa.add_transition("q0", "q0", "b")
+   nfa.add_transition("q0", "q1", "a")
+   nfa.add_transition("q1", "q2", "b")
+   nfa.validate()
+
+   nfa.recognizes("ab")   # True
+   dfa = nfa.determinize()
+
+**Transducer (Mealy machine)** — maps input words to output words. This one
+inverts bits:
+
+.. code-block:: python
+
+   from sofic import MealyMachine
+
+   inv = MealyMachine(
+       input_alphabet=frozenset({"0", "1"}),
+       output_alphabet=frozenset({"0", "1"}),
+       initial_states=frozenset({"q"}),
+   )
+   inv.add_transition("q", "q", "0", "1")   # source, target, input, output
+   inv.add_transition("q", "q", "1", "0")
+   inv.validate()
+
+   inv.transduce("0110")   # {('1', '0', '0', '1')}
+
+All automata also support ``union``, ``intersection``, ``complement``,
+``difference``, ``concat``, and ``kleene_star`` (see the
+``LabeledAutomaton`` base class).
+
+Symbolic shifts
+~~~~~~~~~~~~~~~
+
+**Shift of finite type** — the set of sequences avoiding a finite list of
+forbidden words. The golden-mean shift forbids ``11``:
+
+.. code-block:: python
+
+   from sofic import ShiftOfFiniteType
+
+   sft = ShiftOfFiniteType.from_forbidden_words(
+       {("1", "1")},
+       symbol_alphabet=frozenset({"0", "1"}),
+   )
+   sft.validate()
+
+   sft.forbidden_words()        # frozenset({('1', '1')})
+   sorted(sft.factor_language(3))  # allowed length-3 words
+   sft.is_unifilar()            # True (right-resolving presentation)
+
+**Topological Markov chain** — an adjacency-matrix presentation; compute the
+topological entropy or extract the measure of maximal entropy:
+
+.. code-block:: python
+
+   import numpy as np
+   from sofic import TopologicalMarkovChain
+
+   tmc = TopologicalMarkovChain.from_adjacency(
+       np.array([[1, 1], [1, 0]], dtype=float),   # golden-mean adjacency
+       symbol_alphabet=frozenset({0, 1}),
+   )
+   tmc.validate()
+
+   tmc.topological_entropy()   # 0.4812  (ln of the golden ratio)
+   tmc.parry_measure()         # MealyHMM at maximal entropy
+
+**Sofic shift** — a labeled-graph presentation (the shift-space analog of an
+NFA). This is the even shift (even-length runs of ``0`` between ``1``\ s):
+
+.. code-block:: python
+
+   from sofic import SoficShift
+
+   even = SoficShift(symbol_alphabet=frozenset({0, 1}))
+   even.add_transition("even", "even", 0)
+   even.add_transition("even", "odd", 1)
+   even.add_transition("odd", "even", 1)
+   even.validate()
+
+   even.topological_entropy()   # 0.4812
+
+Converting between model types
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The presentations are related by a web of conversions. Probabilistic models can
+drop their weights to become automata or shifts (keeping only their support);
+HMMs can be minimized to ε-machines; automata can be determinized, minimized,
+and turned into regular expressions:
+
+.. code-block:: python
+
+   # Between stochastic presentations
+   gm.to_mealy()                       # any HMM -> Mealy HMM
+   moore.to_mealy()                    # Moore -> Mealy (joint edge law)
+   EpsilonMachine.from_hmm(gm)         # HMM -> minimal causal ε-machine
+   eps.to_bidirectional()             # ε-machine -> bidirectional presentation
+   eps.mixed_state_presentation()      # -> observer belief-state dynamics
+   EpsilonMachine.from_time_reversed(eps)  # forward -> reverse ε-machine
+
+   # Stochastic -> topological (drop probabilities, keep the support)
+   gm.to_sofic_shift()                 # HMM support as a sofic shift
+   gm.to_support_nfa()                 # HMM support as an NFA
+   gm.to_support_dfa()                 # HMM support as a (determinized) DFA
+
+   # Between automata
+   nfa.determinize()                   # NFA -> DFA
+   DFA.from_nfa(nfa)                   # NFA -> DFA (same result)
+   dfa.minimize()                      # DFA -> minimal DFA
+   dfa.to_regex()                      # automaton -> regular expression
+
+   # Between / out of shifts
+   tmc.to_sofic_shift()                # topological Markov chain -> sofic shift
+   tmc.parry_measure()                 # shift -> max-entropy MealyHMM
+   sofic.parry_measure()               # sofic shift -> max-entropy MealyHMM
+
+Every model can also be round-tripped through YAML:
+
+.. code-block:: python
+
+   text = eps.to_yaml()
+   restored = EpsilonMachine.from_yaml(text)
+   # or: sofic.model_to_yaml(eps) / sofic.model_from_yaml(text)
+
+Information anatomy (advanced)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+With ``dit`` installed, a bidirectional ε-machine exposes the full stored- and
+transient-information anatomy of a process (James, Burke & Crutchfield, 2013):
+
+.. code-block:: python
+
+   from sofic.examples import golden_mean_bidirectional, tent_map_misiurewicz_bidirectional
+
+   bidir = golden_mean_bidirectional(0.5)
+   bidir.statistical_complexity()   # 1.5850 bits  (C±)
+   bidir.excess_entropy()           # 0.2516 bits  (E)
+   bidir.crypticity()               # 1.3333 bits  (chi = C± - E)
+
+   tent = tent_map_misiurewicz_bidirectional()
+   tent.information_anatomy()  # {'rho_mu', 'bound_mu', 'ephemeral_mu',
+                              #  'entropy_rate', 'excess_entropy', 'crypticity'}
+
+License
+-------
+
+``sofic`` is distributed under the BSD 3-Clause License; see ``LICENSE.txt``.

sofic-0.1.0.dist-info/RECORD

@@ -0,0 +1,150 @@
+sofic/__init__.py,sha256=ii_13tOCVcdvHgA3voyBZ7I3IpyPEsFsbjHbXPliPT4,4290
+sofic/base.py,sha256=DwRUWcbDWBrWo3rfFbVCOMk3RoAmhrp7B_-S1YA_TdA,5168
+sofic/core.py,sha256=uEfilrMfffm-T13HguUQxPKmcl_m3YnYFbj52rwHr88,920
+sofic/exceptions.py,sha256=0WKAdfta__X45nnblGJnl-kt4Y4NEI-tEoZVPHXPMBo,921
+sofic/graph.py,sha256=5oomNKxMTreqNfa9EyKZgqlv4d3i0DfL7xJMkWSe7SA,4491
+sofic/indexing.py,sha256=Peb4QdjeoUAFSgn7OmOqTNR61-ZOKpJwtataZUjMBOg,861
+sofic/operations.py,sha256=bM-qyRJbx6lDEMCp-eZZEGH3Ynj_IPFNDHKKMJzTGzE,594
+sofic/properties.py,sha256=cROWDN6PB7AoDK-Di1lpIOyuc165pyMsRCBdbsx3jwg,12538
+sofic/serialization.py,sha256=PsgU3KIVDN3SRkoM6QkUJ38sFVTmOv-o7nRHPeCbrRM,17585
+sofic/states.py,sha256=NnsEaHsKW8qzuFA1x2XV7WeD4OQeBY_du410RTQfxqQ,1111
+sofic/automata/__init__.py,sha256=K3Wom17IgiIQ3DU8Z6LsCjoPW6vFAxje0f-kWwV59VI,5653
+sofic/automata/_config_simulation.py,sha256=OFdq6E_wM9Ih8WuDmvScPlBUvRRi8R_qffvQHhGFm9c,1480
+sofic/automata/active.py,sha256=bryUzkVIN_oGJA70OqwUsE0uzq4K3R7cL7WAPHLBB5g,21549
+sofic/automata/alergia.py,sha256=vHEhb_SN_yjsMfA8b_EYEtmLESDHBh_rVVTK7VfCAug,7862
+sofic/automata/algorithms.py,sha256=xuqFRoy7tP4A_HKDQX1ANNTOlUz8JAPIV1a1ZYoYKA8,13759
+sofic/automata/atomaton.py,sha256=AjUKU9b5yihzHH0EGVrkUPv2DlmEshSBiq6-jCHNRmM,1993
+sofic/automata/base.py,sha256=TAXN3hhDOEkPDAfrMAc2G1-6Mc1ScQIbYyZDcnBfGTk,6371
+sofic/automata/buchi.py,sha256=VnfC-11nTj_Swf_vyLXocJyxJC5wJprU17ab8Z9VXlw,794
+sofic/automata/buchi_simulation.py,sha256=orCoeF199Nl7YxKRF0-r1rgz8vcNKAuS29_Xlogr3-4,2246
+sofic/automata/canonical_dual.py,sha256=3-1rZBCAIuSQMgxpWB05GK_QpLv7nS5X7R7jmkzzjG8,661
+sofic/automata/canonical_extraction.py,sha256=dvp85XAlfMN4fXszp9QZscy4ejmtsOoW3OLn6u21hpY,4551
+sofic/automata/dfa.py,sha256=jzhe7QsweQQsI6fJx1qkDWS4V7KPSB3PvrZhDrIC4fk,3207
+sofic/automata/dfasat.py,sha256=cTuePqzPffX5hTZ5KmJCiX9Bwl3BtBUKGaeY5izsv30,6549
+sofic/automata/edsm.py,sha256=6M1Ux45sQP0zRmXxbCoynjsiVYVrjIRmA8Iv7mnspYc,7352
+sofic/automata/enumeration.py,sha256=77Th5HlQkPWScAkx8UYKsxPnZjN272MpwxxC6OiMGbM,1369
+sofic/automata/icdfa.py,sha256=neEIMajs66DWTSBvglroZ-8bjg_azERPVM8ZkEDAzW0,14164
+sofic/automata/idfa.py,sha256=wKxC4CKrEoDLG_-8zV758ujhR4uehpG_rYUBKfs118I,12006
+sofic/automata/learning.py,sha256=o6zUz92ia5vOZGXyAztR_I6XO7jYy4bxk4Ll0VgmG5Y,2660
+sofic/automata/nfa.py,sha256=FWCkKGJhPAXtOopAvNnYmdbQK2OxfxD6ZcqcRPh5e1I,1313
+sofic/automata/nwa.py,sha256=Jk6yIRAClh6R75-oHcj3cOdr32dWX3b6poCuToW0hSE,14990
+sofic/automata/nwa_simulation.py,sha256=7rE-bfBvLlPDGyOIwNaR-AZ3Q8JGJJelhr06LVYgqp4,2101
+sofic/automata/observation.py,sha256=rdn9-rW2C6wxSc07u8DkuOPPJZptElSo6nqXKsNJzqI,1497
+sofic/automata/papni.py,sha256=-zcfpMBQlwD2Rz5V-4bX1BHs788jSOAcxewYfPK9Mdc,11113
+sofic/automata/regex.py,sha256=iskKWngd593Afo6CObTrD4qeCHzrTF_8kpvp5P7Tl54,4088
+sofic/automata/rfsa.py,sha256=eGWwnv3BJJDiTfTOny-ERi2Z3ggW22PXSXbExwoIIew,1159
+sofic/automata/rpni.py,sha256=bFjaUvlH4PBlk-O3gN79jpfRmonVWesLyFHnTUFIiF0,6384
+sofic/automata/subsequential.py,sha256=E2ntA4v1ZlrPZyDVoIAxVzdPV0BHvr_RpfII6TRMviw,8248
+sofic/automata/transducer_operations.py,sha256=YV8dS5iy_rxFzvmMlCEJN3LnN7JEdG49chyxKxM8kQQ,14125
+sofic/automata/transducer_simulation.py,sha256=9LEvV7BzMyes6ymJPaFqPi3qZi-z7XLY8TLbxeHdGQI,5609
+sofic/automata/transducers.py,sha256=cbYfDtIYSc7OVBnEqkWZPBn5eJTWKFRWFHaxAWEfc2k,15178
+sofic/automata/unifilar.py,sha256=54Qaof-nzFlLbKiPTwFDstPySZoy34D8vjLtXx7k9GE,4486
+sofic/automata/vpa.py,sha256=uBWlqF6qaRv4CJldnPXEUnC5vkP3GcnJ2OZir7BmqqE,58567
+sofic/automata/vpa_simulation.py,sha256=YL3zRQUy4CLMvRWupBLur9ImjUJ7-0y24ha4ZDT-Zsg,2086
+sofic/automata/languages/__init__.py,sha256=hVWvX4ZxePDo7gcThvbNRsL_nGqgxq7l8lUM8SoLKuw,994
+sofic/automata/languages/_quotient_utils.py,sha256=NCIV29vwUP9kQBtqIj9TgNVPU7KHP8EBluxWNsPhVA0,2216
+sofic/automata/languages/atoms.py,sha256=2fDfxlTikWLovDtffGysp0QQTrT8KzkfDesQne35sJk,1383
+sofic/automata/languages/automaton_ops.py,sha256=v7hHPGW9Q9JTyGAFTRv9bi4DuxGobDFmQaTF_mZsXso,8703
+sofic/automata/languages/base.py,sha256=CyBrTUgC3ATMd8JrxdkPvdG61w26K0Uka_JzkeHjFXQ,1997
+sofic/automata/languages/operations.py,sha256=HZRrbgMmJzu8kF3cgLZK850nm0LEjLvAMqqFxZDOhjQ,3633
+sofic/automata/languages/quotients.py,sha256=zeVsQPAQ07Mhhfy3Vhq_qrfc1EUVFTuixNzn_IFEo-Y,2892
+sofic/automata/languages/residuals.py,sha256=JiB3cEsT6ZGg60xShc-hINrvkLjE93OxAXZC0Kos9bo,1046
+sofic/examples/__init__.py,sha256=1GBuCJMFCbKDm9I-hR9vleR3vgOHiVDSTxNNjzzm4vo,2649
+sofic/examples/epsilon_machines.py,sha256=ycpPrxyZy1_s18kAZfS25fMqidtwpzaRqV7Glsi56-o,40571
+sofic/examples/processes.py,sha256=P2KcRN-5I1_EXFJQDqAU0Tl8ssSpxVV1eeHLVsHYye8,52439
+sofic/examples/shifts.py,sha256=uKICqYSUAthqSL8snA_JUzouJfiFveTyNweZSDk4lnk,5415
+sofic/generators/__init__.py,sha256=3XVm0LPR9F-0BWaEjA0YY2Ma3pgeFV91rBnw2sQx5uY,3884
+sofic/generators/_word_measures.py,sha256=Xr4Coupl5do-OLz5OyKUggnD6zqjz74bJXrRpwnBl_A,2955
+sofic/generators/alternative_complexity.py,sha256=Xd_5Cm6nj9nchGsnCS62E88iHJt5-tK4HWNOR3Ne6Ts,3489
+sofic/generators/base.py,sha256=9XhX92SUOyEakHHcmbXtuv8AJ1ubbshuIDU0y4mR6NA,12895
+sofic/generators/bidirectional_construction.py,sha256=PbFlPCR2MkO8_kc9NM3PSoWylc7dY32rYTWC6YcbwF8,27476
+sofic/generators/bidirectional_epsilon_machine.py,sha256=-DHWbCWOoIabRagMC6RUZz8RoBFrj49HXaGQq_qJYIk,30966
+sofic/generators/block_convergence.py,sha256=l3cVnob9a4rEmlmtrEKbR33Cmbi2mF47AwZgM-w7n6Y,25885
+sofic/generators/block_entropy.py,sha256=IdypvElTpJWbieo95Z6n_cp2IqF9Og_Z9PFj6lIxlGA,21587
+sofic/generators/channel_measures.py,sha256=eYYItbcei9rYwZZZTK5NkGe61pacC221nV37HHkyzzc,3386
+sofic/generators/conversions.py,sha256=tpRUaJUXLz8g07QcGO4b5hxEqqzgW7UwwVh5WMaWzMw,6596
+sofic/generators/directional_flow.py,sha256=WyHhLF_l2-p5-F6TT5JHlH4LurqnD_Ion2-FiRpA5Vk,8312
+sofic/generators/edge_emissions.py,sha256=ydNUrclW24gcPmaqbGVAEy0atrr577VhJUi80P5NkMI,1521
+sofic/generators/edge_machine.py,sha256=nnbIXOrruKGiyy4jZzVphjhPBh6rOTyhdx5-U6f8mTY,6222
+sofic/generators/epsilon_construction.py,sha256=H-VQ06MoL2y0u5whKmSVy5jps-1KUrjKQnzXll1wpQA,6888
+sofic/generators/epsilon_inference.py,sha256=3ky0Cw85H6uRLODPu-jCGCpUxrWLVpvX5hnlKdfLhKI,27141
+sofic/generators/epsilon_machine.py,sha256=jBjc2x71MPaN0RzFSHv6AWF9HmGxkW6RYgN7wBXE7nw,25711
+sofic/generators/epsilon_transducer.py,sha256=wNhatXuH7CW-5UAUa6rauCKJYvamr-MjAWWQlw8HGms,7320
+sofic/generators/epsilon_transducer_construction.py,sha256=f_IwrsPPjVSy2XatGG72WzB0Dj1NduUlIh73yh9eFPc,7358
+sofic/generators/epsilon_transducer_inference.py,sha256=gVusFjCOEwNgfohti7PoXQo0xhz8pinMbnN3gwbXma4,19747
+sofic/generators/hmm_inference.py,sha256=FqjlcumjWMUuLY06osp6j3-227RszuAmYn4LKDXvI4c,29280
+sofic/generators/information_diagram.py,sha256=PnBitp04_v6EevAitiFy2zzmMV-Z9MTBPRxiKcuIA3E,15319
+sofic/generators/lumping.py,sha256=AqWeanqXDSpwJ7ZLErLc2zveMm_zVUXcv1PBE6i3TQY,16910
+sofic/generators/markov.py,sha256=ToNzWnH_hJh-B3vxB-SZO8hDMgdunlX85hxF2j23GYI,4091
+sofic/generators/mealy.py,sha256=_5GPCqM9J4vvwi4Bjq4RxQGn5Kcd6YZbw2oks3SyFNQ,5925
+sofic/generators/measures.py,sha256=ai4gAlhqo2Q5_GOM4-LRlVpf-QmQ0--_qn0iGAHiLog,9612
+sofic/generators/minimal_generative_model.py,sha256=7LaVRkvEdvjEbpVtKNe62Pxj_HD2nC17otre8OHobMA,31000
+sofic/generators/mixed_state.py,sha256=qlzV7VygK5vwkd0Lt56868qkHV-NayBUOinhEEm23lI,9161
+sofic/generators/mixed_state_construction.py,sha256=UJNqo8VF7-fNz5HzBHq9UnnUbVyXN0NaT60adybHOVo,6013
+sofic/generators/moore.py,sha256=vyAVzDs8slz_sKl3OGTyAclc_XcOjUehm8v96yA_STk,3209
+sofic/generators/nmachine.py,sha256=WqRuJrEztwEkA1V6i22hxqzYY8LS_whF2fGkUIq_OoQ,3167
+sofic/generators/nmachine_construction.py,sha256=bhh5XXI1cyNYS-qstPngQ9xYLjwg5-lray0HELtDTR0,2548
+sofic/generators/pfa.py,sha256=MA1owkSr_d0fBVLrrdXb7b3AMKUUBYy3KsFa2-za5MI,3972
+sofic/generators/prob.py,sha256=UxqnQed4XvdmKueHKvX-kklmbrmNipLkP0tHNow3qSw,10614
+sofic/generators/process_equivalence.py,sha256=UKORNNeK5Zis6TLJiIknz3NsPD8iL5CWoeeVxnILlfc,7612
+sofic/generators/quasi_inference.py,sha256=a1UdSIpIRH4pTulqrwGCRc6Zt4TnrKll1D7NE5oQha4,2415
+sofic/generators/quasi_realization.py,sha256=QQosziYqNHEPo1Su4Qjp9k0zBxpqi4wzxUwRahZ57Wk,3501
+sofic/generators/reversal.py,sha256=EGf8KP507Ho1oATqdK1dePqZH4hN7eafJF8DHMJGtYY,2453
+sofic/generators/stack_hmm.py,sha256=I_SBENucbWdnTQKKx-HP760X06xKOJylfQC-L70fYp8,18868
+sofic/generators/stack_inference.py,sha256=wCFbP8kbB2Flzp61N8uN6wkcoCY_wE-mDBw-vFTM40I,18000
+sofic/generators/stationary.py,sha256=nN0ugt61Bl1xiY-8ITF-T__0rfkK0icsbwhQapTLZxM,4992
+sofic/generators/stochastic.py,sha256=_mSfLCxGG_NmA42tvV-kBOzWSgqH6n30uX_igITwVxU,2223
+sofic/generators/synchronization.py,sha256=q8VHzMjLFHITpax5wHlG5a3gSfxOgXwNBW5cnng9q5I,16787
+sofic/generators/topological_epsilon_enumeration.py,sha256=ohxAVtEruXzvDbcqB2AmcIvcDyYVz8xoyh2h2X1CoKQ,12572
+sofic/generators/words.py,sha256=ZZMsAumG8_jMy90GcwLBw1-PkljOM2pfI7rGAy40jVA,8382
+sofic/inference/__init__.py,sha256=9x1af3bORgxAKKs4RJRtsXCATsZsK3BmoJPvETCoYi0,1108
+sofic/inference/model_selection.py,sha256=_s38_lYOmvY_t7TOLaOHArYKrdM3qgRyOU9UBzoC5S8,14099
+sofic/inference/spectral.py,sha256=o6XGTaJkQUaV0SWA-5Xun02bHrvKsONo0dMZOXl6WKU,22108
+sofic/inference/bayesian/__init__.py,sha256=xuf70Lejgo-2mdiyDH6MVwocXzMBYiaMUlbmQT9e0yE,2056
+sofic/inference/bayesian/comparison.py,sha256=ZrQbKRS2jkpa7x9gJZp6aIoOv9CFUgeghklZN-LjzNo,7952
+sofic/inference/bayesian/counts.py,sha256=vd-J_plBsr6oFZFfniqdfGSUdVGlucaw2PKb8JmDcvo,8105
+sofic/inference/bayesian/diversity.py,sha256=xfjf8qx6c5cNSFEoutSIz1-JFOwA8ymyTzpe3NTOAZA,9929
+sofic/inference/bayesian/epsilon.py,sha256=sOBoM5oXvqNJG714i30u4JmM472oywRPTCAlWVYaBAI,12035
+sofic/inference/bayesian/hdp_hmm.py,sha256=hbMyknq7RgN-p2akqFc5aKuF2mhSIwy1Aqen-ytPbdY,13749
+sofic/inference/bayesian/markov.py,sha256=_OsE3pZkFxbEGSJ_bDne3NWw5GSM8gBFhMQMitLni6o,12697
+sofic/inference/bayesian/pymc_backend.py,sha256=YMq-2PkUWX3ZXXZSZPdIYfSOXHi2kaeM2mqfaABo6SA,2984
+sofic/inference/bayesian/stack_hmm.py,sha256=wdtv1qOgRxRcdfwaO1OAXx_q2HJRGDqFGszyRVoSoVA,8566
+sofic/shifts/__init__.py,sha256=8MAtvrdAghmtLFwQY0PA5d8jFUg4_5wGl19ESd5Yors,1373
+sofic/shifts/algorithms.py,sha256=JxfvlSWvz9n2j10HCYcclyhk6CfvPc_oOaGkQWcWkHE,2769
+sofic/shifts/base.py,sha256=IFlL_kMv6MTeQD3wMljmnw6G9xBB5Mz7U6rXdRWkHCg,1844
+sofic/shifts/cover_construction.py,sha256=aiRNyhWds7eJ_VAyTzMJlMlNH9L3gf-A0ojba0r9RR0,2901
+sofic/shifts/covers.py,sha256=x8qcbRQIrj6gH8oL9WJLBbeZulmecvsHx1i0daGRCGw,1367
+sofic/shifts/dyck_algorithms.py,sha256=sTuqbjkD2cLydrEwd9i-pKuWOvmzzhwVw84Hsys6KVo,3479
+sofic/shifts/dyck_enumeration.py,sha256=4eQXDu-3J2-J1Pg_qSvhCT9upnFWs9Bof3Qndl0Pthc,10165
+sofic/shifts/markov_dyck.py,sha256=KA8sbHY59xDDVBVNkJUzb8xgBTbcENijlwQFujzcVvs,6813
+sofic/shifts/parry_construction.py,sha256=JLwlXeqvO-bIro5RVXCo0xADsn4s_JhUx-VI2QTn9AI,2823
+sofic/shifts/sft.py,sha256=RSB7zSDlpggdU47AdhtM6xOm02YJHIGZ38JhvKLsMKg,3973
+sofic/shifts/sft_construction.py,sha256=V-PRlhInOOlU_nXQNU7vZLgGEDw-5VueP3K7RaSV5w0,1603
+sofic/shifts/sliding_block_code.py,sha256=RaZXzSNcc1RZsQnglmY7BVhK6VI0HEpvvPuWqRefsyU,6602
+sofic/shifts/sofic.py,sha256=Pghqv4ODoYbRdOhvgUIjaasCXu4vD89bY1cR-AlIBIM,4690
+sofic/shifts/sofic_dyck.py,sha256=MRsImxWj4gAn32KDVAskygHUg3MJX13SmsEoflzEjG4,5569
+sofic/shifts/sofic_relation.py,sha256=PCF30jOSCS5lsWOGOUd0MGCopg6fOBGbMDeV1Yj1ehc,2707
+sofic/shifts/textile.py,sha256=JC8Y6Wjdj5KQdObPDtROdzFdydyRMAtoresaaE5n8PM,4632
+sofic/shifts/tmc.py,sha256=kSwBRGiUyErW8oVBvjinItIFfdUZo-oluqhjzfYzHKo,1442
+sofic/shifts/tmc_construction.py,sha256=bOB8UcaK81P1NfDPwqV3i_IpD2Bz0hDldmSbReYi0aM,2047
+sofic/shifts/topological_anatomy.py,sha256=VzTNX_iih91UZmTDcc856IfquWKmNDnBfmgvIX1XAwg,6687
+sofic/testing/__init__.py,sha256=iXB73G_LmxCYQpE0_QgR5pBkJoRSQBYrKEgKoUQLcZY,167
+sofic/testing/strategies.py,sha256=6CW77uTRioBX9jpSnj-cL4Rep-tCt7zuLIc-WZWW5_A,5210
+sofic/viz/__init__.py,sha256=cvH7NCrlgakhONsUZkQYhwaE0iaIdqdVnNStUWg7jk8,479
+sofic/viz/_context.py,sha256=e8VGhiLyQa7O5WK9FZjrSozEqzl66N9V8oE90TMMVPs,12608
+sofic/viz/_edge.py,sha256=B2TXmelVbqdQ_ulq2E9ZDvvftcisDDnWhLIqQC_J33c,7825
+sofic/viz/_format.py,sha256=-JQSm_Z185OnIpU8hdViCfJnnk6O3dJvlv7NpPRNExo,2730
+sofic/viz/_labels.py,sha256=C67PJVjVMufAUmgoKKc2wvtxfFMuK8BRXzQ82sg5VpE,1314
+sofic/viz/_names.py,sha256=8IE3AbvOTCMU8IRdj-0dOV1LeOtWLPTO4AObcRo9t_0,447
+sofic/viz/_rational.py,sha256=pZ0IAm0LD1WgpScyCy9a5m1sySw5ppSsiVg0wRid1j0,721
+sofic/viz/_tikz_compile.py,sha256=5cVshbDklLtafvNh1lZyf2NccFhtqsmfmt2GxPDnC-E,5942
+sofic/viz/_tikz_format.py,sha256=bYHQt2K22fFoduDm3u8VhD0YBApYi0oGCJKP8wtWQFM,3782
+sofic/viz/_tikz_layout.py,sha256=BzmOYzsCCFRqVRbAwCwJUQq2lSLv0LD0270Qc-6A-As,7406
+sofic/viz/graphviz.py,sha256=0I3JEsJ-dIjR8Wn0Oj0_YRdWPfn_p47lQgEigu9G1Wk,5174
+sofic/viz/idiagram.py,sha256=w1QyptmuwmwXx9O_Xms3oWXdr1NL5naOdD8H5Lf2N5c,12796
+sofic/viz/tikz.py,sha256=FSzRU3WFQDTpe5a4kMiau28xgYf83lAw_w0TTF_Inds,13445
+sofic/viz/assets/vaucanson.tikz,sha256=Mrrrv8zOUfjSUzvAkFUsYVB4AdJH5ymLdO5C-QTsK0c,2657
+sofic-0.1.0.dist-info/METADATA,sha256=Fi8DbQFbtrxMOyyulmyo7P3989MUqsI_cYC2r2-Fk4s,15613
+sofic-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sofic-0.1.0.dist-info/licenses/LICENSE.txt,sha256=ezk-F-oQ6gQkTLC1BA1JLl26_Ou5W01ofFriVuRY5Qs,1519
+sofic-0.1.0.dist-info/RECORD,,

sofic-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sofic-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, sofic contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.