simulation: Add simulation based reduction

* spot/twaalgos/simulation.hh, spot/twaalgos/simulation.cc: Add
  reduce_direct_sim(), reduce_direct_cosim() and
  reduce_direct_iterated() wich reduce an automaton using simulation.
  This functions wrap the class direct_sim wich compute simulation
  with a new method.
* doc/spot.bib: Add ref.
* tests/python/simstate.py: Add tests for the new simulation.

doc/spot.bib

@@ -169,6 +169,15 @@
   doi		= {10.1109/TCAD.2008.2003303}
 }
 
+@article{   clemente.2.17.corr,
+  author    = {Lorenzo Clemente and Richard Mayr},
+  title     = {Efficient reduction of nondeterministic automata with application
+               to language inclusion testing},
+  journal   = {CoRR},
+  volume    = {abs/1711.09946},
+  year      = {2017},
+}
+
 @Article{	  courcoubetis.92.fmsd,
   author	= {Costas Courcoubetis and Moshe Y. Vardi and Pierre Wolper
 		  and Mihalis Yannakakis},

spot/twaalgos/simulation.cc

@@ -956,4 +956,586 @@ namespace spot
     return wrap_simul(iterated_simulations_<true>, t);
   }
 
+  template <bool Cosimulation, bool Sba>
+  class reduce_sim
+  {
+  public:
+    reduce_sim(const const_twa_graph_ptr& aut);
+
+    twa_graph_ptr run();
+
+  private:
+    // If aut_ is deterministic, only the lower left triangle is set.
+    std::vector<bool> compute_simulation();
+
+    const_twa_graph_ptr aut_;
+    const_twa_graph_ptr original_;
+
+    // Only use if Sba && Cosimulation
+    std::vector<acc_cond::mark_t> acc_;
+  };
+
+  template <bool Cosimulation, bool Sba>
+  reduce_sim<Cosimulation, Sba>::reduce_sim(const const_twa_graph_ptr& aut)
+    : original_(aut)
+  {
+    unsigned n = aut->num_states();
+
+    twa_graph_ptr a = make_twa_graph(aut->get_dict());
+    a->copy_ap_of(aut);
+    a->new_states(n);
+    a->set_init_state(aut->get_init_state_number());
+
+    // Whether we simulate or cosimulate, we transform the acceptance into all
+    // fin. If we cosimulate, we also reverse all the edges.
+    const auto all_inf = aut->get_acceptance().used_inf_fin_sets().first;
+
+    for (unsigned s = 0; s < n; ++s)
+      for (const auto& e : aut->out(s))
+        if (Cosimulation)
+          a->new_edge(e.dst, e.src, e.cond, e.acc ^ all_inf);
+        else
+          a->new_edge(e.src, e.dst, e.cond, e.acc ^ all_inf);
+
+    if (!Sba)
+      {
+        bool state_acc = true;
+
+        // common_out[i] is the set of acceptance set numbers common to
+        // all outgoing edges of state i.
+        std::vector<acc_cond::mark_t> common_out(n);
+        for (unsigned s = 0; s < n; ++s)
+          {
+            bool first = true;
+            for (auto& e : a->out(s))
+              if (first)
+                {
+                  common_out[s] = e.acc;
+                  first = false;
+                }
+              else if (common_out[s] != e.acc)
+                {
+                  state_acc = false;
+                  break;
+                }
+
+            if (!state_acc)
+              break;
+          }
+
+      // Pull the common outgoing sets to the incoming
+      // edges.  Doing so seems to favor cases where states
+      // can be merged.
+      if (state_acc)
+        for (auto& e : a->edges())
+          e.acc = (e.acc - common_out[e.src]) | common_out[e.dst];
+      }
+
+    if (Sba && Cosimulation)
+      {
+        acc_.reserve(n);
+        for (unsigned s = 0; s < n; ++s)
+          acc_.push_back(original_->state_acc_sets(s) ^ all_inf);
+      }
+
+    aut_ = std::move(a);
+  }
+
+  template <bool Cosimulation, bool Sba>
+  std::vector<bool> reduce_sim<Cosimulation, Sba>::compute_simulation()
+  {
+    // At the start, we consider that all the pairs of vertices are simulating
+    // each other. At each iteration we detect which ones are not simulating
+    // and we remove them from the set. This information propagate backwards,
+    // so we only need to check the peers whose successors were updated in the
+    // previous iteration. To limit the number of iterations, we update them in
+    // reverse topological order.
+
+    const size_t n = aut_->num_states();
+    const bool only_bisimu = is_deterministic(aut_);
+
+    // We need to have the predecessors of a state for the backward propagation.
+    digraph<void, void> reverse(n, aut_->num_edges());
+    reverse.new_states(n);
+
+    for (unsigned s = 0; s < n; ++s)
+      for (const auto& e : aut_->out(s))
+        reverse.new_edge(e.dst, e.src);
+
+    reverse.sort_edges_([](const auto& e1, const auto& e2)
+        {
+          if (e1.src != e2.src)
+            return e1.src < e2.src;
+          return e1.dst < e2.dst;
+        });
+
+    // Remove all duplicates.
+    auto& edges = reverse.edge_vector();
+    edges.erase(std::unique(edges.begin() + 1, edges.end()), edges.end());
+    reverse.chain_edges_();
+
+    // Compute a reverse topological order for all the states. So that the
+    // algorithm iterates as few times as possible, we must update all the
+    // successors of a state before updating it.
+    std::vector<unsigned> order(n, 0);
+    std::vector<unsigned> todo;
+    todo.reserve(n);
+
+    unsigned init = aut_->get_init_state_number();
+
+    {
+      unsigned i = Cosimulation ? 0 : n - 1;
+      std::vector<bool> seen(n, false);
+      todo.push_back(init);
+      seen[init] = true;
+      while (!todo.empty())
+        {
+          unsigned cur = todo.back();
+          todo.pop_back();
+          order[i] = cur;
+          i += Cosimulation ? 1 : -1;
+
+          for (const auto& e : original_->out(cur))
+            {
+              if (!seen[e.dst])
+                {
+                  seen[e.dst] = true;
+                  todo.push_back(e.dst);
+                }
+            }
+          }
+    }
+
+    std::vector<bool> can_sim(n * n, true);
+
+    // Test if s1 simulates s2.
+    const auto test_sim = [&](size_t s1, size_t s2) -> bool
+      {
+        auto s_edges = aut_->out(s1);
+        auto d_edges = aut_->out(s2);
+
+        // s1 simulates s2 only if for all the edges of s2 there is an edges s1
+        // with compatible condition, acceptance and the destinations simulate
+        // each other.
+        return std::all_of(s_edges.begin(), s_edges.end(),
+          [&](const auto& s_edge) -> bool
+            {
+              size_t i = static_cast<size_t>(s_edge.dst) * n;
+
+              return std::find_if(d_edges.begin(), d_edges.end(),
+                [&](const auto& d_edge) -> bool
+                  {
+                    // Checks if the destinations of the spoiler simulates the
+                    // duplicator.
+                    if (!can_sim[i + static_cast<size_t>(d_edge.dst)])
+                      return false;
+
+                    if (Sba && Cosimulation)
+                      {
+                        if (!(acc_[d_edge.src]).subset(acc_[s_edge.src]))
+                        return false;
+                      }
+                    else
+                      {
+                        if (!(d_edge.acc).subset(s_edge.acc))
+                          return false;
+                      }
+
+                    if (Cosimulation)
+                      {
+                        if (s_edge.dst == init && d_edge.dst != init)
+                          return false;
+                      }
+
+                    return bdd_implies(s_edge.cond, d_edge.cond);
+                  });
+            });
+      };
+
+    todo.resize(n, true);
+
+    bool has_changed;
+    do
+      {
+        has_changed = false;
+        for (unsigned i : order)
+          {
+            if (!todo[i])
+              continue;
+
+            todo[i] = false;
+
+            // Update all the predecessors that changed on last turn.
+            for (const auto& re : reverse.out(i))
+              {
+                size_t u = re.dst;
+                size_t idx = u * n;
+
+                if (only_bisimu)
+                  {
+                    // If the automaton is deterministic, compute only the
+                    // bisimulation.
+                    for (size_t v = 0; v < u; ++v)
+                      {
+                        // u doesn't simulate v
+                        if (!can_sim[idx + v])
+                          continue;
+
+                        if (!test_sim(u, v) || !test_sim(v, u))
+                          {
+                            can_sim[u * n + v] = false;
+                            has_changed = true;
+                            todo[u] = true;
+                            todo[v] = true;
+                          }
+                      }
+                  }
+                else
+                  {
+                    for (unsigned v = 0; v < n; ++v)
+                      {
+                        // u doesn't simulate v
+                        if (!can_sim[idx + v])
+                          continue;
+
+                        if (!test_sim(u, v))
+                          {
+                            can_sim[idx + v] = false;
+                            has_changed = true;
+                            todo[u] = true;
+                          }
+                      }
+                  }
+              }
+          }
+      }
+    while (has_changed);
+
+    if (Cosimulation)
+      {
+        if (!aut_->out(init).begin())
+          {
+            for (unsigned i = 0; i < n; ++i)
+              {
+                can_sim[i * n + init] = i == init;
+                can_sim[init * n + i] = false;
+              }
+          }
+        else
+          for (unsigned i = 0; i < n; ++i)
+            {
+              // i doesn't simulate init
+              can_sim[i * n + init] = i == init;
+            }
+      }
+
+    return can_sim;
+  }
+
+
+  template <bool Cosimulation, bool Sba>
+  twa_graph_ptr reduce_sim<Cosimulation, Sba>::run()
+  {
+    std::vector<bool> can_sim = compute_simulation();
+
+    twa_graph_ptr res = std::make_shared<twa_graph>(original_->get_dict());
+    res->copy_ap_of(original_);
+    res->copy_acceptance_of(original_);
+
+    twa_graph_ptr no_mark = std::make_shared<twa_graph>(original_->get_dict());
+    no_mark->copy_ap_of(original_);
+    no_mark->copy_acceptance_of(original_);
+
+    unsigned init = original_->get_init_state_number();
+
+    size_t n = original_->num_states();
+    std::vector<unsigned> equiv_states(n);
+
+    // If the automaton is deterministic, there is no simple simulation only
+    // bisimulation.
+    bool is_deter = is_deterministic(original_);
+
+    // The number of states in the reduced automaton.
+    // There is at least an initial state.
+    unsigned nr = 1;
+    equiv_states[0] = 0;
+
+    std::vector<unsigned> old;
+    old.reserve(n);
+    old.push_back(0);
+
+    // If two states bisimulate each other, they will be the same state in the
+    // reduced automaton.
+    for (size_t i = 1; i < n; ++i)
+      {
+        bool found = false;
+
+        size_t j = 0;
+        for (; j < i; ++j)
+          {
+            if (can_sim[i * n + j] && (is_deter || can_sim[j * n + i]))
+              {
+                equiv_states[i] = equiv_states[j];
+                found = true;
+                break;
+              }
+          }
+
+        if (!found)
+          {
+            equiv_states[i] = nr++;
+            old.push_back(i);
+          }
+      }
+    res->new_states(nr);
+    no_mark->new_states(nr);
+
+    const auto& gr = aut_->get_graph();
+
+    // Test if the language recognized by taking e1 is included in e2 (in this
+    // case e2 dominates e1).
+    const auto dominates_edge = [&](const auto& e2)
+      {
+        return [&](const auto& e1) -> bool
+          {
+            if (Cosimulation && e2.dst == init && e1.dst != init)
+              return false;
+
+            if (Sba && Cosimulation)
+              {
+                if (!(acc_[e1.src]).subset(acc_[e2.src]))
+                  return false;
+              }
+            else
+              {
+                if (!(e1.acc).subset(e2.acc))
+                  return false;
+              }
+
+            // e1.dst simulates e2.dst
+            return can_sim[e2.dst * n + e1.dst]
+              // if e2.dst also simulates e1.dst, the edge with the higher
+              // index is the dominator (this is arbitrary, but without that
+              // we would remove both edges)
+              && (!can_sim[e1.dst * n + e2.dst]
+                  || gr.index_of_edge(e1) > gr.index_of_edge(e2))
+              // of course the condition of e2 should implies that of e1, but
+              // this we test this last because it is slow.
+              && bdd_implies(e2.cond, e1.cond);
+          };
+      };
+
+    const auto all_inf = original_->get_acceptance().used_inf_fin_sets().first;
+    for (unsigned i = 0; i < nr; ++i)
+      {
+        auto out = aut_->out(old[i]);
+
+        for (const auto& e : out)
+          {
+            // If the language recognized by taking e is include in the
+            // language of an other edge, we don't want to add it.
+            // If the automaton is deterministic, this cannot happen since no
+            // simple simulation are possible.
+            if (is_deter
+                || std::none_of(out.begin(), out.end(), dominates_edge(e)))
+              {
+                auto acc = e.acc ^ all_inf;
+                if (Cosimulation)
+                  res->new_edge(equiv_states[e.dst], i, e.cond, acc);
+                else
+                  res->new_edge(i, equiv_states[e.dst], e.cond, acc);
+
+                no_mark->new_edge(i, equiv_states[e.dst], e.cond);
+              }
+          }
+      }
+
+    res->set_init_state(equiv_states[init]);
+    no_mark->set_init_state(equiv_states[init]);
+    no_mark->merge_edges();
+
+    scc_info si_no_mark(no_mark, scc_info_options::NONE);
+    unsigned nscc = si_no_mark.scc_count();
+
+    std::vector<unsigned> redirect(no_mark->num_states());
+    std::iota(redirect.begin(), redirect.end(), 0);
+
+    // Same as in compute_simulation(), but since we are between two sccs, we
+    // can ignore the colors.
+    const auto test_sim = [&](size_t s1, size_t s2) -> bool
+      {
+        auto s_edges = no_mark->out(s1);
+        auto d_edges = no_mark->out(s2);
+
+        return std::all_of(s_edges.begin(), s_edges.end(),
+          [&](const auto& s_edge) -> bool
+            {
+              size_t idx = static_cast<size_t>(old[s_edge.dst]) * n;
+
+              return std::find_if(d_edges.begin(), d_edges.end(),
+                [&](const auto& d_edge) -> bool
+                  {
+                    if (!can_sim[idx + static_cast<size_t>(old[d_edge.dst])])
+                      return false;
+
+                    return bdd_implies(s_edge.cond, d_edge.cond);
+                  });
+            });
+      };
+
+    // Attempt to merge trivial sccs.
+    for (unsigned scc = 0; scc < nscc; ++scc)
+      {
+        if (!si_no_mark.is_trivial(scc))
+          continue;
+
+        unsigned s = si_no_mark.one_state_of(scc);
+
+        for (unsigned i = 0; i < nr; ++i)
+          {
+            if (si_no_mark.reachable_state(i)
+                && !si_no_mark.is_trivial(si_no_mark.scc_of(i)))
+              {
+                if (test_sim(i, s) && test_sim(s, i))
+                  {
+                    can_sim[old[i] * n + old[s]] = true;
+                    can_sim[old[s] * n + old[i]] = true;
+
+                    if (Cosimulation)
+                      redirect[i] = s;
+                    else
+                      redirect[s] = i;
+
+                    break;
+                  }
+              }
+          }
+      }
+
+    for (auto& e: res->edges())
+      e.dst = redirect[e.dst];
+
+    if (!Sba && !Cosimulation && original_->prop_state_acc())
+      {
+        // common_in[i] is the set of acceptance set numbers
+        // common to all incoming edges of state i.  Only edges
+        // inside one SCC matter.
+        //
+        // ns = nr
+        std::vector<acc_cond::mark_t> common_in(nr);
+        scc_info si(res, scc_info_options::NONE);
+
+        for (unsigned s = 0; s < nr; ++s)
+          {
+            unsigned s_scc = si.scc_of(s);
+            bool first = true;
+            for (auto& e: res->out(s))
+              {
+                if (si.scc_of(e.dst) != s_scc)
+                  continue;
+                if (first)
+                  {
+                    common_in[s] = e.acc;
+                    first = false;
+                  }
+                else
+                  {
+                    common_in[s] &= e.acc;
+                  }
+              }
+          }
+        for (auto& e : res->edges())
+          e.acc = (e.acc - common_in[e.dst]) | common_in[e.src];
+      }
+
+    res->merge_edges();
+    res->set_init_state(redirect[res->get_init_state_number()]);
+    res->purge_unreachable_states();
+    res->prop_copy(original_,
+        { Sba,          // state-based acc
+          true,         // weakness preserved,
+          false, true,  // determinism improved
+          true,         // completeness preserved
+          true,         // stutter inv.
+        });
+
+    return res;
+  }
+
+  twa_graph_ptr reduce_direct_sim(const const_twa_graph_ptr& aut)
+  {
+    // The automaton must not have dead or unreachable states.
+    reduce_sim<false, false> r(scc_filter(aut));
+    return r.run();
+  }
+
+  twa_graph_ptr reduce_direct_sim_sba(const const_twa_graph_ptr& aut)
+  {
+    // The automaton must not have dead or unreachable states.
+    reduce_sim<false, true> r(scc_filter_states(aut));
+    return r.run();
+  }
+
+  twa_graph_ptr reduce_direct_cosim(const const_twa_graph_ptr& aut)
+  {
+    // The automaton must not have dead or unreachable states.
+    reduce_sim<true, false> r(scc_filter(aut));
+    return r.run();
+  }
+
+  twa_graph_ptr reduce_direct_cosim_sba(const const_twa_graph_ptr& aut)
+  {
+    // The automaton must not have dead or unreachable states.
+    reduce_sim<true, true> r(scc_filter_states(aut));
+    return r.run();
+  }
+
+  template <bool Sba>
+  twa_graph_ptr reduce_iterated_(const const_twa_graph_ptr& aut)
+  {
+    unsigned last_states = aut->num_states();
+    unsigned last_edges = aut->num_edges();
+
+    auto a = Sba ? scc_filter_states(aut) : scc_filter(aut);
+
+    reduce_sim<false, Sba> r(a);
+    twa_graph_ptr res = r.run();
+
+    bool cosim = true;
+    do
+      {
+        if (is_deterministic(res))
+          break;
+
+        last_states = res->num_states();
+        last_edges = res->num_edges();
+
+        if (cosim)
+          {
+            reduce_sim<true, Sba> r(res);
+            res = r.run();
+          }
+        else
+          {
+            reduce_sim<false, Sba> r(res);
+            res = r.run();
+          }
+
+        cosim = !cosim;
+
+      }
+    while (last_states > res->num_states() || last_edges > res->num_edges());
+
+    return res;
+  }
+
+  twa_graph_ptr reduce_iterated(const const_twa_graph_ptr& aut)
+  {
+    return reduce_iterated_<false>(aut);
+  }
+
+  twa_graph_ptr reduce_iterated_sba(const const_twa_graph_ptr& aut)
+  {
+    return reduce_iterated_<true>(aut);
+  }
 } // End namespace spot.

spot/twaalgos/simulation.hh

@@ -122,4 +122,59 @@ namespace spot
   iterated_simulations_sba(const const_twa_graph_ptr& automaton);
   /// @}
 
+  /// @{
+  /// \brief Attempt to reduce the automaton by direct simulation.
+  ///
+  /// Compute direct simulation for all states using \cite clemente.2.17.corr,
+  /// then reduce the automaton.
+  ///
+  /// There is no need to call scc_filter() before as it is always applied to
+  /// remove dead and unreacheable states.
+  ///
+  /// \param aut the automaton to simulate.
+  /// \return a new automaton which is at worst a copy of the received
+  /// one
+  SPOT_API
+  twa_graph_ptr reduce_direct_sim(const const_twa_graph_ptr& aut);
+  SPOT_API
+  twa_graph_ptr reduce_direct_sim_sba(const const_twa_graph_ptr& aut);
+  /// @}
+
+  /// @{
+  /// \brief Attempt to reduce the automaton by reverse simulation.
+  ///
+  /// Reverse the automaton, compute the simulation and reduce it in the same
+  /// way as reduce_direct_sim().
+  ///
+  /// There is no need to call scc_filter() before as it is always applied to
+  /// remove dead and unreacheable states.
+  ///
+  /// \param aut the automaton to simulate.
+  /// \return a new automaton which is at worst a copy of the received
+  /// one
+  SPOT_API
+  twa_graph_ptr reduce_direct_cosim(const const_twa_graph_ptr& aut);
+  SPOT_API
+  twa_graph_ptr reduce_direct_cosim_sba(const const_twa_graph_ptr& aut);
+  /// @}
+
+  /// @{
+  /// \brief Iterate reduce_direct_sim() and reduce_direct_cosim().
+  ///
+  /// Runs reduce_direct_sim() and reduce_direct_cosim() in a loop,
+  /// until the automaton does not change size (states and
+  /// transitions).
+  ///
+  /// There is no need to call scc_filter() before as it is always applied to
+  /// remove dead and unreacheable states.
+  ///
+  /// \param aut the automaton to simulate.
+  /// \return a new automaton which is at worst a copy of the received
+  /// one
+  SPOT_API
+  twa_graph_ptr reduce_iterated(const const_twa_graph_ptr& aut);
+  SPOT_API
+  twa_graph_ptr reduce_iterated_sba(const const_twa_graph_ptr& aut);
+  /// @}
+
 } // End namespace spot.

tests/python/simstate.py

@@ -188,3 +188,464 @@ State: 0 "[1,7]"
 [1] 0
 [!1] 0 {0}
 --END--"""
+
+aut = spot.automaton('''HOA: v1
+States: 12
+Start: 0
+AP: 2 "a" "b"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels trans-acc deterministic
+--BODY--
+State: 0
+[!0&1] 1
+[0&!1] 0
+[0&1] 2
+State: 1
+[!0&1] 0
+[0&!1] 3 {0}
+[0&1] 4
+State: 2
+[!0&1] 2
+[0&!1] 4
+[0&1] 5
+State: 3
+[!0&1] 0
+[0&!1] 3
+[0&1] 6
+State: 4
+[!0&1] 7
+[0&!1] 4
+[0&1] 8
+State: 5
+[!0&1] 7
+[0&!1] 4
+[0&1] 8
+State: 6
+[!0&1] 2
+[0&!1] 6
+[0&1] 9
+State: 7
+[!0&1] 10
+[0&!1] 6 {0}
+[0&1] 9 {0}
+State: 8
+[!0&1] 2 {0}
+[0&!1] 6 {0}
+[0&1] 9 {0}
+State: 9
+[!0&1] 2
+[0&!1] 4
+[0&1] 5
+State: 10
+[!0&1] 7
+[0&!1] 4 {0}
+[0&1] 11
+State: 11
+[!0&1] 2 {0}
+[0&!1] 6 {0}
+[0&1] 9 {0}
+--END--''')
+assert spot.reduce_iterated(aut).to_str() == '''HOA: v1
+States: 9
+Start: 0
+AP: 2 "a" "b"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels trans-acc deterministic
+--BODY--
+State: 0
+[0&!1] 0
+[!0&1] 1
+[0&1] 2
+State: 1
+[!0&1] 0
+[0&!1] 3 {0}
+[0&1] 4
+State: 2
+[!0&1] 2
+[0] 4
+State: 3
+[!0&1] 0
+[0&!1] 3
+[0&1] 5
+State: 4
+[0&!1] 4
+[!0&1] 6
+[0&1] 7
+State: 5
+[1] 2
+[0&!1] 5
+State: 6
+[0&1] 2 {0}
+[0&!1] 5 {0}
+[!0&1] 8
+State: 7
+[1] 2 {0}
+[0&!1] 5 {0}
+State: 8
+[0&!1] 4 {0}
+[!0&1] 6
+[0&1] 7
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 6
+Start: 0
+AP: 2 "a" "b"
+acc-name: co-Buchi
+Acceptance: 1 Fin(0)
+properties: trans-labels explicit-labels state-acc very-weak
+--BODY--
+State: 0
+[1] 1
+[1] 2
+State: 1 {0}
+[0] 1
+State: 2
+[0] 3
+State: 3
+[1] 3
+State: 4
+[1] 5
+State: 5
+[0] 5
+--END--''')
+assert spot.reduce_iterated(aut).to_str() == '''HOA: v1
+States: 3
+Start: 0
+AP: 2 "a" "b"
+acc-name: co-Buchi
+Acceptance: 1 Fin(0)
+properties: trans-labels explicit-labels state-acc deterministic
+properties: very-weak
+--BODY--
+State: 0 {0}
+[1] 1
+State: 1
+[0] 2
+State: 2
+[1] 2
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 5
+Start: 0
+AP: 4 "p0" "p1" "p2" "p3"
+Acceptance: 2 Fin(0) & Fin(1)
+properties: trans-labels explicit-labels trans-acc
+--BODY--
+State: 0
+[0&!1&!2&3] 1
+State: 1
+[0&1&!2&3] 2 {0 1}
+[0&1&!2&3] 3 {0 1}
+[0&1&2&!3] 0
+[0&1&!2&3] 4 {0 1}
+[0&1&!2&3] 1 {0 1}
+State: 2
+[0&1&!2&3] 2
+State: 3
+[0&1&!2&3] 2 {1}
+[0&1&!2&3] 3 {1}
+State: 4
+[0&1&!2&3] 2 {0}
+[0&1&!2&3] 4 {0}
+--END--''')
+
+assert spot.reduce_direct_cosim(aut).to_str() == '''HOA: v1
+States: 5
+Start: 0
+AP: 4 "p0" "p2" "p3" "p1"
+Acceptance: 2 Fin(0) & Fin(1)
+properties: trans-labels explicit-labels trans-acc
+--BODY--
+State: 0
+[0&!1&2&!3] 1
+State: 1
+[0&1&!2&3] 0
+[0&!1&2&3] 1 {0 1}
+[0&!1&2&3] 2 {0 1}
+[0&!1&2&3] 3 {0 1}
+[0&!1&2&3] 4 {0 1}
+State: 2
+[0&!1&2&3] 2
+State: 3
+[0&!1&2&3] 3 {1}
+State: 4
+[0&!1&2&3] 4 {0}
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 2
+Start: 0
+AP: 2 "a" "b"
+Acceptance: 2 Fin(0) & Fin(1)
+properties: trans-labels explicit-labels trans-acc
+--BODY--
+State: 0
+[0] 1 {0}
+[0] 1 {1}
+State: 1
+[0] 0
+--END--''')
+assert spot.reduce_direct_sim(aut).to_str() == '''HOA: v1
+States: 1
+Start: 0
+AP: 2 "a" "b"
+Acceptance: 2 Fin(0) & Fin(1)
+properties: trans-labels explicit-labels state-acc deterministic
+--BODY--
+State: 0
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+name: "(p1 U p2) U p3"
+States: 4
+Start: 0
+AP: 3 "p1" "p2" "p3"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels state-acc stutter-invariant
+properties: terminal
+--BODY--
+State: 0
+[1&!2] 0
+[2] 1
+[0&!2] 2
+State: 1 {0}
+[t] 1
+State: 2
+[1&!2] 0
+[1&2] 1
+[0&!1 | 0&!2] 2
+[0&!1&2] 3
+State: 3
+[1] 1
+[0&!1] 3
+--END--''')
+assert spot.reduce_direct_cosim_sba(aut).to_str() == '''HOA: v1
+States: 4
+Start: 0
+AP: 3 "p2" "p3" "p1"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels state-acc stutter-invariant
+properties: terminal
+--BODY--
+State: 0
+[0&!1] 0
+[1] 1
+[!1&2] 2
+State: 1 {0}
+[t] 1
+State: 2
+[0&!1] 0
+[0&1] 1
+[!0&2 | !1&2] 2
+[!0&1&2] 3
+State: 3
+[0] 1
+[!0&2] 3
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 4
+Start: 0
+AP: 2 "a" "b"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels state-acc
+--BODY--
+State: 0
+[0] 1
+State: 1
+[1] 2
+[1] 3
+State: 2
+[1] 2
+State: 3 {0}
+[1] 3
+--END--''')
+assert spot.reduce_direct_cosim(aut).to_str() == '''HOA: v1
+States: 3
+Start: 0
+AP: 2 "a" "b"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels state-acc deterministic
+--BODY--
+State: 0
+[0] 1
+State: 1
+[1] 2
+State: 2 {0}
+[1] 2
+--END--'''
+
+assert spot.reduce_direct_sim_sba(aut).to_str() == '''HOA: v1
+States: 2
+Start: 0
+AP: 2 "a" "b"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels state-acc deterministic
+--BODY--
+State: 0
+[0] 1
+State: 1 {0}
+[1] 1
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 3
+Start: 0
+AP: 1 "a"
+Acceptance: 1 t
+properties: trans-labels explicit-labels state-acc deterministic
+--BODY--
+State: 0
+[0] 1
+State: 1
+[0] 2
+State: 2 {0}
+[0] 2
+--END--''')
+assert spot.reduce_iterated_sba(aut).to_str() == '''HOA: v1
+States: 1
+Start: 0
+AP: 1 "a"
+Acceptance: 1 t
+properties: trans-labels explicit-labels state-acc colored
+properties: deterministic
+--BODY--
+State: 0 {0}
+[0] 0
+--END--'''
+
+aut = spot.automaton('''HOA: v1
+States: 30
+Start: 0
+AP: 4 "c" "d" "a1" "b1"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels trans-acc weak
+--BODY--
+State: 0
+[0&!1&!2&!3] 1
+[0&!1&!2&!3] 2
+State: 1
+[!0&!1&!2&3] 3
+[!0&!1&2&!3] 4
+State: 2
+[!0&!1&!2&3 | !0&!1&2&!3] 5
+[!0&1&!2&!3] 6
+State: 3
+[0&!1&!2&!3] 7
+State: 4
+[0&!1&!2&!3] 8
+State: 5
+[0&!1&!2&!3] 1
+[0&!1&!2&!3] 9
+State: 6
+[!0&!1&!2&3 | !0&!1&2&!3] 10
+State: 7
+[!0&!1&!2&3 | !0&!1&2&!3] 3
+[!0&1&!2&!3] 11
+[!0&1&!2&!3] 12
+[0&!1&!2&!3] 13
+State: 8
+[!0&!1&!2&3 | !0&!1&2&!3] 4
+[!0&1&!2&!3] 14
+[!0&1&!2&!3] 15
+[0&!1&!2&!3] 16
+State: 9
+[!0&!1&!2&3 | !0&!1&2&!3] 5
+[!0&1&!2&!3] 6
+[0&!1&!2&!3] 17
+[0&!1&!2&!3] 18
+State: 10
+[0&!1&!2&!3] 17 {0}
+[0&!1&!2&!3] 19
+State: 11
+[!0&!1&2&!3] 20
+[!0&!1&!2&3] 21 {0}
+State: 12
+[!0&!1&!2&3 | !0&!1&2&!3] 22
+State: 13
+[0&!1&!2&!3] 13
+State: 14
+[!0&!1&2&!3] 21 {0}
+[!0&!1&!2&3] 23
+State: 15
+[!0&!1&!2&3 | !0&!1&2&!3] 24
+State: 16
+[0&!1&!2&!3] 16
+State: 17
+State: 18
+[0&!1&!2&!3] 17
+[0&!1&!2&!3] 18
+State: 19
+[0&!1&!2&!3] 17 {0}
+[0&!1&!2&!3] 19
+State: 20
+[0&!1&!2&!3] 25
+State: 21
+[0&!1&!2&!3] 26 {0}
+State: 22
+[0&!1&!2&!3] 27
+State: 23
+[0&!1&!2&!3] 28
+State: 24
+[0&!1&!2&!3] 29
+State: 25
+[0&!1&!2&!3] 25
+State: 26
+[0&!1&!2&!3] 26 {0}
+State: 27
+[0&!1&!2&!3] 27
+State: 28
+[0&!1&!2&!3] 28
+State: 29
+[0&!1&!2&!3] 29
+--END--''')
+assert spot.reduce_iterated(a).to_str() == '''HOA: v1
+States: 8
+Start: 0
+AP: 2 "p0" "p1"
+acc-name: Buchi
+Acceptance: 1 Inf(0)
+properties: trans-labels explicit-labels trans-acc stutter-invariant
+--BODY--
+State: 0
+[0] 0
+[!0] 1 {0}
+[0&1] 2 {0}
+[!0&1] 3
+State: 1
+[1] 1
+[!1] 1 {0}
+[!0&1] 3
+[0&1] 4
+State: 2
+[0&1] 2 {0}
+State: 3
+[!1] 1 {0}
+[!0&1] 3
+[0&1] 5
+State: 4
+[0&!1] 6
+State: 5
+[!0&!1] 1 {0}
+[!0&1] 3
+[0&1] 5
+[0&!1] 6 {0}
+State: 6
+[!0&!1] 1 {0}
+[0] 6
+[!0&1] 7
+State: 7
+[!1] 1 {0}
+[0&1] 5
+[1] 7
+--END--'''