AFW¶
Module to manage AFW (Alternating Finite automaton on Words).
Formally a AFW (Alternating Finite automaton on Words) is a tuple \((Σ, S, s0, ρ, F )\), where:
Σ is a finite nonempty alphabet;
S is a finite nonempty set of states;
\(s0 ∈ S\) is the initial state (notice that, as in dfas, we have a unique initial state);
F ⊆ S is the set of accepting states;
\(ρ : S × Σ → B+(S)\) is a transition function. \(B+(X)\) be the set of positive Boolean formulas over a given set X ex. of \(ρ: ρ(s, a) = (s1 ∧ s2) ∨ (s3 ∧ s4)\)
In this module a AFW is defined as follows
AFW = dict() with the following keys-values:
alphabet => set()
states => set()
initial_state => ‘state_0’
accepting_states => set()
- transitions => dict(), where
key (state ∈ states, action ∈ alphabet)
- value [string representing a PYTHON boolean expression
over states; where we also allow the formulas True and False]
List
|
Returns the dual of the input formula. |
|
Returns a AFW reading the complemented language read by input AFW. |
|
Side effect on input! Complete the afw adding not present transitions and marking them as False. |
|
Returns a AFW that reads the intersection of the languages read by input AFWs. |
Checks if the input AFW reads any language other than the empty one, returning True/False. |
|
Checks if the language read by the input AFW is different from Σ∗, returning True/False. |
|
Returns a NFA reading the same language of input AFW. |
|
|
Returns a AFW that reads the union of the languages read by input AFWs. |
Returns a AFW reading the same language of input NFA. |
|
|
Side effect on input! Renames all the states of the AFW adding a suffix. |
|
Checks if a word is accepted by input AFW, returning True/False. |
Functions
- PySimpleAutomata.AFW.afw_complementation(afw: dict) dict [source]¶
Returns a AFW reading the complemented language read by input AFW.
Let \(A = (Σ, S, s^0 , ρ, F )\). Define \(Ā = (Σ, S, s^0 , \overline{ρ}, S − F )\), where \(\overline{ρ}(s, a) = \overline{ρ(s, a)}\) for all \(s ∈ S\) and \(a ∈ Σ\). That is, \(\overline{ρ}\) is the dualized transition function. It can be shown that \(L( Ā) = Σ^∗ − L(A)\).
The input afw need to be completed i.e. each non existing transition must be added pointing to False.
- Parameters:
afw (dict) – input AFW.
- Returns:
(dict) representing a AFW.
- PySimpleAutomata.AFW.afw_completion(afw)[source]¶
Side effect on input! Complete the afw adding not present transitions and marking them as False.
- Parameters:
afw (dict) – input AFW.
- PySimpleAutomata.AFW.afw_intersection(afw_1: dict, afw_2: dict) dict [source]¶
Returns a AFW that reads the intersection of the languages read by input AFWs.
Let \(A_1 = (Σ, S_1 , s^0_1, ρ_1 , F_1 )\) and \(A_2 = (Σ, S_2 , s^0_2, ρ_2 , F_2 )\) be alternating automata accepting the languages \(L( A_1)\) and \(L(A_2)\). Then, \(B_∩ = (Σ, S_1 ∪ S_2 ∪ {root}, root, ρ_∩ , F_1 ∪ F_2 )\) with \(ρ_∩ = ρ_1 ∪ ρ_2 ∪ [(root, a): ρ(s^0_1 , a) ∧ ρ(s^0_2 , a)]\) accepts \(L(A_1) ∩ L(A_2)\).
- Parameters:
afw_1 (dict) – first input AFW;
afw_2 (dict) – second input AFW.
- Returns:
(dict) representing a AFW.
- PySimpleAutomata.AFW.afw_nonemptiness_check(afw: dict) bool [source]¶
Checks if the input AFW reads any language other than the empty one, returning True/False.
The afw is translated into a nfa and then its nonemptiness is checked.
- Parameters:
afw (dict) – input AFW.
- Returns:
(bool), True if input afw is nonempty, False otherwise.
- PySimpleAutomata.AFW.afw_nonuniversality_check(afw: dict) bool [source]¶
Checks if the language read by the input AFW is different from Σ∗, returning True/False.
The afw is translated into a nfa and then its nonuniversality is checked.
- Parameters:
afw (dict) – input AFW.
- Returns:
(bool), True if input afw is nonuniversal, False otherwise.
- PySimpleAutomata.AFW.afw_to_nfa_conversion(afw: dict) dict [source]¶
Returns a NFA reading the same language of input AFW.
Let \(A = (Σ, S, s^0 , ρ, F )\) be an afw. Then we define the nfa \(A_N\) such that \(L(A_N) = L(A)\) as follows \(AN = (Σ, S_N , S^0_N , ρ_N , F_N )\) where:
\(S_N = 2^S\)
\(S^0_N= \{\{s^0 \}\}\)
\(F_N=2^F\)
\((Q,a,Q') ∈ ρ_N\) iff \(Q'\) satisfies \(⋀_{ s∈Q} ρ(s, a)\)
We take an empty conjunction in the definition of \(ρ_N\) to be equivalent to true; thus, \((∅, a, ∅) ∈ ρ_N\).
- Parameters:
afw (dict) – input AFW.
- Returns:
(dict) representing a NFA.
- PySimpleAutomata.AFW.afw_union(afw_1: dict, afw_2: dict) dict [source]¶
Returns a AFW that reads the union of the languages read by input AFWs.
Let \(A_1 = (Σ, S_1 , s^0_1, ρ_1 , F_1 )\) and \(A_2 = (Σ, S_2 , s^0_2, ρ_2 , F_2 )\) be alternating automata accepting the languages \(L( A_1)\) and \(L(A_2)\). Then, \(B_∪ = (Σ, S_1 ∪ S_2 ∪ {root}, ρ_∪ , root , F_1 ∪ F_2 )\) with \(ρ_∪ = ρ_1 ∪ ρ_2 ∪ [(root, a): ρ(s^0_1 , a) ∨ ρ(s^0_2 , a)]\) accepts \(L(A_1) ∪ L(A_2)\).
Pay attention to avoid having the AFWs with state names in common, in case use
PySimpleAutomata.AFW.rename_afw_states
function.- Parameters:
afw_1 (dict) – first input AFW;
afw_2 (dict) – second input AFW;.
- Returns:
(dict) representing the united AFW.
- PySimpleAutomata.AFW.afw_word_acceptance(afw: dict, word: list) bool [source]¶
Checks if a word is accepted by input AFW, returning True/False.
The word w is accepted by a AFW if exists at least an accepting run on w. A run for AFWs is a tree and an alternating automaton can have multiple runs on a given input. A run is accepting if all the leaf nodes are accepting states.
- Parameters:
afw (dict) – input AFW;
word (list) – list of symbols ∈ afw[‘alphabet’].
- Returns:
(bool), True if the word is accepted, False otherwise.
- PySimpleAutomata.AFW.formula_dual(input_formula: str) str [source]¶
Returns the dual of the input formula.
The dual operation on formulas in \(B^+(X)\) is defined as: the dual \(\overline{θ}\) of a formula \(θ\) is obtained from θ by switching \(∧\) and \(∨\), and by switching \(true\) and \(false\).
- Parameters:
input_formula (str) – original string.
- Returns:
(str), dual of input formula.
- PySimpleAutomata.AFW.nfa_to_afw_conversion(nfa: dict) dict [source]¶
Returns a AFW reading the same language of input NFA.
Let \(A = (Σ,S,S^0, ρ,F)\) be an nfa. Then we define the afw AA such that \(L(AA) = L(A)\) as follows \(AA = (Σ, S ∪ {s_0}, s_0 , ρ_A , F )\) where \(s_0\) is a new state and \(ρ_A\) is defined as follows:
\(ρ_A(s, a)= ⋁_{(s,a,s')∈ρ}s'\), for all \(a ∈ Σ\) and \(s ∈ S\)
\(ρ_A(s^0, a)= ⋁_{s∈S^0,(s,a,s')∈ρ}s'\), for all \(a ∈ Σ\)
We take an empty disjunction in the definition of AA to be equivalent to false. Essentially, the transitions of A are viewed as disjunctions in AA . A special treatment is needed for the initial state, since we allow a set of initial states in nondeterministic automata, but only a single initial state in alternating automata.
- Parameters:
nfa (dict) – input NFA.
- Returns:
(dict) representing a AFW.
- PySimpleAutomata.AFW.rename_afw_states(afw: dict, suffix: str)[source]¶
Side effect on input! Renames all the states of the AFW adding a suffix.
It is an utility function used during testing to avoid automata to have states with names in common.
Avoid suffix that can lead to special name like “as”, “and”,…
- Parameters:
afw (dict) – input AFW.
suffix (str) – string to be added at beginning of each state name.