std::vector<item> json_item_substitution::get_substitution( const item &it, const std::vector<trait_id> &traits ) const { auto iter = substitutions.find( it.typeId() ); std::vector<item> ret; if( iter == substitutions.end() ) { for( const item &con : it.contents ) { const auto sub = get_substitution( con, traits ); ret.insert( ret.end(), sub.begin(), sub.end() ); } return ret; } const auto sub = std::find_if( iter->second.begin(), iter->second.end(), [&traits]( const substitution & s ) { return s.trait_reqs.meets_condition( traits ); } ); if( sub == iter->second.end() ) { return ret; } const long old_amt = it.count_by_charges() ? it.charges : 1l; for( const substitution::info &inf : sub->infos ) { item result( inf.new_item ); const long new_amt = std::max( 1l, ( long )std::round( inf.ratio * old_amt ) ); if( !result.count_by_charges() ) { for( long i = 0; i < new_amt; i++ ) { ret.push_back( result.in_its_container() ); } } else { result.mod_charges( -result.charges + new_amt ); while( result.charges > 0 ) { const item pushed = result.in_its_container(); ret.push_back( pushed ); result.mod_charges( pushed.contents.empty() ? -pushed.charges : -pushed.contents.back().charges ); } } } return ret; }
BDD Synth::get_nondet_strategy() { /** Get non-deterministic strategy from the winning region. If the system outputs controllable values that satisfy this non-deterministic strategy, then the system wins. I.e., a non-deterministic strategy describes for each state all possible plausible output values (below is assuming W excludes error states) strategy(t,u,c) = ∃t' W(t) & T(t,i,c,t') & W(t') But since t' <-> bdd(t,i,o), (and since we use error=error(t,u,c)), we use: strategy(t,u,c) = ~error(t,u,c) & W(t) & W(t)[t <- bdd_next_t(t,u,c)] :return: non-deterministic strategy bdd :note: The strategy is non-deterministic -- determinization is done later. **/ L_INF("get_nondet_strategy.."); // TODO: do we need win_region? return ~error & win_region & win_region.VectorCompose(get_substitution()); }
BDD Synth::pre_sys(BDD dst) { /** Calculate predecessor states of given states. ∀u ∃c ∃t': tau(t,u,c,t') & dst(t') & ~error(t,u,c) We use the direct substitution optimization (since t' <-> BDD(t,u,c)), thus: ∀u ∃c: (!error(t,u,c) & (dst(t)[t <- bdd_next_t(t,u,c)])) or for Moore machines: ∃c ∀u: (!error(t,u,c) & (dst(t)[t <- bdd_next_t(t,u,c)])) Note that we do not replace t variables in the error bdd. :return: BDD of the predecessor states **/ // NOTE: I tried considering two special cases: error(t,u,c) and error(t), // and move error(t) outside of quantification ∀u ∃c. // It slowed down.. // TODO: try again: on the driver example static vector<VecUint> orders; static bool did_grouping = false; if (!did_grouping && timer.sec_from_origin() > time_limit_sec/4) { // at 0.25*time_limit we fix the order do_grouping(cudd, orders); did_grouping = true; } dst = dst.VectorCompose(get_substitution()); update_order_if(cudd, orders); if (is_moore) { BDD result = dst.And(~error); vector<BDD> uncontrollable = get_uncontrollable_vars_bdds(); if (!uncontrollable.empty()) { BDD uncontrollable_cube = cudd.bddComputeCube(uncontrollable.data(), NULL, (int)uncontrollable.size()); result = result.UnivAbstract(uncontrollable_cube); update_order_if(cudd, orders); } // ∃c ∀u (...) vector<BDD> controllable = get_controllable_vars_bdds(); BDD controllable_cube = cudd.bddComputeCube(controllable.data(), NULL, (int)controllable.size()); result = result.ExistAbstract(controllable_cube); update_order_if(cudd, orders); return result; } // the case of Mealy machines vector<BDD> controllable = get_controllable_vars_bdds(); BDD controllable_cube = cudd.bddComputeCube(controllable.data(), NULL, (int)controllable.size()); BDD result = dst.AndAbstract(~error, controllable_cube); update_order_if(cudd, orders); vector<BDD> uncontrollable = get_uncontrollable_vars_bdds(); if (!uncontrollable.empty()) { // ∀u ∃c (...) BDD uncontrollable_cube = cudd.bddComputeCube(uncontrollable.data(), NULL, (int)uncontrollable.size()); result = result.UnivAbstract(uncontrollable_cube); update_order_if(cudd, orders); } return result; }