diff --git a/alib2algo/src/grammar/convert/ToAutomaton.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
index c0985a08539a37197d586555961c2b4409c9201b..81839b748a6c26ff141fdad647d913b1f110ce5f 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -21,18 +21,18 @@ automaton::Automaton ToAutomaton::convert(const grammar::Grammar& grammar) {
 }
 
 automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
-	std::map<alphabet::Symbol, label::Label> stateMap;
-	std::set<label::Label> states;
+	std::map<DefaultSymbolType, DefaultStateType> stateMap;
+	std::set<DefaultStateType> states;
 
 	// step 2
 	for(const auto& symbol : grammar.getNonterminalAlphabet()) {
-		label::Label state( symbol );
+		DefaultStateType state ( symbol );
 		states.insert(state);
 		stateMap.insert(std::make_pair(symbol, state));
 	}
 
 	// step 1, 4
-	label::Label q0 = common::createUnique(label::InitialStateLabel::instance < label::Label > ( ), states);
+	DefaultStateType q0 = common::createUnique(label::InitialStateLabel::instance < DefaultStateType > ( ), states);
 	states.insert(q0);
 	automaton::NFA < > automaton(q0);
 	automaton.setInputAlphabet(grammar.getTerminalAlphabet());
@@ -40,14 +40,14 @@ automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
 
 	// step 3
 	for(const auto& rule : grammar.getRules()) {
-		const alphabet::Symbol& lhs = rule.first;
+		const DefaultSymbolType& lhs = rule.first;
 		for(const auto& ruleRHS : rule.second) {
-			if(ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>()) { // if B->Ca => \delta(C,a)=B
-				const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
+			if(ruleRHS.is<std::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->Ca => \delta(C,a)=B
+				const std::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<std::pair<DefaultSymbolType, DefaultSymbolType>>();
 				automaton.addTransition(stateMap.find(rhs.first)->second, rhs.second, stateMap.find(lhs)->second);
 			}
 			else { // if B->a => \delta(StartState,a)=B
-				const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
+				const DefaultSymbolType& rhs = ruleRHS.get<DefaultSymbolType>();
 				automaton.addTransition(q0, rhs, stateMap.find(lhs)->second);
 			}
 		}
@@ -64,18 +64,18 @@ automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
 auto ToAutomatonLeftRG = ToAutomaton::RegistratorWrapper<automaton::NFA < > , grammar::LeftRG < > >(ToAutomaton::convert);
 
 automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
-	std::map<alphabet::Symbol, label::Label> stateMap;
-	std::set<label::Label> states;
+	std::map<DefaultSymbolType, DefaultStateType> stateMap;
+	std::set<DefaultStateType> states;
 
 	// step2
 	for(const auto& symbol : grammar.getNonterminalAlphabet()) {
-		label::Label state( symbol );
+		DefaultStateType state( symbol );
 		states.insert(state);
 		stateMap.insert(std::make_pair(symbol, state));
 	}
 
 	// step 1, 4
-	label::Label AState = common::createUnique(label::FinalStateLabel::instance < label::Label > ( ), states);
+	DefaultStateType AState = common::createUnique(label::FinalStateLabel::instance < DefaultStateType > ( ), states);
 	states.insert(AState);
 	automaton::NFA < > automaton(stateMap.find(grammar.getInitialSymbol())->second);
 	automaton.setStates(states);
@@ -84,14 +84,14 @@ automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
 
 	// step 3
 	for(const auto& rule : grammar.getRules()) {
-		const alphabet::Symbol& lhs = rule.first;
+		const DefaultSymbolType& lhs = rule.first;
 		for(const auto& ruleRHS : rule.second) {
-			if(ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>()) { // if B->aC => \delta(B,a)=C
-				const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
+			if(ruleRHS.is<std::pair<DefaultSymbolType, DefaultSymbolType>>()) { // if B->aC => \delta(B,a)=C
+				const std::pair<DefaultSymbolType, DefaultSymbolType>& rhs = ruleRHS.get<std::pair<DefaultSymbolType, DefaultSymbolType>>();
 				automaton.addTransition(stateMap.find(lhs)->second, rhs.first, stateMap.find(rhs.second)->second);
 			}
 			else { // if B->a => \delta(B,a)=AState
-				const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
+				const DefaultSymbolType& rhs = ruleRHS.get<DefaultSymbolType>();
 				automaton.addTransition(stateMap.find(lhs)->second, rhs, AState);
 			}
 		}
@@ -109,20 +109,20 @@ auto ToAutomatonRightRG = ToAutomaton::RegistratorWrapper<automaton::NFA < > , g
 
 template <class T>
 automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
-	automaton::NPDA < > automaton(label::InitialStateLabel::instance < label::Label > ( ), grammar.getInitialSymbol());
+	automaton::NPDA < > automaton(label::InitialStateLabel::instance < DefaultStateType > ( ), grammar.getInitialSymbol());
 
 	automaton.setInputAlphabet(grammar.getTerminalAlphabet());
 
 	automaton.setPushdownStoreAlphabet(grammar.getNonterminalAlphabet());
-	for(const alphabet::Symbol& symbol : grammar.getTerminalAlphabet())
+	for(const DefaultSymbolType& symbol : grammar.getTerminalAlphabet())
 		automaton.addPushdownStoreSymbol(symbol);
 
-	for(const std::pair<const alphabet::Symbol, std::set<std::vector<alphabet::Symbol>>>& kv : grammar.getRules())
-		for(const std::vector<alphabet::Symbol>& rhs : kv.second)
-			automaton.addTransition(automaton.getInitialState(), std::vector<alphabet::Symbol>{kv.first}, automaton.getInitialState(), rhs);
+	for(const std::pair<const DefaultSymbolType, std::set<std::vector<DefaultSymbolType>>>& kv : grammar.getRules())
+		for(const std::vector<DefaultSymbolType>& rhs : kv.second)
+			automaton.addTransition(automaton.getInitialState(), std::vector<DefaultSymbolType>{kv.first}, automaton.getInitialState(), rhs);
 
-	for(const alphabet::Symbol& symbol : grammar.getTerminalAlphabet())
-		automaton.addTransition(automaton.getInitialState(), symbol, std::vector<alphabet::Symbol>{symbol}, automaton.getInitialState(), std::vector<alphabet::Symbol>{});
+	for(const DefaultSymbolType& symbol : grammar.getTerminalAlphabet())
+		automaton.addTransition(automaton.getInitialState(), symbol, std::vector<DefaultSymbolType>{symbol}, automaton.getInitialState(), std::vector<DefaultSymbolType>{});
 
 	return automaton;
 }
diff --git a/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp b/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
index c86e2371db9f0fb0610b19c5114e67b7b6debaf2..68335ad3d99b62219a292ba6aed7ddb161fb39c3 100644
--- a/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
+++ b/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
@@ -23,43 +23,43 @@ void GrammarCFGtoPDATest::tearDown() {
 void GrammarCFGtoPDATest::testTopDown()
 {
 	{
-		alphabet::Symbol nE = alphabet::Symbol('E');
-		alphabet::Symbol nT = alphabet::Symbol('T');
-		alphabet::Symbol nF = alphabet::Symbol('F');
+		DefaultSymbolType nE = DefaultSymbolType('E');
+		DefaultSymbolType nT = DefaultSymbolType('T');
+		DefaultSymbolType nF = DefaultSymbolType('F');
 
-		alphabet::Symbol tP = alphabet::Symbol('+');
-		alphabet::Symbol tS = alphabet::Symbol('*');
-		alphabet::Symbol tL = alphabet::Symbol('(');
-		alphabet::Symbol tR = alphabet::Symbol(')');
-		alphabet::Symbol tA = alphabet::Symbol('a');
+		DefaultSymbolType tP = DefaultSymbolType('+');
+		DefaultSymbolType tS = DefaultSymbolType('*');
+		DefaultSymbolType tL = DefaultSymbolType('(');
+		DefaultSymbolType tR = DefaultSymbolType(')');
+		DefaultSymbolType tA = DefaultSymbolType('a');
 
 		grammar::CFG < > grammar(nE);
-		grammar.setTerminalAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA});
-		grammar.setNonterminalAlphabet(std::set<alphabet::Symbol>{nE, nT, nF});
-		grammar.addRule(nE, std::vector<alphabet::Symbol>{nE, tP, nT});
-		grammar.addRule(nE, std::vector<alphabet::Symbol>{nT});
-		grammar.addRule(nT, std::vector<alphabet::Symbol>{nT, tS, nF});
-		grammar.addRule(nT, std::vector<alphabet::Symbol>{nF});
-		grammar.addRule(nF, std::vector<alphabet::Symbol>{tL, nE, tR});
-		grammar.addRule(nF, std::vector<alphabet::Symbol>{tA});
+		grammar.setTerminalAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
+		grammar.setNonterminalAlphabet(std::set<DefaultSymbolType>{nE, nT, nF});
+		grammar.addRule(nE, std::vector<DefaultSymbolType>{nE, tP, nT});
+		grammar.addRule(nE, std::vector<DefaultSymbolType>{nT});
+		grammar.addRule(nT, std::vector<DefaultSymbolType>{nT, tS, nF});
+		grammar.addRule(nT, std::vector<DefaultSymbolType>{nF});
+		grammar.addRule(nF, std::vector<DefaultSymbolType>{tL, nE, tR});
+		grammar.addRule(nF, std::vector<DefaultSymbolType>{tA});
 
 
-		label::Label q = label::InitialStateLabel::instance < label::Label > ( );
+		DefaultStateType q = label::InitialStateLabel::instance < DefaultStateType > ( );
 
 		automaton::NPDA < > pda(q, nE);
-		pda.setStates(std::set<label::Label>{q});
-		pda.setInputAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA});
-		pda.setPushdownStoreAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA, nE, nT, nF});
+		pda.setStates(std::set<DefaultStateType>{q});
+		pda.setInputAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
+		pda.setPushdownStoreAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA, nE, nT, nF});
 
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nE}, q, std::vector<alphabet::Symbol>{nE, tP, nT});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nE}, q, std::vector<alphabet::Symbol>{nT});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nT}, q, std::vector<alphabet::Symbol>{nT, tS, nF});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nT}, q, std::vector<alphabet::Symbol>{nF});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nF}, q, std::vector<alphabet::Symbol>{tL, nE, tR});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nF}, q, std::vector<alphabet::Symbol>{tA});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nE}, q, std::vector<DefaultSymbolType>{nE, tP, nT});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nE}, q, std::vector<DefaultSymbolType>{nT});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nT}, q, std::vector<DefaultSymbolType>{nT, tS, nF});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nT}, q, std::vector<DefaultSymbolType>{nF});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nF}, q, std::vector<DefaultSymbolType>{tL, nE, tR});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nF}, q, std::vector<DefaultSymbolType>{tA});
 
 		for(const auto& symbol: pda.getInputAlphabet())
-			pda.addTransition(q, symbol, std::vector<alphabet::Symbol>{symbol}, q, std::vector<alphabet::Symbol>{});
+			pda.addTransition(q, symbol, std::vector<DefaultSymbolType>{symbol}, q, std::vector<DefaultSymbolType>{});
 
 		CPPUNIT_ASSERT(pda == grammar::convert::ToAutomaton::convert(grammar));
 	}
@@ -68,48 +68,48 @@ void GrammarCFGtoPDATest::testTopDown()
 void GrammarCFGtoPDATest::testBottomUp()
 {
 	{
-		alphabet::Symbol nE = alphabet::Symbol('E');
-		alphabet::Symbol nT = alphabet::Symbol('T');
-		alphabet::Symbol nF = alphabet::Symbol('F');
+		DefaultSymbolType nE = DefaultSymbolType('E');
+		DefaultSymbolType nT = DefaultSymbolType('T');
+		DefaultSymbolType nF = DefaultSymbolType('F');
 
-		alphabet::Symbol tP = alphabet::Symbol('+');
-		alphabet::Symbol tS = alphabet::Symbol('*');
-		alphabet::Symbol tL = alphabet::Symbol('(');
-		alphabet::Symbol tR = alphabet::Symbol(')');
-		alphabet::Symbol tA = alphabet::Symbol('a');
+		DefaultSymbolType tP = DefaultSymbolType('+');
+		DefaultSymbolType tS = DefaultSymbolType('*');
+		DefaultSymbolType tL = DefaultSymbolType('(');
+		DefaultSymbolType tR = DefaultSymbolType(')');
+		DefaultSymbolType tA = DefaultSymbolType('a');
 
 		grammar::CFG < > grammar(nE);
-		grammar.setTerminalAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA});
-		grammar.setNonterminalAlphabet(std::set<alphabet::Symbol>{nE, nT, nF});
-		grammar.addRule(nE, std::vector<alphabet::Symbol>{nE, tP, nT});
-		grammar.addRule(nE, std::vector<alphabet::Symbol>{nT});
-		grammar.addRule(nT, std::vector<alphabet::Symbol>{nT, tS, nF});
-		grammar.addRule(nT, std::vector<alphabet::Symbol>{nF});
-		grammar.addRule(nF, std::vector<alphabet::Symbol>{tL, nE, tR});
-		grammar.addRule(nF, std::vector<alphabet::Symbol>{tA});
+		grammar.setTerminalAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
+		grammar.setNonterminalAlphabet(std::set<DefaultSymbolType>{nE, nT, nF});
+		grammar.addRule(nE, std::vector<DefaultSymbolType>{nE, tP, nT});
+		grammar.addRule(nE, std::vector<DefaultSymbolType>{nT});
+		grammar.addRule(nT, std::vector<DefaultSymbolType>{nT, tS, nF});
+		grammar.addRule(nT, std::vector<DefaultSymbolType>{nF});
+		grammar.addRule(nF, std::vector<DefaultSymbolType>{tL, nE, tR});
+		grammar.addRule(nF, std::vector<DefaultSymbolType>{tA});
 
 
-		label::Label q = label::InitialStateLabel::instance < label::Label > ( );
-		label::Label r = label::FinalStateLabel::instance < label::Label > ( );
-		alphabet::Symbol bots( alphabet::BottomOfTheStackSymbol::instance < alphabet::Symbol > ( ) );
+		DefaultStateType q = label::InitialStateLabel::instance < DefaultStateType > ( );
+		DefaultStateType r = label::FinalStateLabel::instance < DefaultStateType > ( );
+		DefaultSymbolType bots( alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
 
 		automaton::NPDA < > pda(q, bots);
 		pda.addState(r);
 		pda.addFinalState(r);
-		pda.setInputAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA});
-		pda.setPushdownStoreAlphabet(std::set<alphabet::Symbol>{tP, tS, tL, tR, tA, nE, nT, nF, bots});
+		pda.setInputAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
+		pda.setPushdownStoreAlphabet(std::set<DefaultSymbolType>{tP, tS, tL, tR, tA, nE, nT, nF, bots});
 
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nE, tP, nT}, q, std::vector<alphabet::Symbol>{nE});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nT}, q, std::vector<alphabet::Symbol>{nE});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nT, tS, nF}, q, std::vector<alphabet::Symbol>{nT});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{nF}, q, std::vector<alphabet::Symbol>{nT});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{tL, nE, tR}, q, std::vector<alphabet::Symbol>{nF});
-		pda.addTransition(q, std::vector<alphabet::Symbol>{tA}, q, std::vector<alphabet::Symbol>{nF});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nE, tP, nT}, q, std::vector<DefaultSymbolType>{nE});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nT}, q, std::vector<DefaultSymbolType>{nE});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nT, tS, nF}, q, std::vector<DefaultSymbolType>{nT});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{nF}, q, std::vector<DefaultSymbolType>{nT});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{tL, nE, tR}, q, std::vector<DefaultSymbolType>{nF});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{tA}, q, std::vector<DefaultSymbolType>{nF});
 
 		for(const auto& symbol: pda.getInputAlphabet())
-			pda.addTransition(q, symbol, std::vector<alphabet::Symbol>{}, q, std::vector<alphabet::Symbol>{symbol});
+			pda.addTransition(q, symbol, std::vector<DefaultSymbolType>{}, q, std::vector<DefaultSymbolType>{symbol});
 
-		pda.addTransition(q, std::vector<alphabet::Symbol>{bots, nE}, r, std::vector<alphabet::Symbol>{});
+		pda.addTransition(q, std::vector<DefaultSymbolType>{bots, nE}, r, std::vector<DefaultSymbolType>{});
 
 		CPPUNIT_ASSERT(pda == grammar::convert::ToAutomatonBottomUp::convert(grammar));
 	}