bin/ltl2tgba: New user binary.

* src/tgbaalgos/postproc.cc, src/tgbaalgos/postproc.hh: New class to
capture the postprocessing logic.
* src/tgbaalgos/Makefile.am: Add them.
* src/bin/ltl2tgba.cc, src/bin/man/ltl2tgba.x: New files.
* src/bin/Makefile.am, src/bin/man/Makefile.am: Add them.
* src/tgbatest/spotlbtt.test: Prune the list of configurations slightly.
* src/tgbatest/spotlbtt2.test: New file.
* src/tgbatest/Makefile.am: Add it.
* bench/ltl2tgba/algorithms, bench/ltl2tgba/defs.in: Adjust to
use the new binary.
* NEWS: Update.

src/tgbaalgos/Makefile.am

@@ -48,6 +48,7 @@ tgbaalgos_HEADERS = \
   magic.hh \
   minimize.hh \
   neverclaim.hh \
+  postproc.hh \
   powerset.hh \
   projrun.hh \
   randomgraph.hh \
@@ -87,6 +88,7 @@ libtgbaalgos_la_SOURCES = \
   minimize.cc \
   ndfs_result.hxx \
   neverclaim.cc \
+  postproc.cc \
   powerset.cc \
   projrun.cc \
   randomgraph.cc \

src/tgbaalgos/postproc.cc

@@ -0,0 +1,119 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2012 Laboratoire de Recherche et Développement de
+// l'Epita (LRDE).
+//
+// This file is part of Spot, a model checking library.
+//
+// Spot is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// Spot is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Spot; see the file COPYING.  If not, write to the Free
+// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+
+#include "postproc.hh"
+#include "minimize.hh"
+#include "simulation.hh"
+#include "sccfilter.hh"
+#include "degen.hh"
+#include "stats.hh"
+
+namespace spot
+{
+  unsigned count_states(const tgba* a)
+  {
+    // FIXME: the number of states can be found more
+    // efficiently in explicit automata.
+    tgba_statistics st = stats_reachable(a);
+    return st.states;
+  }
+
+  const tgba* postprocessor::run(const tgba* a, const ltl::formula* f)
+  {
+    if (type_ == TGBA && pref_ == Any && level_ == Low)
+      return a;
+
+    // Remove useless SCCs.
+    {
+      const tgba* s = scc_filter(a, false);
+      delete a;
+      a = s;
+    }
+
+    if (pref_ == Any)
+      {
+	if (type_ == BA)
+	  {
+	    const tgba* d = degeneralize(a);
+	    delete a;
+	    a = d;
+	  }
+	return a;
+      }
+
+    const tgba* wdba = 0;
+    const tgba* sim = 0;
+
+    // (Small,Low) is the only configuration where we do not run
+    // WDBA-minimization.
+    if (pref_ != Small || level_ != Low)
+      {
+	bool reject_bigger = (pref_ == Small) && (level_ == Medium);
+	wdba = minimize_obligation(a, f, 0, reject_bigger);
+	if (wdba == a)	// Minimization failed.
+	  wdba = 0;
+	// The WDBA is a BA, so no degeneralization required.
+      }
+
+    // Run a simulation when wdba failed (or was not run), or
+    // at hard levels if we want a small output.
+    if (!wdba || (level_ == High && pref_ == Small))
+      {
+	if (level_ == Low)
+	  sim = simulation(a);
+	else
+	  sim = iterated_simulations(a);
+
+	// Degeneralize the result of the simulation if needed.
+	if (type_ == BA)
+	  {
+	    const tgba* d = degeneralize(sim);
+	    delete sim;
+	    sim = d;
+	  }
+      }
+
+    delete a;
+
+    if (wdba && sim)
+      {
+	if (count_states(wdba) > count_states(sim))
+	  {
+	    delete wdba;
+	    wdba = 0;
+
+	    if (type_ == TGBA && level_ == High)
+	      {
+		const tgba* s = scc_filter(sim, true);
+		delete sim;
+		sim = s;
+	      }
+	  }
+	else
+	  {
+	    delete sim;
+	    sim = 0;
+	  }
+      }
+
+    return wdba ? wdba : sim;
+  }
+}

src/tgbaalgos/postproc.hh

@@ -0,0 +1,99 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2012 Laboratoire de Recherche et Développement de
+// l'Epita (LRDE).
+//
+// This file is part of Spot, a model checking library.
+//
+// Spot is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// Spot is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Spot; see the file COPYING.  If not, write to the Free
+// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+
+#ifndef SPOT_TGBAALGOS_POSTPROC_HH
+# define SPOT_TGBAALGOS_POSTPROC_HH
+
+#include "tgba/tgba.hh"
+
+namespace spot
+{
+  /// \addtogroup tgba_reduction
+  /// @{
+
+  /// \brief Wrap TGBA/BA post-processing algorithms in an easy interface.
+  ///
+  /// This class is a shell around scc_filter(),
+  /// minimize_obligation(), simulation(), iterated_simulations(), and
+  /// degeneralize().  These different algorithms will be combined
+  /// depending on the various options set with set_type(),
+  /// set_pref(), and set_level().
+  ///
+  /// This helps hiding some of the logic required to combine these
+  /// simplifications efficiently (e.g., there is no point calling
+  /// degeneralize() or any simulation when minimize_obligation()
+  /// succeeded.)
+  ///
+  /// Use set_pref() method to specify whether you favor
+  /// deterministic automata or small automata.  If you don't care,
+  /// less post processing will be done.
+  ///
+  /// The set_level() method let you set the optimization level.
+  /// Higher level enable more costly postprocessign.  For instance
+  /// pref=Small,level=High will try two different postprocessings
+  /// (one with minimize_obligation(), and one with
+  /// iterated_simulations()) an keep the smallest result.
+  /// pref=Small,level=Medium will only try the iterated_simulations()
+  /// when minimized_obligation failed to produce an automaton smaller
+  /// than its input.  pref=Small,level=Low will only run
+  /// simulation().
+  class postprocessor
+  {
+  public:
+    postprocessor()
+      : type_(TGBA), pref_(Small), level_(High)
+    {
+    }
+
+    enum output_type { TGBA, BA };
+    void
+    set_type(output_type type)
+    {
+      type_ = type;
+    }
+
+    enum output_pref { Any, Small, Deterministic };
+    void
+    set_pref(output_pref pref)
+    {
+      pref_ = pref;
+    }
+
+
+    enum optimization_level { Low, Medium, High };
+    void
+    set_level(optimization_level level)
+    {
+      level_ = level;
+    }
+
+    /// Return the optimized automaton and delete \a input.
+    const tgba* run(const tgba* input, const ltl::formula* f);
+
+  private:
+    output_type type_;
+    output_pref pref_;
+    optimization_level level_;
+  };
+  /// @}
+}
+
+#endif // SPOT_TGBAALGOS_POSTPROC_HH