File size: 5,570 Bytes
d5bfab8 |
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 |
structure tptp :> tptp =
struct
open HolKernel Abbrev boolLib aiLib
val ERR = mk_HOL_ERR "tptp"
(* -------------------------------------------------------------------------
Value statements
------------------------------------------------------------------------- *)
(* variables *)
val lmc = list_mk_comb;
val alpha3 = rpt_fun_type 3 alpha;
val alpha4 = rpt_fun_type 4 alpha;
val vx = mk_var ("Vx",alpha);
val vy = mk_var ("Vy",alpha);
val vz = mk_var ("Vz",alpha);
(* constants *)
val zero = mk_var ("z",alpha);
val suc = mk_var ("s", rpt_fun_type 2 alpha);
fun mk_suc x = mk_comb (suc,x);
(* First-order axioms *)
(* addition *)
val addi = mk_var ("addi",alpha3);
fun mk_addi (a,b) = lmc (addi,[a,b]);
val ax0 = mk_eq (mk_addi (vx,zero), vx);
val ax1 = mk_eq (mk_addi (vx, mk_suc vy), mk_suc (mk_addi (vx,vy)));
(* substraction *)
val diff = mk_var ("diff",alpha3);
fun mk_diff (a,b) = lmc (diff,[a,b]);
val ax2 = mk_eq (mk_diff (vx, zero), vx);
val ax3 = mk_eq (mk_diff (zero, vx), zero);
val ax4 = mk_eq (mk_diff (mk_suc vx, mk_suc vy),
mk_diff (vx,vy));
(* multiplication *)
val mult = mk_var ("mult",alpha3);
fun mk_mult (a,b) = lmc (mult,[a,b]);
val ax5 = mk_eq (mk_mult (vx, zero), zero);
val ax6 = mk_eq (mk_mult (vx, mk_suc vy),
mk_addi (vx, mk_mult (vx,vy)));
(* division *)
val divi = mk_var ("divi",alpha3);
fun mk_divi (a,b) = lmc (divi,[a,b]);
val ax7 = mk_eq (mk_divi (vx, zero), zero);
val sxmy0 = mk_eq (mk_diff (mk_suc vx,vy),zero); (* x < y *)
val ymx0 = mk_eq (mk_diff (vy,vx),zero); (* x >= y *)
val eysz = mk_eq (vy,mk_suc vz); (* y = suc z *)
val ax8 = mk_imp (sxmy0, mk_imp (eysz,
mk_eq (mk_divi (vx,vy),zero)));
val ax9 = mk_imp (ymx0,mk_imp (eysz,
mk_eq (mk_divi (vx,vy), mk_suc (mk_divi (mk_diff (vx,vy),vy)))));
(*
x div 0 = 0
x < y & y = suc z ==> x div y = 0
x >= y & y = suc z ==> x div y = suc ((x - y) div y)
*)
(* modulo *)
val modu = mk_var ("modu",alpha3);
fun mk_modu (a,b) = lmc (modu,[a,b]);
val ax10 = mk_eq (mk_modu (vx, zero), zero);
val ax11 = mk_imp (sxmy0, mk_imp (eysz, mk_eq (mk_modu (vx,vy),vx)));
val ax12 = mk_imp (ymx0,mk_imp (eysz,
mk_eq (mk_modu (vx,vy), mk_modu (mk_diff (vx,vy),vy))
));
(*
x mod 0 = 0
x < y & y = suc z ==> x mod y = x
x >= y & y = suc z ==> x mod y = (x - y) mod y
e(a+b,0) = e(a,0) + e(b,0)
*)
(* -------------------------------------------------------------------------
Program statements and evaluation
------------------------------------------------------------------------- *)
val va = mk_var ("Va",alpha);
val vb = mk_var ("Vb",alpha);
val vc = mk_var ("Vc",alpha);
(* Evaluation (higher-order) *)
val eval = mk_var ("e", alpha3);
fun mk_eval (a,b) = lmc (eval,[a,b]);
val zerop = mk_var ("zerop",alpha);
val onep = mk_var ("onep",alpha);
val twop = mk_var ("twop",alpha);
val addip = mk_var ("addip", alpha3);
val diffp = mk_var ("diffp", alpha3);
val multp = mk_var ("multp", alpha3);
val divip = mk_var ("divip", alpha3);
val modup = mk_var ("modup", alpha3);
val varp = mk_var ("varp", alpha);
val ax14 = mk_eq (lmc (eval, [zerop,vx]), zero);
val ax15 = mk_eq (lmc (eval, [onep,vx]), mk_comb (suc,zero));
val ax16 = mk_eq (lmc (eval, [twop,vx]), mk_comb (suc,mk_comb (suc,zero)));
fun transfer (operp,oper) =
mk_eq (
mk_eval (lmc (operp,[va,vb]),vx),
lmc (oper, [mk_eval (va,vx),mk_eval(vb,vx)])
);
val ax17 = transfer (addip,addi);
val ax18 = transfer (diffp,diff);
val ax19 = transfer (multp,mult);
val ax20 = transfer (divip,divi);
val ax21 = transfer (modup,modu);
val ax22 = mk_eq (lmc (eval, [varp,vx]), vx);
val condp = mk_var ("condp",alpha4);
val cond = mk_var ("cond",rpt_fun_type 5 alpha);
val ax23 = mk_eq (
mk_eval (lmc (condp, [va,vb,vc]),vx),
lmc (cond, [mk_eval (va,vx),vb,vc,vx]));
val ax24 = mk_eq (lmc (cond, [zero,vb,vc,vx]),mk_eval (vb,vx));
val ax25 = mk_eq (lmc (cond, [mk_suc vy,vb,vc,vx]),mk_eval (vc,vx));
(*
e (condp (a,b,c),x) = cond (e(a,x),b,c,x)
cond (0,b,c,x) = e(b,x)
cond (s n,b,c,x) = e(c,x)
*)
val funpowp = mk_var ("funpowp",alpha4);
val funpow = mk_var ("funpow",alpha4);
val ax26 =
mk_eq (
mk_eval (lmc (funpowp, [va,vb,vc]),vx),
lmc (funpow, [va,mk_eval (vb,vx),mk_eval (vc,vx)]));
val ax27 = mk_eq (lmc (funpow, [va,zero,vx]),vx);
val ax28 = mk_eq (lmc (funpow, [va,mk_suc vy,vx]),
lmc (funpow, [va,vy,mk_eval (va,vx)]));
val axl_prev = [ax0,ax1,ax2,ax3,ax4,ax5,ax6,ax7,ax8,ax9,ax10,ax11,ax12]
@ [ax14,ax15,ax16,ax17,ax18,ax19,ax20,ax21,ax22,ax23,ax24,ax25,
ax26,ax27,ax28]
val varl = [vx,vy,vz,va,vb,vc]
fun smart_forall tm =
let val vl = filter (fn x => tmem x varl) (free_vars_lr tm) in
list_mk_forall (vl,tm)
end
val axl = map smart_forall axl_prev
(*
e (funpowp (a,b,c),x) = funpowp (a,e(b,x),e(c,x))
funpow (a,0,x) = x
funpow (a,suc y,x) = funpow_aux (a,y,e(a,x))
*)
(* -------------------------------------------------------------------------
Export conjecture from list of numbers
------------------------------------------------------------------------- *)
(*
?a. e(a,0) = 0 /\ e(a,1) = 2 ...
*)
fun mk_sucn n = if n <= 0 then zero else mk_suc (mk_sucn (n-1))
fun mk_cj seq =
let
val seqi = number_fst 0 seq
fun f(x,y) = mk_eq (mk_eval (va,mk_sucn x), mk_sucn y)
in
mk_exists (va, list_mk_conj (map f seqi))
end
end
(*
load "tptp"; open tptp;
load "hhExportFof"; open hhExportFof;
val seq = List.tabulate (16,fn x => x + 1);
p_flag := false;
type_flag := false;
name_flag := false;
fof_export_goal "tptp/atp_in" (axl,mk_cj seq);
*)
|