Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
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";;
|