metaSMT 2
metaSMT/backend/SAT_Clause.hpp
Go to the documentation of this file.
00001 
00002 #pragma once
00003 
00004 #include "../tags/SAT.hpp"
00005 
00006 #include <vector>
00007 
00008 #include <boost/foreach.hpp>
00009 
00010 namespace metaSMT
00011 {
00012   template<typename SatSolver>
00013   class SAT_Clause
00014   {
00015     public:
00016       typedef SAT::tag::lit_tag result_type; 
00017        
00018     public:
00019       SAT_Clause ()
00020       {
00021         true_lit.id = impl::new_var_id();
00022         //std::cout << "<true>\n";
00023         solver.assertion ( true_lit );
00024         //std::cout << "</true>\n";
00025       }
00026 
00027       template<typename Tag, typename Any>
00028       result_type operator() (Tag const& tag, Any arg )
00029       {
00030         return true_lit; 
00031       }
00032 
00033       result_type operator() (logic::tag::var_tag const& tag, boost::any arg )
00034       {
00035         result_type lit = { impl::new_var_id() };
00036         return lit; 
00037       }
00038 
00039       result_type operator() (logic::tag::true_tag const& tag, boost::any arg )
00040       {
00041         //std::cout << "true " << true_lit << std::endl;
00042         return true_lit; 
00043       }
00044 
00045       result_type operator() (logic::tag::false_tag const& tag, boost::any arg )
00046       {
00047         //std::cout << "false " << -true_lit << std::endl;
00048         return -true_lit; 
00049       }
00050            
00051       result_type operator() (logic::tag::and_tag const& tag, result_type lhs, result_type rhs )
00052       {
00053         result_type out = { impl:: new_var_id() };
00054         clause3(-lhs,-rhs, out);
00055         clause2( rhs,-out);
00056         clause2( lhs,-out);
00057         return out;
00058       }
00059 
00060       result_type operator() (logic::tag::or_tag const& tag, result_type lhs, result_type rhs )
00061       {
00062         result_type out = { impl:: new_var_id() };
00063         clause3( lhs, rhs,-out);
00064         clause2(-rhs, out);
00065         clause2(-lhs, out);
00066         return out;
00067       }
00068 
00069       result_type operator() (logic::tag::nor_tag const& tag, result_type lhs, result_type rhs )
00070       {
00071         result_type out = { impl:: new_var_id() };
00072         clause3( lhs, rhs, out);
00073         clause2(-rhs,-out);
00074         clause2(-lhs,-out);
00075         return out;
00076       }
00077 
00078       result_type operator() (logic::tag::implies_tag const& tag, result_type lhs, result_type rhs )
00079       {
00080         return operator()(logic::tag::ite_tag(), lhs, rhs, true_lit);
00081       }
00082 
00083       result_type operator() (logic::tag::nand_tag const& tag, result_type lhs, result_type rhs )
00084       {
00085         result_type out = { impl:: new_var_id() };
00086         clause3(-lhs,-rhs,-out);
00087         clause2( rhs, out);
00088         clause2( lhs, out);
00089         return out;
00090       }
00091 
00092       result_type operator() (logic::tag::xnor_tag const& tag, result_type lhs, result_type rhs )
00093       {
00094         result_type out = { impl:: new_var_id() };
00095         clause3( lhs, rhs, out);
00096         clause3( lhs,-rhs,-out);
00097         clause3(-lhs, rhs,-out);
00098         clause3(-lhs,-rhs, out);
00099         return out;
00100       }
00101 
00102       result_type operator() (logic::tag::xor_tag const& tag, result_type lhs, result_type rhs )
00103       {
00104         result_type out = { impl:: new_var_id() };
00105         clause3( lhs, rhs,-out);
00106         clause3( lhs,-rhs, out);
00107         clause3(-lhs, rhs, out);
00108         clause3(-lhs,-rhs,-out);
00109         return out;
00110       }
00111 
00112 
00113       result_type operator() (logic::tag::equal_tag const& tag, result_type lhs, result_type rhs )
00114       {
00115         return operator()(logic::tag::xnor_tag(), lhs, rhs);
00116       }
00117 
00118       result_type operator() (logic::tag::nequal_tag const& tag, result_type lhs, result_type rhs )
00119       {
00120         return operator()(logic::tag::xor_tag(), lhs, rhs);
00121       }
00122 
00123 
00124       template<typename T>
00125       result_type operator() (T const& tag, result_type lhs, result_type rhs )
00126       {
00127         return true_lit;
00128       }
00129 
00130       result_type operator() (logic::tag::not_tag const& tag, result_type lhs )
00131       {
00132         return -lhs;
00133       }
00134 
00135       template<typename T>
00136       result_type operator() (T const& tag, result_type lhs )
00137       {
00138         return true_lit;
00139       }
00140 
00141       result_type operator() (logic::tag::ite_tag const& tag, result_type op1, result_type op2, result_type op3  )
00142       {
00143         result_type out = { impl:: new_var_id() };
00144         clause3( op1, op3, -out);
00145         clause3( op1,-op3,  out);
00146         clause3(-op1, op2, -out);
00147         clause3(-op1,-op2,  out);
00148         return out;
00149       }
00150 
00151       template<typename T>
00152       result_type operator() (T const& tag, result_type op1, result_type op2, result_type op3  )
00153       {
00154         return true_lit;
00155       }
00156 
00157       void assertion ( result_type lit )
00158       {
00159         //std::cout << "assert " << lit << std::endl;
00160         solver.assertion( lit );
00161       }
00162 
00163       void assumption ( result_type lit )
00164       {
00165         //std::cout << "assume " << lit << std::endl;
00166         solver.assumption( lit );
00167       }
00168 
00169       bool solve () 
00170       {
00171         return solver.solve (); 
00172       }
00173 
00174       result_wrapper read_value ( result_type lit ) 
00175       {
00176         return solver.read_value ( lit ); 
00177       }
00178 
00179       void clause2(result_type a, result_type b){
00180         std::vector<result_type> cls(2);
00181         cls[0]=a;
00182         cls[1]=b;
00183         solver.clause(cls);
00184       }
00185 
00186       void clause3(result_type a, result_type b, result_type c){
00187         std::vector<result_type> cls(3);
00188         cls[0]=a;
00189         cls[1]=b;
00190         cls[2]=c;
00191         solver.clause(cls);
00192       }
00193 
00194     private:
00195       SatSolver solver;
00196       result_type true_lit; 
00197   }; 
00198 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines