Datasets:

Modalities:
Text
Languages:
English
Libraries:
Datasets
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`";