metaSMT 2
|
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 }