diff --git a/alib2data/src/alphabet/common/SymbolNormalize.h b/alib2data/src/alphabet/common/SymbolNormalize.h
index 670b37de4bb21193ec5af491eb400ebed1f35d18..996090ca3b488d4796b8145df76eee9f6403e602 100644
--- a/alib2data/src/alphabet/common/SymbolNormalize.h
+++ b/alib2data/src/alphabet/common/SymbolNormalize.h
@@ -36,6 +36,9 @@ public:
 
 	template < class SymbolType >
 	static std::vector < DefaultSymbolType > normalizeSymbols ( std::vector < SymbolType > && symbols );
+
+	template < class SymbolType, class RankType >
+	static std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedSymbols ( std::vector < std::ranked_symbol < SymbolType, RankType > > && symbols );
 };
 
 template < class SymbolType >
@@ -75,6 +78,15 @@ std::vector < DefaultSymbolType > SymbolNormalize::normalizeSymbols ( std::vecto
 	return res;
 }
 
+template < class SymbolType, class RankType >
+std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > SymbolNormalize::normalizeRankedSymbols ( std::vector < std::ranked_symbol < SymbolType, RankType > > && symbols ) {
+	std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > res;
+	for ( std::ranked_symbol < SymbolType, RankType > & symbol : symbols ) {
+		res.push_back ( normalizeRankedSymbol ( std::move ( symbol ) ) );
+	}
+	return res;
+}
+
 } /* namespace alphabet */
 
 #endif /* SYMBOL_NORMALIZE_H_ */
diff --git a/alib2data/src/tree/common/TreeNormalize.h b/alib2data/src/tree/common/TreeNormalize.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc71ff03e4349b9f27a441f4ffe89b444cdb42f9
--- /dev/null
+++ b/alib2data/src/tree/common/TreeNormalize.h
@@ -0,0 +1,56 @@
+/*
+ * TreeNormalize.h
+ *
+ *  Created on: Mar 31, 2017
+ *      Author: Jan Travnicek
+ */
+
+#ifndef TREE_NORMALIZE_H_
+#define TREE_NORMALIZE_H_
+
+#include <tree>
+
+#include <alphabet/RankedSymbol.h>
+#include <alphabet/common/SymbolNormalize.h>
+
+namespace tree {
+
+/**
+ * This class contains methods to print XML representation of automata to the output stream.
+ */
+class TreeNormalize {
+public:
+	template < class SymbolType >
+	static std::tree < DefaultSymbolType > normalizeTree ( std::tree < SymbolType > && tree );
+
+	template < class SymbolType, class RankType >
+	static std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > && tree );
+
+};
+
+template < class SymbolType >
+std::tree < DefaultSymbolType > TreeNormalize::normalizeTree ( std::tree < SymbolType > && tree ) {
+	std::vector < std::tree < DefaultSymbolType > > children;
+
+	for ( std::tree < SymbolType > & child : tree.getChildren ( ) ) {
+		children.push_back ( normalizeTree ( std::move ( child ) ) );
+	}
+
+	return std::tree < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( tree.getData ( ) ) ), std::move ( children ) );
+}
+
+template < class SymbolType, class RankType >
+std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > TreeNormalize::normalizeRankedTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > && tree ) {
+	std::vector < std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > > children;
+
+	for ( std::tree < std::ranked_symbol < SymbolType, RankType > > & child : tree.getChildren ( ) ) {
+		children.push_back ( normalizeRankedTree ( std::move ( child ) ) );
+	}
+
+	return std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > ( alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( tree.getData ( ) ) ), std::move ( children ) );
+}
+
+} /* namespace tree */
+
+#endif /* TREE_NORMALIZE_H_ */
+
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
index ae2b41614be72adfc4b78337d6f5cc57b2ac8c0d..63d7ad990880b6553847cebe93746a5ab98ff17c 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -26,10 +26,11 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
-#include "../../alphabet/VariablesBarSymbol.h"
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/BarSymbol.h>
+#include <alphabet/VariablesBarSymbol.h>
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -50,9 +51,9 @@ class PrefixRankedBarNonlinearPattern : public RankedTreeBase, public std::Compo
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRankedBar ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & node, const std::ranked_symbol < SymbolType, RankType > & subtreeWildcard, const std::set < std::ranked_symbol < SymbolType, RankType > > & nonlinearVariables, const SymbolType & barBase, const std::ranked_symbol < SymbolType, RankType > & variablesBar );
 
 public:
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedTree < SymbolType, RankType > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedPattern < SymbolType, RankType > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedNonlinearPattern < SymbolType, RankType > & tree );
@@ -126,6 +127,17 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < VariablesBarSymbol > ( ).get ( ) ) );
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarNonlinearPattern < > ( std::move ( bars ), std::move ( variablesBars ), std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index 08b6516546b9878be532e2016a7ffd17f5fb0043..1688ef99ae4e992fbec9d99b78410ef6ab39d20d 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -26,10 +26,11 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
-#include "../../alphabet/VariablesBarSymbol.h"
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/BarSymbol.h>
+#include <alphabet/VariablesBarSymbol.h>
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -115,6 +116,16 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < VariablesBarSymbol > ( ).get ( ) ) );
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarPattern < > ( std::move ( bars ), std::move ( variablesBars ), std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index b223692296187f035bb346b7fa605219d1a950d4..c0605eea9af183b77c26097b952d447d4f3574bd 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -26,8 +26,9 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
+#include <alphabet/BarSymbol.h>
 
 namespace tree {
 
@@ -102,6 +103,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarTree < > ( std::move ( bars ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index 497bbf76821bdd7434f65f65adf3064f24256d13..2b40344f3748b79d75bc190f607fb3770d6ec912 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -25,8 +25,9 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -110,6 +111,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -278,9 +288,9 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::vector < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
+		const std::vector < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
 
-		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		return std::find ( m_content.begin ( ), m_content.end ( ), symbol ) != m_content.end ( ) || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index c9c0adc895d0ccd7b2d932c0198be7a52bb0d6fb..edc1ae25ac9cf2b8cf50200b7743dbbba457365d 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -25,8 +25,9 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -101,6 +102,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index 12e02ca1ed7e5644c9792eb4becd73e3bfadb931..0ded0a3c8d97e3f5fce4a1cee3dfac62056e0f3d 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -25,6 +25,7 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -93,6 +94,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index ed71ded39d0e6d8cb56c48c6537ed1b85870db3e..6b10f84e82bd8c346c38eef2e69520d147d45b25 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -26,6 +26,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -39,7 +40,7 @@ class NonlinearAlphabet;
  */
 template < class SymbolType, class RankType >
 class RankedNonlinearPattern : public RankedTreeBase, public std::Components < RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -118,6 +119,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -127,9 +137,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -156,7 +166,7 @@ RankedTreeBase * RankedNonlinearPattern < SymbolType, RankType >::plunder ( ) &&
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedNonlinearPattern < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -183,18 +193,18 @@ void RankedNonlinearPattern < SymbolType, RankType >::setTree ( std::tree < std:
 	checkAlphabet ( pattern );
 	checkArities ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType, class RankType >
 void RankedNonlinearPattern < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedNonlinearPattern " << this->content << ")";
+	out << "(RankedNonlinearPattern " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedNonlinearPattern < SymbolType, RankType >::compare ( const RankedNonlinearPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -203,7 +213,7 @@ int RankedNonlinearPattern < SymbolType, RankType >::compare ( const RankedNonli
 
 template < class SymbolType, class RankType >
 void RankedNonlinearPattern < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -249,8 +259,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
 	}
 
 	static bool available ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index 6460d17fccf2d9a90410c0264aadbb7b5a8d487d..7e236d12f2fb4570f2f78ae508080035834c459b 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -26,6 +26,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -38,7 +39,7 @@ class SubtreeWildcard;
  */
 template < class SymbolType, class RankType >
 class RankedPattern : public RankedTreeBase, public std::Components < RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -112,6 +113,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -121,9 +130,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -146,7 +155,7 @@ RankedTreeBase * RankedPattern < SymbolType, RankType >::plunder ( ) && {
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedPattern < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -173,18 +182,18 @@ void RankedPattern < SymbolType, RankType >::setTree ( std::tree < std::ranked_s
 	checkAlphabet ( pattern );
 	checkArities ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType, class RankType >
 void RankedPattern < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedPattern " << this->content << ")";
+	out << "(RankedPattern " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedPattern < SymbolType, RankType >::compare ( const RankedPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -193,7 +202,7 @@ int RankedPattern < SymbolType, RankType >::compare ( const RankedPattern & othe
 
 template < class SymbolType, class RankType >
 void RankedPattern < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -237,8 +246,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::RankedPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index 5fc5a8c3a4bb27e7ea4bd5944001bdbd77234d31..233cfa1460f08fce5f5d55d0dc6012432f77d809 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -27,6 +27,8 @@
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
 
+#include <tree/common/TreeNormalize.h>
+
 namespace tree {
 
 class GeneralAlphabet;
@@ -37,7 +39,7 @@ class GeneralAlphabet;
  */
 template < class SymbolType, class RankType >
 class RankedTree : public RankedTreeBase, public std::Components < RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -107,6 +109,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -116,9 +125,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : std::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), content ( std::move ( tree ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : std::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -141,7 +150,7 @@ RankedTreeBase * RankedTree < SymbolType, RankType >::plunder ( ) && {
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedTree < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -168,18 +177,18 @@ void RankedTree < SymbolType, RankType >::setTree ( std::tree < std::ranked_symb
 	checkAlphabet ( tree );
 	checkArities ( tree );
 
-	this->content = std::move ( tree );
+	this->m_content = std::move ( tree );
 }
 
 template < class SymbolType, class RankType >
 void RankedTree < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedTree " << this->content << ")";
+	out << "(RankedTree " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedTree < SymbolType, RankType >::compare ( const RankedTree & other ) const {
-	auto first = std::tie ( content, getAlphabet() );
-	auto second = std::tie ( other.content, other.getAlphabet() );
+	auto first = std::tie ( m_content, getAlphabet() );
+	auto second = std::tie ( other.m_content, other.getAlphabet() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -188,7 +197,7 @@ int RankedTree < SymbolType, RankType >::compare ( const RankedTree & other ) co
 
 template < class SymbolType, class RankType >
 void RankedTree < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -230,8 +239,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedTree < SymbolType, RankType > & tree, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = tree.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end();
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = tree.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end();
 	}
 
 	static bool available ( const ::tree::RankedTree < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.h b/alib2data/src/tree/unranked/PrefixBarTree.h
index 5585a4acd580b9a26b0884a75042036daf90f9f2..1458e0829d454168902c511fa9fdbd9d159e60af 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.h
+++ b/alib2data/src/tree/unranked/PrefixBarTree.h
@@ -24,8 +24,9 @@
 #include "../TreeException.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
+#include <alphabet/BarSymbol.h>
 
 namespace tree {
 
@@ -99,6 +100,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType bar = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < BarSymbol > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < DefaultSymbolType > content = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( m_Data ) );
+
+		return new PrefixBarTree < > ( std::move ( bar ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index 21116d347418a4a78fd973495d872b7318b4fcb0..13acf19ae4eebdf5ec91eaa69688031bd7eb336b 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -38,7 +39,7 @@ class NonlinearAlphabet;
  */
 template < class SymbolType >
 class UnrankedNonlinearPattern : public UnrankedTreeBase, public std::Components < UnrankedNonlinearPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -122,6 +123,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -131,8 +141,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
+UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -160,7 +170,7 @@ UnrankedTreeBase * UnrankedNonlinearPattern < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedNonlinearPattern < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -177,18 +187,18 @@ template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::setTree ( std::tree < SymbolType > pattern ) {
 	checkAlphabet ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedNonlinearPattern " << this->content << ")";
+	out << "(UnrankedNonlinearPattern " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedNonlinearPattern < SymbolType >::compare ( const UnrankedNonlinearPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -197,7 +207,7 @@ int UnrankedNonlinearPattern < SymbolType >::compare ( const UnrankedNonlinearPa
 
 template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -243,8 +253,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedNonlinearPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedNonlinearPattern < SymbolType > & pattern, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+		const std::tree<SymbolType>& m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
 	}
 
 	static bool available ( const ::tree::UnrankedNonlinearPattern < SymbolType > &, const SymbolType & ) {
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 9fd51cf7bc79aab5a825f82f1270f9f7e8e62c14..f8fd599b68ac0b7529d8f84185444caed74f0086 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -37,7 +38,7 @@ class SubtreeWildcard;
  */
 template < class SymbolType >
 class UnrankedPattern : public UnrankedTreeBase, public std::Components < UnrankedPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -110,6 +111,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -119,8 +128,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
+UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -144,7 +153,7 @@ UnrankedTreeBase * UnrankedPattern < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedPattern < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -161,18 +170,18 @@ template < class SymbolType >
 void UnrankedPattern < SymbolType >::setTree ( std::tree < SymbolType > pattern ) {
 	checkAlphabet ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType >
 void UnrankedPattern < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedPattern " << this->content << ")";
+	out << "(UnrankedPattern " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedPattern < SymbolType >::compare ( const UnrankedPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -181,7 +190,7 @@ int UnrankedPattern < SymbolType >::compare ( const UnrankedPattern & other ) co
 
 template < class SymbolType >
 void UnrankedPattern < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -225,8 +234,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedPattern < SymbolType > & pattern, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		const std::tree<SymbolType>& m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::UnrankedPattern < SymbolType > &, const SymbolType & ) {
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index c504e6155b96f58bc4d9baad13a0b04f513e55bf..569d7a35fdf885667464c4ed8e85f6e69a80f63f 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -36,7 +37,7 @@ class GeneralAlphabet;
  */
 template < class SymbolType >
 class UnrankedTree : public UnrankedTreeBase, public std::Components < UnrankedTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -65,7 +66,7 @@ public:
 	}
 
 	/**
-	 * @return content of the tree
+	 * @return m_content of the tree
 	 */
 	const std::tree < SymbolType > & getContent ( ) const;
 
@@ -105,6 +106,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -114,8 +122,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : std::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), content ( std::move ( tree ) ) {
-	checkAlphabet ( content );
+UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : std::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -139,7 +147,7 @@ UnrankedTreeBase * UnrankedTree < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedTree < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -156,18 +164,18 @@ template < class SymbolType >
 void UnrankedTree < SymbolType >::setTree ( std::tree < SymbolType > data ) {
 	checkAlphabet ( data );
 
-	this->content = std::move ( data );
+	this->m_content = std::move ( data );
 }
 
 template < class SymbolType >
 void UnrankedTree < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedTree " << this->content << ")";
+	out << "(UnrankedTree " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedTree < SymbolType >::compare ( const UnrankedTree & other ) const {
-	auto first = std::tie ( content, getAlphabet() );
-	auto second = std::tie ( other.content, other.getAlphabet() );
+	auto first = std::tie ( m_content, getAlphabet() );
+	auto second = std::tie ( other.m_content, other.getAlphabet() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -176,7 +184,7 @@ int UnrankedTree < SymbolType >::compare ( const UnrankedTree & other ) const {
 
 template < class SymbolType >
 void UnrankedTree < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -218,8 +226,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedTree < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedTree < SymbolType > & tree, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = tree.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end();
+		const std::tree<SymbolType>& m_content = tree.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end();
 	}
 
 	static bool available ( const ::tree::UnrankedTree < SymbolType > &, const SymbolType & ) {