Welcome to FAdo’s documentation¶

static dotDrawTransition(st1, label, st2, sep='\n')[source]¶

Draw a transition in dot format

Parameters

st1 (str) – departing state
sym (str) – label
st2 (str) – arriving state
sep (str) – separator

Return type

dotFormat(size='20,20', filename=None, direction='LR', strict=False, maxlblsz=6, sep='\n') → str[source]¶

A dot representation

Parameters

direction (str) – direction of drawing - “LR” or “RL”
size (str) – size of image
filename (str) – output file name
sep (str) – line separator
maxlblsz (int) – max size of labels before getting removed
strict (bool) – use limitations of label sizes

Returns

the dot representation

Return type

New in version 0.9.6.

Changed in version 1.2.1.

eliminateDeadName()[source]¶

Eliminates dead state name (common.DeadName) renaming the state

Returns: self
Return type: DFA

Attention

works inplace

New in version 1.2.

equivalentP(other)[source]¶

Test equivalence between automata

Parameters: other (FA) – the other automata
Return type: bool

New in version 0.9.6.

abstract evalSymbol(stil, sym)[source]¶: Evaluation of a single symbol

finalP(state: int) → bool[source]¶

Tests if a state is final

Parameters: state (int) – state index.
Returns: is the state final?
Return type: bool

finalsP(states: set) → bool[source]¶

Tests if al the states in a set are final

Parameters: states (set) – set of state indexes.
Returns: are all the states final?
Return type: bool

New in version 1.0.

hasStateIndexP(st: int) → bool[source]¶

Checks if a state index pertains to an FA

Parameters: st (int) – index of the state.
Return type: bool

images(sti, c)[source]¶

The set of images of a state by a symbol

Parameters

sti (int) – state
c (object) – symbol

Return type

iterable

indexList(lstn)[source]¶

Converts a list of stateNames into a set of stateIndexes.

Parameters: lstn (list) – list of names
Returns: the list of state indexes
Return type: set
Raises: DFAstateUnknown – if a state name is unknown

initialP(state: int) → bool[source]¶

Tests if a state is initial

Parameters: state – state index
Returns: is the state initial?
Return type: bool

initialSet()[source]¶

The set of initial states

Returns: set of States.
Return type: set

inputS(i)[source]¶

Input labels coming out of state i

Parameters: i (int) – state
Returns: set of input labels
Return type: set of str

New in version 1.0.

noBlankNames()[source]¶

Eliminates blank names

Returns: self
Return type: FA

Attention

in place transformation

plus()[source]¶: Plus of a FA (star without the adding of epsilon)

New in version 0.9.6.

renameState(st, name)[source]¶

Rename a given state.

Parameters

st (int) – state index.
name (object) – name.

Returns

self.

Return type

FA

Note

Deals gracefully both with int and str names in the case of name collision.

Attention

the object is modified in place

renameStates(name_list=None)[source]¶

Renames all states using a new list of names.

Parameters: name_list (list) – list of new names.
Returns: self.
Return type: FA
Raises: DFAerror – if provided list is too short.

Note

If no list of names is given, state indexes are used.

Attention

the object is modified in place

reversal()[source]¶

Returns a NFA that recognizes the reversal of the language

Returns: NFA recognizing reversal language
Return type: NFA

same_nullability(s1: int, s2: int) → bool[source]¶

Tests if this two states have the same nullability

Parameters

s1 (int) – state index.
s2 (int) – state index.

Returns

have the states the same nullability?

Return type

setFinal(statelist)[source]¶

Sets the final states of the FA

Parameters: statelist (int|list|set) – a list (or set) of final states indexes.

Caution

Erases any previous definition of the final state set.

setInitial(stateindex)[source]¶

Sets the initial state of a FA

Parameters: stateindex (int) – index of the initial state.

setSigma(symbol_set)[source]¶

Defines the alphabet for the FA.

Parameters: symbol_set (list|set) – alphabet symbols

stateAlphabet(sti: int) → list[source]¶

Active alphabet for this state

Parameters: sti (int) – state
Return type: list

stateIndex(name, auto_create=False)[source]¶

Index of given state name.

Parameters

name (object) – name of the state.
auto_create (bool, optional) – flag to create state if not already done.

Returns

state index

Return type

Raises

DFAstateUnknown – if the state name is unknown and autoCreate==False

Note

Replaces stateName

Note

If the state name is not known and flag is set creates it on the fly

New in version 1.0.

stateName(name, auto_create=False)[source]¶

Index of given state name.

Parameters

name (object) – name of the state
auto_create (bool, optional) – flag to create state if not already done

Returns

state index

Return type

Raises

DFAstateUnknown – if the state name is unknown and autoCreate==False

Deprecated since version 1.0: Use: stateIndex() instead

Deprecated since version 1.0: Use the stateIndex() function instead

abstract succintTransitions()[source]¶: Collapsed transitions

union(other)[source]¶

A simple literate invocation of __or__

Parameters: other (FA) – right-hand operand.
Returns: Union of self and other.
Return type: FA

words(stringo=True)[source]¶

Lexicographical word generator

Parameters: stringo (bool, optional) – are words strings? Default is True.
Yields: Word – the next word generated.

Attention

Does not generate the empty word

New in version 0.9.8.

class SemiDFA[source]¶

Class of automata without initial or final states

Variables

States (list) – set of states.
sigma (set) – alphabet set.
delta (dict) – the transition function.

dotDrawState(sti: int, sep='\n') → str[source]¶

Dot representation of a state

Parameters

sti (int) – state index.
sep (str, optional) – separator.

Returns

line to add to the dot file.

Return type

static dotDrawTransition(st1: str, lbl1: str, st2, sep='\n') → str[source]¶

Draw a transition in dot format

Parameters

st1 (str) – departing state.
lbl1 (str) – label.
st2 (str) – arriving state.
sep (str, optional) – separator.

Returns

line to add to the dot file.

Return type

dotFormat(size='20,20', filename=None, direction='LR', strict=False, maxlblsz=6, sep='\n') → str[source]¶

A dot representation

Parameters

direction (str) – direction of drawing - “LR” or “RL”
size (str) – size of image
filename (str) – Name of the output file
sep (str) – line separator
maxlblsz (int) – max size of labels before getting removed
strict (bool) – use limitations of label sizes

Returns

the dot representation

Return type

New in version 0.9.6.

Changed in version 1.2.1.

OFA¶

class OFA[source]¶

Base class for one-way automata

Variables

States (list) – set of states.
sigma (set) – alphabet set.
Initial (int) – the initial state index.
Final (set) – set of final states indexes.
delta (dict) – the transition function.

acyclicP(strict=True)[source]¶

Checks if the FA is acyclic

Parameters: strict (bool) – if not True loops are allowed

Returns: True if the FA is acyclic: bool: True if the FA is acyclic

abstract addTransition(st1, sym, st2)[source]¶

Add transition

Parameters

st1 (int) – departing state
sym (str) – label
st2 (int) – arriving state

abstract deleteStates(del_states)[source]¶

To be implemented below

Parameters: del_states (list) – states to be deleted

dotDrawTransition(st1, label, st2, sep='\n')[source]¶

Draw a transition in dot format

Parameters

st1 (str) – departing state
label (str) – symbol
st2 (str) – arriving state
sep (str) – separator

Return type

dump()[source]¶

Returns a python representation of the object

Returns: the python representation (Tags,States,sigma,delta,Initial,Final)
Return type: tuple

dup()[source]¶

Duplicate OFA

Returns: duplicate object
Return type: OFA

eliminateStout(st)[source]¶

Eliminate all transitions outgoing from a given state

Parameters: st (int) – the state index to loose all outgoing transitions

Attention

performs in place alteration of the automata

New in version 0.9.6.

emptyP()[source]¶

Tests if the automaton accepts an empty language

Return type: bool

New in version 1.0.

abstract evalSymbol(stil, sym)[source]¶: Eval symbol

abstract finalCompP(s)[source]¶

To be implemented below

Parameters: s – state
Return type: list

abstract initialComp()[source]¶

Initial component

Return type: list

minimalBrzozowski()[source]¶

Constructs the equivalent minimal DFA using Brzozowski’s algorithm

Returns: equivalent minimal DFA
Return type: DFA

minimalBrzozowskiP()[source]¶

Tests if the FA is minimal using Brzozowski’s algorithm

Return type: bool

abstract stateChildren(_state, _strict=None)[source]¶

To be implemented below

Parameters

_state (state) –
_strict (int) – state id queried

Return type

list

abstract succintTransitions()[source]¶: Collapsed transitions

topoSort()[source]¶

Topological order for the FA

Returns: List of state indexes
Return type: list

Note

self loops are taken in consideration

trim()[source]¶

Removes the states that do not lead to a final state, or, inclusively, that can’t be reached from the initial state. Only useful states remain.

Return type: FA

Attention

in place transformation

trimP()[source]¶

Tests if the FA is trim: initially connected and co-accessible

Return type: bool

abstract uniqueRepr()[source]¶: Abstract method

abstract usefulStates()[source]¶: To be implemented below

DFA¶

class DFA[source]¶

Class for Deterministic Finite Automata.

Variables

States (list) – set of states.
sigma (set) – alphabet set.
Initial (int) – the initial state index.
Final (set) – set of final states indexes.
delta (dict) – the transition function.
delta_inv (dict) – possible inverse transition map
i (bool) – is inverse map computed?

Delta(state, symbol)[source]¶

Evaluates the action of a symbol over a state

Parameters

state (int) – state index
symbol – symbol

Returns

the action of symbol over state

Return type

HKeqP(other, strict=True)[source]¶

Tests the DFA’s equivalence using Hopcroft and Karp’s state equivalence algorithm

Parameters

other –
strict –

Returns

bool

See also

J. E. Hopcroft and r. M. Karp.A Linear Algorithm for Testing Equivalence of Finite Automata.TR 71–114. U. California. 1971

Attention

The automaton must be complete.

MyhillNerodePartition()[source]¶: Myhill-Nerode partition, Moore’s way

New in version 1.3.5.

Attention

No state should be named with DeadName. This states is removed from the obtained partition.

See also

F.Bassino, J.David and C.Nicaud, On the Average Complexity of Moores’s State Minimization Algorihm, Symposium on Theoretical Aspects of Computer Science

aEquiv()[source]¶

Computes almost equivalence, used by hyperMinimial

Returns: partition of states
Return type: dict

Note

may be optimized to avoid dupped

addTransition(sti1, sym, sti2)[source]¶

Adds a new transition from sti1 to sti2 consuming symbol sym.

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym (str) – symbol consumed

Raises

DFAnotNFA – if one tries to add a non deterministic transition

compat(s1, s2, data)[source]¶

Tests compatibility between two states.

Parameters

data –
s1 (int) – state index
s2 (int) – state index

Return type

complete(dead='DeaD')[source]¶

Transforms the automata into a complete one. If sigma is empty nothing is done.

Parameters: dead (str) – dead state name
Returns: the complete FA
Return type: DFA

Note

Adds a dead state (if necessary) so that any word can be processed with the automata. The new state is named dead, so this name should never be used for other purposes.

Attention

The object is modified in place.

Changed in version 1.0.

completeMinimal()[source]¶

Completes a DFA assuming it is a minimal and avoiding de destruction of its minimality If the automaton is not complete, all the non final states are checked to see if tey are not already a dead state. Only in the negative case a new (dead) state is added to the automaton.

Return type: DFA

Attention

The object is modified in place. If the alphabet is empty nothing is done

completeP()[source]¶

Checks if it is a complete FA (if delta is total)

Returns: bool

completeProduct(other)[source]¶

Product structure

Parameters: other – the other DFA

computeKernel()[source]¶

The Kernel of a ICDFA is the set of states that accept a non finite language.

Returns: triple (comp, center , mark) where comp are the strongly connected components, center the set of center states and mark the kernel states
Return type: tuple

concat(fa2, strict=False)[source]¶

Concatenation of two DFAs. If DFAs are not complete, they are completed.

Parameters

strict (bool) – should alphabets be checked?
fa2 (DFA) – the second DFA

Returns

the result of the concatenation

Return type

Raises

DFAdifferentSigma – if alphabet are not equal

concatI(fa2, strict=False)[source]¶

Concatenation of two DFAs.

Parameters

fa2 (DFA) – the second DFA
strict (bool) – should alphabets be checked?

Returns

the result of the concatenation

Return type

Raises

DFAdifferentSigma – if alphabet are not equal

New in version 0.9.5.

Note

this is to be used with non complete DFAs

delTransition(sti1, sym, sti2, _no_check=False)[source]¶

Remove a transition if existing and perform cleanup on the transition function’s internal data structure.

Parameters

_no_check (bool) – use unsecure code?
sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym (str) – symbol consumed

Note

Unused alphabet symbols will be discarded from sigma.

deleteStates(del_states)[source]¶

Delete given iterable collection of states from the automaton.

Parameters: del_states – collection of int representing states

Note

in-place action

Note

delta function will always be rebuilt, regardless of whether the states list to remove is a suffix, or a sublist, of the automaton’s states list.

static deterministicP()[source]¶

Yes it is deterministic!

Return type: bool

dist()[source]¶

Evaluate the distinguishability language for a DFA

Return type: DFA

See also

Cezar Câmpeanu, Nelma Moreira, Rogério Reis: The distinguishability operation on regular languages. NCMA 2014: 85-100

New in version 0.9.8.

distMin()[source]¶

Evaluates the list of minimal words that distinguish each pair of states

Returns: set of minimal distinguishing words
Return type: FL

New in version 0.9.8.

Attention

If the DFA is not minimal, the method loops forever

distR()[source]¶

Evaluate the right distinguishability language for a DFA

Return type: DFA

..seealso:: Cezar Câmpeanu, Nelma Moreira, Rogério Reis:: The distinguishability operation on regular languages. NCMA 2014: 85-100

distRMin()[source]¶

Compute distRMin for DFA

:rtype FL

..seealso:: Cezar Câmpeanu, Nelma Moreira, Rogério Reis:: The distinguishability operation on regular languages. NCMA 2014: 85-100

distTS()[source]¶

Evaluate the two-sided distinguishability language for a DFA

Return type: DFA

..seealso:: Cezar Câmpeanu, Nelma Moreira, Rogério Reis:: The distinguishability operation on regular languages. NCMA 2014: 85-100

dup()[source]¶

Duplicate the basic structure into a new DFA. Basically a copy.deep.

Return type: DFA

enumDFA(n=None)[source]¶

returns the set of words of words of length up to n accepted by self :param int n: highest length or all words if finite

Return type: list of strings or None

equal(other)[source]¶

Verify if the two automata are equivalent. Both are verified to be minimum and complete, and then one is matched against the other… Doesn’t destroy either dfa…

Parameters: other (DFA) – the other DFA
Return type: bool

evalSymbol(init, sym)[source]¶

Returns the state reached from given state through a given symbol.

Parameters

init (int) – set of current states indexes
sym (str) – symbol to be consumed

Returns

reached state

Return type

Raises

DFAsymbolUnknown – if symbol not in alphabet
DFAstopped – if transition function is not defined for the given input

evalSymbolI(init, sym)[source]¶

Returns the state reached from a given state.

Parameters

init (init) – current state
sym (str) – symbol to be consumed

Returns

reached state or -1

Return type

set of int

Raises

DFAsymbolUnknown – if symbol not in alphabet

New in version 0.9.5.

Note

this is to be used with non complete DFAs

evalSymbolL(ls, sym)[source]¶

Returns the set of states reached from a given set of states through a given symbol

Parameters

ls (set of int) – set of states indexes
sym (str) – symbol to be read

Returns

set of reached states

Return type

set of int

evalSymbolLI(ls, sym)[source]¶

Returns the set of states reached from a given set of states through a given symbol

Parameters

ls (set of int) – set of current states
sym (str) – symbol to be consumed

Returns

set of reached states

Return type

set of int

New in version 0.9.5.

Note

this is to be used with non complete DFAs

evalWord(wrd)[source]¶

Evaluates a word

Parameters: wrd (Word) – word
Returns: final state or None
Return type: int | None

New in version 1.3.3.

evalWordP(word, initial=None)[source]¶

Verifies if the DFA recognises a given word

Parameters

word (list of symbols.) – word to be recognised
initial (int) – starting state index

Return type

finalCompP(s)[source]¶

Verifies if there is a final state in strongly connected component containing s.

Parameters: s (int) – state
Returns: 1 if yes, 0 if no

hasTrapStateP()[source]¶

Tests if the automaton has a dead trap state

Return type: bool

New in version 1.1.

hyperMinimal(strict=False)[source]¶

Hyperminization of a minimal DFA

Parameters: strict (bool) – if strict=True it first minimizes the DFA
Returns: an hyperminimal DFA
Return type: DFA

See also

M. Holzer and A. Maletti, An nlogn Algorithm for Hyper-Minimizing a (Minimized) Deterministic Automata, TCS 411(38-39): 3404-3413 (2010)

Note

if strict=False minimality is assumed

inDegree(st)[source]¶

Returns the in-degree of a given state in an FA

Parameters: st (int) – index of the state
Return type: int

infix()[source]¶

Returns a dfa that recognizes infix(L(a))

Return type: DFA

initialComp()[source]¶

Evaluates the connected component starting at the initial state.

Returns: list of state indexes in the component
Return type: list of int

initialP(state)[source]¶

Tests if a state is initial

Parameters: state (int) – state index
Return type: bool

initialSet()[source]¶

The set of initial states

Returns: the set of the initial states
Return type: set of States

joinStates(lst)[source]¶

Merge a list of states.

Parameters: lst (iterable of state indexes.) – set of equivalent states

makeReversible()[source]¶

Make a DFA reversible (if possible)

See also

M.Holzer, s. Jakobi, M. Kutrib ‘Minimal Reversible Deterministic Finite Automata’

Return type: DFA

markNonEquivalent(s1, s2, data)[source]¶

Mark states with indexes s1 and s2 in given map as non equivalent states. If any back-effects exist, apply them.

Parameters

s1 (int) – one state’s index
s2 (int) – the other state’s index
data – the matrix relating s1 and s2

mergeStates(f, t)[source]¶

Merge the first given state into the second. If the first state is an initial state the second becomes the initial state.

Parameters

f (int) – index of state to be absorbed
t (int) – index of remaining state

Attention

It is up to the caller to remove the disconnected state. This can be achieved with `trim().

minimal(method='minimalHopcroft', complete=True)[source]¶

Evaluates the equivalent minimal complete DFA

Parameters

method – method to use in the minimization
complete (bool) – should the result be completed?

Returns

equivalent minimal DFA

Return type

minimalHopcroft()[source]¶

Evaluates the equivalent minimal complete DFA using Hopcroft algorithm

Returns: equivalent minimal DFA
Return type: DFA

See also

John Hopcroft,An n log{n} algorithm for minimizing states in a finite automaton.The Theory of Machines and Computations.AP. 1971

minimalHopcroftP()[source]¶

Tests if a DFA is minimal

Return type: bool

minimalIncremental(minimal_test=False)[source]¶

Minimizes the DFA with an incremental method using the Union-Find algorithm and memoized non-equivalence intermediate results

Parameters: minimal_test (bool) – starts by verifying that the automaton is not minimal?
Returns: equivalent minimal DFA
Return type: DFA

See also

M. Almeida and N. Moreira and and r. Reis.Incremental DFA minimisation. CIAA 2010. LNCS 6482. pp 39-48. 2010

minimalIncrementalP()[source]¶

Tests if a DFA is minimal

Return type: bool

minimalMoore()[source]¶

Evaluates the equivalent minimal automata with Moore’s algorithm

See also

John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation, AW, 1979

Returns: minimal complete DFA
Return type: DFA

minimalMooreSq()[source]¶

Evaluates the equivalent minimal complete DFA using Moore’s (quadratic) algorithm

See also

John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation, AW, 1979

Returns: equivalent minimal DFA
Return type: DFA

minimalMooreSqP()[source]¶

Tests if a DFA is minimal using the quadratic version of Moore’s algorithm

Return type: bool

minimalNCompleteP()[source]¶

Tests if a non necessarely complete DFA is minimal, i.e., if the DFA is non complete, if the minimal complete has only one more state.

Returns: True if not minimal
Return type: bool

Attention

obsolete: use minimalP

minimalNotEquivP()[source]¶

Tests if the DFA is minimal by computing the set of distinguishable (not equivalent) pairs of states

Return type: bool

minimalP(method='minimalMooreSq')[source]¶

Tests if the DFA is minimal

Parameters: method – the minimization algorithm to be used
Return type: bool

..note: if DFA non complete test if complete minimal has one more state

minimalWatson(test_only=False)[source]¶

Evaluates the equivalent minimal complete DFA using Waton’s incremental algorithm

Parameters: test_only (bool) – is it only to test minimality
Returns: equivalent minimal DFA
Return type: DFA
Raises: DFAnotComplete – if automaton is not complete

..attention::: automaton must be complete

minimalWatsonP()[source]¶

Tests if a DFA is minimal using Watson’s incremental algorithm

Return type: bool

notequal(other)[source]¶

Test non equivalence of two DFAs

Parameters: other (DFA) – the other DFA
Return type: bool

orderedStrConnComponents()[source]¶

Topological ordered list of strong components

New in version 1.3.3.

Return type: list

pairGraph()[source]¶

Returns pair graph

Return type: DiGraphVM

See also

A graph theoretic approach to automata minimality. Antonio Restivo and Roberto Vaglica. Theoretical Computer Science, 429 (2012) 282-291. doi:10.1016/j.tcs.2011.12.049 Theoretical Computer Science, 2012 vol. 429 (C) pp. 282-291. http://dx.doi.org/10.1016/j.tcs.2011.12.049

possibleToReverse()[source]¶: Tests if language is reversible

New in version 1.3.3.

pref()[source]¶

Returns a dfa that recognizes pref(L(self))

Return type: DFA

New in version 1.1.

print_data(data)[source]¶

Prints table of compatibility (in the context of the minimalization algorithm).

Parameters: data – data to print

product(other)[source]¶

Returns a DFA resulting of the simultaneous execution of two DFA. No final states set.

Note

this is a fast version of the method. The resulting state names are not meaningfull.

Parameters: other – the other DFA
Return type: DFA

productSlow(other, complete=True)[source]¶

Returns a DFA resulting of the simultaneous execution of two DFA. No final states set.

Note

this is a slow implementation for those that need meaningfull state names

New in version 1.3.3.

Parameters

other – the other DFA
complete (bool) – evaluate product as a complete DFA

Return type

reorder(dicti)[source]¶

Reorders states according to given dictionary. Given a dictionary (not necessarily complete)… reorders states accordingly.

Parameters: dicti (dict) – reorder dictionary

reverseTransitions(rev)[source]¶

Evaluate reverse transition function.

Parameters: rev (DFA) – DFA in which the reverse function will be stored

reversibleP()[source]¶

Test if an automaton is reversible

Return type: bool

sMonoid()[source]¶

Evaluation of the syntactic monoid of a DFA

Returns: the semigroup
Return type: SSemiGroup

sSemigroup()[source]¶

Evaluation of the syntactic semigroup of a DFA

Returns: the semigroup
Return type: SSemiGroup

shuffle(other, strict=False)[source]¶

CShuffle of two languages: L1 W L2

Parameters

other (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

C. Câmpeanu, K. Salomaa and s. Yu, Tight lower bound for the state complexity of CShuffle of regular languages. J. Autom. Lang. Comb. 7 (2002) 303–310.

simDiff(other)[source]¶

Symetrical difference

Parameters: other –
Returns

sop(other)[source]¶

Strange operation

Parameters: other (DFA) – the other automaton
Return type: DFA

See also

Nelma Moreira, Giovanni Pighizzini, and Rogério Reis. Universal disjunctive concatenation

and star. In Jeffrey Shallit and Alexander Okhotin, editors, Proceedings of the 17th Int. Workshop on Descriptional Complexity of Formal Systems (DCFS15), number 9118 in LNCS, pages 197–208. Springer, 2015.

New in version 1.2b2.

star(flag=False)[source]¶

Star of a DFA. If the DFA is not complete, it is completed.

..versionchanged: 0.9.6

Parameters: flag (bool) – plus instead of star
Returns: the result of the star
Return type: DFA

starI()[source]¶

Star of an incomplete DFA.

Returns: the Kleene closure DFA
Return type: DFA

stateChildren(state, strict=False)[source]¶

Set of children of a state

Parameters

strict (bool) – if not strict a state is never its own child even if a self loop is in place
state (int) – state id queried

Returns

map children -> multiplicity

Return type

dictionary

stronglyConnectedComponents()[source]¶

Dummy method that uses the NFA conterpart

New in version 1.3.3.

Return type: list

subword()[source]¶

Returns a dfa that recognizes subword(L(self))

Return type: dfa

New in version 1.1.

succintTransitions()[source]¶: Collects the transition information in a compact way suitable for graphical representation. :rtype: list of tupples

New in version 0.9.8.

suff()[source]¶

Returns a dfa that recognizes suff(L(self))

Return type: DFA

New in version 0.9.8.

syncPower()[source]¶

Evaluates the Power automata for the action of each symbol

Returns: The Power automata being the set of all states the initial state and all singleton states final.
Return type: DFA

toADFA()[source]¶

Try to convert DFA to ADFA

Returns: the same automaton as a ADFA
Return type: ADFA
Raises: notAcyclic – if this is not an acyclic DFA

New in version 1.2.

Changed in version 1.2.1.

toDFA()[source]¶

Dummy function. It is already a DFA

Returns: a self deep copy
Return type: DFA

toNFA()[source]¶

Migrates a DFA to a NFA as dup()

Returns: DFA seen as new NFA
Return type: NFA

transitions()[source]¶: Iterator over transitions :rtype: symbol, int

transitionsA()[source]¶: Iterator over transitions :rtype: symbol, int

uniqueRepr()[source]¶

Normalise unique string for the string icdfa’s representation. .. seealso:: TCS 387(2):93-102, 2007 https://www.dcc.fc.up.pt/~nam/publica/tcsamr06.pdf

Returns: normalised representation
Return type: list
Raises: DFAnotComplete – if DFA is not complete

universalP(minimal=False)[source]¶

Checks if the automaton is universal through minimisation

Parameters: minimal (bool) – is the automaton already minimal?
Return type: bool

unmark()[source]¶

Unmarked NFA that corresponds to a marked DFA: in which each alfabetic symbol is a tuple (symbol, index)

Returns: a NFA
Return type: NFA

usefulStates(initial_states=None)[source]¶

Set of states reacheable from the given initial state(s) that have a path to a final state.

Parameters: initial_states (iterable of int) – starting states
Returns: set of state indexes
Return type: set of int

static vDescription()[source]¶

Generation of Verso interface description

New in version 0.9.5.

Returns: the interface list

witness()[source]¶

Witness of non emptyness

Returns: word
Return type: str

witnessDiff(other)[source]¶

Returns a witness for the difference of two DFAs and:

0	if the witness belongs to the other language
1	if the witness belongs to the self language

Parameters: other (DFA) – the other DFA
Returns: a witness word
Return type: list of symbols
Raises: DFAequivalent – if automata are equivalent

NFA¶

class NFA[source]¶

Class for Non-deterministic Finite Automata (CEpsilon-transitions allowed).

Variables

States (list) – set of states.
sigma (set) – alphabet set.
Initial (set) – initial state indexes.
Final (set) – set of final states indexes.
delta (dict) – the transition function.

HKeqP(other, strict=True)[source]¶

Test NFA equivalence with extended Hopcroft-Karp method

See also

J. E. Hopcroft and r. M. Karp. A Linear Algorithm for Testing Equivalence of Finite Automata.TR 71–114. U. California. 1971

Parameters

other – NFA
strict – if True checks for same alphabets

Returns

Boolean

addEpsilonLoops()[source]¶: Add epsilon loops to every state :return: self

Attention

in-place modification

New in version 1.0.

addInitial(stateindex)[source]¶

Add a new state to the set of initial states.

Parameters: stateindex (int) – index of new initial state

addTransition(sti1, sym, sti2)[source]¶

Adds a new transition. Transition is from sti1 to sti2 consuming symbol sym. sti2 is a unique state, not a set of them.

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
str (str) – symbol consumed

addTransitionQ(srci, dest, symb, qfuture, qpast)[source]¶

Add transition to the new transducer instance.

Parameters

qpast (set) – past queue
qfuture (set) – future queue
symb – symbol
dest (int) – destination state
srci (int) – source state

New in version 1.0.

autobisimulation()[source]¶

Largest right invariant equivalence between states of the NFA

Returns: Incomplete equivalence relation (transitivity, and reflexivity not calculated) as a set of unordered pairs of states
Return type: Set of frozensets

See also

Ilie&Yu, 2003

autobisimulation2()[source]¶

Alternative space-efficient definition of NFA.autobisimulation.

Returns: Incomplete equivalence relation (reflexivity, symmetry, and transitivity not calculated) as a set of pairs of states
Return type: list of tuples

closeEpsilon(st)[source]¶

Add all non CEpsilon transitions from the states in the CEpsilon closure of given state to given state.

Parameters: st (int) – state index

computeFollowNames()[source]¶

Computes the follow set to use in names

Return type: list

concat(other, middle='middle')[source]¶

Concatenation of NFA

Parameters

middle (str) – glue state name
other (FA) – the other NFA

Returns

the result of the concatenation

Return type

NFA

countTransitions()[source]¶

Number of transitions of a NFA

Return type: int

delTransition(sti1, sym, sti2, _no_check=False)[source]¶

Remove a transition if existing and perform cleanup on the transition function’s internal data structure.

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym – symbol consumed
_no_check (bool) – dismiss secure code

Note

unused alphabet symbols will be discarded from sigma.

deleteStates(del_states)[source]¶

Delete given iterable collection of states from the automaton.

Parameters: del_states (set|list) – collection of int representing states

Note

delta function will always be rebuilt, regardless of whether the states list to remove is a suffix, or a sublist, of the automaton’s states list.

detSet(generic=False)[source]¶

Computes the determination uppon a followFromPosition result

Return type: NFA

deterministicP()[source]¶

Verify whether this NFA is actually deterministic

Return type: bool

dotFormat(size='20,20', filename=None, direction='LR', strict=False, maxlblsz=6, sep='\n') → str[source]¶

A dot representation

Parameters

direction (str) – direction of drawing - “LR” or “RL”
size (str) – size of image
filename (str) – output file name
sep (str) – line separator
maxlblsz (int) – max size of labels before getting removed
strict (bool) – use limitations of label sizes

Returns

the dot representation

Return type

New in version 0.9.6.

Changed in version 1.2.1.

dup()[source]¶

Duplicate the basic structure into a new NFA. Basically a copy.deep.

Return type: NFA

elimEpsilon()[source]¶

Eliminate CEpsilon-transitions from this automaton.

:rtype : NFA

Attention

performs in place modification of automaton

Changed in version 1.1.1.

eliminateEpsilonTransitions()[source]¶: Eliminates all epslilon-transitions with no state addition

Attention

in-place modification

eliminateTSymbol(symbol)[source]¶

Delete all trasitions through a given symbol

Parameters: symbol (str) – the symbol to be excluded from delta

Attention

in place alteration of the automata

New in version 0.9.6.

enumNFA(n=None)[source]¶

returns the set of words of words of length up to n accepted by self :param int n: highest lenght or all words if finite

Return type: list of strings or None

epsilonClosure(st)[source]¶

Returns the set of states CEpsilon-connected to from given state or set of states.

Parameters: st (int|set) – state index or set of state indexes
Returns: the list of state indexes CEpsilon connected to st
Return type: set of int

Attention

st must exist.

epsilonP()[source]¶

Whether this NFA has CEpsilon-transitions

Return type: bool

epsilonPaths(start, end)[source]¶

All states in all paths (DFS) through empty words from a given starting state to a given ending state.

Parameters

start (int) – start state
end (int) – end state

Returns

states in CEpsilon paths from start to end

Return type

set of states

equivReduced(equiv_classes)[source]¶

Equivalent NFA reduced according to given equivalence classes.

Parameters: equiv_classes (UnionFind) – Equivalence classes
Returns: Equivalent NFA
Return type: NFA

evalSymbol(stil, sym)[source]¶

Set of states reacheable from given states through given symbol and CEpsilon closure.

Parameters

stil (set|list) – set of current states
sym (str) – symbol to be consumed

Returns

set of reached state indexes

Return type

set

Raises

DFAsymbolUnknown – if symbol is not in alphabet

evalWordP(word)[source]¶

Verify if the NFA recognises given word.

Parameters: word (str) – word to be recognised
Return type: bool

finalCompP(s)[source]¶

Verify whether there is a final state in strongly connected component containing given state.

Parameters: s (int) – state index
Returns: :: bool

followFromPosition()[source]¶: computes follow automaton from a Position automaton :rtype: NFA

half()[source]¶: Half operation

New in version 0.9.6.

hasTransitionP(state, symbol=None, target=None)[source]¶

Whether there’s a transition from given state, optionally through given symbol, and optionally to a specific target.

Parameters

state (int) – source state
symbol (str) – optional transition symbol
target (int) – optional target state

Returns

if there is a transition

Return type

homogeneousFinalityP()[source]¶

Tests if states have incoming transitions froms states with different finalities

Return type: bool

homogenousP(x)[source]¶

Whether this NFA is homogenous; that is, for all states, whether all incoming transitions to that state are through the same symbol.

Parameters: x – dummy parameter to agree with the method in DFAr
Return type: bool

initialComp()[source]¶

Evaluate the connected component starting at the initial state.

Returns: list of state indexes in the component
Return type: list of int

lEquivNFA()[source]¶

Equivalent NFA obtained from merging equivalent states from autobisimulation of this NFA’s reversal.

Return type: NFA

Note

returns copy of self if autobisimulation renders no equivalent states.

lrEquivNFA()[source]¶

Equivalent NFA obtained from merging equivalent states from autobisimulation of this NFA, and from autobisimulation of its reversal; i.e., merges all states that are equivalent w.r.t. the largest right invariant and largest left invariant equivalence relations.

Return type: NFA

Note

returns copy of self if autobisimulations render no equivalent states.

minimal()[source]¶

Evaluates the equivalent minimal DFA

Returns: equivalent minimal DFA
Return type: DFA

minimalDFA()[source]¶

Evaluates the equivalent minimal complete DFA

Returns: equivalent minimal DFA
Return type: DFA

product(other)[source]¶

Returns a NFA (skeletom) resulting of the simultaneous execution of two DFA.

Parameters: other (NFA) – the other automata
Return type: NFA

Note

No final states are set.

Attention

the name EmptySet is used in a unique special state name
the method uses 3 internal functions for simplicity of code (really!)

rEquivNFA()[source]¶

Equivalent NFA obtained from merging equivalent states from autobisimulation of this NFA.

Return type: NFA

Note

returns copy of self if autobisimulation renders no equivalent states.

renameStatesFromPosition()[source]¶

Rename states of a Glushkov automaton using the positions of the marked RE

Return type: NFA

reorder(dicti)[source]¶

Reorder states indexes according to given dictionary.

Parameters: dicti (dict) – state name reorder

Note

dictionary does not have to be complete

reversal()[source]¶

Returns a NFA that recognizes the reversal of the language

Returns: NFA recognizing reversal language
Return type: NFA

reverseTransitions(rev)[source]¶

Evaluate reverse transition function.

Parameters: rev (NFA) – NFA in which the reverse function will be stored

setInitial(statelist)[source]¶

Sets the initial states of an NFA

Parameters: statelist (set|list|int) – an iterable of initial state indexes

shuffle(other)[source]¶

Shuffle of a NFA

Parameters: other (FA) – an FA

Returns: the resulting NFA: NFA: the resulting NFA

star(flag=False)[source]¶

Kleene star of a NFA

Parameters: flag (bool) – plus instead of star?
Returns: the resulting NFA
Return type: NFA

stateChildren(state, strict=False)[source]¶

Set of children of a state

Parameters

strict (bool) – if not strict a state is never its own child even if a self loop is in place
state (int) – state id queried

Returns

children states

Return type

Set of int

stronglyConnectedComponents()[source]¶

Strong components

Return type: list

New in version 1.0.

subword()[source]¶

returns a nfa that recognizes subword(L(self))

Return type: nfa

succintTransitions()[source]¶: Collects the transition information in a compact way suitable for graphical representation. :rtype: list

toDFA()[source]¶

Construct a DFA equivalent to this NFA, by the subset construction method.

Return type: DFA

Note

valid to CEpsilon-NFA

toNFA()[source]¶

Dummy identity function

Return type: NFA

toNFAr()[source]¶

NFA with the reverse mapping of the delta function.

Returns: shallow copy with reverse delta function added
Return type: NFAr

uniqueRepr()[source]¶: Dummy representation. Used DFA.uniqueRepr() :rtype: tuple

usefulStates(initial_states=None)[source]¶

Set of states reacheable from the given initial state(s) that have a path to a final state.

Parameters: initial_states (set of int or list of int) – set of initial states
Returns: set of state indexes
Return type: set of int

static vDescription()[source]¶

Generation of Verso interface description

Return type: list

New in version 0.9.5.

witness()[source]¶

Witness of non emptiness

Returns: word
Return type: str

wordImage(word, ist=None)[source]¶

Evaluates the set of states reached consuming given word

Parameters

word (list of stings) – the word
ist (int) – starting state index (or set of)

Returns

the set of ending states

Return type

Set of int

NFAr¶

class NFAr[source]¶

Class for Non-deterministic Finite Automata with reverse delta function added by construction.: Includes efficient methods for merging states.

addTransition(sti1, sym, sti2)[source]¶

Adds a new transition. Transition is from sti1 to sti2 consuming symbol sym. sti2 is a unique state, not a set of them. Reversed transition function is also computed

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym (str) – symbol consumed

delTransition(sti1, sym, sti2, _no_check=False)[source]¶

Remove a transition if existing and perform cleanup on the transition function’s internal data structure and in the reversal transition function

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym (str) – symbol consumed
_no_check (bool) – dismiss secure code

deleteStates(del_states)[source]¶

Delete given iterable collection of states from the automaton. Performe deletion in the transition function and its reversal.

Parameters: del_states (set or list of int) – collection of int representing states

elimEpsilonO()[source]¶

Eliminate CEpsilon-transitions from this automaton, with reduction of states through elimination of CEpsilon-cycles, and single CEpsilon-transition cases.

Returns: itself
Return type

Attention

performs inplace modification of automaton

homogenousP(inplace=False)[source]¶

Checks is the automaton is homogenous, i.e.the transitions that reaches a state have all the same label.

Parameters: inplace (bool) – if True performs CEpsilon transitions elimination
Returns: True if homogenous
Return type: bool

mergeStates(f, t)[source]¶

Merge the first given state into the second. If first state is an initial or final state, the second becomes respectively an initial or final state.

Parameters

f (int) – index of state to be absorbed
t (int) – index of remaining state

Attention

It is up to the caller to remove the disconnected state. This can be achieved with `trim().

mergeStatesSet(tomerge, target=None)[source]¶

Merge a set of states with a target merge state. If the states in the set have transitions among them, those transitions will be directly merged into the target state.

Parameters

tomerge (Set of int) – set of states to merge with target
target (int) – optional target state

Note

if target state is not given, the minimal index with be considered.

Attention

The states of the list will become unreacheable, but won’t be removed. It is up to the caller to remove them. That can be achieved with trim().

toNFA()[source]¶

Turn into an instance of NFA, and remove the reverse mapping of the delta function.

Returns: shallow copy without reverse delta function
Return type: NFA

unlinkSoleIncoming(state)[source]¶

If given state has only one incoming transition (indegree is one), and it’s through CEpsilon, then remove such transition and return the source state.

Parameters: state (int) – state to check
Returns: source state
Return type: int or None

Note

if conditions aren’t met, returned source state is None, and automaton remains unmodified.

unlinkSoleOutgoing(state)[source]¶

If given state has only one outgoing transition (outdegree is one), and it’s through CEpsilon, then remove such transition and return the target state.

Parameters: state (int) – state to check
Returns: target state
Return type: int or None

Note

if conditions aren’t met, returned target state is None, and automaton remains unmodified.

SSemiGroup¶

class SSemiGroup[source]¶

Class support for the Syntactic SemiGroup.

Variables

elements – list of tuples representing the transformations
words – a list of pairs (index of the prefix transformation, index of the suffix char)
gen – a list of the max index of each generation
sigma – set of symbols

WordI(i)[source]¶

Representative of an element given as index

Parameters: i (int) – index of the element
Returns: the first word originating the element
Return type: str

WordPS(pref, sym)[source]¶

Representative of an element given as prefix symb

Parameters

pref (int) – prefix index
sym (int) – symbol index

Returns

word

Return type

add(tr, pref, sym, tmpLists)[source]¶

Try to add a new transformation to the monoid

Parameters

tr (tuple of int) – transformation
pref (int or None) – prefix of the generating word
sym (int) – suffix symbol
tmpLists (pairs of lists as (elements,words)) – this generation lists

addGen(tmpLists)[source]¶

Add a new generation to the monoid

Parameters: tmpLists (pair of lists as (elements, words)) – the new generation data

EnumL¶

class EnumL(aut, store=False)[source]¶

Class for enumerate FA languages: See: Efficient enumeration of words in regular languages, M. Ackerman and J. Shallit, Theor. Comput. Sci. 410, 37, pp 3461-3470. 2009. http://dx.doi.org/10.1016/j.tcs.2009.03.018

Variables

aut (FA) – Automaton of the language
tmin (dict) – table for minimal words for each s in aut.States
Words (list) – list of words (if stored)
sigma (list) – alphabet

New in version 0.9.8.

enum(m)[source]¶

Enumerates the first m words of L(A) according to the lexicographic order if there are at least m words. Otherwise, enumerates all words accepted by A.

Parameters: m (int) – max number of words

enumCrossSection(n)[source]¶

Enumerates the nth cross-section of L(A)

Parameters: n (int) – nonnegative integer

abstract fillStack(w)[source]¶: Abstract method :param str w: :type w: str

iCompleteP(i, q)[source]¶

Tests if state q is i-complete

Parameters

i (int) – int
q (int) – state index

abstract initStack()[source]¶: Abstract method

minWord(m)[source]¶: Computes the minimal word of length m accepted by the automaton :param m: :type m: int

abstract minWordT(n)[source]¶: Abstract method :param int n: :type n: int

abstract nextWord(w)[source]¶: Abstract method :param w: :type w: str

Functions¶

saveToString¶

saveToString(aut, sep='&')[source]¶

Finite automata definition as a string using the input format.

New in version 0.9.5.

Changed in version 0.9.6: Names are now used instead of indexes.

Changed in version 0.9.7: New format with quotes and alphabet

Parameters

aut (FA) – the FA
sep (str) – separation between lines

Returns

the representation

Return type

stringToDFA¶

stringToDFA(s, f, n, k)[source]¶

Converts a string icdfa’s representation to dfa.

Parameters

s (list) – canonical string representation
f (list) – bit map of final states
n (int) – number of states
k (int) – number of symbols

Returns

a complete dfa with sigma [k], States [n]

Return type

Changed in version 0.9.8: symbols are converted to str

Module: Conversion of Finite Automata: (`conversions`)¶

Conversions between objects.

Deterministic and non-deterministic automata manipulation, conversion and evaluation. .. Authors: Rogério Reis & Nelma Moreira .. This is part of FAdo project https://fado.dcc.fc.up.pt.

Classes¶

GFA¶

class GFA[source]¶

Class for Generalized Finite Automata: NFA with a unique initial state and transitions are labeled with RegExp.

DFS(io)[source]¶

Depth first search

Parameters: io –

addTransition(sti1, sym, sti2)[source]¶

Adds a new transition from sti1 to sti2 consuming symbol sym. Label of the transition function: is a RegExp.

Parameters

sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym (str) – symbol consumed

Raises

DFAepsilonRedefenition – if sym is Epsilon

assignLow(st)[source]¶

Parameters: st –

assignNum(st)[source]¶

Parameters: st –

completeDelta()[source]¶: Adds empty set transitions between the automatons final and initial states in order to make it complete. It’s only meant to be used in the final stage of SEA…

deleteState(sti)[source]¶: deletes a state from the GFA :param sti:

deleteStates(del_states)[source]¶

To be implemented below

Parameters: del_states (list) – states to be deleted

dfs_visit(s, visited, io)[source]¶

Parameters

s – state
visited – list od states visited
io –

dup()[source]¶

Returns a copy of a GFA

Return type: GFA

eliminate(st)[source]¶

Eliminate a state.

Parameters: st (int) – state to be eliminated

eliminateAll(lr)[source]¶

Eliminate a list of states.

Parameters: lr (list) – list of states indexes

eliminateState(st)[source]¶

Deletes a state and updates the automaton

Parameters: st (int) – the state to be deleted

evalNumberOfStateCycles()[source]¶

Evaluates the number of cycles each state participates

Returns: state->list of cycle lengths
Return type: dict

evalSymbol(stil, sym)[source]¶: Eval symbol

finalCompP(s)[source]¶

To be implemented below

Parameters: s – state
Return type: list

initialComp()[source]¶

Initial component

Return type: list

normalize()[source]¶: Create a single initial and final state with Epsilon transitions.

Attention

works in place

reorder(dictio)[source]¶

Reorder states indexes according to given dictionary.

Parameters: dictio (dict) – order

Note

dictionary does not have to be complete

stateChildren(state, strict=False)[source]¶

Set of children of a state

Parameters

strict (bool) – a state is never its own children even if a self loop is in place
state (int) – state id queried

Returns

map: children -> alphabetic length

Return type

dictionary

succintTransitions()[source]¶: Collapsed transitions

uniqueRepr()[source]¶: Abstract method

usefulStates()[source]¶: To be implemented below

weight(state)[source]¶

Calculates the weight of a state based on a heuristic

Parameters: state (int) – state
Returns: the weight of the state
Return type: int

weightWithCycles(state, cycles)[source]¶

Parameters

state –
cycles –

Returns

:members:

Functions¶

FA2GFA¶

FA2GFA(aut)[source]¶

Creates a GFA equivalent to NFA

Parameters: aut (OFA) – the automaton
Returns: a GFA deep copy
Return type: GFA

FAallRegExps¶

FAallRegExps(aut)[source]¶

Evaluates the alphabetic length of the equivalent regular expression using every possible order of state elimination.

Parameters: aut (OFA) – the automaton
Return type: list of tuples (int, list of states)

cutPoints¶

cutPoints(aut)[source]¶

Set of FA’s cut points

Parameters: aut (OFA) – the automaton
Returns: set of states
Return type: set of int

FA2regexpSE¶

FA2regexpSE(aut)[source]¶

A regular expression obtained by state elimination algorithm whose language is recognised by the FA aut.

Parameters: aut (OFA) – the automaton
Returns: the equivalent regular expression
Return type: reex.RegExp

FA2regexpSE_nn¶

FA2regexpSE_nn(aut, order=None)[source]¶

Regular expression from state elimination whose language is recognised by the FA. The FA is not normalized before the state elimination.

Parameters

aut (OFA) – the automaton
order (list) – state elimination sequence

Returns

the equivalent regular expression

Return type

SP2regexp¶

SP2regexp(aut)[source]¶

Checks if FA is SP (Serial-PArallel), and if so returns the regular expression whose language is recognised by the FA

Parameters: aut (OFA) – the automaton
Returns: equivalent regular expression
Return type: reex.RegExp
Raises: NotSP – if the automaton is not Serial-Parallel

See also

Moreira & Reis, Fundamenta Informatica, Series-Parallel automata and short regular expressions, n.91 3-4, pag 611-629. https://www.dcc.fc.up.pt/~nam/publica/spa07.pdf

Note

Automata must be Serial-Parallel

FAeliminateSingles¶

FAeliminateSingles(aut)[source]¶

Eliminates every state that only have one successor and one predecessor.

Parameters: aut (OFA) – the automaton
Returns: GFA after eliminating states
Return type: GFA

FA2regexpCG¶

FA2regexpCG(aut)[source]¶

Regular expression from state elimination whose language is recognised by the FA. Uses a heuristic to choose the order of elimination.

Parameters: aut (OFA) – the automaton
Returns: the equivalent regular expression
Return type: reex.RegExp

FA2regexpCG_nn¶

FA2regexpCG_nn(aut: FAdo.fa.OFA)[source]¶

Regular expression from state elimination whose language is recognised by the FA. Uses a heuristic to choose the order of elimination. The FA is not normalized before the state elimination.

Parameters: aut (OFA) – the automaton
Returns: the equivalent regular expression
Return type: reex.RegExp

FA2regexpSEO¶

FA2regexpSEO(aut, order=None)[source]¶

Regular expression from state elimination whose language is recognised by the FA. The FA is normalized before the state elimination.

Parameters

aut (OFA) – the automaton
order (list) – state elimination sequence

Returns

the equivalent regular expression

Return type

FA2regexpDynamicCycleHeuristic¶

FA2regexpDynamicCycleHeuristic(aut)[source]¶

State elimination Heuristic based on the number of cycles that passes through each state. Here those numbers are evaluated dynamically after each elimination step

Parameters: aut (OFA) – the automaton
Returns: an equivalent regular expression
Return type: reex.RegExp

See also

Nelma Moreira, Davide Nabais, and Rogério Reis. State elimination ordering strategies: Some experimental results. Proc. of 11th Workshop on Descriptional Complexity of Formal Systems (DCFS10), pages 169-180.2010. DOI: 10.4204/EPTCS.31.16

FA2regexpStaticCycleHeuristic¶

FA2regexpStaticCycleHeuristic(aut)[source]¶

State elimination Heuristic based on the number of cycles that passes through each state. Here those numbers are evaluated statically in the beginning of the process

Parameters: aut (OFA) – the automaton
Returns: a equivalent regular expression
Return type: reex.RegExp

See also

Nelma Moreira, Davide Nabais, and Rogério Reis. State elimination ordering strategies: Some experimental results. Proc. of 11th Workshop on Descriptional Complexity of Formal Systems (DCFS10), pages 169-180.2010. DOI: 10.4204/EPTCS.31.16

DFA2regexpDijkstra¶

DFA2regexpDijkstra(aut) → FAdo.reex.RegExp[source]¶

Returns a regexp for the current DFA considering the recursive method. Very inefficent.

Parameters: aut (DFA) – the automaton
Returns: a regexp equivalent to the current DFA
Return type: reex.RegExp

DFAsyncWords¶

DFAsyncWords(aut)[source]¶

Evaluates the regular expression corresponding to the synchronizing pwords of the automata.

Parameters: aut (DFA) – the automata
Returns: a regular expression of the sync words of the automata
Return type: reex.RegExp

Module: Common Definitions (`common`)¶

Common definitions for FAdo files

Classes¶

Word¶

class Word(data=None, it=None)[source]¶

Class to implement generic words as iterables with pretty-print

Basically a unified way to deal with words with caracters of sizes different of one with no much fuss

Drawable¶

class Drawable[source]¶

Any FAdo object that is drawable

display(filename=None, size='30,20', strict=False, maxlblsz=6)[source]¶

Display automata using dot

Parameters

size – size of representation
fileName – filename to use for the graphic representation (default a os tmpfile
maxlblsz (int) – max size of labels before getting removed
strict (bool) – use limitations of label sizes

Changed in version 1.2.1.

abstract dotFormat(size='20,20', filename=None, direction='LR', strict=False, maxlblsz=6, sep='\n')[source]¶

Some dot representation

Parameters

size (str) – size parameter for dotviz
filename (str) – filename
direction (str) –
strict (bool) –
maxlblsz (int) –
sep (str) –

Returns: str:

dotLabel(lbl0)[source]¶: Label string

makePNG(filename=None, size='30,20')[source]¶

Produce png file to display

Parameters

filename (str) – file name, if None will be a tmpfile
size – size for graphviz

Returns

name of the file created

New in version 1.0.4.

Module: FAdo IO Functions (`fio`)¶

In/Out.

FAdo I/O methods. The parsing grammars for most of the objects reside here.

Classes¶

Class BuildFadoObject¶

class BuildFadoObject(visit_tokens=True)[source]¶: Semantics of the FAdo grammars’ objects

Functions¶

readFromFile¶

readFromFile(FileName)[source]¶

Reads list of finite automata definition from a file.

Parameters: FileName (str) – file name
Return type: list

The format of these files must be the as simple as possible:

# begins a comment
@DFA or @NFA begin a new automata (and determines its type) and must be followed by the list of the final states separated by blanks
fields are separated by a blank and transitions by a CR: state symbol new state
in case of a NFA declaration, the “symbol” @epsilon is interpreted as a CEpsilon-transition
the source state of the first transition is the initial state
in the case of a NFA, its declaration @NFA can, after the declaration of the final states, have a * followed by the list of initial states
both, NFA and DFA, may have a declaration of alphabet starting with a $ followed by the symbols of the alphabet
a line with a sigle name, decrares a state

FAdo       ::=  FA | FA CR FAdo
FA         ::=  DFA | NFA | Transducer
DFA        ::=  "@DFA" LsStates Alphabet CR dTrans
NFA        ::=  "@NFA" LsStates Initials Alphabet CR nTrans
Transducer ::=  "@Transducer" LsStates Initials Alphabet Output CR tTrans
Initials   ::=  "*" LsStates | /CEpsilon
Alphabet   ::=  "$" LsSymbols | /CEpsilon
Output     ::=  "$" LsSymbols | /CEpsilon
nSymbol    ::=  symbol | "@epsilon"
LsStates   ::=  stateid | stateid , LsStates
LsSymbols  ::=  symbol | symbol , LsSymbols
dTrans     ::=  stateid symbol stateid |
               | stateid symbol stateid CR dTrans
nTrans     ::=  stateid nSymbol stateid |
               | stateid nSymbol stateid CR nTrans
tTrans     ::=  stateid nSymbol nSymbol stateid |
               | stateid nSymbol nSymbol stateid CR nTrans

Note

If an error occur, either syntactic or because of a violation of the declared automata type, an exception is raised

Changed in version 0.9.6.

Changed in version 1.0.

readOneFromFile¶

readOneFromFile(fileName)[source]¶

Read the first of the FAdo objects from File

Parameters: fileName (str) – name of the file
Return type: DFA|FA|STF|SST

readOneFromString¶

readOneFromString(s)[source]¶

Reads one finite automata definition from a file.

See also

readFromFile for description of format

Parameters: s (str) – the string
Return type: DFA|NFA|SFT

saveToFile¶

saveToFile(FileName, fa, mode='a')[source]¶

Saves a list finite automata definition to a file using the input format

Changed in version 0.9.5.

Changed in version 0.9.6.

Changed in version 0.9.7: New format with quotes and alphabet

Parameters

FileName (str) – file name
fa (list of FA) – the FA
mode (str) – writing mode

saveToJson¶

saveToJson(FileName, aut, mode='w')[source]¶: Saves a finite automata definition to a file using the JSON format

saveToString¶

saveToString(fa)[source]¶

Saves a finite automaton definition to a string :param fa: automaton :return: the string containing the automaton definition :rtype: str

..versionadded:: 1.2.1

toJson¶

toJson(aut)[source]¶

Json for a FA

Parameters: aut (FA) – the automaton
Return type: str

Constants¶

const: FAdo.fio.FAdoGrammar

Module: Regular Expressions (`reex`)¶

Regular expressions manipulation

Regular expression classes and manipulation

Classes¶

RegularExpression¶

class RegularExpression[source]¶: Abstract base class for all regular expression objects

RegExp¶

class RegExp(sigma=None)[source]¶

Base class for regular expressions.

Variables: Sigma – alphabet set of strings

abstract static alphabeticLength()[source]¶

Number of occurrences of alphabet symbols in the regular expression.

Return type: integer

Attention

Doesn’t include the empty word.

compare(r, cmp_method='compareMinimalDFA', nfa_method='nfaPD')[source]¶: Compare with another regular expression for equivalence. :param r: :param cmp_method: :param nfa_method:

compareMinimalDFA(r, nfa_method='nfaPosition')[source]¶: Compare with another regular expression for equivalence through minimal DFAs. :param r: :param nfa_method:

dfaAuPoint()[source]¶

DFA “au-point” acconding to Nipkow

Returns: “au-point” DFA
Return type: fa.DFA

See also

Andrea Asperti, Claudio Sacerdoti Coen and Enrico Tassi, Regular Expressions, au point. arXiv 2010

See also

Tobias Nipkow and Dmitriy Traytel, Unified Decision Procedures for

Regular Expression Equivalence

dfaBrzozowski(memo=None)[source]¶

Word derivatives automaton of the regular expression

Returns: word derivatives automaton
Return type: DFA

See also

1. Brzozowski, Derivatives of Regular Expressions. J. ACM 11(4): 481-494 (1964)

dfaYMG()[source]¶

DFA Yamada-McNaugthon-Gluskov acconding to Nipkow

Returns: Y-M-G DFA
Return type: DFA

See also

Tobias Nipkow and Dmitriy Traytel, Unified Decision Procedures for

Regular Expression Equivalence

static emptysetP()[source]¶

Whether the regular expression is the empty set.

Return type: Boolean

abstract static epsilonLength()[source]¶

Number of occurrences of the empty word in the regular expression.

Return type: integer

static epsilonP()[source]¶

Whether the regular expression is the empty word.

Return type: Boolean

equivP(other, strict=True)[source]¶

Test RE equivalence with extended Hopcroft-Karp method

Parameters

other (RegExp) – RE
strict (bool) – if True checks for same alphabets

Return type

equivalentP(other)[source]¶

Tests equivalence

Parameters: other –
Return type: bool

evalWordP(word)[source]¶

Verifies if a word is a member of the language represented by the regular expression.

Parameters: word (str) – the word
Return type: bool

static ewp()[source]¶

Whether the empty word property holds for this regular expression’s language.

Return type: Boolean

abstract first()[source]¶

Return type: set

abstract last()[source]¶

Return type: set

abstract linearForm()[source]¶

Return type: dic

abstract mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

marked()[source]¶

Regular expression in which every alphabetic symbol is marked with its Position.

The kind of regular expression returned is known, depending on the literary source, as marked, linear or restricted regular expression.

Returns: linear regular expression
Return type: RegExp

See also

r. McNaughton and H. Yamada, Regular Expressions and State Graphs for Automata, IEEE Transactions on Electronic Computers, V.9 pp:39-47, 1960

..attention: mark and unmark do not preserve the alphabet, neither set the new alphabet

nfaFollow()[source]¶

NFA that accepts the regular expression’s language, whose structure, equiand construction.

Return type: NFA

See also

Ilie & Yu (Follow Automata, 03)

nfaFollowEpsilon(trim=True)[source]¶

Epsilon-NFA constructed with Ilie and Yu’s method () that accepts the regular expression’s language.

Parameters: trim –
Returns: NFA possibly with CEpsilon transitions
Return type: NFAe

Note

The regular expression must be reduced

See also

Ilie & Yu, Follow automta, Inf. Comp. ,v. 186 (1),140-162,2003

nfaGlushkov()[source]¶

Position or Glushkov automaton of the regular expression. Recursive method.

Returns: NFA

nfaNaiveFollow()[source]¶

NFA that accepts the regular expression’s language, and is equal in structure to the follow automaton.

Return type: NFA

Note

Included for testing purposes.

See also

Ilie & Yu (Follow Automata, 2003)

nfaPD(pdmethod='nfaPDDAG')[source]¶: Computes the partial derivative automaton : param pdmethod str: an implementation of the PD automaton. Default value : nfaPDDAG :return: a PD nfa :rtype: NFA

nfaPDDAG()[source]¶

” :return: a PD nfa build using a DAG :rtype: NFA

..seealso:: s.Konstantinidis, A. Machiavelo, N. Moreira, and r. Reis.: Partial derivative automaton by compressing regular expressions. DCFS 2021, volume 13037 of LNCS, pages 100–112. Springer, 2022

nfaPDNaive()[source]¶

NFA that accepts the regular expression’s language,: and which is constructed from the expression’s partial derivatives.
Returns: NFA: partial derivatives [or equation] automaton

See also

V. M. Antimirov, Partial Derivatives of Regular Expressions and Finite Automaton Constructions .Theor. Comput. Sci.155(2): 291-319 (1996)

nfaPDO()[source]¶

NFA that accepts the regular expression’s language, and which is constructed from the expression’s partial: derivatives.

Note

optimized version

Returns: partial derivatives [or equation] automaton
Return type: NFA

nfaPSNF()[source]¶

Position or Glushkov automaton of the regular expression constructed from the expression’s star normal form.

Returns: Position automaton
Return type: NFA

nfaPosition(lstar=True)[source]¶

Position automaton of the regular expression.

Parameters: lstar (boolean) – if not None followlists are computed as disjunct
Returns: Position NFA
Return type: NFA

nfaPre()[source]¶: Prefix NFA of a regular expression States are of the form (RegExp,sym) :return: prefix automaton :rtype: NFA

See also

Maia et al, Prefix and Right-partial derivative automata, 11th CIE 2015, 258-267 LNCS 9136, 2015

nfaPreSlow()[source]¶: Prefix NFA of a regular expression :return: prefix automaton :rtype: NFA .. seealso:: Maia et al, Prefix and Right-partial derivative automata, 11th CIE 2015, 258-267 LNCS 9136, 2015 ..note:: not working with current tailForm

notEmptyW()[source]¶

Witness of non emptyness

Returns: word or None

abstract rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

abstract static setOfSymbols()[source]¶

Return type: set

setSigma(symbolset=None, strict=False)[source]¶

Set the alphabet for a regular expression and all its nodes

Parameters

symbolset (list or set of str) – accepted symbols. If None, alphabet is unset.
strict (bool) – if True checks if setOfSymbols is included in symbolSet

..attention: Normally this attribute is not defined in a RegExp()

abstract static starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

abstract tailForm()[source]¶

Return type: dict

toDFA()[source]¶: DFA that accepts the regular expression’s language

toNFA(nfa_method='nfaPDNaive')[source]¶: NFA that accepts the regular expression’s language. :param nfa_method:

abstract static treeLength()[source]¶

Number of nodes of the regular expression’s syntactical tree.

Return type: integer

unionSigma(other)[source]¶

Returns the union of two alphabets

Return type: set

wordDerivative(word)[source]¶

Derivative of the regular expression in relation to the given word,: which is represented by a list of symbols.

Parameters: word – list of arbitrary symbols.
Return type: regular expression

See also

1. Brzozowski, Derivatives of Regular Expressions. J. ACM 11(4): 481-494 (1964)

SpecialConstant¶

class SpecialConstant(sigma=None)[source]¶

Base class for Epsilon and EmptySet

Parameters: sigma – alphabet

static alphabeticLength()[source]¶

Returns

derivative(sigma)[source]¶

Parameters: sigma –
Returns

distDerivative(sigma)[source]¶

Parameters: sigma – an arbitrary symbol.
Return type: regular expression

static epsilonLength()[source]¶

Number of occurrences of the empty word in the regular expression.

Return type: integer

static first(parent_first=None)[source]¶

Parameters: parent_first –
Returns

followLists(lists=None)[source]¶

Parameters: lists –
Returns

followListsD(lists=None)[source]¶

Parameters: lists –
Returns

static followListsStar(lists=None)[source]¶

Parameters: lists –
Returns

last(parent_last=None)[source]¶

Parameters: parent_last –
Returns

linearForm()[source]¶

Returns

mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

reversal()[source]¶

Reversal of RegExp

Return type: reex.RegExp

abstract rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

static setOfSymbols()[source]¶

Returns

static starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

support(side=True)[source]¶

Returns

supportlast(side=True)[source]¶

Returns

tailForm()[source]¶

Returns

static treeLength()[source]¶

Number of nodes of the regular expression’s syntactical tree.

Return type: integer

unmark()[source]¶: Conversion back to unmarked atoms :rtype: SpecialConstant

unmarked()[source]¶

The unmarked form of the regular expression. Each leaf in its syntactical tree becomes a RegExp(), the CEpsilon() or the CEmptySet().

Return type: (general) regular expression

wordDerivative(word)[source]¶

Parameters: word –
Returns

CEpsilon¶

class CEpsilon(sigma=None)[source]¶

Class that represents the empty word.

Parameters: sigma – alphabet

static epsilonLength()[source]¶

Number of occurrences of the empty word in the regular expression.

Return type: integer

static epsilonP()[source]¶

Return type: bool

static ewp()[source]¶

Return type: bool

static measure(from_parent=None)[source]¶

Parameters: from_parent –
Returns: measures

nfaThompson()[source]¶

Return type: NFA

partialDerivatives(_)[source]¶

Returns

partialDerivativesC(_)[source]¶

Returns

rpn()[source]¶

Returns: str

snf(_hollowdot=False)[source]¶

Parameters: _hollowdot –
Returns

CEmptySet¶

class CEmptySet(sigma=None)[source]¶

Class that represents the empty set.

Parameters: sigma – alphabet

static emptysetP()[source]¶

Returns

static epsilonLength()[source]¶

Returns

static epsilonP()[source]¶

Returns

static ewp()[source]¶

Returns

static measure(from_parent=None)[source]¶

Parameters: from_parent –
Returns

nfaPD(pdmethod='nfaPDNaive')[source]¶: Computes the partial derivative automaton

partialDerivativesC(_)[source]¶

Returns

rpn()[source]¶

Returns

SigmaP¶

SigmaP¶: alias of @sigmaP

SigmaS¶

SigmaS¶: alias of @sigmaS

Connective¶

class Connective(arg1, arg2, sigma=None)[source]¶

Base class for (binary) operations: concatenation, disjunction, etc

alphabeticLength()[source]¶

Number of occurrences of alphabet symbols in the regular expression.

Return type: integer

Attention

Doesn’t include the empty word.

epsilonLength()[source]¶

Number of occurrences of the empty word in the regular expression.

Return type: integer

first(parent_first=None)[source]¶

Return type: set

last(parent_last=None)[source]¶

Return type: set

abstract linearForm()[source]¶

Return type: dic

abstract mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

abstract rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

setOfSymbols()[source]¶

Return type: set

starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

treeLength()[source]¶

Number of nodes of the regular expression’s syntactical tree.

Return type: integer

Star¶

Concat¶

Disj¶

Power¶

class Power(arg, n=1, sigma=None)[source]¶

Class for Power operation on regular expressions.

alphabeticLength()[source]¶

Number of occurrences of alphabet symbols in the regular expression.

Return type: integer

Attention

Doesn’t include the empty word.

epsilonLength()[source]¶

Number of occurrences of the empty word in the regular expression.

Return type: integer

first()[source]¶

Return type: set

last()[source]¶

Return type: set

linearForm()[source]¶

Return type: dic

mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

reversal()[source]¶

Reversal of RegExp

Return type: reex.RegExp

rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

setOfSymbols()[source]¶

Return type: set

starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

tailForm()[source]¶

Return type: dict

treeLength()[source]¶

Number of nodes of the regular expression’s syntactical tree.

Return type: integer

Option¶

Option¶: alias of -

Conj¶

Conj¶: alias of &

Shuffle¶

Shuffle¶: alias of :

Atom¶

Position¶

class Position(val, sigma=None)[source]¶

Class for marked regular expression symbols.

Constructor of a regular expression symbol.

Parameters: val – the actual symbol

setOfSymbols()[source]¶

Set of symbols that occur in a regular expression..

Returns: set of symbols
Return type: set of symbols

unmarked()[source]¶

The unmarked form of the regular expression. Each leaf in its syntactical tree becomes a RegExp(), the CEpsilon() or the CEmptySet().

Return type: (general) regular expression

SConnective¶

class SConnective(arg, sigma=None)[source]¶

Special regular expressions modulo associativity, commutativity, idempotence of disjunction and intersection;

associativity of concatenation; identities sigma^* and sigma^+. Connectives are:

SDisj: disjunction SConj: intersection SConcat: concatenation

For parsing use str2sre

alphabeticLength()[source]¶

Returns

epsilonLength()[source]¶

Returns

first()[source]¶

Return type: set

last()[source]¶

Return type: set

linearForm()[source]¶

Return type: dic

mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

nfaPD(pdmethod='nfaPDNaive')[source]¶: Computes the partial derivative automaton

rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

setOfSymbols()[source]¶

Returns

starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

syntacticLength()[source]¶

Returns

abstract tailForm()[source]¶

Return type: dict

treeLength()[source]¶

Returns

SConcat¶

class SConcat(arg, sigma=None)[source]¶

Class that represents the concatenation operation.

derivative(sigma)[source]¶

Parameters: sigma –
Returns

ewp()[source]¶

Returns

head()[source]¶

Returns

head_rev()[source]¶

Returns

linearForm()[source]¶

Returns

linearFormC()[source]¶

Returns

partialDerivatives(sigma)[source]¶

Parameters: sigma –
Returns

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

support(side=True)[source]¶

Returns

tail()[source]¶

Returns

tailForm()[source]¶

Return type: dict

tail_rev()[source]¶

Returns

SStar¶

class SStar(arg, sigma=None)[source]¶

Special regular expressions modulo associativity, commutativity, idempotence of disjunction and intersection;: associativity of concatenation; identities sigma^* and sigma^+.

SStar: Class that represents Kleene star

derivative(sigma)[source]¶

Parameters: sigma –
Returns

linearForm()[source]¶

Returns

nfaPD(pdmethod='nfaPDNaive')[source]¶: Computes the partial derivative automaton

partialDerivatives(sigma)[source]¶

Parameters: sigma –
Returns

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

support(side=True)[source]¶

Returns

SDisj¶

class SDisj(arg, sigma=None)[source]¶

Class that represents the disjunction operation for special regular expressions.

static cross(ri, s, lists)[source]¶

Return type: list

derivative(sigma)[source]¶

Parameters: sigma –
Returns

ewp()[source]¶

Returns

first()[source]¶

Returns

followLists(lists=None)[source]¶

Parameters: lists –
Returns

followListsStar(lists=None)[source]¶

Parameters: lists –
Returns

last()[source]¶

Returns

linearForm()[source]¶

Returns

linearFormC()[source]¶

Returns

partialDerivatives(sigma)[source]¶

Parameters: sigma –
Returns

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

support(side=True)[source]¶

Returns

tailForm()[source]¶

Return type: dict

SConj¶

class SConj(arg, sigma=None)[source]¶

Class that represents the conjunction operation.

derivative(sigma)[source]¶

Parameters: sigma –
Returns

ewp()[source]¶

Returns

linearForm()[source]¶

Returns

partialDerivatives(sigma)[source]¶

Parameters: sigma –
Returns

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

support(side=True)[source]¶

Returns

tailForm()[source]¶

Return type: dict

SNot¶

class SNot(arg, sigma=None)[source]¶

Special regular expressions modulo associativity, commutativity, idempotence of disjunction and intersection;: associativity of concatenation; identities sigma^* and sigma^+. SNot: negation

alphabeticLength()[source]¶

Returns

derivative(sigma)[source]¶: :param sigma :return:

epsilonLength()[source]¶

Returns

ewp()[source]¶

Returns

first()[source]¶

Return type: set

last()[source]¶

Return type: set

linearForm()[source]¶

Returns

linearFormC()[source]¶

Returns

mark()[source]¶: Make all atoms maked (tag False) :rtype: RegExp

nfaPD(pdmethod='nfaPDNaive')[source]¶: Computes the partial derivative automaton

partialDerivatives(sigma)[source]¶

Parameters: sigma –
Returns

partialDerivativesC(sigma)[source]¶

Parameters: sigma –
Returns

rpn()[source]¶: RPN representation :rtype: str :return: printable RPN representation

setOfSymbols()[source]¶

Returns

starHeight()[source]¶

Maximum level of nested regular expressions with a star operation applied.

For instance, starHeight(((a*b)*+b*)*) is 3.

Return type: integer

support(side=True)[source]¶

Returns

syntacticLength()[source]¶

Returns

tailForm()[source]¶

Return type: dict

treeLength()[source]¶

Returns

DAG¶

class DAG(reg)[source]¶

Class to support dags representing regexps

…seealso: P. Flajolet, P. Sipala, J.-M. Steyaert, Analytic variations on the common subexpression problem,: in: Automata, Languages and Programmin, LNCS, vol. 443, Springer, New York, 1990, pp. 220–234.

Variables: reg (reex) – regular expression

catLF(idl, idr, delay=False)[source]¶: both arguments are assumed to be already present in the DAG

static plusLF(diff1, diff2)[source]¶

Union of partial derivatives

Parameters

diff1 (dict) – partial diff of the first argument
diff2 (dict) – partial diff of the second argument

Return type

dict

DNode¶

class DNode(op, arg1=None, arg2=None)[source]¶

MAtom¶

class MAtom(val, mark, sigma=None)[source]¶

Base class for pointed (marked) regular expressions

Used directly to represent atoms (characters). This class is used to obtain Yamada or Asperti automata. There is no evident use for it, outside this module.

Parameters

val – symbol
sigma – alphabet

unmark()[source]¶

Conversion back to RegExp

Return type: reex.RegExp

BuildRegexp¶

class BuildRegexp(context=None)[source]¶: Semantics of the FAdo grammars’ regexps Priorities of operators: disj > conj > shuffle > concat > not > star >= option

BuildRPNRegexp¶

class BuildRPNRegexp(context=None)[source]¶

BuildRPNSRE¶

class BuildRPNSRE(context=None)[source]¶

BuildSRE¶

class BuildSRE(context=None)[source]¶: Parser for sre

Functions¶

str2regexp¶

str2regexp(s, parser=Lark(open('/Users/rvr/Work/FAdo/FAdo/regexp_grammar.lark'), parser='lalr', lexer='contextual', ...), sigma=None, strict=False)[source]¶

Reads a RegExp from string.

Parameters

s (string) – the string representation of the regular expression
parser – a parser generator for regexps
sigma (list or set of symbols) – alphabet of the regular expression
strict (boolean) – if True tests if the symbols of the regular expression are included in sigma

Return type

str2sre¶

str2sre(s, parser=Lark(open('/Users/rvr/Work/FAdo/FAdo/regexp_grammar.lark'), parser='lalr', lexer='contextual', ...), sigma=None, strict=False)[source]¶

Reads a sre from string. Arguments as str2regexp.

Return type: reex.sre

rpn2regexp¶

rpn2regexp(s, sigma=None, strict=False)[source]¶

Reads a (simple) RegExp from a RPN representation

r ::=  .RR | +RR | *r | L | @
L ::=  [a-z] | [A-Z]

Parameters

s (str) – RPN representation
strict (bool) – Boolean
sigma (set) – alphabet

Return type

Note

This method uses python stack… thus depth limitations apply

to_s¶

to_s(r)[source]¶

Returns a sre from FAdo regexp.

Parameters: r (RegExp) – the FAdo representation regexp for a regular expression.
Return type: RegExp

Module: Transducers (`transducers`)¶

Finite Tranducer Support

Transducer manipulation.

New in version 1.0.

Classes¶

Transducer¶

class Transducer[source]¶

Base class for Transducers

setOutput(listOfSymbols)[source]¶

Set Output

Parameters: listOfSymbols (set|list) – output symbols

succintTransitions()[source]¶: Collects the transition information in a concat way suitable for graphical representation. :rtype: list of tupples

SFT¶

class SFT[source]¶

Standard Form Tranducer

Variables: Output (set) – output alphabet

addEpsilonLoops()[source]¶: Add a loop transition with CEpsilon input and output to every state in the transducer.

addTransition(stsrc, symi, symo, sti2)[source]¶

Adds a new transition

Parameters

stsrc (int) – state index of departure
sti2 (int) – state index of arrival
symi (str) – symbol consumed
symo (str) – symbol output

addTransitionProductQ(src, dest, ddest, sym, out, futQ, pastQ)[source]¶

Add transition to the new transducer instance.

Version for the optimized product

Parameters

src – source state
dest – destination state
ddest – destination as tuple
sym – symbol
out – output
futQ (set) – queue for later
pastQ (set) – past queue

addTransitionQ(src, dest, sym, out, futQ, pastQ)[source]¶

Add transition to the new transducer instance.

Parameters

src – source state
dest – destination state
sym – symbol
out – output
futQ (set) – queue for later
pastQ (set) – past queue

composition(other)[source]¶

Composition operation of a transducer with a transducer.

Parameters: other (SFT) – the second transducer
Return type: SFT

concat(other)[source]¶

Concatenation of transducers

Parameters: other (SFT) – the other operand
Return type: SFT

delTransition(sti1, sym, symo, sti2, _no_check=False)[source]¶

Remove a transition if existing and perform cleanup on the transition function’s internal data structure.

Parameters

symo – symbol output
sti1 (int) – state index of departure
sti2 (int) – state index of arrival
sym – symbol consumed
_no_check (bool) – dismiss secure code

deleteState(sti)[source]¶

Remove given state and transitions related with that state.

Parameters: sti (int) – index of the state to be removed
Raises: DFAstateUnknown – if state index does not exist

deleteStates(lstates)[source]¶

Delete given iterable collection of states from the automaton.

Parameters: lstates (set|list) – collection of int representing states

dup()[source]¶: Duplicate of itself :rtype: SFT

Attention

only duplicates the initially connected component

emptyP()[source]¶

Tests if the relation realized the empty transducer

Return type: bool

epsilonOutP()[source]¶

Tests if CEpsilon occurs in transition outputs

Return type: bool

epsilonP()[source]¶

Test whether this transducer has input CEpsilon-transitions

Return type: bool

evalWordP(wp)[source]¶

Tests whether the transducer returns the second word using the first one as input

Parameters: wp (tuple) – pair of words
Return type: bool

evalWordSlowP(wp)[source]¶

Tests whether the transducer returns the second word using the first one as input

Note: original :param tuple wp: pair of words :rtype: bool

functionalP()[source]¶

Tests if a transducer is functional using Allauzer & Mohri and Béal&Carton&Prieur&Sakarovitch algorithms.

Return type: bool

See also

Cyril Allauzer and Mehryar Mohri, Journal of Automata Languages and Combinatorics, Efficient Algorithms for Testing the Twins Property, 8(2): 117-144, 2003.

See also

M.P. Béal, O. Carton, C. Prieur and J. Sakarovitch. Squaring transducers: An efficient procedure for deciding functionality and sequentiality. Theoret. Computer Science 292:1 (2003), 45-63.

Note

This is implemented using nonFunctionalW()

inIntersection(other)[source]¶

Conjunction of transducer and automata: X & Y.

Note

This is a fast version of the method that does not produce meaningfull state names.

Note

The resulting transducer is not trim.

Parameters: other (DFA|NFA) – the automata needs to be operated.
Return type: SFT

inIntersectionSlow(other)[source]¶

Conjunction of transducer and automata: X & Y.

Note

This is the slow version of the method that keeps meaningfull names of states.

Parameters: other (DFA|NFA) – the automata needs to be operated.
Return type: SFT

inverse()[source]¶

Switch the input label with the output label.

No initial or final state changed.

Returns: Transducer with transitions switched.
Return type: SFT

nonEmptyW()[source]¶

Witness of non emptyness

Returns: pair (in-word, out-word)
Return type: tuple

nonFunctionalW()[source]¶

Returns a witness of non funcionality (if is that the case) or a None filled triple

Returns: witness
Return type: tuple

outIntersection(other)[source]¶

Conjunction of transducer and automaton: X & Y using output intersect operation.

Parameters: other (DFA|NFA) – the automaton used as a filter of the output
Return type: SFT

outIntersectionDerived(other)[source]¶

Naive version of outIntersection

Parameters: other (DFA|NFA) – the automaton used as a filter of the output
Return type: SFT

outputS(s)[source]¶

Output label coming out of the state i

Parameters: s (int) – index state
Return type: set

productInput(other)[source]¶

Returns a transducer (skeleton) resulting from the execution of the transducer with the automaton as filter on the input.

Note

This version does not use stateIndex() with the price of generating some unreachable sates

Parameters: other (NFA) – the automaton used as filter
Return type: SFT

Changed in version 1.3.3.

productInputSlow(other)[source]¶

Returns a transducer (skeleton) resulting from the execution of the transducer with the automaton as filter on the input.

Note

This is the slow version of the method that keeps meaningfull names of states.

Parameters: other (NFA) – the automaton used as filter
Return type: SFT

reversal()[source]¶

Returns a transducer that recognizes the reversal of the relation.

Returns: Transducer recognizing reversal language
Return type: SFT

runOnNFA(nfa)[source]¶

Result of applying a transducer to an automaton

Parameters: nfa (DFA|NFA) – input language to transducer
Returns: resulting language
Return type: NFA

runOnWord(word)[source]¶

Returns the automaton accepting the outup of the transducer on the input word

Parameters: word – the word
Return type: NFA

setInitial(sts)[source]¶

Sets the initial state of a Transducer

Parameters: sts (list) – list of states

square()[source]¶

Conjunction of transducer with itself

Return type: NFA

square_fv()[source]¶

Conjunction of transducer with itself (Fast Version)

Return type: NFA

star(flag=False)[source]¶

Kleene star

Parameters: flag (bool) – plus instead of star
Returns: the resulting Transducer
Return type: SFT

toInNFA()[source]¶

Delete the output labels in the transducer. Translate it into an NFA

Return type: NFA

toNFT()[source]¶

Transformation into Nomal Form Transducer

Return type: NFT

toOutNFA()[source]¶

Returns the result of considering the output symbols of the transducer as input symbols of a NFA (ignoring the input symbol, thus)

Returns: the NFA
Return type: NFA

toSFT()[source]¶

Pacifying rule

Return type: SFT

trim()[source]¶: Remove states that do not lead to a final state, or, inclusively, that can’t be reached from the initial state. Only useful states remain.

Attention

in place transformation

union(other)[source]¶

Union of the two transducers

Parameters: other (SFT) – the other operand
Return type: SFT

NFT¶

class NFT[source]¶

Normal Form Transducer.

Transsitions here have labels of the form (s,Epsilon) or (Epsilon,s)

GFT¶

class GFT[source]¶

General Form Transducer

addOutput(sym)[source]¶

Add a new symbol to the output alphabet

There is no problem with duplicate symbols because Output is a Set. No symbol Epsilon can be added

Parameters: sym (str) – symbol or regular expression to be added

addTransition(stsrc, wi, wo, sti2)[source]¶

Adds a new transition

Parameters

stsrc (int) – state index of departure
sti2 (int) – state index of arrival
wi (str) – word consumed
wo (str) – word outputed

codeOfTransducer()[source]¶

Appends into one string the codes of the alphabets and initial and final state sets and the set of transitions

Return type: tuple

listOfTransitions()[source]¶

Collects into a sorted list the transitions of the transducer.

Return type: set of tuples

toSFT()[source]¶

Conversion to an equivalent SFT

rtype: SFT

:members:

Functions¶

hypercodeTransducer¶

hypercodeTransducer(alphabet, preserving=False)[source]¶

Creates an hypercode property transducer based on given alphabet

Parameters

preserving (bool) – input preserving transducer, else input altering
alphabet (list|set) – alphabet

Return type

infixTransducer¶

infixTransducer(alphabet, preserving=False)[source]¶

Creates an infix property transducer based on given alphabet

Parameters

preserving (bool) – input preserving transducer, else input altering
alphabet (list|set) – alphabet

Return type

isLimitExceed¶

isLimitExceed(NFA0Delta, NFA1Delta)[source]¶

Decide if the size of NFA0 and NFA1 exceed the limit.

Size of NFA0 is denoted as N, and size of NFA1 is denoted as M. If N*N*M exceeds 1000000, return False, else return True. If bothNFA is False, then NFA0 should be NFA, and NFA1 should be Transducer. If both NFA is True, then NFA0 and NFA1 are both NFAs.

Parameters

NFA0Delta (dict) – NFA0’s transition Delta
NFA1Delta (dict) – NFA1’s transition Delta

Return type

outfixTransducer¶

outfixTransducer(alphabet, preserving=False)[source]¶

Creates an outfix property transducer based on given alphabet

Parameters

preserving (bool) – input preserving transducer, else input altering
alphabet (list|set) – alphabet

Return type

prefixTransducer¶

prefixTransducer(alphabet, preserving=False)[source]¶

Creates an prefix property transducer based on given alphabet

Parameters

preserving (bool) – input preserving transducer, else input altering
alphabet (list|set) – alphabet

Return type

suffixTransducer¶

suffixTransducer(alphabet, preserving=False)[source]¶

Creates an suffix property transducer based on given alphabet

Parameters

preserving (bool) – input preserving transducer, else input altering
alphabet (list|set) – alphabet

Return type

Module: Finite Languages (`fl`)¶

Finite languages and related automata manipulation

Finite languages manipulation

Classes¶

FL¶

class FL(wordsList=None, Sigma=None)[source]¶

Finite Language Class

Variables

Words – the elements of the language
Sigma – the alphabet

MADFA()[source]¶

Generates the minimal acyclical DFA using specialized algorithm

New in version 1.3.3.

See also

Incremental Construction of Minimal Acyclic Finite-State Automata, J.Daciuk, s.Mihov, B.Watson and r.E.Watson

Return type: ADFA

addWord(word)[source]¶: Adds a word to a FL :type word: Word :rtype: FL

addWords(wList)[source]¶

Adds a list of words to a FL

Parameters: wList (list) – words to add

diff(other)[source]¶

Difference of FL: a - b

Parameters: other (FL) – right hand operand
Return type: FL
Raises: FAdoGeneralError – if both arguments are not FL

filter(automata)[source]¶

Separates a language in two other using a DFA of NFA as a filter

Parameters: automata (DFA|NFA) – the automata to be used as a filter
Returns: the accepted/unaccepted pair of languages
Return type: tuple of FL

intersection(other)[source]¶

Intersection of FL: a & b

Parameters: other (FL) – right hand operand
Raises: FAdoGeneralError – if both arguments are not FL

multiLineAutomaton()[source]¶

Generates the trivial linear ANFA equivalent to this language

Return type: ANFA

setSigma(Sigma, Strict=False)[source]¶

Sets the alphabet of a FL

Parameters

Sigma (set) – alphabet
Strict (bool) – behaviour

Attention

Unless Strict flag is set to True, alphabet can only be enlarged. The resulting alphabet is in fact the union of the former alphabet with the new one. If flag is set to True, the alphabet is simply replaced.

suffixClosedP()[source]¶

Tests if a language is suffix closed

Return type: bool

toDFA()[source]¶

Generates a DFA recognizing the language

Return type: ADFA

New in version 1.2.

toNFA()[source]¶

Generates a NFA recognizing the language

Return type: ANFA

New in version 1.2.

trieFA()[source]¶

Generates the trie automaton that recognises this language

Returns: the trie automaton
Return type: ADFA

union(other)[source]¶

union of FL: a | b

Parameters: other (FL) – right hand operand
Return type: FL
Raises: FAdoGeneralError – if both arguments are not FL

DCFA¶

class DFCA[source]¶

Deterministic Cover Automata class

property length¶

size of the longest word :rtype: int

Type: return

AFA¶

class AFA[source]¶

Base class for Acyclic Finite Automata

note: This is just a container for some common methods. Not to be used directly!!

abstract addState(_)[source]¶

Return type: int

directRank()[source]¶

Compute rank function

Returns: ranf map
Return type: dict

ensureDead()[source]¶: Ensures that a state is defined as dead

evalRank()[source]¶

Evaluates the rank map of a automaton

Returns: pair of sets of states by rank map, reverse delta accessability map
Return type: tuple

getLeaves()[source]¶

The set of leaves, i.e. final states for last symbols of language words

Returns: set of leaves
Return type: set

ordered()[source]¶

Orders states names in its topological order

Returns: ordered list of state indexes
Return type: list of int

Note

one could use the FA.toposort() method, but special care must be taken with the dead state for the algorithms related with cover automata.

setDeadState(sti)[source]¶

Identifies the dead state

Parameters: sti (int) – index of the dead state

Attention

nothing is done to ensure that the state given is legitimate

Note

without dead state identified, most of the methods for acyclic automata can not be applied

ADFA¶

class ADFA[source]¶

Acyclic Deterministic Finite Automata class

Changed in version 1.3.3.

addSuffix(st, w)[source]¶

Adds a suffix starting in st

Parameters

st (int) – state
w (Word) – suffix

New in version 1.3.3.

Attention

in place transformation

complete(dead=None)[source]¶

Make the ADFA complete

Parameters: dead (int) – a state to be identified as dead state if one was not identified yet
Return type: ADFA

Attention

The object is modified in place

Changed in version 1.3.3.

diss()[source]¶

Evaluates the dissimilarity language

Return type: FL

New in version 1.2.1.

dissMin(witnesses=None)[source]¶: Evaluates the minimal dissimilarity language :param dict witnesses: optional witness dictionay :rtype: FL

New in version 1.2.1.

dup()[source]¶

Duplicate the basic structure into a new ADFA. Basically a copy.deep.

Return type: ADFA

forceToDFA()[source]¶

Conversion to DFA

Return type: DFA

forceToDFCA()[source]¶

Conversion to DFCA

Return type: DFA

level()[source]¶

Computes the level for each state

Returns: levels of states
Return type: dict

New in version 0.9.8.

minDFCA()[source]¶

Generates a minimal deterministic cover automata from a DFA

Return type: DFCA

New in version 0.9.8.

See also

Cezar Campeanu, Andrei Päun, and Sheng Yu, An efficient algorithm for constructing minimal cover automata for finite languages, IJFCS

minReversible()[source]¶

Returns the minimal reversible equivalent automaton

Return type: ADFA

minimal()[source]¶

Finds the minimal equivalent ADFA

See also

[TCS 92 pp 181-189] Minimisation of acyclic deterministic automata in linear time, Dominique Revuz

Changed in version 1.3.3.

Returns: the minimal equivalent ADFA
Return type: ADFA

minimalP(method=None)[source]¶

Tests if the DFA is minimal

Parameters: method – minimization algorithm (here void)
Return type: bool

Changed in version 1.3.3.

possibleToReverse()[source]¶: Tests if language is reversible

New in version 1.3.3.

statePairEquiv(s1, s2)[source]¶

Tests if two states of a ADFA are equivalent

Parameters

s1 (int) – state1
s2 (int) – state2

Return type

New in version 1.3.3.

toANFA()[source]¶

Converts the ADFA in a equivalent ANFA

Return type: ANFA

toNFA()[source]¶

Converts the ADFA in a equivalent NFA

Return type: ANFA

New in version 1.2.

trim()[source]¶: Remove states that do not lead to a final state, or, inclusively, that can’t be reached from the initial state. Only useful states remain.

Attention

in place transformation

wordGenerator()[source]¶

Creates a random word generator

Returns: the random word generator
Return type: RndWGen

New in version 1.2.

ANFA¶

class ANFA[source]¶

Acyclic Nondeterministic Finite Automata class

mergeInitial()[source]¶: Merge initial states

Attention

object is modified in place

mergeLeaves()[source]¶: Merge leaves

Attention

object is modified in place

mergeStates(s1, s2)[source]¶

Merge state s2 into state s1

Parameters

s1 (int) – state
s2 (int) – state

Note

no attempt is made to check if the merging preserves the language of teh automaton

Attention

the object is modified in place

moveFinal(st, stf)[source]¶: Unsets a set as final transfering transition to another final :param int st: the state to be ‘moved’ :param int stf: the destination final state

Note

stf must be a ‘last’ final state, i.e., must have no out transitions to anywhere but to a possible dead state

Attention

the object is modified in place

RndWGen¶

class RndWGen(aut)[source]¶

Word random generator class

New in version 1.2.

Parameters: aut (ADFA) – automata recognizing the language

Functions¶

sigmaInitialSegment¶

sigmaInitialSegment(Sigma, l, exact=False)[source]¶: Generates the ADFA recognizing sigma^i for i<=l :param set Sigma: the alphabet :param int l: length :param bool exact: only the words with exactly that length? :returns: the automaton :rtype: ADFA

genRndTrieBalanced¶

genRndTrieBalanced(maxL, Sigma, safe=True)[source]¶: Generates a random trie automaton for a binary language of balanced words of a given leght for max word :param int maxL: length of the max word :param set Sigma: alphabet to be used :param bool safe: should a word of size maxl be present in every language? :return: the generated trie automaton :rtype: ADFA

genRndTrieUnbalanced¶

genRndTrieUnbalanced(maxL, Sigma, ratio, safe=True)[source]¶

Generates a random trie automaton for a binary language of balanced words of a given length for max word

Parameters

maxL (int) – length of the max word
Sigma (set) – alphabet to be used
ratio (int) – the ratio of the unbalance
safe (bool) – should a word of size maxl be present in every language?

Returns

the generated trie automaton

Return type

ADFA

genRandomTrie¶

genRandomTrie(maxL, Sigma, safe=True)[source]¶: Generates a random trie automaton for a finite language with a given length for max word :param int maxL: length of the max word :param set Sigma: alphabet to be used :param bool safe: should a word of size maxl be present in every language? :return: the generated trie automaton :rtype: ADFA

genRndTriePrefix¶

genRndTriePrefix(maxL, Sigma, ClosedP=False, safe=True)[source]¶: Generates a random trie automaton for a finite (either prefix free or prefix closed) language with a given length for max word :param int maxL: length of the max word :param set Sigma: alphabet to be used :param bool ClosedP: should it be a prefix closed language? :param bool safe: should a word of size maxl be present in every language? :return: the generated trie automaton :rtype: ADFA

DFAtoADFA¶

DFAtoADFA(aut)[source]¶

Transforms an acyclic DFA into a ADFA

Parameters: aut (DFA) – the automaton to be transformed
Raises: notAcyclic – if the DFA is not acyclic
Returns: the converted automaton
Return type: ADFA

stringToADFA¶

stringToADFA(s)[source]¶: Convert a canonical string representation of a ADFA to a ADFA :param list s: the string in its canonical order :returns: the ADFA :rtype: ADFA

See also

Marco Almeida, Nelma Moreira, and Rogério Reis. Exact generation of minimal acyclic deterministic finite automata. International Journal of Foundations of Computer Science, 19(4):751-765, August 2008.

Module: Context Free Grammars Manipulation (`cfg`)¶

Context Free Grammars Manipulation.

Basic context-free grammars manipulation for building uniform random generetors

Classes¶

CFGrammar¶

class CFGrammar(gram)[source]¶

Class for context-free grammars

Variables

Rules – grammar rules
Terminals – terminals symbols
Nonterminals – nonterminals symbols
Start (str) – start symbol
ntr – dictionary of rules for each nonterminal

Initialization

Parameters: gram – is a list for productions; each production is a tuple (LeftHandside, RightHandside) with LeftHandside nonterminal, RightHandside list of symbols, First production is for start symbol

NULLABLE()[source]¶: Determines which nonterminals X ->* []

makenonterminals()[source]¶: Extracts C{nonterminals} from grammar rules.

maketerminals()[source]¶: Extracts C{terminals} from the rules. Nonterminals must already exist

CNF¶

class CNF(gram, mark='A@')[source]¶

Chomsky Normal Form. No useless nonterminals or eepsipsilon rules are ALLOWED… Given a CFG grammar description generates one in CNF Then its possible to random generate words of a given size. Before some pre-calculations are needed.

Initialization

Parameters: gram – is a list for productions; each production is a tuple (LeftHandside, RightHandside) with LeftHandside nonterminal, RightHandside list of symbols, First production is for start symbol

chomsky()[source]¶: Transform to CNF

elim_unitary()[source]¶: Elimination of unitary rules

cfgGenerator¶

class cfgGenerator(cfgr, size)[source]¶

CFG uniform genetaror

Object initialization :param cfgr: grammar for the random objects :type cfgr: CNF :param size: size of objects :type size: integer

generate()[source]¶

Generates a new random object generated from the start symbol

Returns: object
Return type: string

reStringRGenerator¶

class reStringRGenerator(Sigma=None, size=10, cfgr=None, epsilon=None, empty=None, ident='Ti')[source]¶

Uniform random Generator for reStrings

Uniform random generator for regular expressions. Used without arguments generates an uncollapsible re: over {a,b} with size 10. For generate an arbitary re over an alphabet of 10 symbols of size 100: reStringRGenerator (smallAlphabet(10),100,reGrammar[“g_regular_base”])

Parameters

Sigma (list|set) – re alphabet (that will be the set of grammar terminals)
size (int) – word size
cfgr – base grammar
epsilon – if not None is added to a grammar terminals
empty – if not None is added to a grammar terminals

Note

the grammar can have already this symbols

Functions¶

gRules¶

gRules(rules_list, rulesym='->', rhssep=None, rulesep='|')[source]¶

Transforms a list of rules into a grammar description.

Parameters

rules_list – is a list of rule where rule is a string of the form: Word rulesym Word1 … Word2 or Word rulesym []
rulesym – LHS and RHS rule separator
rhssep – RHS values separator (None for white chars)

Returns

a grammar description

smallAlphabet¶

smallAlphabet(k, sigma_base='a')[source]¶

Easy way to have small alphabets

Parameters

k – alphabet size (must be less than 52)
sigma_base – initial symbol

Returns

alphabet

Return type

list

Constants¶

const: reGrammar

Module: Random DFA Generator (`rndfap`)¶

Random DFA generation (alternative version in python)

ICDFA Random generation binding

New in version 1.0.

Classes¶

ICDFArgen¶

class ICDFArgen(n, k, nd=False, pn=1, seed=0)[source]¶

Generic ICDFA random generator class

Variables

n (int) – number of states
k (int) – size of the alphabet
pn (int) – how more problable shall a non defined transition be?
seed (int) – seed for the random generator. Default is to generate a time & system dependent.

See also

Marco Almeida, Nelma Moreira, and Rogério Reis. Enumeration and generation with a string automata representation. Theoretical Computer Science, 387(2):93-102, 2007

Changed in version 1.3.4: seed added to the random generator

genFinalities()[source]¶

Generate bit map of final states

Return type: list

ICDFArnd¶

class ICDFArnd(n, k, seed=0)[source]¶

Complete ICDFA random generator class

This is the class for the uniform random generator for Initially Connected DFAs

Variables

n (int) – number of states
k (int) – size of alphabet
seed (int) – seed for the random generator (if 0 uses time as seed)

Note

This is an abstract class, not to be used directly

Changed in version 1.3.4: seed added to the random generator

ICDFArndIncomplete¶

class ICDFArndIncomplete(n, k, bias=None, seed=0)[source]¶

Incomplete ICDFA random generator class

Variables

n (int) – number of states
k (int) – size of alphabet
bias (float) – how often must the gost sink state appear (default None)
seed (int) – seed for the random generator (if 0 uses time as seed)

Raises

IllegalBias – if a bias >=1 or <=0 is provided

Changed in version 1.3.4: seed added to the random generator

Module: Random ADFA Generator (`rndadfa`)¶

Random ADFA generation

ADFA Random generation binding

New in version 1.2.1.

Classes¶

ADFArnd¶

class ADFArnd(n, k=2, s=1)[source]¶

Sets a random generator for Adfas by sources. By default, s=1 to be initially connected

Variables

n (int) – number of states
k (int) – size of the alphabet
s (int) – number of sources

Note: For ICDFA s=1

alpha(n, s, k=2)[source]¶

Number of labeled acyclic initially connected DFA by states and by sources

Parameters

k (int) – alphabet size
n (int) – number of states
s (int) – number of souces

Return type

Note

uses countAdfabySource

alpha0(n, s, k=2)[source]¶

Number of labeled acyclic initially connected DFA by states and by sources

Parameters

k (int) – alphabet size
n (int) – number of states
s (int) – number of souces

Return type

Note

uses gamma instead of beta or rndAdfa

beta(n, s, u, k=2)[source]¶

Number of valid configurations of transitions

Parameters

k (int) – alphabet size
n (int) – number of states
s (int) – number of souces
u (int) – number of souces of n-s

Return type

Note

not used by alpha or rndAdfa

beta0(n, s, u, k=2)[source]¶: Function beta computed using sets

countAdfaBySources(n, s, k=2)[source]¶

Number of labelled (initially connected) acyclic automata with n states, alphabet size k, and s sources

Parameters

k (int) – alphabet size
n (int) – number of states
s (int) – number of souces

Raises

IndexError – if number of states less than number of sources

gamma(t, u, r)[source]¶

Parameters

t (int) – size of T
u (int) – size of U
r (int) – size of r

Return type

rndAdfa(n, s)[source]¶

Recursively generates a initially connected adfa

Parameters

n (int) – number of states
s (int) – number of sources

See also

Felice & Nicaud, CSR 2013 Lncs 7913, pp 88-99, Random Generation of Deterministic Acyclic Automata Using the Recursive Method, DOI:10.1007/978-3-642-38536-0_8

rndNumberSecondSources(n, s)[source]¶

Uniformaly random generates the number of secondary sources

Parameters

n (int) – number of states
s (int) – number of sources

Return type

rndTransitionsFromSources(n, s, u)[source]¶

Generates the transitions from the sources, ensuring that all secondary sources are connected

Parameters

n (int) – number of states
s (int) – number of sources
u (int) – number of secondary sources

Module: Combo Operations (`comboperations`)¶

Several combined operations for DFAs

Combined operations

Functions¶

starConcat¶

starConcat(fa1, fa2, strict=False)[source]¶

Star of concatenation of two languages: (L1.L2)*

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Yuan Gao, Kai Salomaa, and Sheng Yu. ‘The state complexity of two combined operations: star of catenation and star of reversal’. Fundamenta Informaticae, 83:75–89, Jan 2008.

concatWStar¶

concatWStar(fa1, fa2, strict=False)[source]¶

Concatenation combined with star: (L1.L2*)

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Bo Cui, Yuan Gao, Lila Kari, and Sheng Yu. ‘State complexity of two combined operations: Reversal-catenation and star-catenation’. CoRR, abs/1006.4646, 2010.

starWConcat¶

starWConcat(fa1, fa2, strict=False)[source]¶

Star combined with concatenation: (L1*.L2)

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Bo Cui, Yuan Gao, Lila Kari, and Sheng Yu. ‘State complexity of catenation combined with Star and reversal’. CoRR, abs/1008.1648, 2010

starDisj¶

starDisj(fa1, fa2, strict=False)[source]¶

Star of Union of two DFAs: (L1 + L2)*

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Arto Salomaa, Kai Salomaa, and Sheng Yu. ‘State complexity of combined operations’. Theor. Comput. Sci., 383(2-3):140–152, 2007.

starInter0¶

starInter0(fa1, fa2, strict=False)[source]¶

Star of Intersection of two DFAs: (L1 & L2)*

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Arto Salomaa, Kai Salomaa, and Sheng Yu. ‘State complexity of combined operations’. Theor. Comput. Sci., 383(2-3):140–152, 2007.

starInter¶

starInter(fa1, fa2, strict=False)[source]¶

Star of Intersection of two DFAs: (L1 & L2)*

Parameters

fa1 (DFA) – first automaton
fa2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

disjWStar¶

disjWStar(f1, f2, strict=True)[source]¶

Union with Star: (L1 + L2*)

Parameters

f1 (DFA) – first automaton
f2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Yuan Gao and Sheng Yu. ‘State complexity of union and intersection combined with Star and reversal’. CoRR, abs/1006.3755, 2010.

interWStar¶

interWStar(f1, f2, strict=True)[source]¶

Intersection with Star: (L1 & L2*)

Parameters

f1 (DFA) – first automaton
f2 (DFA) – second automaton
strict (bool) – should the alphabets be necessary equal?

Return type

See also

Yuan Gao and Sheng Yu. ‘State complexity of union and intersection combined with Star and reversal’. CoRR, abs/1006.3755, 2010.

Module: Codes (`codes`)¶

Code theory module

New in version 1.0.

Classes¶

CodeProperty¶

class CodeProperty(name, alph)[source]¶

See: K. Dudzinski and s. Konstantinidis: Formal descriptions of code properties: decidability, complexity,: implementation. International Journal of Foundations of Computer Science 23:1 (2012), 67–85.

Variables: sigma – the alphabet

abstract maximalP(aut, U=None)[source]¶

Tests if the language is maximal w.r.t. the property

Parameters

U (DFA|NFA) – Universe of permitted words (sigma^* as default)
aut (DFA|NFA) – the automaton

Return type

abstract notMaximalW(aut, U=None)[source]¶

Witness of non maximality

Parameters

aut (DFA|NFA) – the automaton
U (DFA|NFA) – Universe of permitted words (sigma^* as default)

Returns

a witness

Return type

abstract notSatisfiesW(aut)[source]¶

Return a witness of non-satisfaction of the property by the automaton language

Parameters: aut (DFA|NFA) – the automaton
Returns: word witness tuple
Return type: tuple

abstract satisfiesP(aut)[source]¶

Satisfaction of the property by the automaton language

Parameters: aut (NFA|DFA) – the automaton
Return type: bool

TrajProp¶

class TrajProp(aut, Sigma)[source]¶

Class of trajectoty properties

Constructor

Parameters

aut (DFA|NFA) – regular expression over {0,1}
Sigma (set) – the alphabet

static trajToTransducer(traj, Sigma)[source]¶

Input Altering Tranducer corresponding to a Trajectory

Parameters

traj (NFA) – trajectory language
Sigma (set) – alphabet

Return type

IPTProp¶

class IPTProp(aut, name=None)[source]¶

Input Preserving Transducer Property

Variables

Aut (SFT) – the transducer defining the property
sigma (set) – alphabet

Constructor :param SFT aut: Input preserving transducer

addToCode(aut, N, n=2000)[source]¶

Returns an NFA and a list W of up to N words of length ell, such that the NFA accepts L(aut) union W, which is an error-detecting language. ell is computed from aut

Parameters

aut (NFA) – the automaton
N (int) – the number of words to construct
n (int) – number of tries when needing a new word

Returns

an automaton and a list of strings

Return type

tuple

makeCode(N, ell, s, n=2000, ov_free=False)[source]¶

Returns an NFA and a list W of up to N words of length ell, such that the NFA accepts W, which is an error-detecting language. The alphabet to use is {0,1,…,s-1}. where s <= 10.

Parameters

N (int) – the number of words to construct
ell (int) – the codeword length
s (int) – the alphabet size (must be <= 10)
n (int) – number of tries when needing a new word

Returns

an automaton and a list of strings

Return type

tuple

makeCodeO(N, ell, s, n=2000, end=None, ov_free=False)[source]¶

Returns an NFA and a list W of up to N words of length ell, such that the NFA accepts W, which is an error-detecting language. The alphabet to use is {0,1,…,s-1}. where s <= 10.

Parameters

N (int) – the number of words to construct
ell (int) – the codeword length
s (int) – the alphabet size (must be <= 10)
n (int) – number of tries when needing a new word
end (Word) – a Word or None that should much the end of code words
ov_free (Boolean) – if True code words much be overlap free

Returns

an automaton and a list of strings

Return type

tuple

Note: not ov_free and end defined simultaneously Note: end should be a Word

maximalP(aut, U=None)[source]¶

Tests if the language is maximal w.r.t. the property

Parameters

aut (NFA) – the automaton
U (NFA) – Universe of permitted words (sigma^* as default)

Return type

notMaxStatW(aut, ell, n=2000, ov_free=False)[source]¶

Returns a word of length ell to add into aut or None; simpler version of function nonMaxStatFEpsW

Parameters

aut (NFA) – the automaton
ell (int) – the length of the words in aut
n (int) – number of words to try

Returns

a string or None

Return type

notMaximalW(aut, U=None)[source]¶

Tests if the language is maximal w.r.t. the property

Parameters

aut (DFA|NFA) – the automaton
U (DFA|NFA) – Universe of permitted words (sigma^* as default)

Return type

Raises

PropertyNotSatisfied – if not satisfied

notSatisfiesW(aut)[source]¶

Return a witness of non-satisfaction of the property by the automaton language

Parameters: aut (DFA|NFA) – the automaton
Returns: word witness pair
Return type: tuple

satisfiesP(aut)[source]¶

Satisfaction of the property by the automaton language

Parameters: aut (DFA|NFA) – the automaton
Return type: bool

IATProp¶

class IATProp(aut, name=None)[source]¶

Input Altering Transducer Property

Constructor :param SFT aut: Input preserving transducer

notSatisfiesW(aut)[source]¶

Return a witness of non-satisfaction of the property by the automaton language

Parameters: aut (DFA|NFA) – the automaton
Returns: word witness pair
Return type: tuple

PrefixProp¶

class PrefixProp(t)[source]¶

Prefix Property

Constructor

Parameters

aut (DFA|NFA) – regular expression over {0,1}
Sigma (set) – the alphabet

satisfiesPrefixP(aut)[source]¶

Satisfaction of property by the automaton language: faster than satisfiesP

Parameters: aut (DFA|NFA) – the automaton
Return type: bool

ErrDetectProp¶

ErrDetectProp¶: alias of FAdo.codes.IPTProp

ErrCorrectProp¶

class ErrCorrectProp(t)[source]¶

Error Correcting Property

Constructor :param SFT aut: Input preserving transducer

notMaximalW(aut, U=None)[source]¶

Tests if the language is maximal w.r.t. the property

Parameters

aut (DFA|NFA) – the automaton
U (DFA|NFA) – Universe of permitted words (sigma^* as default)

Return type

notSatisfiesW(aut)[source]¶

Satisfaction of the code property by the automaton language

Parameters: aut (DFA|NFA) – the automaton
Return type: tuple

satisfiesP(aut)[source]¶

Satisfaction of the property by the automaton language

See also

s. Konstantinidis: Transducers and the Properties of Error-Detection, Error-Correction and Finite-Delay Decodability. Journal Of Universal Computer Science 8 (2002), 278-291.

Parameters: aut (DFA|NFA) – the automaton
Return type: bool

Functions¶

buildTrajPropS¶

buildTrajPropS(regex, sigma)[source]¶

Builds a TrajProp from a string RegExp

Parameters

regex (str) – the regular expression
sigma (set) – alphabet

Return type

TrajProp

buildIATPropF¶

buildIATPropF(fname)[source]¶

Builds a IATProp from a FAdo SFT file

Parameters: fname (str) – file name
Return type: IATProp

buildIPTPropF¶

buildIPTPropF(fname)[source]¶

Builds a IPTProp from a FAdo SFT file

Parameters: fname (str) – file name
Return type: IPTProp

buildIATPropS¶

buildIATPropS(s)[source]¶

Builds a IATProp from a FAdo SFT string

Parameters: s (str) – string containing SFT
Return type: IATProp

buildIPTPropS¶

buildIPTPropS(s)[source]¶

Builds a IPTProp from a FAdo SFT string

Parameters: s (str) – file name
Return type: IPTProp

buildErrorDetectPropF¶

buildErrorCorrectPropF¶

buildErrorDetectPropF(fname)[source]¶

Builds an Error Detecting Property

Parameters: fname (str) – file name
Return type: ErrDetectProp

buildErrorCorrectPropF¶

buildErrorCorrectPropF(fname)[source]¶

Builds an Error Correcting Property

Parameters: fname (str) – file name
Return type: ErrCorrectProp

buildErrorDetectPropS¶

buildErrorDetectPropS(s)[source]¶

Builds an Error Detecting Property from string

Parameters: s (str) – transducer string
Return type: ErrDetectProp

buildErrorCorrectPropS¶

buildErrorCorrectPropS(s)[source]¶

Builds an Error Correcting Property from string

Parameters: s (str) – transducer string
Return type: ErrCorrectProp

buildPrefixProperty¶

buildPrefixProperty(alphabet)[source]¶

Builds a Prefix Code Property

Parameters: alphabet (set) – alphabet
Return type: PrefixProp

editDistanceW¶

editDistanceW(auto)[source]¶

Compute the edit distance of a given regular language accepted by the NFA via Input-altering transducer.

Parameters: auto (NFA) – language recogniser
Returns: The edit distance of the given regular language plus a witness pair
Return type: tuple

Attention

language should have at least two words

See also

Lila Kari, Stavros Konstantinidis, Steffen Kopecki, Meng Yang. An efficient algorithm for computing the edit distance of a regular language via input-altering transducers. arXiv:1406.1041 [cs.FL]

exponentialDensityP¶

exponentialDensityP(aut)[source]¶

Checks if language density is exponential: Using breadth first search (BFS)

Parameters: aut (NFA) – the representation of the language
Return type: bool

Attention

aut should not have Epsilon transitions

createInputAlteringSIDTrans¶

createInputAlteringSIDTrans(n, sigmaSet)[source]¶

Create an input-altering SID transducer based

Parameters

n (int) – max number of errors
sigmaSet (set) – alphabet

Returns

a transducer representing the SID channel

Return type

Module: Set Specification Transducers and Automata (`sst`)¶

Set Specification Transducer supportt

New in version 1.4.

Classes¶

PSP¶

class PSP[source]¶: Relation pair of set specifications

PSPVanila¶

class PSPVanila(arg1, arg2)[source]¶

Relation pair of two set specifications

alphabet()[source]¶

The covering alphabet of a PSP

Return type: set

behaviour(sigma)[source]¶

Expansion of a PSP

Return type: (set, set)

inIntersection(other, alph)[source]¶

Evaluates the intersect on input with another Set Specification

Parameters

other (SetSpec) – the other
alph (set) – alphabet

Return type

PSP

inverse()[source]¶

Inverse of a PSP

Return type: PSPVanila

isAInvariant()[source]¶

Is this an alphabet invariant PSP?

Return type: bool

PDPEqual¶

class PSPEqual(arg1)[source]¶

Relation pair of two set specifications (constrained by equality)

inIntersection(other, alph)[source]¶

Evaluates the intersect on input wit anothe Set Specification

Parameters

other (SetSpec) – the other
alph (set) – alphabet

Return type

PSP

PSPDiff¶

class PSPDiff(arg1, arg2)[source]¶

Relation pair of two set specifications (constrained by non equality)

inIntersection(other, alph)[source]¶

Evaluates the intersect on input wit anothe Set Specification

Parameters

other (SetSpec) – the other
alph (set) – alphabet

Return type

PSP

SetSpec¶

class SetSpec[source]¶: Set Specification labels

Module: graphs (graph creation and manipulation)¶

Graph support

Basic Graph object support and manipulation

Classes¶

Graph¶

class Graph[source]¶

Graph base class

Variables

Vertices (list) – Vertices’ names
Edges (set) – set of pairs (always sorted)

addEdge(v1, v2)[source]¶: Adds an edge :param int v1: vertex 1 index :param int v2: vertex 2 index :raises GraphError: if edge is loop

addVertex(vname)[source]¶

Adds a vertex (by name)

Parameters: vname – vertex name
Returns: vertex index
Return type: int
Raises: DuplicateName – if vname already exists

abstract dotFormat(size)[source]¶

Some dot representation

Parameters

size (str) – size parameter for dotviz
filename (str) – filename
direction (str) –
strict (bool) –
maxlblsz (int) –
sep (str) –

Returns: str:

vertexIndex(vname, autoCreate=False)[source]¶

Return vertex index

Parameters

autoCreate (bool) – auto creation of non existing states
vname – vertex name

Return type

Raises

GraphError – if vname not found

DiGraph¶

class DiGraph[source]¶

Directed graph base class

addEdge(v1, v2)[source]¶

Adds an edge

Parameters

v1 (int) – vertex 1 index
v2 (int) – vertex 2 index

static dotDrawEdge(st1, st2, sep='\n')[source]¶

Draw a transition in Dot Format

Parameters

st1 (str) – starting state
st2 (str) – ending state
sep (str) – separator

Return type

dotDrawVertex(sti, sep='\n')[source]¶

Draw a Vertex in Dot Format

Parameters

sti (int) – index of the state
sep (str) – separator

Return type

dotFormat(size='20,20', direction='LR', sep='\n', strict=False, maxLblSz=10)[source]¶

A dot representation

Parameters

direction (str) – direction of drawing
size (str) – size of image
sep (str) – line separator
maxLblSz – max size of labels before getting removed
strict – use limitations of label sizes

Returns

the dot representation

Return type