con_supcc.cppGo to the documentation of this file.00001 /** @file con_controllability.cpp Conditionalcontrollability */ 00002 00003 /* 00004 * Implementation of the conditionally controllable algorithm 00005 * 00006 * Copyright (C) 2012 Tomas Masopust 00007 * 00008 */ 00009 00010 00011 #include "con_supcc.h" 00012 #include "con_include.h" 00013 #include "op_include.h" 00014 #include <vector> 00015 00016 namespace faudes { 00017 00018 bool SupConditionalControllable( 00019 const Generator& gen, 00020 const GeneratorVector& genVector, 00021 const EventSet& ACntrl, 00022 const EventSet& InitEk, 00023 GeneratorVector& supVector, 00024 Generator& Coord) { 00025 00026 /* Steps of the algorithm 00027 * 1. compute Ek so that it contains all shared events 00028 * 2. extend Ek so that K = L(gen) is CD 00029 * 3. extend Ek so that Pk is Li-observer, i=1,2,...,n 00030 * 4. compute the coordinator Gk and supCk, supCi+k 00031 * 5. if supCk subseteq Pk(supCi+k), return supCi+k and the supervised coordinator (supCk) 00032 * 6. extend Ek so that P^{i+k}_k is (P^{i+k}_k)^{-1}(Li)-observer and OCC for that language 00033 * 7. recompute supCi+k a return them and the supervised coordinator 00034 */ 00035 00036 Idx i; 00037 00038 // the generators must be deterministic and prefix-closed 00039 if (gen.IsDeterministic() == false || IsPrefixClosed(gen) == false) { 00040 std::stringstream errstr; 00041 errstr << "Generators must be deterministic and prefix-closed"; 00042 throw Exception("ConditionalControllability", errstr.str(), 201); 00043 } 00044 for (i = 0; i < genVector.Size(); i++) { 00045 if (genVector.At(i).IsDeterministic() == false || IsPrefixClosed(genVector.At(i)) == false) { 00046 std::stringstream errstr; 00047 errstr << "Generators of genVector must be deterministic and prefix-closed"; 00048 throw Exception("ConditionalControllability", errstr.str(), 201); 00049 } 00050 } 00051 00052 /* 1. compute Ek so that it contains all shared events */ 00053 EventSet unionset; // contains union of Ei 00054 EventSet shared; // contains union of intersections 00055 00056 // Compute unionset 00057 for (i = 0; i < genVector.Size(); i++) { 00058 SetUnion(unionset,genVector.At(i).Alphabet(),unionset); 00059 } 00060 00061 // Compute the set of shared events 00062 for (i = 0; i < genVector.Size(); i++) { 00063 for (Idx j = 0; j < genVector.Size(); j++) { 00064 if (j != i) { 00065 EventSet eHelpInt; 00066 SetIntersection(genVector.At(i).Alphabet(),genVector.At(j).Alphabet(),eHelpInt); 00067 SetUnion(shared,eHelpInt,shared); 00068 } 00069 } 00070 } 00071 00072 EventSet ek = shared + InitEk; 00073 std::cerr << "Initial Ek = { "; 00074 EventSet::Iterator eit; 00075 for (eit=ek.Begin(); eit != ek.End(); ++eit) { 00076 std::cerr << ek.SymbolicName(*eit) << " "; 00077 } 00078 std::cerr << "}" << std::endl; 00079 00080 // Alphabet of the generator must be under union Ei 00081 bool ok = SetInclusion(gen.Alphabet(),unionset); 00082 if (ok == false) { 00083 std::stringstream errstr; 00084 errstr << "Generator alphabet is not included in union of the alphabets"; 00085 throw Exception("ConditionalDecomposability", errstr.str(), 100); 00086 } 00087 00088 // Alphabet of the generator must contain Ek 00089 ok = SetInclusion(ek,gen.Alphabet()); 00090 if (ok == false) { 00091 std::stringstream errstr; 00092 errstr << "Generator alphabet does not include the alphabet ek"; 00093 throw Exception("ConditionalDecomposability", errstr.str(), 100); 00094 } 00095 00096 /* 2. extend Ek so that K = L(gen) is CD */ 00097 std::cerr << "Extension of Ek for Conditional Decomposability..." << std::endl; 00098 EventSetVector ee; 00099 for (i = 0; i < genVector.Size(); i++) { 00100 ee.Append(genVector.At(i).Alphabet()); 00101 } 00102 ConDecExtension(gen,ee,ek); 00103 00104 /* 3. extend Ek so that Pk is Li-observer, i=1,2,...,n */ 00105 bool repeat = true; 00106 std::cerr << "Extension of Ek for Li-observers..." << std::endl; 00107 while (repeat) { 00108 repeat = false; 00109 for (i = 0; i < genVector.Size(); i++) { 00110 if (IsObs(genVector.At(i),ek*genVector.At(i).Alphabet()) == false ) { 00111 repeat = true; 00112 EventSet ekHelp = ek * genVector.At(i).Alphabet(); 00113 calcNaturalObserver(genVector.At(i),ekHelp); 00114 SetUnion(ek,ekHelp,ek); 00115 } 00116 } 00117 } 00118 std::cerr << "Extended Ek = { "; 00119 for (eit=ek.Begin(); eit != ek.End(); ++eit) { 00120 std::cerr << ek.SymbolicName(*eit) << " "; 00121 } 00122 std::cerr << "}" << std::endl; 00123 00124 /* 4. compute the coordinator Gk and supCk, supCi+k */ 00125 // coordinator Gk = || P_k(G_i) 00126 Generator gk; 00127 FullLanguage(ek,gk); 00128 for (i = 0; i < genVector.Size(); i++) { 00129 Generator pomGen; 00130 Project(genVector.At(i),ek,pomGen); 00131 Parallel(gk,pomGen,gk); 00132 } 00133 00134 // compute P_k(K) and the vector of P_{i+k}(K) 00135 Generator pk; 00136 Project(gen,ek,pk); 00137 GeneratorVector specVect; 00138 for (i = 0; i < genVector.Size(); i++) { 00139 Generator pomGen; 00140 Project(gen,ek+genVector.At(i).Alphabet(),pomGen); 00141 specVect.Append(pomGen); 00142 } 00143 00144 // the set of controllable events E_{k,c} 00145 EventSet ekc; 00146 SetIntersection(ek,ACntrl,ekc); 00147 // supCk supervisor 00148 Generator supCk; 00149 // vector of supC_{i+k} supervisors 00150 GeneratorVector supCkVector; 00151 00152 // compute supremal controllable sublanguage of P_k(K) wrt L(G_k) and E_{k,c} 00153 // if (IsControllable(gk,ekc,pk)) -- DO NOT USE, if K not subset of L, then the results are wrong!!! 00154 SupConClosed(gk,ekc,pk,supCk); 00155 00156 // compute supremal controllable sublanguage of P_{i+k}(K) wrt L(G_i)||supCk and E_{1+k,c} 00157 for (i = 0; i < genVector.Size(); i++) { 00158 Generator helpPlant; 00159 Parallel(genVector.At(i),supCk,helpPlant); 00160 Generator supCik; 00161 SupConClosed(helpPlant,helpPlant.Alphabet()*ACntrl,specVect.At(i),supCik); 00162 supCkVector.Append(supCik); // supC_{i+k} = supCik 00163 } 00164 00165 /* 5. if supCk subseteq Pk(supCi+k), return supCi+k and the supervised coordinator*/ 00166 bool incl = true; 00167 // TODO -- implement this test nodeterministically!!! 00168 for (i = 0; i < supCkVector.Size(); i++) { 00169 Generator PkHelp; 00170 Project(supCkVector.At(i),ek,PkHelp); 00171 incl = incl && LanguageInclusion(supCk,PkHelp); 00172 } 00173 // incl = true ==> ok 00174 if (incl) { 00175 Coord = supCk; 00176 supVector = supCkVector; 00177 std::cout << "Finished: supCk is a subset of all Pk(supCi+k)." << std::endl; 00178 return true; 00179 } 00180 00181 /* 6. extend Ek so that P^{i+k}_k is (P^{i+k}_i)^{-1}(Li)-observer and OCC for that language */ 00182 // Here LCC is used instead of OCC 00183 // compute a vector of (P^{i+k}_k)^{-1}(Li) 00184 GeneratorVector invLiVect; 00185 for (i = 0; i < genVector.Size(); i++) { 00186 Generator invLi; 00187 aInvProject(genVector.At(i),ek+genVector.At(i).Alphabet(),invLi); 00188 invLiVect.Append(invLi); 00189 } 00190 repeat = true; 00191 while (repeat) { 00192 repeat = false; 00193 for (i = 0; i < invLiVect.Size(); i++) { 00194 if (IsObs(invLiVect.At(i),ek) && IsLCC(invLiVect.At(i),ek) == false ) { 00195 repeat = true; 00196 calcNaturalObserverLCC(genVector.At(i),ekc,ek); 00197 } 00198 } 00199 } 00200 00201 /* 7. recompute supCi+k a return them and the supervised coordinator*/ 00202 // recompute the set of controllable events E_{k,c} 00203 ekc = ek * ACntrl; 00204 supCk.Clear(); 00205 supCkVector.Clear(); 00206 00207 // coordinator Gk = || P_k(G_i) 00208 gk.Clear(); 00209 FullLanguage(ek,gk); 00210 for (i = 0; i < genVector.Size(); i++) { 00211 Generator pomGen; 00212 Project(genVector.At(i),ek,pomGen); 00213 Parallel(gk,pomGen,gk); 00214 } 00215 00216 // compute P_k(K) and the vector of P_{i+k}(K) 00217 pk.Clear(); 00218 Project(gen,ek,pk); 00219 specVect.Clear(); 00220 for (i = 0; i < genVector.Size(); i++) { 00221 Generator pomGen; 00222 Project(gen,ek+genVector.At(i).Alphabet(),pomGen); 00223 specVect.Append(pomGen); 00224 } 00225 00226 // compute supremal controllable sublanguage of P_k(K) wrt L(G_k) and E_{k,c} 00227 SupConClosed(gk,ekc,pk,supCk); 00228 00229 // compute supremal controllable sublanguages of P_{i+k}(K) wrt L(G_i)||supCk and E_{1+k,c} 00230 for (i = 0; i < genVector.Size(); i++) { 00231 Generator helpPlant; 00232 Parallel(genVector.At(i),supCk,helpPlant); 00233 Generator supCik; 00234 SupConClosed(helpPlant,helpPlant.Alphabet()*ACntrl,specVect.At(i),supCik); 00235 supCkVector.Append(supCik); // supC_{i+k} = supCik 00236 } 00237 00238 // the resulting supervisors 00239 supVector = supCkVector; 00240 Coord = supCk; 00241 std::cout << "Finished: supCk was NOT a subset of all Pk(supCi+k)." << std::endl; 00242 return true; 00243 00244 } 00245 00246 00247 } // name space 00248 00249 00250 libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen |