Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
File size: 18,175 Bytes
4365a98 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 |
(******************************************************************************)
(* FILE : rewrite_rules.ml *)
(* DESCRIPTION : Using axioms and lemmas as rewrite rules. *)
(* *)
(* READS FILES : <none> *)
(* WRITES FILES : <none> *)
(* *)
(* AUTHOR : R.J.Boulton *)
(* DATE : 14th May 1991 *)
(* *)
(* LAST MODIFIED : R.J.Boulton *)
(* DATE : 15th October 1992 *)
(* *)
(* LAST MODIFIED : P. Papapanagiotou (University of Edinburgh) *)
(* DATE : 2008 *)
(******************************************************************************)
(*----------------------------------------------------------------------------*)
(* is_permutative : term -> bool *)
(* *)
(* Determines whether or not an equation is permutative (the left-hand and *)
(* right-hand sides are instances of one another). A permutative equation may *)
(* cause looping when it is used for rewriting. *)
(*----------------------------------------------------------------------------*)
let is_permutative tm =
try (let (l,r) = dest_eq tm
in let bind1 = term_match [] l r
and bind2 = term_match [] r l
in true
) with Failure _ -> false;;
(*----------------------------------------------------------------------------*)
(* lex_smaller_term : term -> term -> bool *)
(* *)
(* Computes whether the first term is `alphabetically' smaller than the *)
(* second term. Used to avoid looping when rewriting with permutative rules. *)
(* *)
(* A constant is considered to be smaller than a variable which in turn is *)
(* considered to be smaller than an application. Two variables or two *)
(* constants are compared alphabetically by name. An application (f1 x1) is *)
(* considered to be smaller than another application (f2 x2) if either f1 is *)
(* smaller than f2, or f1 equals f2 and x1 is smaller than x2. *)
(*----------------------------------------------------------------------------*)
let rec lex_smaller_term tm1 tm2 =
try
(if (is_const tm1) then
(if (is_const tm2)
then let (name1,type1) = dest_const tm1
and (name2,type2) = dest_const tm2
in (if (type1 = type2)
then name1 < name2
else failwith "" )
else true)
else if (is_var tm1) then
(if (is_const tm2) then false
else if (is_var tm2)
then let (name1,type1) = dest_var tm1
and (name2,type2) = dest_var tm2
in (if (type1 = type2)
then name1 < name2
else failwith "" )
else true)
else if (is_comb tm1) then
(if (is_comb tm2)
then let (rator1,rand1) = dest_comb tm1
and (rator2,rand2) = dest_comb tm2
in (lex_smaller_term rator1 rator2) ||
((rator1 = rator2) && (lex_smaller_term rand1 rand2))
else false)
else failwith ""
) with Failure _ -> failwith "lex_smaller_term";;
(*----------------------------------------------------------------------------*)
(* inst_eq_thm : ((term # term) list # (type # type) list) -> thm -> thm *)
(* *)
(* Instantiates a theorem (possibly having hypotheses) with a binding. *)
(* Assumes the conclusion is an equality, so that discharging then undisching *)
(* cannot cause parts of the conclusion to be moved into the hypotheses. *)
(*----------------------------------------------------------------------------*)
let inst_eq_thm (tm_bind,ty_bind) th =
let (insts,vars) = List.split tm_bind
in (UNDISCH_ALL o (SPECL insts) o (GENL vars) o
(INST_TYPE ty_bind) o DISCH_ALL) th;;
(*----------------------------------------------------------------------------*)
(* applicable_rewrites : term -> thm list *)
(* *)
(* Returns the results of rewriting the term with those rewrite rules that *)
(* are applicable to it. A rewrite rule is not applicable if it's permutative *)
(* and the rewriting does not produce an alphabetically smaller term. *)
(*----------------------------------------------------------------------------*)
let applicable_rewrites tm =
let applicable_rewrite tm th =
let conc = concl th
in let (_,tm_bind,ty_bind) = term_match [] (lhs conc) tm
in let instth = inst_eq_thm (tm_bind,ty_bind) th
in if (is_permutative conc)
then (let (l,r) = dest_eq (concl instth)
in if (lex_smaller_term r l)
then instth
else failwith "")
else instth
in mapfilter ((applicable_rewrite tm) o snd) !system_rewrites;;
(*----------------------------------------------------------------------------*)
(* ARGS_CONV : conv -> conv *)
(* *)
(* Applies a conversion to every argument of an application of the form *)
(* "f x1 ... xn". *)
(*----------------------------------------------------------------------------*)
let rec ARGS_CONV conv tm =
try (
((RATOR_CONV (ARGS_CONV conv)) THENC (RAND_CONV conv)) tm
) with Failure _ -> ALL_CONV tm;;
(*----------------------------------------------------------------------------*)
(* assump_inst_hyps : term list -> *)
(* term -> *)
(* term list -> *)
(* ((term # term) list # (type # type) list) *)
(* *)
(* Searches a list of hypotheses for one that matches the specified *)
(* assumption such that the variables instantiated are precisely those in the *)
(* list of variables given. If such a hypothesis is found, the binding *)
(* produced by the match is returned. *)
(*----------------------------------------------------------------------------*)
let rec assump_inst_hyps vars assump hyps =
try(let (_,tm_bind,ty_bind) = term_match [] (hd hyps) assump
in let bind = (tm_bind,ty_bind)
in if (set_eq vars (map snd (fst bind)))
then bind
else failwith "")
with Failure _ -> try (assump_inst_hyps vars assump (tl hyps))
with Failure _ -> failwith "assump_inst_hyps";;
(*----------------------------------------------------------------------------*)
(* assumps_inst_hyps : term list -> *)
(* term list -> *)
(* term list -> *)
(* ((term # term) list # (type # type) list) *)
(* *)
(* Searches a list of hypotheses and a list of assumptions for a pairing that *)
(* match (the assumption is an instance of the hypothesis) such that the *)
(* variables instantiated are precisely those in the list of variables given. *)
(* If such a pair is found, the binding produced by the match is returned. *)
(*----------------------------------------------------------------------------*)
let rec assumps_inst_hyps vars assumps hyps =
try (assump_inst_hyps vars (hd assumps) hyps)
with Failure _ -> try (assumps_inst_hyps vars (tl assumps) hyps)
with Failure _ -> failwith "assumps_inst_hyps";;
(*----------------------------------------------------------------------------*)
(* inst_frees_in_hyps : term list -> thm -> thm *)
(* *)
(* Takes a theorem (possibly with hypotheses) and computes a list of *)
(* variables that are free in the hypotheses but not in the conclusion. *)
(* If this list of variables is empty the original theorem is returned. *)
(* The function also takes a list of assumptions as another argument. Once it *)
(* has the list of variables it searches for an assumption and a hypothesis *)
(* such that the hypothesis matches the assumption binding precisely those *)
(* variables in the list. If this is successful the original theorem is *)
(* returned having had the variables in the list instantiated. *)
(*----------------------------------------------------------------------------*)
let inst_frees_in_hyps assumps th =
try (let hyps = hyp th
in let hyp_frees = setify (flat (map frees hyps))
in let vars = subtract hyp_frees (frees (concl th))
in if (vars = [])
then th
else let bind = assumps_inst_hyps vars assumps hyps
in inst_eq_thm bind th
) with Failure _ -> failwith "inst_frees_in_hyps";;
(*----------------------------------------------------------------------------*)
(* NOT_IMP_EQ_EQ_EQ_OR = |- (~x ==> (y = y')) = ((y \/ x) = (y' \/ x)) *)
(*----------------------------------------------------------------------------*)
let NOT_IMP_EQ_EQ_EQ_OR =
prove
(`(~x ==> (y = y')) = ((y \/ x) = (y' \/ x))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `y:bool` THEN
BOOL_CASES_TAC `y':bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* IMP_EQ_EQ_EQ_OR_NOT = |- (x ==> (y = y')) = ((y \/ ~x) = (y' \/ ~x)) *)
(*----------------------------------------------------------------------------*)
let IMP_EQ_EQ_EQ_OR_NOT =
prove
(`(x ==> (y = y')) = ((y \/ ~x) = (y' \/ ~x))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `y:bool` THEN
BOOL_CASES_TAC `y':bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* NOT_IMP_EQ_OR_EQ_EQ_OR_OR = *)
(* |- (~x ==> ((y \/ t) = (y' \/ t))) = ((y \/ (x \/ t)) = (y' \/ (x \/ t))) *)
(*----------------------------------------------------------------------------*)
let NOT_IMP_EQ_OR_EQ_EQ_OR_OR =
prove
(`(~x ==> ((y \/ t) = (y' \/ t))) = ((y \/ (x \/ t)) = (y' \/ (x \/ t)))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `y:bool` THEN
BOOL_CASES_TAC `y':bool` THEN
BOOL_CASES_TAC `t:bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* IMP_EQ_OR_EQ_EQ_OR_NOT_OR = *)
(* |- (x ==> ((y \/ t) = (y' \/ t))) = ((y \/ (~x \/ t)) = (y' \/ (~x \/ t))) *)
(*----------------------------------------------------------------------------*)
let IMP_EQ_OR_EQ_EQ_OR_NOT_OR =
prove
(`(x ==> ((y \/ t) = (y' \/ t))) = ((y \/ (~x \/ t)) = (y' \/ (~x \/ t)))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `y:bool` THEN
BOOL_CASES_TAC `y':bool` THEN
BOOL_CASES_TAC `t:bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* IMP_EQ_EQ_EQ_NOT_OR = |- (x ==> (t = t')) = ((~x \/ t) = (~x \/ t')) *)
(*----------------------------------------------------------------------------*)
let IMP_EQ_EQ_EQ_NOT_OR =
prove
(`(x ==> (t = t')) = ((~x \/ t) = (~x \/ t'))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `t:bool` THEN
BOOL_CASES_TAC `t':bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* IMP_NOT_EQ_EQ_EQ_OR = |- (~x ==> (t = t')) = ((x \/ t) = (x \/ t')) *)
(*----------------------------------------------------------------------------*)
let IMP_NOT_EQ_EQ_EQ_OR =
prove
(`(~x ==> (t = t')) = ((x \/ t) = (x \/ t'))`,
BOOL_CASES_TAC `x:bool` THEN
BOOL_CASES_TAC `t:bool` THEN
BOOL_CASES_TAC `t':bool` THEN
REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* T_OR = |- T \/ t = T *)
(* OR_T = |- t \/ T = T *)
(* F_OR = |- F \/ t = t *)
(* OR_F = |- t \/ F = t *)
(*----------------------------------------------------------------------------*)
let [T_OR;OR_T;F_OR;OR_F;_] = CONJUNCTS (SPEC_ALL OR_CLAUSES);;
(*----------------------------------------------------------------------------*)
(* UNDER_DISJ_DISCH : term -> thm -> thm *)
(* *)
(* A, ~x |- y \/ t = y' \/ t A, x |- y \/ t = y' \/ t *)
(* ------------------------------- --------------------------------- *)
(* A |- y \/ x \/ t = y' \/ x \/ t A |- y \/ ~x \/ t = y' \/ ~x \/ t *)
(* *)
(* A, ~x |- y = y' A, x |- y = y' *)
(* --------------------- ----------------------- *)
(* A |- y \/ x = y' \/ x A |- y \/ ~x = y' \/ ~x *)
(* *)
(* The function assumes that y is a literal, so it is valid to test the LHS *)
(* of the theorem to see if it is a disjunction in order to determine which *)
(* rule to use. *)
(*----------------------------------------------------------------------------*)
let UNDER_DISJ_DISCH tm th =
try
(let rewrite =
if (is_disj (lhs (concl th)))
then if (is_neg tm)
then NOT_IMP_EQ_OR_EQ_EQ_OR_OR
else IMP_EQ_OR_EQ_EQ_OR_NOT_OR
else if (is_neg tm)
then NOT_IMP_EQ_EQ_EQ_OR
else IMP_EQ_EQ_EQ_OR_NOT
in CONV_RULE (REWR_CONV rewrite) (DISCH tm th)
) with Failure _ -> failwith "UNDER_DISJ_DISCH";;
(*----------------------------------------------------------------------------*)
(* OVER_DISJ_DISCH : term -> thm -> thm *)
(* *)
(* A, ~x |- t = t' A, x |- t = t' *)
(* --------------------- ----------------------- *)
(* A |- x \/ t = x \/ t' A |- ~x \/ t = ~x \/ t' *)
(*----------------------------------------------------------------------------*)
let OVER_DISJ_DISCH tm th =
try (let rewrite =
if (is_neg tm)
then IMP_NOT_EQ_EQ_EQ_OR
else IMP_EQ_EQ_EQ_NOT_OR
in CONV_RULE (REWR_CONV rewrite) (DISCH tm th)
) with Failure _ -> failwith "OVER_DISJ_DISCH";;
(*----------------------------------------------------------------------------*)
(* MULTI_DISJ_DISCH : (term list # term list) -> thm -> thm *)
(* *)
(* Examples: *)
(* *)
(* MULTI_DISJ_DISCH (["x1"; "x2"],["~x3"; "x4"]) x1, ~x3, x4, x2 |- y = y' *)
(* ---> *)
(* |- ~x1 \/ ~x2 \/ y \/ x3 \/ ~x4 = ~x1 \/ ~x2 \/ y' \/ x3 \/ ~x4 *)
(* *)
(* *)
(* MULTI_DISJ_DISCH (["x1"; "x2"],["~x3"; "x4"]) x1, ~x3, x4, x2 |- y = F *)
(* ---> *)
(* |- ~x1 \/ ~x2 \/ y \/ x3 \/ ~x4 = ~x1 \/ ~x2 \/ x3 \/ ~x4 *)
(* *)
(* *)
(* MULTI_DISJ_DISCH (["x1"; "x2"],["~x3"; "x4"]) x1, ~x3, x4, x2 |- y = T *)
(* ---> *)
(* |- ~x1 \/ ~x2 \/ y \/ x3 \/ ~x4 = T *)
(*----------------------------------------------------------------------------*)
let MULTI_DISJ_DISCH (overs,unders) th =
try
(let th1 = itlist UNDER_DISJ_DISCH unders th
in let tm1 = rhs (concl th1)
in let th2 =
if (try(is_T (fst (dest_disj tm1))) with Failure _ -> false) then
(CONV_RULE (RAND_CONV (REWR_CONV T_OR)) th1)
else if (try(is_F (fst (dest_disj tm1))) with Failure _ -> false) then
(CONV_RULE (RAND_CONV (REWR_CONV F_OR)) th1)
else th1
in let tm2 = rhs (concl th2)
in let rule =
if (is_T tm2) then CONV_RULE (RAND_CONV (REWR_CONV OR_T)) else I
in itlist (fun tm th -> rule (OVER_DISJ_DISCH tm th)) overs th2
) with Failure _ -> failwith "MULTI_DISJ_DISCH";;
|