diff --git a/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp b/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
index 9142dd5..03c5bef 100644
--- a/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
+++ b/examples/agent-functionalities/Reliability-functionality-agent-context/Reliability-agents.cpp
@@ -1,340 +1,340 @@
 //===- examples/agent-functionalities/Reliability-functionality.cpp *C++-*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file examples/agent-functionalities/Reliability-functionality.cpp
 ///
 /// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at )
 ///
 /// \date 2019
 ///
 /// \brief A simple example on defining Relianility Functionalities inside a
 /// master slave context.
 /// \note This is not finished. and is currently inactive
 ///
 //===----------------------------------------------------------------------===//
 
 #define Reliability_trace_level 5
 
 #include "rosa/config/version.h"
 
 #include "rosa/support/log.h"
 
 #include "rosa/agent/CrossReliability.h"
 #include "rosa/agent/RangeConfidence.hpp"
 #include "rosa/agent/Reliability.h"
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include <map>
 #include <vector>
 
 typedef double SensorValueType;
 typedef long StateType;
 typedef double ReliabilityType;
 
 #include "./helper.h" // just stuff from Rel-func to increase readability
 
 using namespace rosa::agent;
 using namespace rosa;
 using namespace rosa::deluxe;
 using namespace rosa::terminal;
 
 #define NumberOfSimulationCycles 10
 
 // -------------------------------------------------------------------------------
 //				Bunch of recusive templates to simplify usage
 // -------------------------------------------------------------------------------
 
 template <std::size_t, typename... types> struct conversion;
 
 template <std::size_t size, typename... TypesA, template <typename...> class A,
           typename... TypesB, template <typename...> class B>
 struct conversion<size, A<TypesA...>, B<TypesB...>> {
   using type = typename conversion<size - 1, std::tuple<TypesA...>,
                                    std::tuple<TypesB..., TypesA...>>::type;
 };
 
 template <typename... TypesA, template <typename...> class A,
           typename... TypesB, template <typename...> class B>
 struct conversion<0, A<TypesA...>, B<TypesB...>> {
   using type = DeluxeTuple<TypesB...>;
 };
 
 template <std::size_t size, typename... Types>
 using unrolled_data_type =
     typename conversion<size, std::tuple<Types...>, std::tuple<>>::type;
 
 //--------------------------------------------------------------------------------
 template <std::size_t max, std::size_t at> struct __convert_to_vector {
   void operator()(std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
                   unrolled_data_type<max / 2, StateType, ReliabilityType> I) {
     __convert_to_vector<max, at - 2>()(feedback, I);
     feedback.push_back({std::get<at>(I), std::get<at + 1>(I)});
   }
 };
 template <std::size_t max> struct __convert_to_vector<max, 0> {
   void operator()(std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
                   unrolled_data_type<max / 2, StateType, ReliabilityType> I) {
     feedback.push_back({std::get<0>(I), std::get<1>(I)});
   }
 };
 
 template <std::size_t number>
 void convert_to_vector(
     std::vector<ConfOrRel<StateType, ReliabilityType>> &feedback,
     unrolled_data_type<number, StateType, ReliabilityType> I) {
   __convert_to_vector<number * 2, number * 2 - 2>()(feedback, I);
 }
 //----------------------------------------------------------------------------
 // template <std::size_t size, typename... types> struct unrole_vector {};
 //
 // template <std::size_t size, template <typename...> v, typename... vT,
 //          template <typename...> class T, typename... TT, typename... types>
 // struct unrole_vector<size, v<vT...>,T<TT...>, types...> {
 //  void operator()(c vec, types... A) {
 //    unrole_vector<size - 1, v<vT...>, T<TT...>, auto>()(vec,
 //    vec.at(size).score,
 //                                                        vec.at(size).score);
 //  }
 //};
 
 // ---------------------------------------------------------------------------
 //					main
 // ---------------------------------------------------------------------------
 int main(void) {
 
   const std::size_t number_of_states = 3;
 
   std::unique_ptr<DeluxeContext> C = DeluxeContext::create("Deluxe");
 
   //---------------------- Sensors -------------------------------------
   //--------------------------------------------------------------------
   const std::string SensorName1 = "Sensor1";
   const std::string SensorName2 = "Sensor2";
   const std::string SensorName3 = "Sensor3";
   AgentHandle Sensor1 = C->createSensor<uint32_t, SensorValueType>(
       SensorName1, [&SensorName1](std::pair<uint32_t, bool> I) {
         LOG_INFO_STREAM << "\n******\n"
                         << SensorName1 << " sensor-input "
                         << (I.second ? "<New>" : "<Old>")
                         << " value: " << I.first << "\n******\n";
       });
   AgentHandle Sensor2 = C->createSensor<uint32_t, SensorValueType>(
       SensorName2, [&SensorName2](std::pair<uint32_t, bool> I) {
         LOG_INFO_STREAM << "\n******\n"
                         << SensorName2 << " sensor-input "
                         << (I.second ? "<New>" : "<Old>")
                         << " value: " << I.first << "\n******\n";
       });
   AgentHandle Sensor3 = C->createSensor<uint32_t, SensorValueType>(
       SensorName3, [&SensorName3](std::pair<uint32_t, bool> I) {
         LOG_INFO_STREAM << "\n******\n"
                         << SensorName3 << " sensor-input "
                         << (I.second ? "<New>" : "<Old>")
                         << " value: " << I.first << "\n******\n";
       });
 
   //------------------------- lowlevel agents --------------------------------
   //--------------------------------------------------------------------------
 
   const std::string LowLevelAgentName1 = "LowLevelAgent1";
   const std::string LowLevelAgentName2 = "LowLevelAgent2";
   const std::string LowLevelAgentName3 = "LowLevelAgent3";
 
   using conf = unrolled_data_type<
       number_of_states, StateType,
       ReliabilityType>; // this is the confidence expressed as one tuple it
                         // uses the format
                         // (first.state,first.rel,second.sate...)
 
   using LowLevelAgentMasterResult = void; // no return
   using LowLevelReturnFromMaster = std::pair<conf, bool>;
   using FloatMasterHandler =
       std::function<LowLevelAgentMasterResult(LowLevelReturnFromMaster)>;
   using FloatResult = Optional<DeluxeTuple<StateType, ReliabilityType>>;
   using FloatHandler =
       std::function<FloatResult(std::pair<DeluxeTuple<SensorValueType>, bool>)>;
 
   auto lowlevel1 = create_lowlevel_func();
   auto lowlevel2 = create_lowlevel_func();
   auto lowlevel3 = create_lowlevel_func();
 
   AgentHandle SlaveAgent1 = C->createAgent(
       LowLevelAgentName1,
       // Master-input handler.
       FloatMasterHandler(
           [&LowLevelAgentName1,
            lowlevel1](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
             LOG_INFO_STREAM << "inside: " << LowLevelAgentName1 << "feedback\n";
             if (I.second) {
               std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
               convert_to_vector<number_of_states>(feedback, I.first);
               lowlevel1->feedback(feedback);
             }
           }),
       // Slave-input handler.
       FloatHandler(
           [&LowLevelAgentName1, lowlevel1](
               std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
             LOG_INFO_STREAM
                 << "\n******\n"
                 << LowLevelAgentName1 << " " << (I.second ? "<New>" : "<Old>")
                 << " value: " << std::get<0>(I.first) << "\n******\n";
 
             auto tmp = lowlevel1->operator()(std::get<0>(I.first));
-            DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
+            DeluxeTuple<long, double> ret(tmp.score, tmp.Likeliness);
             return {ret};
           }));
 
   AgentHandle SlaveAgent2 = C->createAgent(
       LowLevelAgentName2,
       // Master-input handler.
       FloatMasterHandler(
           [&LowLevelAgentName2,
            lowlevel2](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
             LOG_INFO_STREAM << "inside: " << LowLevelAgentName2 << "feedback\n";
             if (I.second) {
               std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
               convert_to_vector<number_of_states>(feedback, I.first);
               lowlevel2->feedback(feedback);
             }
           }),
       // Slave-input handler.
       FloatHandler(
           [&LowLevelAgentName2, lowlevel2](
               std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
             LOG_INFO_STREAM
                 << "\n******\n"
                 << LowLevelAgentName2 << " " << (I.second ? "<New>" : "<Old>")
                 << " value: " << std::get<0>(I.first) << "\n******\n";
 
             auto tmp = lowlevel2->operator()(std::get<0>(I.first));
-            DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
+            DeluxeTuple<long, double> ret(tmp.score, tmp.Likeliness);
             return {ret};
           }));
 
   AgentHandle SlaveAgent3 = C->createAgent(
       LowLevelAgentName3,
       // Master-input handler.
       FloatMasterHandler(
           [&LowLevelAgentName3,
            lowlevel3](LowLevelReturnFromMaster I) -> LowLevelAgentMasterResult {
             LOG_INFO_STREAM << "inside: " << LowLevelAgentName3 << "feedback\n";
             if (I.second) {
               std::vector<ConfOrRel<StateType, ReliabilityType>> feedback;
               convert_to_vector<number_of_states>(feedback, I.first);
               lowlevel3->feedback(feedback);
             }
           }),
       // Slave-input handler.
       FloatHandler(
           [&LowLevelAgentName3, lowlevel3](
               std::pair<DeluxeTuple<SensorValueType>, bool> I) -> FloatResult {
             LOG_INFO_STREAM
                 << "\n******\n"
                 << LowLevelAgentName3 << " " << (I.second ? "<New>" : "<Old>")
                 << " value: " << std::get<0>(I.first) << "\n******\n";
 
             auto tmp = lowlevel3->operator()(std::get<0>(I.first));
-            DeluxeTuple<long, double> ret(tmp.score, tmp.Reliability);
+            DeluxeTuple<long, double> ret(tmp.score, tmp.Likeliness);
             return {ret};
           }));
 
   //------------------------- high level rel ---------------------------------
   //--------------------------------------------------------------------------
 
   auto highlevel = create_highlevel_func();
 
   using conf1 = Optional<unrolled_data_type<
       number_of_states, StateType,
       ReliabilityType>>; // this is the confidence expressed as one tuple it
                          // uses the format
                          // (first.state,first.rel,second.sate...)
 
   using MasterResult =
       std::tuple<Optional<DeluxeTuple<ReliabilityType>>, conf1, conf1, conf1>;
   using SlaveOutputs = DeluxeTuple<StateType, ReliabilityType>;
   using MasterHandler = std::function<MasterResult(
       std::pair<SlaveOutputs, bool>, std::pair<SlaveOutputs, bool>,
       std::pair<SlaveOutputs, bool>)>;
   AgentHandle MasterAgent = C->createAgent(
       "Master Agent",
       MasterHandler([&](std::pair<SlaveOutputs, bool> I0,
                         std::pair<SlaveOutputs, bool> I1,
                         std::pair<SlaveOutputs, bool> I2) -> MasterResult {
         ReliabilityForHighLevelAgents<StateType, ReliabilityType>::InputType
             input;
         input.push_back({0, std::get<0>(I0.first), std::get<1>(I0.first)});
         input.push_back({1, std::get<0>(I1.first), std::get<1>(I1.first)});
         input.push_back({2, std::get<0>(I2.first), std::get<1>(I2.first)});
         auto out = highlevel->operator()(input);
 
-        DeluxeTuple<ReliabilityType> rel(out.CrossReliability);
+        DeluxeTuple<ReliabilityType> rel(out.CrossLikeliness);
 
         conf c[3];
         for (std::size_t at = 0; at < 3; at++) {
-          std::get<0>(c[at]) = out.CrossConfidence.at(at).at(0).score;
-          std::get<1>(c[at]) = out.CrossConfidence.at(at).at(0).Reliability;
-          std::get<2>(c[at]) = out.CrossConfidence.at(at).at(1).score;
-          std::get<3>(c[at]) = out.CrossConfidence.at(at).at(1).Reliability;
-          std::get<4>(c[at]) = out.CrossConfidence.at(at).at(2).score;
-          std::get<5>(c[at]) = out.CrossConfidence.at(at).at(2).Reliability;
+          std::get<0>(c[at]) = out.Likeliness.at(at).at(0).score;
+          std::get<1>(c[at]) = out.Likeliness.at(at).at(0).Likeliness;
+          std::get<2>(c[at]) = out.Likeliness.at(at).at(1).score;
+          std::get<3>(c[at]) = out.Likeliness.at(at).at(1).Likeliness;
+          std::get<4>(c[at]) = out.Likeliness.at(at).at(2).score;
+          std::get<5>(c[at]) = out.Likeliness.at(at).at(2).Likeliness;
         }
         return {{rel}, {c[0]}, {c[1]}, {c[2]}};
       }));
   // -------------------------------------------------------------------------
   //			Sensors and connecting
   // -------------------------------------------------------------------------
 
   std::vector<SensorValueType> FloatValues(NumberOfSimulationCycles);
   std::generate(FloatValues.begin(), FloatValues.end(),
                 [f = 0.5f](void) mutable {
                   f += 0.3f;
                   return std::floor(f) + 0.5f;
                 });
   C->registerSensorValues(Sensor1, FloatValues.begin(), FloatValues.end());
   C->registerSensorValues(Sensor2, FloatValues.begin(), FloatValues.end());
   C->registerSensorValues(Sensor3, FloatValues.begin(), FloatValues.end());
 
   // Connection
   C->connectSensor(SlaveAgent1, 0, Sensor1, "Sensor 1");
   C->connectSensor(SlaveAgent2, 0, Sensor2, "Sensor 2");
   C->connectSensor(SlaveAgent3, 0, Sensor3, "Sensor 3");
 
   C->connectAgents(MasterAgent, 0, SlaveAgent1, "Slave1");
   C->connectAgents(MasterAgent, 1, SlaveAgent2, "Slave2");
   C->connectAgents(MasterAgent, 2, SlaveAgent3, "Slave3");
 
   // Logger
   AgentHandle LoggerAgent = C->createAgent(
       "Logger Agent", std::function<Optional<DeluxeTuple<unit_t>>(
                           std::pair<DeluxeTuple<ReliabilityType>, bool>)>(
                           [](std::pair<DeluxeTuple<ReliabilityType>, bool> Sum)
                               -> Optional<DeluxeTuple<unit_t>> {
                             if (Sum.second) {
                               LOG_INFO_STREAM
                                   << "Result: Rel: " << std::get<0>(Sum.first)
                                   << "\n";
                             }
                             return {};
                           }));
 
   C->connectAgents(LoggerAgent, 0, MasterAgent, "Sum Agent Channel");
   // -------------------------------------------------------------------------------
   //			Simulate
   // -------------------------------------------------------------------------------
 
   C->simulate(NumberOfSimulationCycles);
 
   delete highlevel;
   delete lowlevel1;
   delete lowlevel2;
-}
\ No newline at end of file
+}
diff --git a/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h b/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
index 7de4fac..472fbcc 100644
--- a/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
+++ b/examples/agent-functionalities/Reliability-functionality-agent-context/helper.h
@@ -1,170 +1,170 @@
 #include "rosa/config/version.h"
 
 #include "rosa/support/log.h"
 
 #include "rosa/agent/CrossReliability.h"
 #include "rosa/agent/RangeConfidence.hpp"
 #include "rosa/agent/Reliability.h"
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include <map>
 #include <vector>
 
 using namespace rosa::agent;
 using namespace rosa;
 using namespace rosa::deluxe;
 using namespace rosa::terminal;
 
 
 auto create_lowlevel_func() {
   std::unique_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
       Confidence(new RangeConfidence<ReliabilityType, StateType,
                                      SensorValueType>(
           {{0, PartialFunction<double, double>(
                    {
                        {{0, 3},
                         std::make_shared<LinearFunction<double, double>>(
                             0, 1.0 / 3)},
                        {{3, 6},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             3.0, -1.0 / 3)},
                    },
                    0)},
            {1, PartialFunction<double, double>(
                    {
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             -2, 1.0 / 3)},
                        {{9, 12},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             5, -1.0 / 3)},
                    },
                    0)},
            {2, PartialFunction<double, double>(
                    {
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             -4, 1.0 / 3)},
                        {{15, 18},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{18, 21},
                         std::make_shared<LinearFunction<double, double>>(
                             7, -1.0 / 3)},
                    },
                    0)}}));
 
   std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
       new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
 
   std::unique_ptr<Abstraction<SensorValueType, ReliabilityType>>
       ReliabilitySlope(
           new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
 
   std::unique_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
       new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));
 
   auto lowlevel = new ReliabilityForLowLevelAgents<SensorValueType, StateType,
                                                    ReliabilityType>();
 
   std::vector<long> states;
   states.push_back(0);
   states.push_back(1);
   states.push_back(2);
 
   lowlevel->setConfidenceFunction(Confidence);
-  lowlevel->setReliabilityFunction(Reliability);
+  lowlevel->setAbsoluteReliabilityFunction(Reliability);
   lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
-  lowlevel->setTimeConfidenceFunction(TimeConfidence);
-  lowlevel->setStates(states);
+  lowlevel->setTimeFunctionForLikelinessFunction(TimeConfidence);
+  lowlevel->setIdentifiers(states);
   lowlevel->setHistoryLength(2);
-  lowlevel->setValueSetCounter(1);
+  lowlevel->setTimeStep(1);
 
   return lowlevel;
 }
 
 auto create_highlevel_func(){
   std::vector<long> states;
   states.push_back(0);
   states.push_back(1);
   states.push_back(2);
 
   ReliabilityForHighLevelAgents<StateType, ReliabilityType> *highlevel =
       new ReliabilityForHighLevelAgents<StateType, ReliabilityType>();
 
   std::unique_ptr<CrossReliability<StateType, ReliabilityType>>
       CrossReliability1(new CrossReliability<StateType, ReliabilityType>());
 
   std::unique_ptr<Abstraction<long, double>> func1(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
   std::unique_ptr<Abstraction<long, double>> func2(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
   std::unique_ptr<Abstraction<long, double>> func3(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
 
-  CrossReliability1->addCrossReliabilityProfile(0, 1, func1);
-  CrossReliability1->addCrossReliabilityProfile(0, 2, func2);
-  CrossReliability1->addCrossReliabilityProfile(2, 1, func3);
+  CrossReliability1->addCrossLikelinessProfile(0, 1, func1);
+  CrossReliability1->addCrossLikelinessProfile(0, 2, func2);
+  CrossReliability1->addCrossLikelinessProfile(2, 1, func3);
   CrossReliability1->setCrossReliabilityMethod(
       CrossReliability<StateType, ReliabilityType>::AVERAGE);
-  CrossReliability1->setCrossReliabilityParameter(1);
+  CrossReliability1->setCrossLikelinessParameter(1);
 
   std::unique_ptr<CrossConfidence<StateType, ReliabilityType>> CrossConfidence1(
       new CrossConfidence<StateType, ReliabilityType>());
 
   std::unique_ptr<Abstraction<long, double>> func4(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
   std::unique_ptr<Abstraction<long, double>> func5(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
   std::unique_ptr<Abstraction<long, double>> func6(
       new PartialFunction<long, double>(
           {
               {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
               {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
           },
           0));
 
-  CrossConfidence1->addCrossReliabilityProfile(0, 1, func4);
-  CrossConfidence1->addCrossReliabilityProfile(0, 2, func5);
-  CrossConfidence1->addCrossReliabilityProfile(2, 1, func6);
+  CrossConfidence1->addCrossLikelinessProfile(0, 1, func4);
+  CrossConfidence1->addCrossLikelinessProfile(0, 2, func5);
+  CrossConfidence1->addCrossLikelinessProfile(2, 1, func6);
   CrossConfidence1->setCrossReliabilityMethod(
       CrossConfidence<StateType, ReliabilityType>::AVERAGE);
-  CrossConfidence1->setCrossReliabilityParameter(1);
+  CrossConfidence1->setCrossLikelinessParameter(1);
 
   highlevel->setCrossConfidence(CrossConfidence1);
   highlevel->setCrossReliability(CrossReliability1);
 
   highlevel->addStates(0, states);
   highlevel->addStates(1, states);
   highlevel->addStates(2, states);
 
   return highlevel;
-}
\ No newline at end of file
+}
diff --git a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
index 2e35af8..593db3f 100644
--- a/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
+++ b/examples/agent-functionalities/Reliability-functionality/Reliability-functionality.cpp
@@ -1,253 +1,253 @@
 //===- examples/agent-functionalities/Reliability-functionality.cpp *C++-*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file examples/agent-functionalities/Reliability-functionality.cpp
 ///
 /// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at )
 ///
 /// \date 2019
 ///
 /// \brief A simple example on defining Relianility Functionalities.
 ///
 //===----------------------------------------------------------------------===//
 
 #define Reliability_trace_level 5
 
 #include "rosa/config/version.h"
 
 #include "rosa/support/log.h"
 
 #include "rosa/agent/CrossCombinator.h"
 #include "rosa/agent/RangeConfidence.hpp"
 #include "rosa/agent/ReliabilityConfidenceCombinator.h"
 
 #include <map>
 #include <vector>
 
 using namespace rosa::agent;
 
 int main(void) {
   typedef double SensorValueType;
   typedef long StateType;
   typedef double ReliabilityType;
 
   std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
       Confidence(new RangeConfidence<ReliabilityType, StateType,
                                      SensorValueType>(
           {{0, PartialFunction<double, double>(
                    {
                        {{0, 3},
                         std::make_shared<LinearFunction<double, double>>(
                             0, 1.0 / 3)},
                        {{3, 6},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             3.0, -1.0 / 3)},
                    },
                    0)},
            {1, PartialFunction<double, double>(
                    {
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             -2, 1.0 / 3)},
                        {{9, 12},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             5, -1.0 / 3)},
                    },
                    0)},
            {2, PartialFunction<double, double>(
                    {
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             -4, 1.0 / 3)},
                        {{15, 18},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{18, 21},
                         std::make_shared<LinearFunction<double, double>>(
                             7, -1.0 / 3)},
                    },
                    0)}}));
 
   std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability(
       new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
 
   std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
       ReliabilitySlope(
           new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 3));
 
   std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence(
       new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 3));
 
   auto lowlevel =
       new ReliabilityAndConfidenceCombinator<SensorValueType, StateType,
                                              ReliabilityType>();
 
   std::vector<long> states;
   states.push_back(0);
   states.push_back(1);
   states.push_back(2);
    
   lowlevel->setConfidenceFunction(Confidence);
-  lowlevel->setReliabilityFunction(Reliability);
+  lowlevel->setAbsoluteReliabilityFunction(Reliability);
   lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
-  lowlevel->setTimeConfidenceFunction(TimeConfidence);
-  lowlevel->setStates(states);
+  lowlevel->setTimeFunctionForLikelinessFunction(TimeConfidence);
+  lowlevel->setIdentifiers(states);
   lowlevel->setHistoryLength(2);
-  lowlevel->setValueSetCounter(1);
+  lowlevel->setTimeStep(1);
 
   /* ----------------------------- Do Something
    * ---------------------------------------------------------------- */
   std::cout << "Testing the lowlevel component with static feedback telling it "
                "that the most lickely state is 2.\n";
   for (int a = 0; a < 30; a++)
     std::cout << "a: " << a << "\n"
               << (lowlevel->feedback({{0, 0}, {1, 0.3}, {2, 0.8}}),
-                  lowlevel->getmostLikelyIdentifierAndReliability(a))
+                  lowlevel->bestSymbol(a))
               << "\n";
 
 
   std::cout << "---------------------------------------------------------------"
                "---------------------------------\n";
   std::cout << "------------------------------------High level "
                "Test---------------------------------------------\n";
 
   std::cout
       << "Configured in a way that the Master thinks that both Sensors "
          "should have the same State.\n While feeding both the \"opposite\" "
          "values one acending the other decending from the maximum.\n";
 
   std::shared_ptr<RangeConfidence<ReliabilityType, StateType, SensorValueType>>
       Confidence2(new RangeConfidence<ReliabilityType, StateType,
                                       SensorValueType>(
           {{0, PartialFunction<double, double>(
                    {
                        {{0, 3},
                         std::make_shared<LinearFunction<double, double>>(
                             0, 1.0 / 3)},
                        {{3, 6},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             3.0, -1.0 / 3)},
                    },
                    0)},
            {1, PartialFunction<double, double>(
                    {
                        {{6, 9},
                         std::make_shared<LinearFunction<double, double>>(
                             -2, 1.0 / 3)},
                        {{9, 12},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             5, -1.0 / 3)},
                    },
                    0)},
            {2, PartialFunction<double, double>(
                    {
                        {{12, 15},
                         std::make_shared<LinearFunction<double, double>>(
                             -4, 1.0 / 3)},
                        {{15, 18},
                         std::make_shared<LinearFunction<double, double>>(1, 0)},
                        {{18, 21},
                         std::make_shared<LinearFunction<double, double>>(
                             7, -1.0 / 3)},
                    },
                    0)}}));
 
   std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>> Reliability2(
       new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
 
   std::shared_ptr<Abstraction<SensorValueType, ReliabilityType>>
       ReliabilitySlope2(
           new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0 / 9));
 
   std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeConfidence2(
       new LinearFunction<std::size_t, ReliabilityType>(1, -1.0 / 9));
 
   auto lowlevel2 =
       new ReliabilityAndConfidenceCombinator<SensorValueType, StateType,
                                                     ReliabilityType>();
 
   std::vector<long> states2;
   states2.push_back(0);
   states2.push_back(1);
   states2.push_back(2);
 
   lowlevel2->setConfidenceFunction(Confidence2);
-  lowlevel2->setReliabilityFunction(Reliability2);
+  lowlevel2->setAbsoluteReliabilityFunction(Reliability2);
   lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
-  lowlevel2->setTimeConfidenceFunction(TimeConfidence2);
-  lowlevel2->setStates(states2);
+  lowlevel2->setTimeFunctionForLikelinessFunction(TimeConfidence2);
+  lowlevel2->setIdentifiers(states2);
   lowlevel2->setHistoryLength(2);
-  lowlevel2->setValueSetCounter(1);
+  lowlevel2->setTimeStep(1);
 
   CrossCombinator<StateType, ReliabilityType> *highlevel =
       new CrossCombinator<StateType, ReliabilityType>();
 
   std::shared_ptr<Abstraction<long, double>> func1(new PartialFunction<long, double>(
       {
           {{0, 1}, std::make_shared<LinearFunction<long, double>>(1, 0)},
           {{1, 2}, std::make_shared<LinearFunction<long, double>>(2, -1.0)},
       },
       0));
 
-  highlevel->addCrossReliabilityProfile(0, 1, func1);
-  highlevel->setCrossReliabilityCombinatorMethod(
+  highlevel->addCrossLikelinessProfile(0, 1, func1);
+  highlevel->setCrossLikelinessCombinatorMethod(
       CrossCombinator<StateType, ReliabilityType>::predefinedMethods::AVERAGE);
-  highlevel->setCrossReliabilityParameter(1);
+  highlevel->setCrossLikelinessParameter(1);
 
   highlevel->addIdentifiers(0, states);
   highlevel->addIdentifiers(1, states);
 
   for (int a = 0; a < 21; a++) {
-    auto out1 = lowlevel->getmostLikelyIdentifierAndReliability(a),
-         out2 = lowlevel2->getmostLikelyIdentifierAndReliability((int)21 - a);
+    auto out1 = lowlevel->bestSymbol(a),
+         out2 = lowlevel2->bestSymbol((int)21 - a);
     std::cout << "s1: " << out1 << "\ns2:" << out2 << "\n";
     std::vector<std::tuple<rosa::id_t, StateType, ReliabilityType>> tmp2;
-    tmp2.push_back({0, out1.Identifier, out1.Reliability});
-    tmp2.push_back({1, out2.Identifier, out2.Reliability});
+    tmp2.push_back({0, out1.Identifier, out1.Likeliness});
+    tmp2.push_back({1, out2.Identifier, out2.Likeliness});
 
     auto out_o = highlevel->operator()(tmp2);
-    std::cout << "it: " << a << "\t rel: " << out_o.CrossReliability << "\n";
+    std::cout << "it: " << a << "\t rel: " << out_o.CrossLikeliness << "\n";
     std::cout << "\t subs:\n";
-    for (auto q : out_o.CrossConfidence) {
+    for (auto q : out_o.Likeliness) {
       std::cout << "\t\t id:" << q.first << "\n";
       /*
       for(auto z: q.second)
       {
-        std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Reliability
-      << "\n"; tmp.push_back({z.Identifier,z.Reliability});
+        std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
+      << "\n"; tmp.push_back({z.Identifier,z.Likeliness});
       }
       */
       for (auto z : q.second) {
-        std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Reliability
+        std::cout << "\t\t\t Identifier: " << z.Identifier << "\tRel: " << z.Likeliness
                   << "\n";
       }
 
       if (q.first == 0)
         lowlevel->feedback(q.second);
       else
         lowlevel2->feedback(q.second);
     }
   }
   /* ----------------------------- Cleanup
    * --------------------------------------------------------------------- */
 
   delete highlevel;
   delete lowlevel;
   delete lowlevel2;
-}
\ No newline at end of file
+}
diff --git a/include/rosa/agent/ReliabilityConfidenceCombinator.h b/include/rosa/agent/ReliabilityConfidenceCombinator.h
index d9b8a61..3048d3f 100644
--- a/include/rosa/agent/ReliabilityConfidenceCombinator.h
+++ b/include/rosa/agent/ReliabilityConfidenceCombinator.h
@@ -1,761 +1,761 @@
 //===-- rosa/agent/ReliabilityConfidenceCombinator.h ------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/ReliabilityConfidenceCombinator.h
 ///
 /// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief  Definition of *ReliabilityConfidenceCombinator* *functionality*.
 ///
 /// \note based on Maximilian Goetzinger (maxgot@utu.fi) code in
 /// CAM_Dirty_include SA-EWS2_Version... inside Agent.cpp
 ///
 /// \note By defining and setting Reliability_trace_level it is possible to
 /// change the level to which it should be traced. \note All classes throw
 /// runtime errors if not all things are set
 ///
 /// \note should the Reliability be capped?
 ///
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_ReliabilityConfidenceCombinator_H
 #define ROSA_AGENT_ReliabilityConfidenceCombinator_H
 
 #include "rosa/core/forward_declarations.h" // needed for id_t
 #include "rosa/support/log.h"
 
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/RangeConfidence.hpp"
 
 #include <algorithm>
 #include <functional>
 #include <type_traits>
 #include <vector>
 
 /// 0 everything
 /// 1 vectors
 /// 2 outputs
 #define trace_everything 0
 #define trace_vectors 1
 #define trace_outputs 2
 
 #ifndef Reliability_trace_level
 #define Reliability_trace_level 0
 #endif
 #define trace_end "\n\n\n"
 
 namespace rosa {
 namespace agent {
 /// This is a struct with a few methods that make Likeliness Combinator
 /// more readable \tparam IdentifierType The Data-type of the Identifiers \tparam
 /// LikelinessType The Data-type of the Likeliness
 /// \note this should/will be changed into a std::pair because it isn't needed
 /// anymore
 template <typename IdentifierType, typename LikelinessType> struct Symbol {
   /// making both Template Arguments readable to make a few things easier
   using _IdentifierType = IdentifierType;
   /// making both Template Arguments readable to make a few things easier
   using _LikelinessType = LikelinessType;
 
   /// The actual place where the data is stored
   IdentifierType Identifier;
   /// The actual place where the data is stored
   LikelinessType Likeliness;
 
   Symbol(IdentifierType _Identifier, LikelinessType _Likeliness)
       : Identifier(_Identifier), Likeliness(_Likeliness){};
   Symbol(){};
 
   /// Pushes the Data in a Human readable form
   /// \param out The stream where it is written to
   /// \param c The struct itself
   friend std::ostream &operator<<(std::ostream &out, const Symbol &c) {
     out << "Identifier: " << c.Identifier << "\t Likeliness: " << c.Likeliness
         << " ";
     return out;
   }
 
   /// needed or it throws an clang diagnosic error
   using map =
       std::map<IdentifierType, LikelinessType>; // needed or it throws an
                                                  // clang diagnosic error
   /// Filles the vector with the data inside the map
   /// \param me The vector to be filled
   /// \param data The data wich is to be pushed into the vector
   friend std::vector<Symbol> &operator<<(std::vector<Symbol> &me,
                                             map &&data) {
     for (auto tmp : data) {
       me.push_back(Symbol(tmp.first, tmp.second));
 #if Reliability_trace_level <= trace_everything
       LOG_TRACE_STREAM << "\n" << Symbol(tmp.first, tmp.second) << trace_end;
 #endif
     }
     return me;
   }
 
   /// This is to push the data inside a vector in a human readable way into the
   /// ostream \param out The ostream \param c The vector which is read
   friend std::ostream &operator<<(std::ostream &out,
                                   const std::vector<Symbol> &c) {
     std::size_t index = 0;
     for (Symbol data : c) {
       out << index << " : " << data << "\n";
       index++;
     }
     return out;
   }
 };
 
 /// This is the combinator for Reliability and confidences it takes the
 /// Value, its "History" and feedback from \c
 /// CrossCombinator to calculate different Reliabilities.
 /// \tparam ValueType Data-type of the Value	( Typically
 /// double or float) \tparam IdentifierType Data-type of the Identifier ( Typically
 /// long or int)
 ///	\tparam ReliabilityType Data-type of the Reliability		(
 /// Typically double	or float)
 ///
 /// \note more information about how it calculates
 /// the Reliabilities it should be considered feedback is a sort of Confidence
 /// \verbatim
 ///----------------------------------------------------------------------------------
 ///
 ///
 ///                  ->AbsoluteReliabilityFunction---> getInputReliability()
 ///                  |             |
 ///                  |             V
 ///  Sensor Value ---|       ReliabilityAndConfidenceCombinator -> next line
 ///                  |             A					|
 ///                  |             |					V
 ///                  ->ConfidenceFunction 			getPossibleIdentifiers()
 ///
 ///-----------------------------------------------------------------------------------
 ///
 ///           feedback
 ///               |
 ///               V
 ///           FeedbackSymbols
 ///               |               -> History -------|
 ///               V               |                 V
 /// here -> LikelinessFeedbackCombinator ------>LikelinessHistoryCombinator->next line
 ///                   |                                   |
 ///                   V                                   V
 /// getpossibleIdentifiersWithMasterFeedback()      SymbolsWithHistory()
 ///
 ///----------------------------------------------------------------------------------
 ///
 /// here -> sort -> most likely -> bestSymbol()
 ///
 ///---------------------------------------------------------------------------------
 /// \endverbatim
 /// the mentioned methods are early outs so if two ore more of them are run in
 /// the same step they will be interpreted as different time steps
 /// <pre>
 /// Default values for Combinators:
 ///	AbsoluteAndSlopeReliabilityCombinationMethod		= combinationMin;
 ///	ReliabilityAndConfidenceCombinator=ReliabilityAndConfidenceCombinatorMin;
 /// LikelinessFeedbackCombinator		= LikelinessFeedbackCombinatorAverage;
 /// LikelinessHistoryCombinator			= LikelinessHistoryCombinatorMax;
 ///	</pre>
 /// To understand the place where the combinator methods come into play a list
 /// for each early exit and which Methods are used.
 ///
 /// <pre>
 /// \c getInputReliability():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 /// \c getPossibleIdentifiers():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 /// \c getpossibleIdentifiersWithMasterFeedback():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 /// \c SymbolsWithHistory():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 ///		-LikelinessHistoryCombinator
 /// \c bestSymbol():
 ///		-AbsoluteAndSlopeReliabilityCombinationMethod
 ///		-ReliabilityAndConfidenceCombinator
 ///		-LikelinessFeedbackCombinator
 ///		-LikelinessHistoryCombinator
 /// </pre>
 template <typename ValueType, typename IdentifierType,
           typename ReliabilityType>
 class ReliabilityAndConfidenceCombinator {
 public:
   static_assert(std::is_arithmetic<ValueType>::value,
                 "LowLevel: ValueType has to an arithmetic type\n");
   static_assert(std::is_arithmetic<IdentifierType>::value,
                 "LowLevel: IdentifierType has to an arithmetic type\n");
   static_assert(std::is_arithmetic<ReliabilityType>::value,
                 "LowLevel: ReliabilityType has to an arithmetic type\n");
 
   /// Typedef to shorten the writing.
   /// \c Symbol
   using Symbol = Symbol<IdentifierType, ReliabilityType>;
 
   /// Calculates the input Reliability by combining Reliability of the Sensor
   /// and the Slope Reliability \param SensorValue The sensor Value \note to set
   /// the combination method \c setAbsoluteAndSlopeReliabilityCombinationMethod()
   ReliabilityType
   getInputReliability(const ValueType &SensorValue) noexcept {
     ReliabilityType inputReliability =
         getReliability(SensorValue, previousSensorValue, timeStep);
     previousSensorValue = SensorValue;
     PreviousSensorValueExists = true;
     return inputReliability;
   }
 
   /// Calculates the possible Identifiers
   /// \param SensorValue the Sensor Value
   /// \brief it combines the input reliability and the confidence of the Sensor.
   /// The use combination method can be set using \c
   /// setReliabilityAndConfidenceCombinator()
   std::vector<Symbol>
   getPossibleIdentifiers(const ValueType &SensorValue) noexcept {
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     return possibleIdentifiers;
   }
 
   /// return the Possible Values with the feedback in mind
   /// \param SensorValue The sensor Value
   /// \brief it combines the input reliability and the confidence of the Sensor.
   /// The combines them with LikelinessFeedbackCombinator and returns the result.
   std::vector<Symbol> getpossibleIdentifiersWithMasterFeedback(
       const ValueType &SensorValue) noexcept {
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
 
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
     return possibleIdentifiers;
   }
 
   /// returns all possible Identifiers and Reliabilities with the History in
   /// mind \param SensorValue the Sensor value how this is done is described at
   /// the class.
   std::vector<Symbol> SymbolsWithHistory(
       const ValueType &SensorValue) noexcept {
     std::vector<Symbol> ActuallPossibleIdentifiers;
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
 
     saveInHistory(possibleIdentifiers);
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\nActuallPossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
     LOG_TRACE_STREAM << "\npossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
 #endif
     possibleIdentifiers.clear();
 
     return SymbolsFromHistory();
   }
 
   /// Calculates the Reliability
   /// \param SensorValue The current Values of the Sensor
   ///
   /// \return Reliability and Identifier of the current SensorValue
   ///
   Symbol bestSymbol(
       const ValueType &SensorValue) noexcept {
 #if Reliability_trace_level <= trace_outputs
     LOG_TRACE_STREAM << "\nTrace level is set to: " << Reliability_trace_level
                      << "\n"
                      << "Will trace: "
                      << ((Reliability_trace_level == trace_outputs)
                              ? "outputs"
                              : (Reliability_trace_level == trace_vectors)
                                    ? "vectors"
                                    : (Reliability_trace_level ==
                                       trace_everything)
                                          ? "everything"
                                          : "undefined")
                      << trace_end;
 #endif
 
     std::vector<Symbol> ActuallPossibleIdentifiers;
     std::vector<Symbol> possibleIdentifiers;
     ReliabilityType inputReliability = getInputReliability(SensorValue);
 
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\ninput Rel: " << inputReliability << trace_end;
 #endif
 
     possibleIdentifiers << ConfidenceFunction->operator()(SensorValue);
 
     possibleIdentifiers = ReliabilityAndConfidenceCombinator(
         possibleIdentifiers, inputReliability);
     possibleIdentifiers =
         LikelinessFeedbackCombinator(possibleIdentifiers, FeedbackSymbols);
 
     saveInHistory(possibleIdentifiers);
 #if Reliability_trace_level <= trace_vectors
     LOG_TRACE_STREAM << "\nActuallPossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
     LOG_TRACE_STREAM << "\npossibleIdentifiers:\n"
                      << possibleIdentifiers << trace_end;
 #endif
     possibleIdentifiers.clear();
 
     possibleIdentifiers = SymbolsFromHistory();
 
     std::sort(possibleIdentifiers.begin(), possibleIdentifiers.end(),
               [](Symbol A, Symbol B) -> bool {
                 return A.Likeliness > B.Likeliness;
               });
 
 #if Reliability_trace_level <= trace_outputs
     LOG_TRACE_STREAM << "\noutput lowlevel: " << possibleIdentifiers.at(0)
                      << trace_end;
 #endif
     return possibleIdentifiers.at(0);
   }
 
   /// feedback for this functionality most commonly it comes from a Master Agent
   /// \param _FeedbackSymbols The Identifiers + Reliability for the feedback
   /// \brief This input kind of resembles a confidence but not
   /// directly it more or less says: compared to the other Identifiers inside
   /// the System these are the Identifiers with the Reliability that you have.
   void feedback(
       const std::vector<Symbol>
           &_FeedbackSymbols) noexcept // it is being copied internally anyway
   {
     FeedbackSymbols = _FeedbackSymbols;
   }
 
   //
   // ----------------------Reliability and Confidence Function setters----------
   //
   /// This is the setter for Confidence Function
-  /// \param _Confidence A pointer to the Functional for the \c Confidence of the
-  /// Sensor value
+  /// \param _ConfidenceFunction A pointer to the Functional for the
+  /// \c Confidence of the Sensor value
   void setConfidenceFunction(
       std::shared_ptr<RangeConfidence<ReliabilityType, IdentifierType,
                                       ValueType>> &_ConfidenceFunction) noexcept {
     ConfidenceFunction = _ConfidenceFunction;
   }
 
   /// This is the setter for AbsoluteReliabilityFunction 
   /// \param _AbsoluteReliabilityFunction A pointer to the Functional for the AbsoluteReliabilityFunction
   /// \brief The AbsoluteReliabilityFunction takes the current Sensor value and return the
   /// AbsoluteReliabilityFunction of the value.
   void setAbsoluteReliabilityFunction(
       std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
           &_AbsoluteReliabilityFunction) noexcept {
     AbsoluteReliabilityFunction = _AbsoluteReliabilityFunction;
   }
 
   /// This is the setter for ReliabilitySlopeFunction Function
   /// \param _ReliabilitySlopeFunction A pointer to the Functional for the
   /// ReliabilitySlopeFunction
   /// \brief The ReliabilitySlopeFunction takes the difference of the current Sensor
   /// Value to the last one and tells you how likely the change is.
   void setReliabilitySlopeFunction(
       std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
           &_ReliabilitySlopeFunction) noexcept {
     ReliabilitySlopeFunction = _ReliabilitySlopeFunction;
   }
 
   /// This is the setter for TimeFunctionForLikeliness Function
   /// \param _TimeFunctionForLikeliness A pointer to the Functional for the TimeFunctionForLikeliness
   /// \brief The time function takes the position in the History with greater
   /// equals older and return a Reliability of how "relevant" it is.
   void setTimeFunctionForLikelinessFunction(
       std::shared_ptr<Abstraction<std::size_t, ReliabilityType>>
           &_TimeFunctionForLikeliness) noexcept {
     TimeFunctionForLikeliness = _TimeFunctionForLikeliness;
   }
 
   /// This is the setter for all possible Identifiers
   /// \param Identifiers A vector containing all Identifiers
   /// \brief This exists even though \c Identifier Type is an arithmetic Type because
   /// the Identifiers do not need to be "next" to each other ( ex. Identifiers={ 1 7 24 })
   void setIdentifiers(const std::vector<IdentifierType> &Identifiers) noexcept {
     this->Identifiers = Identifiers;
   }
 
   /// This sets the Maximum length of the History
   /// \param length The length
   void setHistoryLength(const std::size_t &length) noexcept {
     this->HistoryMaxSize = length;
   }
 
   /// This sets the Value set Counter
   /// \param timeStep the new Value
   /// \note This might actually be only an artifact. It is only used to get the
   /// reliability from the \c ReliabilitySlopeFunction [ ReliabilitySlopeFunction->operator()(
   /// (lastValue - actualValue) / (ValueType)timeStep) ]
-  void settimeStep(const unsigned int &timeStep) noexcept {
+  void setTimeStep(const unsigned int &timeStep) noexcept {
     this->timeStep = timeStep;
   }
 
   //
   // ----------------combinator setters-----------------------------------------
   //
 
   /// This sets the combination method used by the History
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct LikelinessHistoryCombinator<method>()
   void setLikelinessHistoryCombinator(
       const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
           &Meth) noexcept {
     LikelinessHistoryCombinator = Meth;
   }
 
   /// sets the predefined method for the combination of the possible Identifiers
   /// and the master
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct LikelinessFeedbackCombinator<method>()
   void setLikelinessFeedbackCombinator(
       const std::function<std::vector<Symbol>(
           std::vector<Symbol>, std::vector<Symbol>)> &Meth) noexcept {
     LikelinessFeedbackCombinator = Meth;
   }
 
   /// Sets the used combination method for Possible Identifiers
   /// \param Meth the method which should be used. predefined inside the  \c
   /// predefinedMethods struct setReliabilityAndConfidenceCombinator<method>()
   void setReliabilityAndConfidenceCombinator(
       const std::function<std::vector<Symbol>(
           std::vector<Symbol>, ReliabilityType)> &Meth) noexcept {
     ReliabilityAndConfidenceCombinator = Meth;
   }
 
   /// sets the input reliability combinator method
   /// \param method the method which should be used. predefined inside the  \c
   /// predefinedMethods struct combination<method>()
   void setAbsoluteAndSlopeReliabilityCombinationMethod(
       const std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
           &&method) noexcept {
     AbsoluteAndSlopeReliabilityCombinationMethod = method;
   }
 
   //
   // ----------------predefined combinators------------------------------------
   //
   /// This struct is a pseudo name space to have easier access to all predefined
   /// methods while still not overcrowding the class it self
   struct predefinedMethods {
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMin(ReliabilityType A, ReliabilityType B) noexcept {
       return std::min(A, B);
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMax(ReliabilityType A, ReliabilityType B) noexcept {
       return std::max(A, B);
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorMult(ReliabilityType A, ReliabilityType B) noexcept {
       return A * B;
     }
     /// predefined Method
     static ReliabilityType
     LikelinessHistoryCombinatorAverage(ReliabilityType A,
                                    ReliabilityType B) noexcept {
       return (A + B) / 2;
     }
 
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorAverage(std::vector<Symbol> A,
                                     std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness =
                 (tmp_me.Likeliness + tmp_other.Likeliness) / 2;
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMin(std::vector<Symbol> A,
                                 std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness =
                 std::min(tmp_me.Likeliness + tmp_other.Likeliness);
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMax(std::vector<Symbol> A,
                                 std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness =
                 std::max(tmp_me.Likeliness + tmp_other.Likeliness);
           }
         }
       return A;
     }
     /// predefined method
     static std::vector<Symbol>
     LikelinessFeedbackCombinatorMult(std::vector<Symbol> A,
                                  std::vector<Symbol> B) noexcept {
       for (auto &tmp_me : A)
         for (auto &tmp_other : B) {
           if (tmp_me.Identifier == tmp_other.Identifier) {
             tmp_me.Likeliness = tmp_me.Likeliness * tmp_other.Likeliness;
           }
         }
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMin(std::vector<Symbol> A,
                                            ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = std::min(tmp.Likeliness, B);
       return A;
     }
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMax(std::vector<Symbol> A,
                                            ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = std::max(tmp.Likeliness, B);
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorAverage(std::vector<Symbol> A,
                                                ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = (tmp.Likeliness + B) / 2;
       return A;
     }
 
     /// Predefined combination method for possible Identifiers
     static std::vector<Symbol>
     ReliabilityAndConfidenceCombinatorMult(std::vector<Symbol> A,
                                             ReliabilityType B) noexcept {
       for (auto tmp : A)
         tmp.Likeliness = tmp.Likeliness * B / 2;
       return A;
     }
 
     /// The predefined min combinator method
     static ReliabilityType combinationMin(ReliabilityType A,
                                           ReliabilityType B) noexcept {
       return std::min(A, B);
     }
 
     /// The predefined max combinator method
     static ReliabilityType combinationMax(ReliabilityType A,
                                           ReliabilityType B) noexcept {
       return std::max(A, B);
     }
 
     /// The predefined average combinator method
     static ReliabilityType combinationAverage(ReliabilityType A,
                                               ReliabilityType B) noexcept {
       return (A + B) / 2;
     }
 
     /// The predefined average combinator method
     static ReliabilityType combinationMult(ReliabilityType A,
                                            ReliabilityType B) noexcept {
       return A * B;
     }
   };
 
   // ----------------------------------------------------------------
   //			Stored Values
   // ----------------------------------------------------------------
 private:
   std::vector<std::vector<Symbol>> History;
   std::size_t HistoryMaxSize;
   std::vector<Symbol> FeedbackSymbols;
 
   ValueType previousSensorValue;
   unsigned int timeStep;
   std::vector<IdentifierType> Identifiers;
   bool PreviousSensorValueExists = false;
 
   std::shared_ptr<
       RangeConfidence<ReliabilityType, IdentifierType, ValueType>>
       ConfidenceFunction;
   std::shared_ptr<Abstraction<ValueType, ReliabilityType>> AbsoluteReliabilityFunction;
   std::shared_ptr<Abstraction<ValueType, ReliabilityType>>
       ReliabilitySlopeFunction;
   std::shared_ptr<Abstraction<std::size_t, ReliabilityType>> TimeFunctionForLikeliness;
 
   // combination functions
   std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
       AbsoluteAndSlopeReliabilityCombinationMethod = predefinedMethods::combinationMin;
 
   std::function<std::vector<Symbol>(std::vector<Symbol>, ReliabilityType)>
       ReliabilityAndConfidenceCombinator =
           predefinedMethods::ReliabilityAndConfidenceCombinatorMin;
 
   std::function<std::vector<Symbol>(std::vector<Symbol>,
                                        std::vector<Symbol>)>
       LikelinessFeedbackCombinator =
           predefinedMethods::LikelinessFeedbackCombinatorAverage;
   std::function<ReliabilityType(ReliabilityType, ReliabilityType)>
       LikelinessHistoryCombinator = predefinedMethods::LikelinessHistoryCombinatorMax;
 
   // ---------------------------------------------------------------------------
   //			needed Functions
   // ---------------------------------------------------------------------------
 
   /// returns the Reliability
   /// \param actualValue The Value of the Sensor
   /// \param lastValue of the Sensor this is stored in the class
   /// \param _timeStep It has an effect on the difference of the current
   /// and last value This might not be needed anymore
   /// \brief it returns the combination the \c Reliability function and \c
   /// ReliabilitySlopeFunction if the previous value exists. if it doesn't it only
   /// returns the \c Reliability function value.
   ReliabilityType getReliability(const ValueType &actualValue,
                                  const ValueType &lastValue,
                                  const unsigned int &_timeStep) noexcept {
     ReliabilityType relAbs = AbsoluteReliabilityFunction->operator()(actualValue);
     if (PreviousSensorValueExists) {
       ReliabilityType relSlo = ReliabilitySlopeFunction->operator()(
           (lastValue - actualValue) / (ValueType)_timeStep);
 
       return AbsoluteAndSlopeReliabilityCombinationMethod(relAbs, relSlo);
     } else
       return relAbs;
   }
 
   /// adapts the possible Identifiers by checking the History and combines those
   /// values.
   /// \brief combines the historic values with the \c TimeFunctionForLikeliness function
   /// and returns the maximum Reliability for all Identifiers.
   std::vector<Symbol> SymbolsFromHistory() noexcept {
     // iterate through all history entries
     std::size_t posInHistory = 0;
     std::vector<Symbol> symbolFromHistory; //History Symbols
     for (auto timeStep = History.begin(); timeStep < History.end();
          timeStep++, posInHistory++) {
 
       // iterate through all possible Identifiers of each history entry
       for (Symbol &symbol : *timeStep) {
 
         IdentifierType historyIdentifier = symbol.Identifier;
         ReliabilityType historyConf = symbol.Likeliness;
 
         historyConf = historyConf * TimeFunctionForLikeliness->operator()(posInHistory);
 
         bool foundIdentifier = false;
         for (Symbol &pS : symbolFromHistory) {
 
           if (pS.Identifier == historyIdentifier) {
 
             pS.Likeliness =
                 LikelinessHistoryCombinator(pS.Likeliness, historyConf);
 
             foundIdentifier = true;
           }
         }
 
         if (foundIdentifier == false) {
 
           Symbol possibleIdentifier;	// Symbol
           possibleIdentifier.Identifier = historyIdentifier;
           possibleIdentifier.Likeliness = historyConf;
 
           symbolFromHistory.push_back(possibleIdentifier);
         }
       }
     }
 
     return symbolFromHistory;
   }
 
   /// saves the Identifiers in the History
   /// \brief It checks the incoming Identifiers if any have a Reliability
   /// greater than 0.5 all of them get saved inside the History and then the
   /// History get shortened to the maximal length. It only saves the Value if
   /// the History is empty.
   ///
   /// \param actualPossibleIdentifiers The Identifiers which should be saved
   ///
   /// \note Does the History really make sense if the values are to small it
   /// only stores something if it's empty and not if it isn't completely filled
   void saveInHistory(
       const std::vector<Symbol> &actualPossibleIdentifiers) noexcept { // Symbols
 
     // check if the reliability of at least one possible Identifier is high
     // enough
     bool atLeastOneRelIsHigh = false;
     for (Symbol pS : actualPossibleIdentifiers) {
       if (pS.Likeliness > 0.5) {
         atLeastOneRelIsHigh = true;
       }
     }
     // save possible Identifiers if at least one possible Identifier is high
     // enough (or if the history is empty)
     if (History.size() < 1 || atLeastOneRelIsHigh == true) {
       History.insert(History.begin(), actualPossibleIdentifiers);
 
       // if history size is higher than allowed, save oldest element
       while (History.size() > HistoryMaxSize) {
         // delete possibleIdentifierHistory.back();
         History.pop_back();
       }
     }
   }
 };
 
 } // namespace agent
 } // namespace rosa
 #endif // !ROSA_AGENT_ReliabilityConfidenceCombinator_H