/** * Convert an LTL formula to a DRA. * @param ltl the LTL formula * @param options which operators are allowed * @return a shared_ptr to the DRA */ private DRA ltl2dra(LTLFormula ltl, BuchiAutomata buchiAutomata, LTL2DSTAR_Options options) { APSet ap_set = ltl.getAPSet(); LTLFormula ltl_pnf = ltl.toPNF(); if (options.allow_union && ltl_pnf.getRootNode().getType() == type_t.T_OR) { LTLFormula ltl_left = ltl_pnf.getSubFormula(ltl_pnf.getRootNode().getLeft()); LTLFormula ltl_right = ltl_pnf.getSubFormula(ltl_pnf.getRootNode().getRight()); LTL2DSTAR_Options rec_opt = options; rec_opt.recursion(); DRA dra_left = ltl2dra(ltl_left, buchiAutomata, rec_opt); DRA dra_right = ltl2dra(ltl_right, buchiAutomata, rec_opt); return(DRA.calculateUnion(dra_left, dra_right, _safra_opt.union_trueloop) as DRA); } if (options.safety) { LTLSafetyAutomata lsa = new LTLSafetyAutomata(); DRA safety_dra = lsa.ltl2dra(ltl, buchiAutomata); if (safety_dra != null) { return(safety_dra); } } DRA dra = new DRA(ap_set); NBA nba = LTL2NBA.ltl2nba(ltl_pnf, buchiAutomata); if (nba == null) { throw new Exception("Couldn't create NBA from LTL formula"); } NBA2DRA nba2dra = new NBA2DRA(_safra_opt); nba2dra.convert(nba, dra); if (options.optimizeAcceptance) { dra.optimizeAcceptanceCondition(); } if (options.bisim) { DRAOptimizations dra_optimizer = new DRAOptimizations(); dra = dra_optimizer.optimizeBisimulation(dra); } return(dra); }
/** * Convert the NBA to a DRA using Safra's algorithm, using stuttering * @param nba the NBA * @param dra_result the result DRA * @param limit limit for the size of the DRA */ //template < typename NBA_t, typename DRA_t > void convert_safra_stuttered(NBA nba, DRA dra_result, int limit) //=0 { SafraAlgorithm safras_algo = new SafraAlgorithm(nba, _options); StutteredNBA2DA nba2dra_stuttered = new StutteredNBA2DA(_detailed_states, _stutter_information); nba2dra_stuttered.convert(safras_algo, dra_result, limit); }
/** * Perform quotienting using bisimulation * @param dra the DRA to be optimized * @param printColoring print colorings on std::cerr? * @param detailedStates save detailed information on the interals in the state? * @param printStats print statistics on std::cerr? * @return shared_ptr to the quotiented DRA */ public DRA optimizeBisimulation(DRA dra) { bool printColoring = false; bool detailedStates = false; bool printStats = false; //if (!dra.isCompact()) {dra.makeCompact();} List <int> states = new List <int>(dra.size()); for (int i = 0; i < dra.size(); i++) { //states[i] = i; states.Add(i); } AcceptanceSignatureContainer accsig_container = new AcceptanceSignatureContainer(dra); AcceptanceSignatureComparator accsig_comp = new AcceptanceSignatureComparator(accsig_container); Coloring coloring = new Coloring(dra, detailedStates); // generate initial coloring by running with the // different acceptance signature Coloring new_coloring = generateColoring(states, coloring, accsig_comp); //delete coloring; coloring = new_coloring; int old_size = dra.size(); int initial_partition = coloring.countColors(); int oldColors; do { oldColors = coloring.countColors(); ColoredStateComparator cnc = new ColoredStateComparator(coloring, dra); Coloring new_coloring_temp = generateColoring(states, coloring, cnc); //delete coloring; coloring = new_coloring_temp; } while (oldColors != coloring.countColors()); //if (printColoring) { // std::cerr << *coloring << std::endl; //} DRA dra_new = generateDRAfromColoring(dra, coloring, detailedStates); //delete coloring; int new_size = dra_new.size(); //if (printStats) { // std::cerr << "Bisimulation: From (" << old_size << ") To (" << new_size << ") Initial: (" << initial_partition << ")" << std::endl; //} return(dra_new); }
public static DRA dba2dra(NBA nba, bool complement) { APSet ap_set = nba.getAPSet();; DRA dra_p = new DRA(ap_set); dba2dra(nba, dra_p, complement); return(dra_p); }
public static DA calculateUnion(DRA dra1, DRA dra2, bool trueloop_check, bool detailed_states) { if (dra1.isStreett() || dra2.isStreett()) { throw new Exception("Can not calculate union for Streett automata"); } return(DAUnionAlgorithm.calculateUnion(dra1, dra2, trueloop_check, detailed_states)); }
public static DA calculateUnion(DRA dra1, DRA dra2, bool trueloop_check, bool detailed_states) { if (dra1.isStreett() || dra2.isStreett()) { throw new Exception("Can not calculate union for Streett automata"); } return DAUnionAlgorithm.calculateUnion(dra1, dra2, trueloop_check, detailed_states); }
public static DRA dba2dra(NBA nba, bool complement) { APSet ap_set = nba.getAPSet(); ; DRA dra_p = new DRA(ap_set); dba2dra(nba, dra_p, complement); return dra_p; }
/** * Perform quotienting using bisimulation * @param dra the DRA to be optimized * @param printColoring print colorings on std::cerr? * @param detailedStates save detailed information on the interals in the state? * @param printStats print statistics on std::cerr? * @return shared_ptr to the quotiented DRA */ public DRA optimizeBisimulation(DRA dra) { bool printColoring = false; bool detailedStates = false; bool printStats = false; //if (!dra.isCompact()) {dra.makeCompact();} List<int> states = new List<int>(dra.size()); for (int i = 0; i < dra.size(); i++) { //states[i] = i; states.Add(i); } AcceptanceSignatureContainer accsig_container = new AcceptanceSignatureContainer(dra); AcceptanceSignatureComparator accsig_comp = new AcceptanceSignatureComparator(accsig_container); Coloring coloring = new Coloring(dra, detailedStates); // generate initial coloring by running with the // different acceptance signature Coloring new_coloring = generateColoring(states, coloring, accsig_comp); //delete coloring; coloring = new_coloring; int old_size = dra.size(); int initial_partition = coloring.countColors(); int oldColors; do { oldColors = coloring.countColors(); ColoredStateComparator cnc = new ColoredStateComparator(coloring, dra); Coloring new_coloring_temp = generateColoring(states, coloring, cnc); //delete coloring; coloring = new_coloring_temp; } while (oldColors != coloring.countColors()); //if (printColoring) { // std::cerr << *coloring << std::endl; //} DRA dra_new = generateDRAfromColoring(dra, coloring, detailedStates); //delete coloring; int new_size = dra_new.size(); //if (printStats) { // std::cerr << "Bisimulation: From (" << old_size << ") To (" << new_size << ") Initial: (" << initial_partition << ")" << std::endl; //} return dra_new; }
//bool trueloop_check=true, bool detailed_states=false public static DA calculateUnionStuttered(DRA dra1, DRA dra2, StutterSensitivenessInformation stutter_information, bool trueloop_check, bool detailed_states) { if (dra1.isStreett() || dra2.isStreett()) { throw new Exception("Can not calculate union for Streett automata"); } return DAUnionAlgorithm.calculateUnionStuttered(dra1, dra2, stutter_information, trueloop_check, detailed_states); }
//bool trueloop_check=true, bool detailed_states=false public static DA calculateUnionStuttered(DRA dra1, DRA dra2, StutterSensitivenessInformation stutter_information, bool trueloop_check, bool detailed_states) { if (dra1.isStreett() || dra2.isStreett()) { throw new Exception("Can not calculate union for Streett automata"); } return(DAUnionAlgorithm.calculateUnionStuttered(dra1, dra2, stutter_information, trueloop_check, detailed_states)); }
/** Constructor. * @param algo The Algorithm_t to use * @param da_result The result automaton * @param limit Limit the number of states in the result automaton? * @param detailed_states Generate detailed descriptions? * @param stutter_information Information about which symbols may be stuttered */ public StutteredConvertorUnion(DAUnionAlgorithm algo, DRA da_result, int limit, bool detailed_states, StutterSensitivenessInformation stutter_information) { _da_result = da_result; _limit = limit; _algo = algo; _detailed_states = detailed_states; _stutter_information = stutter_information; //added by ly _state_mapper = new StateMapper <TreeWithAcceptance, DA_State>(); _unprocessed = new Stack <KeyValuePair <TreeWithAcceptance, DA_State> >(); }
/** Constructor. * @param algo The Algorithm_t to use * @param da_result The result automaton * @param limit Limit the number of states in the result automaton? * @param detailed_states Generate detailed descriptions? * @param stutter_information Information about which symbols may be stuttered */ public StutteredConvertorUnion(DAUnionAlgorithm algo, DRA da_result, int limit, bool detailed_states, StutterSensitivenessInformation stutter_information) { _da_result = da_result; _limit = limit; _algo = algo; _detailed_states = detailed_states; _stutter_information = stutter_information; //added by ly _state_mapper = new StateMapper<TreeWithAcceptance, DA_State>(); _unprocessed = new Stack<KeyValuePair<TreeWithAcceptance, DA_State>>(); }
/** * Perform union construction */ public override void calculate(int level, int limit) { // if (_options.verbose_scheduler) { //std::cerr << "Calculate ("<< level <<"): " << typeid(*this).name() << std::endl; // } try { children[0].calculate(level + 1, limit); children[1].calculate(level + 1, limit); } catch (LimitReachedException e) { //_automaton.reset(); return; } if (children[0]._automaton == null || children[1]._automaton == null) { return; } bool union_trueloop = _sched.getLTL2DRA().getOptions().union_trueloop; if (_sched.getLTL2DRA().getOptions().stutter) { _automaton = DRA.calculateUnionStuttered(children[0]._automaton, children[1]._automaton, _stutter_information, union_trueloop, _options.detailed_states) as DRA; } else { _automaton = DRA.calculateUnion(children[0]._automaton, children[1]._automaton, union_trueloop, _options.detailed_states) as DRA; /* _automaton=DRAOperations::dra_union(*children[0]->_automaton, * children[1]->_automaton, * union_trueloop, * _options.detailed_states); */ } _comment = "Union{" + children[0]._comment + "," + children[1]._comment + "}"; if (_options.optimizeAcceptance) { _automaton.optimizeAcceptanceCondition(); } if (_options.bisim) { DRAOptimizations dra_optimizer = new DRAOptimizations(); _automaton = dra_optimizer.optimizeBisimulation(_automaton); //, false, _options.detailed_states, false } hook_after_calculate(); }
public void convert(NBA nba, DRA dra_result, int limit) //=0 { if (nba.size() == 0 || nba.getStartState() == null) { // the NBA is empty -> construct DRA that is empty dra_result.constructEmpty(); return; } if (_options.dba_check && nba.isDeterministic()) { DBA2DRA.dba2dra(nba, dra_result); return; } if (_options.stutter_closure) { if (_stutter_information != null && !_stutter_information.isCompletelyInsensitive()) { //std::cerr << //"WARNING: NBA might not be 100% stutter insensitive, applying stutter closure can create invalid results!" << //std::endl; } NBA nba_closed = NBAStutterClosure.stutter_closure(nba); if (can_stutter()) { convert_safra_stuttered(nba_closed, dra_result, limit); return; } convert_safra(nba_closed, dra_result, limit); return; } if (can_stutter()) { convert_safra_stuttered(nba, dra_result, limit); return; } convert_safra(nba, dra_result, limit); return; }
/** * Constructor, get initial size of the coloring from DRA. * @param dra the DRA * @param detailed Keep detailed information on the equivalence classes? */ public Coloring(DRA dra, bool detailed) //=false { _nr_of_colors = 0; _detailed = detailed; _coloring = new List <int>(); Ultility.resize(_coloring, dra.size()); _color2state = new List <int>(); //_coloring.resize(dra.size()); if (_detailed) { _color2states = new List <BitSet>(); } else { _color2states = null; } }
/** * Convert an NBA to a DRA using Safra's algorithm. * If limit is specified (>0), the conversion is * aborted with LimitReachedException when the number of * states exceeds the limit. * @param nba the formula * @param limit a limit on the number of states (0 for no limit) * @param detailedStates save detailed interal information (Safra trees) * in the generated states * @param stutter_information Information about the symbols that can be stuttered * @return a shared_ptr to the created DRA */ public DRA nba2dra(NBA nba, int limit, bool detailedStates, StutterSensitivenessInformation stutter_information) { DRA dra = new DRA(nba.getAPSet_cp()); NBA2DRA nba2dra = new NBA2DRA(_safra_opt, detailedStates, stutter_information); try { nba2dra.convert(nba, dra, limit); } catch (LimitReachedException e) { //dra.reset(); // rethrow to notify caller //throw; } return(dra); }
/** * Convert an NBA to a DRA using Safra's algorithm. * If limit is specified (>0), the conversion is * aborted with LimitReachedException when the number of * states exceeds the limit. * @param nba the formula * @param limit a limit on the number of states (0 for no limit) * @param detailedStates save detailed interal information (Safra trees) * in the generated states * @param stutter_information Information about the symbols that can be stuttered * @return a shared_ptr to the created DRA */ public DRA nba2dra(NBA nba, int limit, bool detailedStates, StutterSensitivenessInformation stutter_information) { DRA dra = new DRA(nba.getAPSet_cp()); NBA2DRA nba2dra = new NBA2DRA(_safra_opt, detailedStates, stutter_information); try { nba2dra.convert(nba, dra, limit); } catch (LimitReachedException e) { //dra.reset(); // rethrow to notify caller //throw; } return dra; }
/** * Convert the NBA to a DRA using Safra's algorithm * @param nba the NBA * @param dra_result the result DRA * @param limit limit for the size of the DRA */ public void convert_safra(NBA nba, DRA dra_result, int limit) //=0 { SafraAlgorithm safras_algo = new SafraAlgorithm(nba, _options); if (!_options.opt_rename) { NBA2DA nba2da = new NBA2DA(_detailed_states); nba2da.convert(safras_algo, dra_result, limit); } else { //typedef typename SafrasAlgorithm<NBA_t>::result_t result_t; //typedef typename SafrasAlgorithm<NBA_t>::state_t key_t; //<safra_t,DRA_t, StateMapperFuzzy<result_t, key_t, typename DRA_t::state_type, SafraTreeCandidateMatcher> > NBA2DA nba2da_fuzzy = new NBA2DA(_detailed_states); nba2da_fuzzy.convert(safras_algo, dra_result, limit); } }
/** Calculate the automaton for this building block, by default * calculate the automata for the children and then choose the smallest. */ public virtual void calculate(int level, int limit) { //if (_options.verbose_scheduler) { // std::cerr << "Calculate ("<< level <<"): " << typeid(*this).name() << std::endl; //} calculateChildren(level, limit); bool first = true; //for (child_vector::iterator it=children.begin();it!=children.end();++it) for (int i = 0; i < children.Count; i++) { LTL2DSTAR_Tree it = children[i]; if (it._automaton == null) { continue; } if (first) { _automaton = it._automaton; _comment = it._comment; } else { if (_automaton.size() > it._automaton.size()) { _automaton = it._automaton; _comment = it._comment; } } first = false; } hook_after_calculate(); }
/** Type of an acceptance signature */ // public KeyValuePair<BitSet, BitSet> acceptance_signature_t; /** * Constructor, fills the container with the acceptance signatures of the states. * @param dra the DRA */ public AcceptanceSignatureContainer(DRA dra) { //_acceptancesig_vector.resize(dra.size()); _acceptancesig_vector = new List <KeyValuePair <BitSet, BitSet> >(); //Ultility.resize(_acceptancesig_vector, dra.size()); _bitsets = new List <BitSet>(); for (int i = 0; i < dra.size(); i++) { BitSet b = dra.acceptance().getAcceptance_L_forState(i); BitSet bp = new BitSet(b); _bitsets.Add(bp); //push_back // _acceptancesig_vector[i].Key = bp; b = dra.acceptance().getAcceptance_U_forState(i); BitSet bp1 = new BitSet(b); _bitsets.Add(bp1); // //_acceptancesig_vector[i].Value = bp1; _acceptancesig_vector.Add(new KeyValuePair <BitSet, BitSet>(bp, bp1)); } }
/** * Generate a DRA/DSA for the LTL formula */ public DRA calculate(LTLFormula ltl, BuchiAutomata ba, LTL2DSTAR_Options ltl_opt) { LTLFormula ltl_p = (ltl.toPNF()); //if (ltl_opt.verbose_scheduler) { // std::cerr << ltl_p->toStringInfix() << std::endl; //} LTL2DSTAR_Tree_Start root = new LTL2DSTAR_Tree_Start(ltl_p, ba, ltl_opt, this); //if (ltl_opt.verbose_scheduler) { // root.printTree(std::cerr); //} root.calculate(); DRA result = root._automaton; if (result != null) { result.setComment(root._comment); //+ getTimingInformation() } return(result); }
//=0 public void convert(NBA nba, DRA dra_result, int limit) { if (nba.size() == 0 || nba.getStartState() == null) { // the NBA is empty -> construct DRA that is empty dra_result.constructEmpty(); return; } if (_options.dba_check && nba.isDeterministic()) { DBA2DRA.dba2dra(nba, dra_result); return; } if (_options.stutter_closure) { if (_stutter_information != null && !_stutter_information.isCompletelyInsensitive()) { //std::cerr << //"WARNING: NBA might not be 100% stutter insensitive, applying stutter closure can create invalid results!" << //std::endl; } NBA nba_closed = NBAStutterClosure.stutter_closure(nba); if (can_stutter()) { convert_safra_stuttered(nba_closed, dra_result, limit); return; } convert_safra(nba_closed, dra_result, limit); return; } if (can_stutter()) { convert_safra_stuttered(nba, dra_result, limit); return; } convert_safra(nba, dra_result, limit); return; }
//=0 /** * Convert an NBA to an DRA (having APElements as edge labels). * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DRA than the limit. * @param nba the NBA * @param dra_result the DRA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ //template < typename NBA_t, typename DRA_t> public void convert(NBA nba, DRA dra_result) { convert(nba, dra_result, 0); }
//=0 /** * Convert the NBA to a DRA using Safra's algorithm, using stuttering * @param nba the NBA * @param dra_result the result DRA * @param limit limit for the size of the DRA */ //template < typename NBA_t, typename DRA_t > void convert_safra_stuttered(NBA nba, DRA dra_result, int limit) { SafraAlgorithm safras_algo = new SafraAlgorithm(nba, _options); StutteredNBA2DA nba2dra_stuttered = new StutteredNBA2DA(_detailed_states, _stutter_information); nba2dra_stuttered.convert(safras_algo, dra_result, limit); }
//=0 /** * Convert the NBA to a DRA using Safra's algorithm * @param nba the NBA * @param dra_result the result DRA * @param limit limit for the size of the DRA */ public void convert_safra(NBA nba, DRA dra_result, int limit) { SafraAlgorithm safras_algo = new SafraAlgorithm(nba, _options); if (!_options.opt_rename) { NBA2DA nba2da = new NBA2DA(_detailed_states); nba2da.convert(safras_algo, dra_result, limit); } else { //typedef typename SafrasAlgorithm<NBA_t>::result_t result_t; //typedef typename SafrasAlgorithm<NBA_t>::state_t key_t; //<safra_t,DRA_t, StateMapperFuzzy<result_t, key_t, typename DRA_t::state_type, SafraTreeCandidateMatcher> > NBA2DA nba2da_fuzzy = new NBA2DA(_detailed_states); nba2da_fuzzy.convert(safras_algo, dra_result, limit); } }
//trueloop_check=true,bool detailed_states=false public static DA calculateUnion(DRA dra1, DRA dra2, bool trueloop_check) { return calculateUnion(dra1, dra2, trueloop_check, false); }
public static void dba2dra(NBA nba, DRA dra_result, bool complement) { //complement=false DRA dra = dra_result; APSet ap_set = dra.getAPSet();; dra.acceptance().newAcceptancePair(); for (int i = 0; i < nba.size(); i++) { dra.newState(); if (complement) { // Final states -> U_0, all states -> L_0 if (nba[i].isFinal()) { dra.acceptance().stateIn_U(0, i); } dra.acceptance().stateIn_L(0, i); } else { // Final states -> L_0, U_0 is empty if (nba[i].isFinal()) { dra.acceptance().stateIn_L(0, i); } } } if (nba.getStartState() != null) { dra.setStartState(dra[nba.getStartState().getName()]); } DA_State sink_state = null; for (int i = 0; i < nba.size(); i++) { NBA_State nba_state = nba[i]; DA_State dra_from = dra[i]; //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end(); ++label) for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { BitSet to = nba_state.getEdge(new APElement(label)); int to_cardinality = 0; if (to != null) { to_cardinality = to.cardinality(); } DA_State dra_to = null; if (to == null || to_cardinality == 0) { // empty to -> go to sink state if (sink_state == null) { // we have to create the sink sink_state = dra.newState(); // if we complement, we have to add the sink to // L_0 if (complement) { sink_state.acceptance().addTo_L(0); } } dra_to = sink_state; } else if (to_cardinality == 1) { int to_index = to.nextSetBit(0); // std::cerr << "to: " << to_index << std::endl; dra_to = dra[to_index]; } else { // to_cardinality>1 ! throw new IllegalArgumentException("NBA is no DBA!"); } dra_from.edges().addEdge(new APElement(label), dra_to); } } if (sink_state != null) { // there is a sink state // make true-loop from sink state to itself //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end();++label) { for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { sink_state.edges().addEdge(new APElement(label), sink_state); } } }
//trueloop_check=true,bool detailed_states=false public static DA calculateUnion(DRA dra1, DRA dra2, bool trueloop_check) { return(calculateUnion(dra1, dra2, trueloop_check, false)); }
public override void Initialize(SpecificationBase spec) { ltl2ba.Node LTLHeadNode; switch (ConstraintType) { case QueryConstraintType.PROB: //create the DRA from the BA LTLHeadNode = LTL2BA.ParseLTL("!(" + this.LTLString + ")", "", new CommonToken(0, "")); NegativeDRA = BA2DRAConverter.ConvertBA2DRA(BA, LTLHeadNode); NegativeDRA.DeclarationDatabase = BA.DeclarationDatabase; //todo: builf the positve DRA too //create the DRA from the BA LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, "")); PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode); PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase; break; case QueryConstraintType.PMAX: //create the DRA from the BA LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, "")); PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode); PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase; break; case QueryConstraintType.PMIN: //create the DRA from the BA if(AlmostFair)//note add by ssz { LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, "")); PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode); PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase; } else { LTLHeadNode = LTL2BA.ParseLTL("!(" + this.LTLString + ")", "", new CommonToken(0, "")); NegativeDRA = BA2DRAConverter.ConvertBA2DRA(BA, LTLHeadNode); NegativeDRA.DeclarationDatabase = BA.DeclarationDatabase; } break; } if (ConstraintType == QueryConstraintType.NONE) { base.Initialize(spec); } else { //initialize model checking options ModelCheckingOptions = new ModelCheckingOptions(); List<string> LTLEngine = new List<string>(); LTLEngine.Add(Constants.ENGINE_MDP_SEARCH); #if DEBUG LTLEngine.Add(Constants.ENGINE_MDP_MEC_SEARCH); LTLEngine.Add(Constants.ENGINE_MDP_SIM_SEARCH); #endif ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, LTLEngine); } }
/** * Generate a new DRA from a coloring */ DRA generateDRAfromColoring(DRA oldDRA, Coloring coloring, bool detailedStates) { DRA newDRA = oldDRA.createInstance(oldDRA.getAPSet()) as DRA; newDRA.acceptance().newAcceptancePairs(oldDRA.acceptance().size()); for (int color = 0; color < coloring.countColors(); ++color) { newDRA.newState(); } int old_start_state = oldDRA.getStartState().getName(); int start_state_color = coloring.state2color(old_start_state); newDRA.setStartState(newDRA.get(start_state_color)); APSet apset = newDRA.getAPSet(); for (int color = 0; color < coloring.countColors(); ++color) { DA_State new_state = newDRA.get(color); int old_state_representative = coloring.color2state(color); DA_State old_state = oldDRA[old_state_representative]; if (detailedStates) { BitSet old_states = coloring.color2states(color); // create new description... if (old_states.cardinality() == 1) { if (old_state.hasDescription()) { new_state.setDescription(old_state.getDescription()); } } else { //std::ostringstream s; //s << "<TABLE BORDER=\"1\" CELLBORDER=\"0\"><TR><TD>{</TD>"; StringBuilder s = new StringBuilder(@"<TABLE BORDER=\""1\"" CELLBORDER=\""0\""><TR><TD>{</TD>"); bool first = true; for (int it = BitSetIterator.start(old_states); it != BitSetIterator.end(old_states); it = BitSetIterator.increment(old_states, it)) { if (first) { first = false; } else { s.Append("<TD>,</TD>"); } s.Append("<TD>"); if (!oldDRA[it].hasDescription()) { s.Append(it); } else { s.Append(oldDRA[it].getDescription()); } s.Append("</TD>"); } s.Append("<TD>}</TD></TR></TABLE>"); new_state.setDescription(s.ToString()); ; } } // Create appropriate acceptance conditions int old_state_index = old_state.getName(); for (int i = 0; i < oldDRA.acceptance().size(); ++i) { if (oldDRA.acceptance().isStateInAcceptance_L(i, old_state_index)) { new_state.acceptance().addTo_L(i); } if (oldDRA.acceptance().isStateInAcceptance_U(i, old_state_index)) { new_state.acceptance().addTo_U(i); } } //for (APSet::element_iterator label=apset.all_elements_begin();label!=apset.all_elements_end();++label) for (int label = apset.all_elements_begin(); label != apset.all_elements_end(); ++label) { DA_State old_to = old_state.edges().get(new APElement(label)); int to_color = coloring.state2color(old_to.getName()); new_state.edges().addEdge(new APElement(label), newDRA.get(to_color)); } } return(newDRA); }
/** * Convert an NBA to an DRA (having APElements as edge labels). * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DRA than the limit. * @param nba the NBA * @param dra_result the DRA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ //template < typename NBA_t, typename DRA_t> public void convert(NBA nba, DRA dra_result) //=0 { convert(nba, dra_result, 0); }
/// <summary> /// Run the verification and get the result. /// </summary> /// <returns></returns> public override void RunVerification() { if (ConstraintType == QueryConstraintType.NONE) { base.RunVerification(); return; } if (IsSafety) { RunVerificationSafety(); return; } if (!IsNegateLiveness) { RunVerificationNegate(); return; } if (SelectedEngineName == Constants.ENGINE_MDP_SEARCH) { switch (ConstraintType) { case QueryConstraintType.PROB: DRA = NegativeDRA; BuildMDP(); //note this function is just used to calculate the maximal probability. Min = 1 - mdp.MaxProbability(VerificationOutput); DRA = PositiveDRA; BuildMDP(); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMAX: DRA = PositiveDRA; BuildMDP(); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMIN: if (AlmostFair) //note add by ssz { DRA = PositiveDRA; BuildMDP(); Min = mdp.MinProbability(VerificationOutput); } else { DRA = NegativeDRA; BuildMDP(); Min = 1 - mdp.MaxProbability(VerificationOutput); } break; } } else if (SelectedEngineName == Constants.ENGINE_MDP_MEC_SEARCH) { switch (ConstraintType) { case QueryConstraintType.PROB: DRA = NegativeDRA; BuildMD_ImprovedTarjan(); //note this function is just used to calculate the maximal probability. Min = 1 - mdp.MaxProbability(VerificationOutput); DRA = PositiveDRA; BuildMD_ImprovedTarjan(); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMAX: DRA = PositiveDRA; //BuildMDP(); BuildMD_ImprovedTarjan(); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMIN: if (AlmostFair) //note add by ssz { DRA = PositiveDRA; BuildMD_ImprovedTarjan(); Min = mdp.MinProbability(VerificationOutput); } else { DRA = NegativeDRA; BuildMD_ImprovedTarjan(); Min = 1 - mdp.MaxProbability(VerificationOutput); } break; } } else if (SelectedEngineName == Constants.ENGINE_MDP_SIM_SEARCH) { switch (ConstraintType) { case QueryConstraintType.PROB: DRA = NegativeDRA; BuildMDP(); //note this function is just used to calculate the maximal probability. mdp = mdp.ComputeGCPP(VerificationOutput); Min = 1 - mdp.MaxProbability(VerificationOutput); DRA = PositiveDRA; BuildMDP(); mdp = mdp.ComputeGCPP(VerificationOutput); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMAX: DRA = PositiveDRA; BuildMDP(); mdp = mdp.ComputeGCPP(VerificationOutput); Max = mdp.MaxProbability(VerificationOutput); break; case QueryConstraintType.PMIN: if (AlmostFair) //note add by ssz { DRA = PositiveDRA; BuildMDP(); mdp = mdp.ComputeGCPP(VerificationOutput); Min = mdp.MinProbability(VerificationOutput); } else { DRA = NegativeDRA; BuildMDP(); mdp = mdp.ComputeGCPP(VerificationOutput); Min = 1 - mdp.MaxProbability(VerificationOutput); } break; } } if (Min == 1) { VerificationOutput.VerificationResult = VerificationResultType.VALID; } else if (Max == 0) { VerificationOutput.VerificationResult = VerificationResultType.INVALID; } else { VerificationOutput.VerificationResult = VerificationResultType.WITHPROBABILITY; } }
/** Constructor */ public ColoredStateComparator(Coloring coloring, DRA dra) { _coloring = coloring; _dra = dra; }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(DAUnionAlgorithm algo, DRA da_result, int limit) { StateMapper <StateInterface, DA_State> state_mapper = new StateMapper <StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet(); if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; algo.prepareAcceptance(da_result.acceptance()); StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState(); start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack <KeyValuePair <StateInterface, DA_State> > unprocessed = new Stack <KeyValuePair <StateInterface, DA_State> >(); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair <StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key; DA_State from = top.Value; //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) { APElement elem = new APElement(it_elem); ResultStateInterface <UnionState> result = algo.delta(cur as UnionState, elem); DA_State to = state_mapper.find(result.getState()); if (to == null) { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to); if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(DAUnionAlgorithm algo, DRA da_result, int limit) { StateMapper<StateInterface, DA_State> state_mapper = new StateMapper<StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet(); if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; algo.prepareAcceptance(da_result.acceptance()); StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState(); start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack<KeyValuePair<StateInterface, DA_State>> unprocessed = new Stack<KeyValuePair<StateInterface, DA_State>>(); unprocessed.Push(new KeyValuePair<StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair<StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key; DA_State from = top.Value; //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) { APElement elem = new APElement(it_elem); ResultStateInterface<UnionState> result = algo.delta(cur as UnionState, elem); DA_State to = state_mapper.find(result.getState()); if (to == null) { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair<StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to); if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(SafraAlgorithm algo, DRA da_result, int limit) { /** The hash map from DA_State to StateInterface */ StateMapper <StateInterface, DA_State> state_mapper = new StateMapper <StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet();////////////************where dose this dra have ap_set? if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; //* Creates new acceptance pairs according to da_result's acceptance. algo.prepareAcceptance(da_result.acceptance());////*********don't understand well StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState();/////************?? what is in this newState? start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack <KeyValuePair <StateInterface, DA_State> > unprocessed = new Stack <KeyValuePair <StateInterface, DA_State> >(); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair <StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key; //safratreeNode DA_State from = top.Value; //DA_state //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) ///from 0 to 2^ap_set.size { APElement elem = new APElement(it_elem); /////////set simpleBitset = it_elem ResultStateInterface <SafraTree> result = algo.delta(cur as SafraTree, elem); /////get a new safraTree through elem DA_State to = state_mapper.find(result.getState()); if (to == null)////////////////result is not in state mapper. { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair <StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to);//////////////add this edge. if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
/** * Generate a DA using the Algorithm * Throws LimitReachedException if a limit is set (>0) and * there are more states in the generated DA than the limit. * @param algo the algorithm * @param da_result the DA where the result is stored * (has to have same APSet as the nba) * @param limit a limit for the number of states (0 disables the limit). */ public void convert(SafraAlgorithm algo, DRA da_result, int limit) { /** The hash map from DA_State to StateInterface */ StateMapper<StateInterface, DA_State> state_mapper = new StateMapper<StateInterface, DA_State>(); APSet ap_set = da_result.getAPSet();////////////************where dose this dra have ap_set? if (algo.checkEmpty()) { da_result.constructEmpty(); return; } //typedef typename DA_t::state_type da_state_t; //typedef typename Algorithm_t::state_t algo_state_t; //typedef typename Algorithm_t::result_t algo_result_t; //* Creates new acceptance pairs according to da_result's acceptance. algo.prepareAcceptance(da_result.acceptance());////*********don't understand well StateInterface start = algo.getStartState(); DA_State start_state = da_result.newState();/////************?? what is in this newState? start.generateAcceptance(start_state.acceptance()); if (_detailed_states) { start_state.setDescription(start.toHTML()); } state_mapper.add(start, start_state); da_result.setStartState(start_state); //typedef std::pair<algo_state_t, da_state_t*> unprocessed_value; Stack<KeyValuePair<StateInterface, DA_State>> unprocessed = new Stack<KeyValuePair<StateInterface, DA_State>>(); unprocessed.Push(new KeyValuePair<StateInterface, DA_State>(start, start_state)); while (unprocessed.Count > 0) { KeyValuePair<StateInterface, DA_State> top = unprocessed.Pop(); //unprocessed.pop(); StateInterface cur = top.Key;//safratreeNode DA_State from = top.Value;//DA_state //for (APSet::element_iterator it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem) for (int it_elem = ap_set.all_elements_begin(); it_elem != ap_set.all_elements_end(); ++it_elem)///from 0 to 2^ap_set.size { APElement elem = new APElement(it_elem);/////////set simpleBitset = it_elem ResultStateInterface<SafraTree> result = algo.delta(cur as SafraTree, elem);/////get a new safraTree through elem DA_State to = state_mapper.find(result.getState()); if (to == null)////////////////result is not in state mapper. { to = da_result.newState(); result.getState().generateAcceptance(to.acceptance()); if (_detailed_states) { to.setDescription(result.getState().toHTML()); } state_mapper.add(result.getState(), to); unprocessed.Push(new KeyValuePair<StateInterface, DA_State>(result.getState(), to)); } from.edges().set(elem, to);//////////////add this edge. if (limit != 0 && da_result.size() > limit) { throw new LimitReachedException(""); } } } }
/** * Internal helper function to perform the conversion from NBA to DRA. * @param nba the NBA (has to be deterministic) * @param dra_result the DRA into which the converted automaton is saved * @param complement complement the DBA? */ public static void dba2dra(NBA nba, DRA dra_result) { dba2dra(nba, dra_result, false); }
/** The output format */ //enum {OUT_v2, OUT_NBA, OUT_DOT, OUT_PLUGIN} flag_output; public static DRA ConvertBA2DRA(BuchiAutomata BA, Node LTLHeadNode) { /** Flag: Convert LTL->DRA->NBA? */ //bool flag_dra2nba; /** Flag: Print the NBA afert LTL->NBA? */ //bool flag_print_ltl_nba; /** Flag: Use limiting with scheduler? */ bool flag_sched_limits; /** The limiting factor for the scheduler (alpha) */ double alpha; /** The options for Safra's algorithm */ Options_Safra opt_safra = new Options_Safra(); /** The options for LTL2DSTAR */ LTL2DSTAR_Options opt_ltl2dstar = new LTL2DSTAR_Options(); opt_ltl2dstar.opt_safra = opt_safra; // std::map<std::string, std::string> defaults; //defaults["--ltl2nba"]="--ltl2nba=spin:ltl2ba"; //defaults["--automata"]="--automata=rabin"; //defaults["--output"]="--output=automaton"; //defaults["--detailed-states"]="--detailed-states=no"; //defaults["--safra"]="--safra=all"; //defaults["--bisimulation"]="--bisimulation=yes"; //defaults["--opt-acceptance"]="--opt-acceptance=yes"; //defaults["--union"]="--union=yes"; //defaults["--alpha"]="--alpha=10.0"; //defaults["--stutter"]="--stutter=yes"; //defaults["--partial-stutter"]="--partial-stutter=no"; //// defaults["--scheck"]=""; // scheck disabled /// /// // default values... //flag_dra2nba = false; flag_sched_limits = false; alpha = 1.0; // options not yet covered //flag_print_ltl_nba = false; //flag_stat_nba = false; //if (isRabin) //{ opt_ltl2dstar.automata = automata_type.RABIN; //} //else //{ // opt_ltl2dstar.automata = automata_type.STREETT; //} opt_safra.opt_all(); opt_safra.stutter = false; opt_ltl2dstar.bisim = false; opt_safra.opt_rename = false; LTLFormula ltl = LTLPrefixParser.parse(LTLHeadNode); //APSet ap_set = ltl.getAPSet(); //Debug.Assert(ltl2nba != null); LTL2DRA ltl2dra = new LTL2DRA(opt_safra); //, ltl2nba.get() //if (opt_ltl2dstar.automata == automata_type.ORIGINAL_NBA) //{ // // We just generate the NBA for the LTL formula // // and print it // NBA nba = ltl2dra.ltl2nba(ltl); // if (nba == null) // { // throw new Exception("Can't generate NBA for LTL formula"); // } // //if (flag_output==OUT_DOT) { // // nba->print_dot(out); // //} else { // // nba->print_lbtt(out); // //} // //return 0; //} LTL2DSTAR_Scheduler ltl2dstar_sched = new LTL2DSTAR_Scheduler(ltl2dra, flag_sched_limits, alpha); //ltl2dstar_sched.flagStatNBA(flag_stat_nba); ltl2dstar_sched.flagStatNBA(false); opt_ltl2dstar.opt_safra = opt_safra; DRA dra = ltl2dstar_sched.calculate(ltl, BA, opt_ltl2dstar); //if (!dra.isCompact()) { // dra.makeCompact(); //} if (dra == null) { throw new Exception("Couldn't generate DRA!"); } //if (!dra.isCompact()) { // dra.makeCompact(); //} return(dra); }
/** * Convert an LTL formula to a DRA. * @param ltl the LTL formula * @param options which operators are allowed * @return a shared_ptr to the DRA */ private DRA ltl2dra(LTLFormula ltl, BuchiAutomata buchiAutomata, LTL2DSTAR_Options options) { APSet ap_set = ltl.getAPSet(); LTLFormula ltl_pnf = ltl.toPNF(); if (options.allow_union && ltl_pnf.getRootNode().getType() == type_t.T_OR) { LTLFormula ltl_left = ltl_pnf.getSubFormula(ltl_pnf.getRootNode().getLeft()); LTLFormula ltl_right = ltl_pnf.getSubFormula(ltl_pnf.getRootNode().getRight()); LTL2DSTAR_Options rec_opt = options; rec_opt.recursion(); DRA dra_left = ltl2dra(ltl_left, buchiAutomata, rec_opt); DRA dra_right = ltl2dra(ltl_right,buchiAutomata, rec_opt); return DRA.calculateUnion(dra_left, dra_right, _safra_opt.union_trueloop) as DRA; } if (options.safety) { LTLSafetyAutomata lsa = new LTLSafetyAutomata(); DRA safety_dra = lsa.ltl2dra(ltl, buchiAutomata); if (safety_dra != null) { return safety_dra; } } DRA dra = new DRA(ap_set); NBA nba = LTL2NBA.ltl2nba(ltl_pnf, buchiAutomata); if (nba == null) { throw new Exception("Couldn't create NBA from LTL formula"); } NBA2DRA nba2dra = new NBA2DRA(_safra_opt); nba2dra.convert(nba, dra); if (options.optimizeAcceptance) { dra.optimizeAcceptanceCondition(); } if (options.bisim) { DRAOptimizations dra_optimizer = new DRAOptimizations(); dra = dra_optimizer.optimizeBisimulation(dra); } return dra; }
/** Constructor */ public ColoredStateComparator(Coloring coloring, DRA dra) { _coloring = coloring; _dra = dra; }
/** * Generate a new DRA from a coloring */ DRA generateDRAfromColoring(DRA oldDRA, Coloring coloring, bool detailedStates) { DRA newDRA = oldDRA.createInstance(oldDRA.getAPSet()) as DRA; newDRA.acceptance().newAcceptancePairs(oldDRA.acceptance().size()); for (int color = 0; color < coloring.countColors(); ++color) { newDRA.newState(); } int old_start_state = oldDRA.getStartState().getName(); int start_state_color = coloring.state2color(old_start_state); newDRA.setStartState(newDRA.get(start_state_color)); APSet apset = newDRA.getAPSet(); for (int color = 0; color < coloring.countColors(); ++color) { DA_State new_state = newDRA.get(color); int old_state_representative = coloring.color2state(color); DA_State old_state = oldDRA[old_state_representative]; if (detailedStates) { BitSet old_states = coloring.color2states(color); // create new description... if (old_states.cardinality() == 1) { if (old_state.hasDescription()) { new_state.setDescription(old_state.getDescription()); } } else { //std::ostringstream s; //s << "<TABLE BORDER=\"1\" CELLBORDER=\"0\"><TR><TD>{</TD>"; StringBuilder s = new StringBuilder(@"<TABLE BORDER=\""1\"" CELLBORDER=\""0\""><TR><TD>{</TD>"); bool first = true; for (int it = BitSetIterator.start(old_states); it != BitSetIterator.end(old_states); it = BitSetIterator.increment(old_states, it)) { if (first) { first = false; } else { s.Append("<TD>,</TD>"); } s.Append("<TD>"); if (!oldDRA[it].hasDescription()) { s.Append(it); } else { s.Append(oldDRA[it].getDescription()); } s.Append("</TD>"); } s.Append("<TD>}</TD></TR></TABLE>"); new_state.setDescription(s.ToString()); ; } } // Create appropriate acceptance conditions int old_state_index = old_state.getName(); for (int i = 0; i < oldDRA.acceptance().size(); ++i) { if (oldDRA.acceptance().isStateInAcceptance_L(i, old_state_index)) { new_state.acceptance().addTo_L(i); } if (oldDRA.acceptance().isStateInAcceptance_U(i, old_state_index)) { new_state.acceptance().addTo_U(i); } } //for (APSet::element_iterator label=apset.all_elements_begin();label!=apset.all_elements_end();++label) for (int label = apset.all_elements_begin(); label != apset.all_elements_end(); ++label) { DA_State old_to = old_state.edges().get(new APElement(label)); int to_color = coloring.state2color(old_to.getName()); new_state.edges().addEdge(new APElement(label), newDRA.get(to_color)); } } return newDRA; }
/** * Internal helper function to perform the conversion from NBA to DRA. * @param nba the NBA (has to be deterministic) * @param dra_result the DRA into which the converted automaton is saved * @param complement complement the DBA? */ public static void dba2dra(NBA nba, DRA dra_result) { dba2dra(nba, dra_result, false); }
/** * Constructor, get initial size of the coloring from DRA. * @param dra the DRA * @param detailed Keep detailed information on the equivalence classes? */ public Coloring(DRA dra, bool detailed) //=false { _nr_of_colors = 0; _detailed = detailed; _coloring = new List<int>(); Ultility.resize(_coloring, dra.size()); _color2state = new List<int>(); //_coloring.resize(dra.size()); if (_detailed) { _color2states = new List<BitSet>(); } else { _color2states = null; } }
public static void dba2dra(NBA nba, DRA dra_result, bool complement) { //complement=false DRA dra = dra_result; APSet ap_set = dra.getAPSet(); ; dra.acceptance().newAcceptancePair(); for (int i = 0; i < nba.size(); i++) { dra.newState(); if (complement) { // Final states -> U_0, all states -> L_0 if (nba[i].isFinal()) { dra.acceptance().stateIn_U(0, i); } dra.acceptance().stateIn_L(0, i); } else { // Final states -> L_0, U_0 is empty if (nba[i].isFinal()) { dra.acceptance().stateIn_L(0, i); } } } if (nba.getStartState() != null) { dra.setStartState(dra[nba.getStartState().getName()]); } DA_State sink_state = null; for (int i = 0; i < nba.size(); i++) { NBA_State nba_state = nba[i]; DA_State dra_from = dra[i]; //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end(); ++label) for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { BitSet to = nba_state.getEdge(new APElement(label)); int to_cardinality = 0; if (to != null) { to_cardinality = to.cardinality(); } DA_State dra_to = null; if (to == null || to_cardinality == 0) { // empty to -> go to sink state if (sink_state == null) { // we have to create the sink sink_state = dra.newState(); // if we complement, we have to add the sink to // L_0 if (complement) { sink_state.acceptance().addTo_L(0); } } dra_to = sink_state; } else if (to_cardinality == 1) { int to_index = to.nextSetBit(0); // std::cerr << "to: " << to_index << std::endl; dra_to = dra[to_index]; } else { // to_cardinality>1 ! throw new IllegalArgumentException("NBA is no DBA!"); } dra_from.edges().addEdge(new APElement(label), dra_to); } } if (sink_state != null) { // there is a sink state // make true-loop from sink state to itself //for (APSet::element_iterator label=ap_set->all_elements_begin();label!=ap_set->all_elements_end();++label) { for (int label = ap_set.all_elements_begin(); label != ap_set.all_elements_end(); ++label) { sink_state.edges().addEdge(new APElement(label), sink_state); } } }
/** Type of an acceptance signature */ // public KeyValuePair<BitSet, BitSet> acceptance_signature_t; /** * Constructor, fills the container with the acceptance signatures of the states. * @param dra the DRA */ public AcceptanceSignatureContainer(DRA dra) { //_acceptancesig_vector.resize(dra.size()); _acceptancesig_vector = new List<KeyValuePair<BitSet, BitSet>>(); //Ultility.resize(_acceptancesig_vector, dra.size()); _bitsets = new List<BitSet>(); for (int i = 0; i < dra.size(); i++) { BitSet b = dra.acceptance().getAcceptance_L_forState(i); BitSet bp = new BitSet(b); _bitsets.Add(bp); //push_back // _acceptancesig_vector[i].Key = bp; b = dra.acceptance().getAcceptance_U_forState(i); BitSet bp1 = new BitSet(b); _bitsets.Add(bp1); // //_acceptancesig_vector[i].Value = bp1; _acceptancesig_vector.Add(new KeyValuePair<BitSet, BitSet>(bp, bp1)); } }
/** Calculate the automaton for this building block, by default * calculate the automata for the children and then choose the smallest. */ public virtual void calculate(int level, int limit) { //if (_options.verbose_scheduler) { // std::cerr << "Calculate ("<< level <<"): " << typeid(*this).name() << std::endl; //} calculateChildren(level, limit); bool first = true; //for (child_vector::iterator it=children.begin();it!=children.end();++it) for (int i = 0; i < children.Count; i++) { LTL2DSTAR_Tree it = children[i]; if (it._automaton == null) { continue; } if (first) { _automaton = it._automaton; _comment = it._comment; } else { if (_automaton.size() > it._automaton.size()) { _automaton = it._automaton; _comment = it._comment; } } first = false; } hook_after_calculate(); }