Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
File size: 11,024 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 |
(******************************************************************************)
(* FILE : equalities.ml *)
(* DESCRIPTION : Using equalities. *)
(* *)
(* READS FILES : <none> *)
(* WRITES FILES : <none> *)
(* *)
(* AUTHOR : R.J.Boulton *)
(* DATE : 19th June 1991 *)
(* *)
(* LAST MODIFIED : R.J.Boulton *)
(* DATE : 7th August 1992 *)
(* *)
(* LAST MODIFIED : P. Papapanagiotou (University of Edinburgh) *)
(* DATE : 2008 *)
(******************************************************************************)
(*----------------------------------------------------------------------------*)
(* is_explicit_value_template : term -> bool *)
(* *)
(* Function to compute whether a term is an explicit value template. *)
(* An explicit value template is a non-variable term composed entirely of *)
(* T or F or variables or applications of shell constructors. *)
(* A `bottom object' corresponds to an application to no arguments. I have *)
(* also made numeric constants valid components of explicit value templates, *)
(* since they are equivalent to some number of applications of SUC to 0. *)
(*----------------------------------------------------------------------------*)
let is_explicit_value_template tm =
let rec is_explicit_value_template' constructors tm =
(is_T tm) || (is_F tm) || ((is_const tm) && (type_of tm = `:num`)) ||
(is_var tm) || (is_numeral tm) ||
(let (f,args) = strip_comb tm
in (try(mem (fst (dest_const f)) constructors) with Failure _ -> false) &&
(forall (is_explicit_value_template' constructors) args))
in (not (is_var tm)) &&
(is_explicit_value_template' (all_constructors ()) tm);;
(*----------------------------------------------------------------------------*)
(* subst_conv : thm -> conv *)
(* *)
(* Substitution conversion. Given a theorem |- l = r, it replaces all *)
(* occurrences of l in the term with r. *)
(*----------------------------------------------------------------------------*)
let subst_conv th tm = SUBST_CONV [(th,lhs (concl th))] tm tm;;
(*----------------------------------------------------------------------------*)
(* use_equality_subst : bool -> bool -> thm -> conv *)
(* *)
(* Function to perform substitution when using equalities. The first argument *)
(* is a Boolean that controls which side of an equation substitution is to *)
(* take place on. The second argument is also a Boolean, indicating whether *)
(* or not we have decided to cross-fertilize. The third argument is a *)
(* substitution theorem of the form: *)
(* *)
(* t' = s' |- t' = s' *)
(* *)
(* If we are not cross-fertilizing, s' is substituted for t' throughout the *)
(* term. If we are cross-fertilizing, the behaviour depends on the structure *)
(* of the term, tm: *)
(* *)
(* (a) if tm is "l = r", substitute s' for t' in either r or l. *)
(* (b) if tm is "~(l = r)", substitute s' for t' throughout tm. *)
(* (c) otherwise, do not substitute. *)
(*----------------------------------------------------------------------------*)
(* The heuristic above is modified so that in case (c) a substitution does *)
(* take place. This reduces the chances of an invalid subgoal (clause) being *)
(* generated, and has been shown to be a better option for certain examples. *)
let use_equality_subst right cross_fert th tm =
try (if cross_fert
then if (is_eq tm) then
(if right
then RAND_CONV (subst_conv th) tm
else RATOR_CONV (RAND_CONV (subst_conv th)) tm)
else if ((is_neg tm) && (try(is_eq (rand tm)) with Failure _ -> false)) then subst_conv th tm
else (* ALL_CONV tm *) subst_conv th tm
else subst_conv th tm
) with Failure _ -> failwith "use_equality_subst";;
(*----------------------------------------------------------------------------*)
(* EQ_EQ_IMP_DISJ_EQ = *)
(* |- !x x' y y'. (x = x') /\ (y = y') ==> (x \/ y = x' \/ y') *)
(*----------------------------------------------------------------------------*)
let EQ_EQ_IMP_DISJ_EQ =
prove
(`!x x' y y'. (x = x') /\ (y = y') ==> ((x \/ y) = (x' \/ y'))`,
REPEAT STRIP_TAC THEN
ASM_REWRITE_TAC []);;
(*----------------------------------------------------------------------------*)
(* DISJ_EQ : thm -> thm -> thm *)
(* *)
(* |- x = x' |- y = y' *)
(* ------------------------ *)
(* |- (x \/ y) = (x' \/ y') *)
(*----------------------------------------------------------------------------*)
let DISJ_EQ th1 th2 =
try
(let (x,x') = dest_eq (concl th1)
and (y,y') = dest_eq (concl th2)
in MP (SPECL [x;x';y;y'] EQ_EQ_IMP_DISJ_EQ) (CONJ th1 th2)
) with Failure _ -> failwith "DISJ_EQ";;
(*----------------------------------------------------------------------------*)
(* use_equality_heuristic : (term # bool) -> ((term # bool) list # proof) *)
(* *)
(* Heuristic for using equalities, and in particular for cross-fertilizing. *)
(* Given a clause, the function looks for a literal of the form ~(s' = t') *)
(* where t' occurs in another literal and is not an explicit value template. *)
(* If no such literal is present, the function looks for a literal of the *)
(* form ~(t' = s') where t' occurs in another literal and is not an explicit *)
(* value template. If a substitution literal of one of these two forms is *)
(* found, substitution takes place as follows. *)
(* *)
(* If the clause is an induction step, and there is an equality literal *)
(* mentioning t' on the RHS (or LHS if the substitution literal was *)
(* ~(t' = s')), and s' is not an explicit value, the function performs a *)
(* cross-fertilization. The substitution function is called for each literal *)
(* other than the substitution literal. Each call results in a theorem of the *)
(* form: *)
(* *)
(* t' = s' |- old_lit = new_lit *)
(* *)
(* If the clause is an induction step and s' is not an explicit value, the *)
(* substitution literal is rewritten to F, and so will subsequently be *)
(* eliminated. Otherwise this literal is unchanged. The theorems for each *)
(* literal are recombined using the DISJ_EQ rule, and the new clause is *)
(* returned. See the comments for the substitution heuristic for a *)
(* description of how the original clause is proved from the new clause. *)
(*----------------------------------------------------------------------------*)
let use_equality_heuristic (tm,(ind:bool)) =
try (let checkx (tml1,tml2) t' =
(not (is_explicit_value_template t')) &&
((exists (is_subterm t') tml1) || (exists (is_subterm t') tml2))
in let rec split_disjuncts side prevl tml =
if (can (check (checkx (prevl,tl tml)) o side o dest_neg) (hd tml))
then (prevl,tml)
else split_disjuncts side ((hd tml)::prevl) (tl tml)
in let is_subterm_of_side side subterm tm =
(try(is_subterm subterm (side tm)) with Failure _ -> false)
in let literals = disj_list tm
in let (right,(overs,neq'::unders)) =
try (true,(hashI rev) (split_disjuncts rhs [] literals)) with Failure _ ->
(false,(hashI rev) (split_disjuncts lhs [] literals))
in let side = if right then rhs else lhs
in let flipth = if right then ALL_CONV neq' else RAND_CONV SYM_CONV neq'
in let neq = rhs (concl flipth)
in let eq = dest_neg neq
in let (s',t') = dest_eq eq
in let delete = ind && (not (is_explicit_value s'))
in let cross_fert = delete &&
((exists (is_subterm_of_side side t') overs) ||
(exists (is_subterm_of_side side t') unders))
in let sym_eq = mk_eq (t',s')
in let sym_neq = mk_neg sym_eq
in let ass1 = EQ_MP (SYM flipth) (NOT_EQ_SYM (ASSUME sym_neq))
and ass2 = ASSUME sym_eq
in let subsfun = use_equality_subst right cross_fert ass2
in let overths = map subsfun overs
and neqth =
if delete
then TRANS (RAND_CONV (RAND_CONV (subst_conv ass2)) neq)
(ISPEC s' NOT_EQ_F)
else ADD_ASSUM sym_eq (REFL neq)
and underths = map subsfun unders
in let neqth' = TRANS flipth neqth
in let th1 = itlist DISJ2 overs (try DISJ1 ass1 (list_mk_disj unders) with Failure _ -> ass1)
and th2 = itlist DISJ_EQ overths (end_itlist DISJ_EQ (neqth'::underths))
and th3 = SPEC sym_eq EXCLUDED_MIDDLE
in let tm' = rhs (concl th2)
in let proof th = DISJ_CASES th3 (EQ_MP (SYM th2) th) th1
in (proof_print_string_l "-> Use Equality Heuristic" () ;
([(tm',ind)],apply_fproof "use_equality_heuristic" (proof o hd) [tm']))
) with Failure _ -> failwith "use_equality_heuristic`";
|