diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
index a7f3eb137c483e6974340417bdf721bad472c9e7..ad84682d41af62281fc6e6876c1d9d6599a939a1 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
@@ -1,6 +1,22 @@
 /*
  * EpsilonRemoverIncoming.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 24. 11. 2014
  *	  Author: Jan Travnicek
  */
@@ -19,17 +35,45 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Removes epsilon transitions from an automaton.
+ * This method is the one teached at BI-AAG course.
+ *
+ * @sa automaton::simplify::EpsilonRemoverOutgoing
+ */
 class EpsilonRemoverIncoming {
 public:
 	/**
-	 * Computes epsilon closure of a state in epsilon nonfree automaton
+	 * Removes epsilon transitions from an automaton.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam EpsilonType Type for epsilon symbol.
+	 * @tparam StateType Type for states.
+	 * @param fsm automaton to remove epsilon transitions from
+	 * @return an automaton equivalent to @p fsm but without epsilon transitions
 	 */
 	template < class SymbolType, class EpsilonType, class StateType >
 	static automaton::NFA < SymbolType, StateType > remove( const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::MultiInitialStateNFA < SymbolType, StateType > remove( const automaton::MultiInitialStateNFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * For nondeterministic finite automata, we remove nothing and return the @p fsm
+	 *
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > remove( const automaton::NFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * For deterministic finite automata, we remove nothing and return the @p fsm
+	 *
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > remove( const automaton::DFA < SymbolType, StateType > & fsm );
 
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
index 5fe44f2c1c0f0511d9dcbd18099dc6b4fa981482..eaf600626801e09f6927eed62016916160de99f4 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
@@ -1,6 +1,22 @@
 /*
  * EpsilonRemoverOutgoing.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 16. 1. 2014
  *	  Author: Tomas Pecka
  */
@@ -21,17 +37,41 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Removes epsilon transitions from an automaton.
+ * This method returns multi-initial state automata (it is not the one teached at BI-AAG course).
+ *
+ * @sa automaton::simplify::EpsilonRemoverIncoming
+ */
 class EpsilonRemoverOutgoing {
 public:
 	/**
-	 * Computes epsilon closure of a state in epsilon nonfree automaton
+	 * Removes epsilon transitions from an automaton.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam EpsilonType Type for epsilon symbol.
+	 * @tparam StateType Type for states.
+	 * @param fsm automaton to remove epsilon transitions from
+	 * @return an automaton (with multiple initial states) equivalent to @p fsm but without epsilon transitions
 	 */
 	template < class StateType, class EpsilonType, class SymbolType >
 	static automaton::MultiInitialStateNFA < SymbolType, StateType > remove( const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 */
 	template < class StateType, class SymbolType >
 	static automaton::MultiInitialStateNFA < SymbolType, StateType > remove( const automaton::MultiInitialStateNFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 */
 	template < class StateType, class SymbolType >
 	static automaton::NFA < SymbolType, StateType > remove( const automaton::NFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 */
 	template < class StateType, class SymbolType >
 	static automaton::DFA < SymbolType, StateType > remove( const automaton::DFA < SymbolType, StateType > & fsm );
 };
diff --git a/alib2algo/src/automaton/simplify/Minimize.h b/alib2algo/src/automaton/simplify/Minimize.h
index aaf184f9430df4be7aec9b4e00be362ed6f34385..98a7a7665ecd94bc3b3df6170398a4d5ca16556f 100644
--- a/alib2algo/src/automaton/simplify/Minimize.h
+++ b/alib2algo/src/automaton/simplify/Minimize.h
@@ -1,6 +1,22 @@
 /*
  * Minimize.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: Dec 9, 2013
  *	  Author: Jan Travnicek
  */
@@ -22,23 +38,67 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Minimization of automata.
+ *
+ * For finite automata, we implement Hopcroft's subset minimization.
+ * For finite tree automata, we implement ???.
+ *
+ * @sa automaton::simplify::MinimizeBrzozowski
+ */
 class Minimize {
 public:
+	/**
+	 * Minimizes deterministic finite autmaton.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param dfa deterministic finite automaton to minimize.
+	 * @return Minimal deterministic finite automaton equivalent to @p dfa
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > minimize(const automaton::DFA < SymbolType, StateType >& dfa) {
 		size_t steps;
 		return minimize ( dfa, steps );
 	}
 
+	/**
+	 * Minimizes deterministic finite autmaton, also reports number of iterations it took.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param dfa deterministic finite automaton to minimize.
+	 * @param[out] steps Number of steps in the subset minimization performed until finished
+	 * @return Minimal deterministic finite automaton equivalent to @p dfa
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > minimize(const automaton::DFA < SymbolType, StateType >& dfa, size_t & steps);
 
+	/**
+	 * Minimizes deterministic finite tree autmaton.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam RankType Type for rank (arity) in ranked alphabet.
+	 * @tparam StateType Type for states.
+	 * @param dfta deterministic finite tree automaton to minimize.
+	 * @return Minimal deterministic finite automaton equivalent to @p dfa
+	 */
 	template < class SymbolType, class RankType, class StateType >
 	static automaton::DFTA < SymbolType, RankType, StateType > minimize(const automaton::DFTA < SymbolType, RankType, StateType >& dfta) {
 		size_t steps;
 		return minimize ( dfta, steps );
 	}
 
+	/**
+	 * Minimizes deterministic finite tree autmaton, also reports number of iterations it took.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam RankType Type for rank (arity) in ranked alphabet.
+	 * @tparam StateType Type for states.
+	 * @param dfta deterministic finite tree automaton to minimize.
+	 * @param[out] steps Number of steps in the subset minimization performed until finished
+	 * @return Minimal deterministic finite automaton equivalent to @p dfa
+	 */
 	template < class SymbolType, class RankType, class StateType >
 	static automaton::DFTA < SymbolType, RankType, StateType > minimize(const automaton::DFTA < SymbolType, RankType, StateType >& dfta, size_t & steps);
 
diff --git a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
index f0ee0987296e23bca9d0df3c14de21028fc59eee..0c46eeb3c8a2730b11ab6d010f46e1f1b70cfe6e 100644
--- a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
+++ b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
@@ -1,6 +1,22 @@
 /*
  * MinimizeBrzozowski.cpp
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 18. 11. 2014
  *	  Author: Tomas Pecka
  */
@@ -19,10 +35,29 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Minimization of finite automata.
+ *
+ * For finite automata, we implement Brzozowski's method. This method works also for the minimization of NFA to minimal DFA.
+ *
+ * Implements: Brzozowski, J.A.: Canonical regular expressions and minimal state graphs for definite events (1962)
+ *
+ * @sa automaton::simplify::Minimize
+ */
 class MinimizeBrzozowski {
 public:
+	/**
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param dfa finite automaton to minimize.
+	 * @return Minimal deterministic finite automaton equivalent to @p dfa
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, ext::set < ext::set < StateType > > > minimize(const automaton::DFA < SymbolType, StateType > & dfa);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, ext::set < ext::set < StateType > > > minimize(const automaton::NFA < SymbolType, StateType > & nfa);
 };
diff --git a/alib2algo/src/automaton/simplify/Normalize.h b/alib2algo/src/automaton/simplify/Normalize.h
index d5473d7901b4b8a78802c17a31f82d3f3c3a129d..1227a421573d20dd61077b699697aec59c26325e 100644
--- a/alib2algo/src/automaton/simplify/Normalize.h
+++ b/alib2algo/src/automaton/simplify/Normalize.h
@@ -1,6 +1,22 @@
 /*
  * Normalize.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: Dec 9, 2013
  *	  Author: Jan Travnicek
  */
@@ -15,15 +31,46 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Normalization of an automaton.
+ * Basically, we rename the automaton's properties (states, pushdown symbols, ...) in such fashion, that the naming is same for isomorphic automata.
+ *
+ * Unlike Rename, we can normalize only deterministic automata.
+ *
+ * @sa automaton::simplify::Rename
+ */
 class Normalize {
 public:
 	/**
-	 * @param dfa automaton to normalize
+	 * Normalization of deterministic finite automata.
+	 * The process of normalization is a BFS traversal through the graph representing the automaton. The states are named by integers in the visited order.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param dfa determinsitic finite automaton to normalize
+	 * @return @p dfa with state labels normalized
+	 *
+	 * @throws exception::CommonException if the passed dfa was not minimal connected dfa
 	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, unsigned > normalize(const automaton::DFA < SymbolType, StateType > & dfa);
+
+	/**
+	 * Normalization of deterministic pushdown automata.
+	 * The process of normalization of states is a BFS traversal through the graph representing the automaton. The states are named by integers in the visited order.
+	 * We normalize also the pushdown store symbols.
+	 *
+	 * @tparam InputSymbolType Type for input symbols.
+	 * @tparam EpsilonType Type for epsilon symbol.
+	 * @tparam PushdownStoreSymbolType Type for pushdown store symbols.
+	 * @tparam StateType Type for states.
+	 * @param dpda determinsitic pushdown automaton to normalize
+	 * @return @p dpda with state labels normalized
+	 *
+	 * @throws exception::CommonException if the passed dpda was not deterministic connected pda
+	 */
 	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-	static automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > normalize(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & dfa);
+	static automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > normalize(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & dpda);
 };
 
 template < class SymbolType, class StateType >
@@ -91,10 +138,10 @@ automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > Normalize::
 		bool stateFinished = true;
 		// For each transition from state current
 		for ( const std::pair < const ext::tuple < StateType, ext::variant < EpsilonType, InputSymbolType >, ext::vector < PushdownStoreSymbolType > >, std::pair < StateType, ext::vector < PushdownStoreSymbolType > > > & iter : pda.getTransitionsFromState(current)) {
-			// look whether all poped symbols are already transformed
+			// look whether all pop symbols are already transformed
 			if(std::all_of(std::get<2>(iter.first).begin(), std::get<2>(iter.first).end(), [&](const PushdownStoreSymbolType& symbol) { return normalizationDataSymbol.find(symbol) != normalizationDataSymbol.end(); })) {
 				ext::vector < unsigned > transformedSymbols;
-				// if so compute vector of transformed poped symbol -- this can be compared to other vectors of transformed symbols and the order can by trusted
+				// if so compute vector of transformed poped symbol -- this can be compared to other vectors of transformed symbols and the order can be trusted
 				for(const PushdownStoreSymbolType& symbol : std::get<2> ( iter.first ) ) {
 					transformedSymbols.push_back(normalizationDataSymbol.find(symbol)->second);
 				}
@@ -105,21 +152,21 @@ automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > Normalize::
 				stateFinished = false;
 			}
 		}
-		// if there was a single transition with undefined transformation for poped symbol process this state again later
+		// if there was a single transition with undefined transformation for pop symbol process this state again later
 		if(!stateFinished) {
 			processingData.push_back(std::move ( current ) );
 		}
-		// now transitions are trivialy sorted by input symbol and the already transformed symbols
+		// now transitions are trivially sorted by input symbol and the already transformed symbols
 
-		// for each pair state, pushed symbols in order given by input symbol and transformed poped symbols
+		// for each pair state, pushed symbols in order given by input symbol and transformed pop symbols
 		for(const auto& iter : transform) {
 			const auto& iters = iter.second;
-			// if the state is new asign a unique number to it and mark it for processing
+			// if the state is new assign a unique number to it and mark it for processing
 			if( normalizationDataState.find(iters.first) == normalizationDataState.end() ) {
 				normalizationDataState.insert(std::make_pair(iters.first, counterState++));
 				processingData.push_back(iters.first);
 			}
-			// if the symbols in order given by order of pushing are new asign a unique number to them
+			// if the symbols in order given by order of pushing are new assign a unique number to them
 			for(const PushdownStoreSymbolType & iter2 : iters.second) {
 				if( normalizationDataSymbol.find(iter2) == normalizationDataSymbol.end() ) {
 					normalizationDataSymbol.insert(std::make_pair(iter2, counterSymbol++));
diff --git a/alib2algo/src/automaton/simplify/Rename.h b/alib2algo/src/automaton/simplify/Rename.h
index f93086b4c5aa8e6620602f6a322990abbf98031a..2009ab4f7c733969db8130f057b7c5edb96f8e50 100644
--- a/alib2algo/src/automaton/simplify/Rename.h
+++ b/alib2algo/src/automaton/simplify/Rename.h
@@ -1,6 +1,22 @@
 /*
  * Rename.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: Dec 9, 2013
  *      Author: Jan Travnicek
  */
@@ -25,23 +41,56 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Rename an automaton.
+ * Basically, we rename the automaton's properties (states, pushdown symbols, ...) to integer values in non-defined order.
+ *
+ * Unlike Normalize, we can rename also nondeterministic automata as the order is not important.
+ *
+ * @sa automaton::simplify::Normalize
+ */
 class Rename {
 public:
+	/**
+	 * Rename automaton's properties.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param dfa finite automaton to normalize
+	 * @return @p dfa with renamed properties
+	 *
+	 * @throws exception::CommonException if the passed dfa was not minimal connected dfa
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, unsigned > rename ( const automaton::DFA < SymbolType, StateType > & dfa );
 
+	/**
+	 * @overload
+	 */
 	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 	static automaton::DPDA < InputSymbolType, EpsilonType, unsigned, unsigned > rename ( const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & pda );
 
+	/**
+	 * @overload
+	 */
 	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 	static automaton::SinglePopDPDA < InputSymbolType, EpsilonType, unsigned, unsigned > rename ( const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & pda );
 
+	/**
+	 * @overload
+	 */
 	template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 	static automaton::InputDrivenDPDA < InputSymbolType, unsigned, unsigned > rename ( const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & pda );
 
+	/**
+	 * @overload
+	 */
 	template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 	static automaton::VisiblyPushdownDPDA < InputSymbolType, unsigned, unsigned > rename ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & pda );
 
+	/**
+	 * @overload
+	 */
 	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 	static automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, unsigned, unsigned > rename ( const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & pda );
 };
diff --git a/alib2algo/src/automaton/simplify/SingleInitialState.h b/alib2algo/src/automaton/simplify/SingleInitialState.h
index 715bd9303928a975e60d5345b9ad30f1d29e3113..6eea5391e522b3481e5806a8cee0cfc646ae7b1f 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialState.h
+++ b/alib2algo/src/automaton/simplify/SingleInitialState.h
@@ -1,6 +1,22 @@
 /*
  * SingleInitialState.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 20. 9. 2014
  *	  Author: Tomas Pecka
  */
@@ -27,26 +43,57 @@ namespace automaton {
 namespace simplify {
 
 /**
- * Makes finite automaton's transition function convert.
- * Source: Melichar: Algorithm 2.22
+ * Algorithm for the conversion of multi-initial state finite automata to single-initial state finite automata.
+ * This algorithm is an implementation of Melichar: Jazyky a překlady 2.46.
+ *
+ * @sa automaton::simplify::SingleInitialStateEpsilonTransition
  */
 class SingleInitialState {
 public:
 	/**
-	 * Computes epsilon closure of a state in epsilon nonfree automaton
+	 * Converts multi-initial state automaton to a single-initial state automaton.
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param automaton automaton to convert
+	 * @return an automaton equivalent to @p with only one initial state
 	 */
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > convert(const automaton::MultiInitialStateNFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class EpsilonType, class StateType >
 	static automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > convert(const automaton::MultiInitialStateEpsilonNFA < SymbolType, EpsilonType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 * @tparam EpsilonType Type for epsilon symbol.
+	 */
 	template < class SymbolType, class EpsilonType, class StateType >
 	static automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > convert(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::ExtendedNFA < SymbolType, StateType > convert(const automaton::ExtendedNFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::CompactNFA < SymbolType, StateType > convert(const automaton::CompactNFA < SymbolType, StateType > & automaton);
 };
diff --git a/alib2algo/src/automaton/simplify/SingleInitialStateEpsilonTransition.h b/alib2algo/src/automaton/simplify/SingleInitialStateEpsilonTransition.h
index 22e590b75f67347d95f5d4385907b0923ec3af6d..eabda3151e8be5d10709e69df5e1b7423acb7828 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialStateEpsilonTransition.h
+++ b/alib2algo/src/automaton/simplify/SingleInitialStateEpsilonTransition.h
@@ -1,6 +1,22 @@
 /*
  * SingleInitialStateEpsilonTransition.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 6. 6. 2018
  *	  Author: Jan Travnicek
  */
@@ -24,26 +40,56 @@ namespace automaton {
 namespace simplify {
 
 /**
- * Makes finite automaton's transition function convert.
- * Source: Melichar: Algorithm 2.22
+ * Algorithm for the conversion of multi-initial state finite automata to single-initial state finite automata using epsilon transitions.
+ *
+ * @sa automaton::simplify::SingleInitialState
  */
 class SingleInitialStateEpsilonTransition {
 public:
 	/**
-	 * Computes epsilon closure of a state in epsilon nonfree automaton
+	 * Converts multi-initial state automaton to a single-initial state automaton with the use of epsilon transitions.
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @tparam EpsilonType Type for epsilon symbol.
+	 * @param automaton automaton to convert
+	 * @return an automaton equivalent to @p with only one initial state
 	 */
 	template < class SymbolType, class StateType >
 	static automaton::EpsilonNFA < SymbolType, DefaultEpsilonType, StateType > convert(const automaton::MultiInitialStateNFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class EpsilonType, class StateType >
 	static automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > convert(const automaton::MultiInitialStateEpsilonNFA < SymbolType, EpsilonType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class EpsilonType, class StateType >
 	static automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > convert(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::ExtendedNFA < SymbolType, StateType > convert(const automaton::ExtendedNFA < SymbolType, StateType > & automaton);
+
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::CompactNFA < SymbolType, StateType > convert(const automaton::CompactNFA < SymbolType, StateType > & automaton);
 };
diff --git a/alib2algo/src/automaton/simplify/Total.h b/alib2algo/src/automaton/simplify/Total.h
index 819f89621e5e44068d61adcee5d69b3d52d73f80..33491bd7eaf9cb2d63c303a87d1b4cb7eaef7b57 100644
--- a/alib2algo/src/automaton/simplify/Total.h
+++ b/alib2algo/src/automaton/simplify/Total.h
@@ -1,6 +1,22 @@
 /*
  * Total.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 20. 9. 2014
  *	  Author: Tomas Pecka
  */
@@ -20,19 +36,27 @@ namespace automaton {
 namespace simplify {
 
 /**
- * Makes finite automaton's transition function total.
- * Source: Melichar: Algorithm 2.22
+ * Algorithm that makes finite automaton's transition function total (every state has a transition for every symbol).
+ * Implementation of Melichar: Jazyky a překlady, 2.22.
  */
 class Total {
 public:
 	/**
-	 * Computes epsilon closure of a state in epsilon nonfree automaton
+	 * Makes a finite automaton's transition function total.
+	 *
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 * @param automaton automaton to alter
+	 * @return an automaton equivalent to @p automaton with total transition function
 	 */
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > total(const automaton::NFA < SymbolType, StateType > & automaton);
 
+	/**
+	 * @overload
+	 */
 	template < class SymbolType, class StateType >
-	static automaton::DFA < SymbolType, StateType > total(const automaton::DFA < SymbolType, StateType >& automaton);
+	static automaton::DFA < SymbolType, StateType > total(const automaton::DFA < SymbolType, StateType > & automaton);
 };
 
 template < class SymbolType, class StateType >
diff --git a/alib2algo/src/automaton/simplify/Trim.h b/alib2algo/src/automaton/simplify/Trim.h
index 8c042a97c4204185f9043987e25b5652910b584e..3f0da70bd8e0d02d5c6d3bb15a63be9279e80465 100644
--- a/alib2algo/src/automaton/simplify/Trim.h
+++ b/alib2algo/src/automaton/simplify/Trim.h
@@ -1,6 +1,22 @@
 /*
  * Trim.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 23. 3. 2014
  *	  Author: Tomas Pecka
  */
@@ -15,10 +31,19 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Algorithm for the removal of dead states from a finite automaton.
+ * Firstly, it calls the useless states removal algorithm, then unreachable states removal algorithm.
+ *
+ * @sa automaton::simplify::UselessStatesRemover
+ * @sa automaton::simplify::UnreachableStatesRemover
+ */
 class Trim {
 public:
 	/**
-	 * Removes dead states from FSM. Melichar 2.29
+	 * @tparam T type of a finite automaton
+	 * @param fsm automaton to trim
+	 * @return T trimmed @p autoamton
 	 */
 	template<class T>
 	static T trim( const T & fsm );
diff --git a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
index 5a9bfc0e4e1559a5cd75956880dc54c28c2bc731..5b55af5854c8f2ef635c7923a766ff0f44f21971 100644
--- a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
@@ -1,6 +1,22 @@
 /*
  * UnreachableStatesRemover.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 23. 3. 2014
  *	  Author: Tomas Pecka
  */
@@ -22,17 +38,54 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Algorithm for the removal of unreachable states from a finite automaton and a deterministic finite tree automaton.
+ * Unreachable state is a state that is not accessible from the initial state of the automaton by any string.
+ *
+ * @details
+ * For a finite automaton, we implement Melichar: Jazyky a překlady, 2.29.
+ * For a deterministic finite tree automaton, we implement ???
+ *
+ * @sa automaton::simplify::Trim
+ * @sa automaton::simplify::UselessStatesRemover
+ */
 class UnreachableStatesRemover {
 public:
 	/**
-	 * Removes dead states from FSM. Melichar 2.29
+	 * Removes unreachable states from an automaton.
+	 * @tparam T type of a finite automaton
+	 * @param automaton automaton to trim
+	 * @return @p automaton without unreachable states
 	 */
 	template < class T >
 	static T remove( const T & automaton );
+
+	/**
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > remove( const automaton::DFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::MultiInitialStateNFA < SymbolType, StateType > remove( const automaton::MultiInitialStateNFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * Removes unreachable states from a deterministic finite tree automaton.
+	 *
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam RankType Type for rank (arity) in ranked alphabet.
+	 * @tparam StateType Type for states.
+	 * @param dfta automaton to trim
+	 * @return @p autoamton without unreachable states
+	 */
 	template < class SymbolType, class RankType, class StateType >
 	static automaton::DFTA < SymbolType, RankType, StateType > remove( const automaton::DFTA < SymbolType, RankType, StateType > & dfta );
 };
diff --git a/alib2algo/src/automaton/simplify/UselessStatesRemover.h b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
index 175ed5b0f88b9644a8e3c63f7ec525ee6153328f..96d213026382e60ac273210030cabbfcf76b556a 100644
--- a/alib2algo/src/automaton/simplify/UselessStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
@@ -1,6 +1,22 @@
 /*
  * UselessStatesRemover.h
  *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Created on: 23. 3. 2014
  *	  Author: Tomas Pecka
  */
@@ -22,17 +38,53 @@ namespace automaton {
 
 namespace simplify {
 
+/**
+ * Algorithm for the removal of useless states from a finite automaton and a deterministic finite tree automaton.
+ * A state @p q is called useless if there is no path from @p q to any final state.
+ *
+ * For a finite automaton, we implement Melichar: Jazyky a překlady, 2.32.
+ * For a deterministic finite tree automaton, we implement ???
+ *
+ * @sa automaton::simplify::Trim
+ * @sa automaton::simplify::UnreachableStatesRemover
+ */
 class UselessStatesRemover {
 public:
 	/**
-	 * Removes dead states from FSM. Melichar 2.29
+	 * Removes useless states from an automaton.
+	 * @tparam T type of a finite automaton
+	 * @param automaton automaton to trim
+	 * @return @p automaton without useless states
 	 */
 	template < class T >
 	static T remove( const T & automaton );
+
+	/**
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, StateType > remove( const automaton::DFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam StateType Type for states.
+	 */
 	template < class SymbolType, class StateType >
 	static automaton::MultiInitialStateNFA < SymbolType, StateType > remove( const automaton::MultiInitialStateNFA < SymbolType, StateType > & fsm );
+
+	/**
+	 * Removes unreachable states from a deterministic finite tree automaton.
+	 *
+	 * @overload
+	 * @tparam SymbolType Type for input symbols.
+	 * @tparam RankType Type for rank (arity) in ranked alphabet.
+	 * @tparam StateType Type for states.
+	 * @param dfta automaton to trim
+	 * @return @p autoamton without unreachable states
+	 */
 	template < class SymbolType, class RankType, class StateType >
 	static automaton::DFTA < SymbolType, RankType, StateType > remove( const automaton::DFTA < SymbolType, RankType, StateType > & dfta );
 };