Processes a production rule Parameters ---------- rule : :class:`~pyformlang.indexed_grammar.ProductionRule` The

Removes a given state from the epsilon NFA CAREFUL: This method modifies the current automaton, for internal usage only! Th

Set the state index

Set the symbol index

Add the production rule: left[sigma] -> right[prod sigma] Parameters ----------- left : any The left

Add a state Parameters ---------- state : str The state to add idx : int The index of

Add a symbol Parameters ----------- symbol : :class:`~pyformlang.finite_automaton.Symbol` The symbol Ex

Add a transition to the function Parameters ---------- s_from : :class:`~pyformlang.pda.State` The starting symb

Adds several transitions Parameters ---------- transitions : Transitions as they would be given to add_t

addrec_bis Optimized version of addrec :param l_sets: a list containing tuples (C, M) where: * C is a non-terminal on the left of a co

addrec Explores all possible combination of consumption rules to mark a production rule. :param l_sets: a list containing tuples (C, M) wh

Concatenates a regular expression with an other one. Equivalent to: >>> regex0 + regex1 Parameters ------

Makes the concatenation of two fst Parameters ---------- other_fst : :class:`~pyformlang.fst.FST` The oth

Makes the concatenation of two regexable objects Parameters ---------- other : :class:`~pyformlang.finite_automaton.Regexabl

Check containment

Delete an element

Gets the symbol which is consumed Returns ---------- f : any The symbol being consumed by the rule

Import a networkx graph into a PDA. \ The imported graph requires to have the good format, i.e. to come \ from the function t

Import a networkx graph into an finite state transducer. \ The imported graph requires to have the good format, i.e. to come \

Import a networkx graph into an finite state automaton. \ The imported graph requires to have the good format, i.e. to come \

Read a regex from a string Parameters ---------- regex_str : str A regular expression Returns

Gets the rules for a context-free grammar to represent the \ operator

Gets the closure of the CFG (*) Returns ---------- new_cfg : :class:`~pyformlang.cfg.CFG` The closure of the cur

Gets DFA example with several cycles on path to final

Gets NFA example with several cycles on path to final

DFA example for the word generation test

DFA example accepting no words

Gets the edges Returns ---------- edges : generator of (:class:`~pyformlang.finite_automaton.State`, \ :class:`~

A non minimal NFA, equivalent to example0

ENFA example with an epsilon cycle

Gives a dfa

A non minimal example a.a*.b

Get the groups

Get the key of the state

Gets Nondeterministic Finite Automaton \ example for the word generation test.

Gets NFA example with duplicate word chains

Gets NFA example with final state at start

Gets NFA example with start state at the end

Get a parse tree for a given word Parameters ---------- word : list The word to pars

Gets the positive closure of the CFG (+) Returns ---------- new_cfg : :class:`~pyformlang.cfg.CFG` The positive

Combines the transitions in the regex simple function

The string representation of the node Parameters ---------- sons_repr : iterable of str The sons represe

Generates the suffix language of the CFL, i.e., the language containing all suffixes of valid words

Gets a temp values in the computation of the simple automaton regex

Gets transitions from the given state

Get the valid sets

Whether the rule is a consumption rule or not Returns ---------- is_consumption : bool Whether the rule is a cons

Whether the rule is a consumption rule or not Returns ---------- is_consumption : bool Whether the rule is a cons

Whether the rule is a duplication rule or not Returns ---------- is_duplication : bool Whether the rule is a dupl

Check if empty

Check whether two recursive automata are equals by boxes. Not equivalency in terms of formal languages theory, just mapping boxes

Check whether two boxes are equivalent Parameters ---------- other : :class:`~pyformlang.rsa.Box` A sequence of

Whether the rule is a production rule or not Returns ---------- is_production : bool Whether the rule is a produc

Check if valid and get

Computes the kleene star of the FST Returns ------- fst_star : :class:`~pyformlang.fst.FST` A FST repres

Makes the kleene star of the current regexable object Returns ---------- enfa : :class:`~pyformlang.finite_automaton.Epsilon

Move elements to a new class

Check if the next symbol to process is a variable

Check if the next symbol matches a given word

The random ordering Returns ---------- new_rules : iterable of \ :class:`~pyformlang.indexed_grammar.ReducedRule`

Removes the epsilon transitions from the automaton Returns ---------- dfa : :class:`~pyformlang.finite_automaton.\ Nondeter

Get all combinations of productions rules after removing nullable

Recursive sub function to remove nullable objects

Remove the production rule: left[sigma] -> right[prod sigma] Parameters ----------- left : any The le

Compute the reversed EpsilonNFA Equivalent to: >> ~automaton Returns --------- enfa : :class:`~pyformlang

Set valid

Turns the automaton into a deterministic one

Get the transitions of the PDA as a dictionary Returns ------- transitions : dict The transitions

Transforms the tree into a Networkx Directed Graph Returns ------- tree : networkx.Digraph The tree in N

Creates a named subgraph representing a box

Makes the union with another regex. Equivalent to: >>> regex0 or regex1 Parameters ---------- oth

Write the PDA in dot format into a file Parameters ---------- filename : str The filename where to write

Write the FST in dot format into a file Parameters ---------- filename : str The filename where to write

Write the automaton in dot format into a file Parameters ---------- filename : str The filename where to

Makes the concatenation of two CFGs Parameters ---------- other : :class:`~pyformlang.cfg.CFG` The other CFG to

Concatenates a regular expression with an other one. Parameters ---------- other : :class:`~pyformlang.regular_expre

Makes the concatenation of two fst Parameters ---------- other : :class:`~pyformlang.fst.FST` The other F

Computes the intersection of the current indexed grammar with the other object Parameters ---------- other : any

Gives the intersection of the current CFG with an other object Parameters ---------- other : any The other objec

Gets the intersection of the current PDA with something else Equivalent to: >> pda and regex Parameters -------