Datasets:

Modalities:
Text
Languages:
English
Libraries:
Datasets
License:
File size: 9,217 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
(******************************************************************************)
(* FILE          : induction.ml                                               *)
(* DESCRIPTION   : Induction.                                                 *)
(*                                                                            *)
(* READS FILES   : <none>                                                     *)
(* WRITES FILES  : <none>                                                     *)
(*                                                                            *)
(* AUTHOR        : R.J.Boulton                                                *)
(* DATE          : 26th June 1991                                             *)
(*                                                                            *)
(* LAST MODIFIED : P. Papapanagiotou (University of Edinburgh)                *)
(* DATE          : 2008                                                       *)
(******************************************************************************)

let (CONV_OF_RCONV: conv -> conv) =
  let rec get_bv tm =
    if is_abs tm then bndvar tm
    else if is_comb tm then
         try get_bv (rand tm) with Failure _ -> get_bv (rator tm)
    else failwith "" in
  fun conv tm ->
  let v = get_bv tm in
  let th1 = conv tm in
  let th2 = ONCE_DEPTH_CONV (GEN_ALPHA_CONV v) (rhs(concl th1)) in
  TRANS th1 th2;;

let (CONV_OF_THM: thm -> conv) =
  CONV_OF_RCONV o REWR_CONV;;

let RIGHT_IMP_FORALL_CONV = CONV_OF_THM RIGHT_IMP_FORALL_THM;;
(* Does this work?? *)

(*----------------------------------------------------------------------------*)
(* is_rec_const_app : term -> bool                                            *)
(*                                                                            *)
(* This function returns true if the term it is given is an application of a  *)
(* currently known recursive function constant.                               *)
(*----------------------------------------------------------------------------*)

let is_rec_const_app tm =
try (let (f,args) = strip_comb tm
  in  let (n,defs) = (get_def o fst o dest_const) f
  in  (n > 0) &&
      ((length o snd o strip_comb o lhs o concl o snd o hd) defs = length args)
 ) with Failure _ -> false;;


(*----------------------------------------------------------------------------*)
(* possible_inductions : term -> (term list # term list)                      *)
(*                                                                            *)
(* Function to compute two lists of variables on which induction could be     *)
(* performed. The first list of variables for which the induction is unflawed *)
(* and the second is of variables for which the induction is flawed.          *)
(*                                                                            *)
(* From a list of applications of recursive functions, the arguments are      *)
(* split into those that are in a recursive argument position and those that  *)
(* are not. Possible inductions are on the variables in the recursive         *)
(* argument positions, but if the variable also appears in a non-recursive    *)
(* argument position then the induction is flawed.                            *)
(*----------------------------------------------------------------------------*)

let possible_inductions tm =
   let apps = find_bm_terms is_rec_const_app tm
   in  let (rec_args,other_args) =
          List.split (map (fun app -> let (f,args) = strip_comb app
                            in  let name = fst (dest_const f)
                            in  let n = (fst o get_def) name
                            in  remove_el n args) apps)
   in  let vars = setify (filter is_var rec_args)
   in  let others = setify (flat other_args)
   in  partition (fun v -> not (mem v others)) vars;;

(*----------------------------------------------------------------------------*)
(* DEPTH_FORALL_CONV : conv -> conv                                           *)
(*                                                                            *)
(* Given a term of the form "!x1 ... xn. t", this function applies the        *)
(* argument conversion to "t".                                                *)
(*----------------------------------------------------------------------------*)

let rec DEPTH_FORALL_CONV conv tm =
   if (is_forall tm)
   then RAND_CONV (ABS_CONV (DEPTH_FORALL_CONV conv)) tm
   else conv tm;;

(*----------------------------------------------------------------------------*)
(* induction_heuristic : (term # bool) -> ((term # bool) list # proof)        *)
(*                                                                            *)
(* Heuristic for induction. It performs one of the possible unflawed          *)
(* inductions on a clause, or failing that, one of the flawed inductions.     *)
(* The heuristic fails if no inductions are possible.                         *)
(*                                                                            *)
(* Having obtained a variable on which to perform induction, the function     *)
(* computes the name of the top-level type constructor in the type of the     *)
(* variable. The appropriate induction theorem is then obtained from the      *)
(* shell environment. The theorem is specialised for the argument clause and  *)
(* beta-reduction is performed at the appropriate places.                     *)
(*                                                                            *)
(* The resulting theorem will be of the form:                                 *)
(*                                                                            *)
(*    |- (case1 /\ ... /\ casen) ==> (!x. f[x])                         ( * ) *)
(*                                                                            *)
(* So, if we can establish casei for each i, we shall have |- !x. f[x]. When  *)
(* specialised with the induction variable, this theorem has the original     *)
(* clause as its conclusion. Each casei is of one of these forms:             *)
(*                                                                            *)
(*    !x1 ... xn. s ==> (!y1 ... ym. t)                                       *)
(*    !x1 ... xn. t                                                           *)
(*                                                                            *)
(* where the yi's do not appear in s. We simplify the casei's that have the   *)
(* first form by proving theorems like:                                       *)
(*                                                                            *)
(*    |- (!x1 ... xn. s ==> (!y1 ... ym. t)) =                                *)
(*       (!x1 ... xn y1 ... ym. s ==> t)                                      *)
(*                                                                            *)
(* For consistency, theorems of the form |- (!x1 ... xn. t) = (!x1 ... xn. t) *)
(* are proved for the casei's that have the second form. The bodies of the    *)
(* right-hand sides of these equations are returned as the new goal clauses.  *)
(* A body that is an implication is taken to be an inductive step and so is   *)
(* returned paired with true. Bodies that are not implications are paired     *)
(* with false.                                                                *)
(*                                                                            *)
(* The proof of the original clause from these new clauses proceeds as        *)
(* follows. The universal quantifications that were stripped from the         *)
(* right-hand sides are restored by generalizing the theorems. From the       *)
(* equations we can then obtain theorems for the left-hand sides. These are   *)
(* conjoined and used to satisfy the antecedant of the theorem ( * ). As      *)
(* described above, specialising the resulting theorem gives a theorem for    *)
(* the original clause.                                                       *)
(*----------------------------------------------------------------------------*)

let induction_heuristic (tm,(ind:bool)) =
try
 (let (unflawed,flawed) = possible_inductions tm
  in  let var = try (hd unflawed) with Failure _ -> (hd flawed)
  in  let ty_name = fst (dest_type (type_of var))
  in  let induct_thm = (sys_shell_info ty_name).induct
  in  let P = mk_abs (var,tm)
  in  let th1 = ISPEC P induct_thm
  in  let th2 =
         CONV_RULE
            (ONCE_DEPTH_CONV
                (fun tm -> if (rator tm = P) then BETA_CONV tm else failwith "")) th1
  in  let new_goals = conj_list (rand (rator (concl th2)))
  in  let ths =
         map (REPEATC (DEPTH_FORALL_CONV RIGHT_IMP_FORALL_CONV)) new_goals
  in  let (varsl,tml) = List.split (map (strip_forall o rhs o concl) ths)
  in  let proof thl =
         let thl' = map (uncurry GENL) (lcombinep (varsl,thl))
         in  let thl'' = map (fun (eq,th) -> EQ_MP (SYM eq) th) (lcombinep (ths,thl'))
         in  SPEC var (MP th2 (LIST_CONJ thl''))
  in  (map (fun tm -> (tm,((is_imp tm) && (not (is_neg tm))))) tml,
       apply_fproof "induction_heuristic" proof tml)
 ) with Failure _ -> failwith "induction_heuristic";;