author  wenzelm 
Mon, 10 Dec 2012 15:39:20 +0100  
changeset 50453  262dc5873f80 
parent 48891  c0eafbd55de3 
child 51306  f0e5af7aa68b 
permissions  rwrr 
1477  1 
(* Title: FOLP/IFOLP.thy 
2 
Author: Martin D Coen, Cambridge University Computer Laboratory 

1142  3 
Copyright 1992 University of Cambridge 
4 
*) 

5 

17480  6 
header {* Intuitionistic FirstOrder Logic with Proofs *} 
7 

8 
theory IFOLP 

9 
imports Pure 

10 
begin 

0  11 

48891  12 
ML_file "~~/src/Tools/misc_legacy.ML" 
13 

39557
fe5722fce758
renamed structure PureThy to Pure_Thy and moved most content to Global_Theory, to emphasize that this is globalonly;
wenzelm
parents:
38800
diff
changeset

14 
setup Pure_Thy.old_appl_syntax_setup 
26956
1309a6a0a29f
setup PureThy.old_appl_syntax_setup  theory Pure provides regular application syntax by default;
wenzelm
parents:
26480
diff
changeset

15 

17480  16 
classes "term" 
36452  17 
default_sort "term" 
0  18 

17480  19 
typedecl p 
20 
typedecl o 

0  21 

17480  22 
consts 
0  23 
(*** Judgements ***) 
1477  24 
Proof :: "[o,p]=>prop" 
0  25 
EqProof :: "[p,p,o]=>prop" ("(3_ /= _ :/ _)" [10,10,10] 5) 
17480  26 

0  27 
(*** Logical Connectives  Type Formers ***) 
41310  28 
eq :: "['a,'a] => o" (infixl "=" 50) 
17480  29 
True :: "o" 
30 
False :: "o" 

2714  31 
Not :: "o => o" ("~ _" [40] 40) 
41310  32 
conj :: "[o,o] => o" (infixr "&" 35) 
33 
disj :: "[o,o] => o" (infixr "" 30) 

34 
imp :: "[o,o] => o" (infixr ">" 25) 

35 
iff :: "[o,o] => o" (infixr "<>" 25) 

0  36 
(*Quantifiers*) 
1477  37 
All :: "('a => o) => o" (binder "ALL " 10) 
38 
Ex :: "('a => o) => o" (binder "EX " 10) 

39 
Ex1 :: "('a => o) => o" (binder "EX! " 10) 

0  40 
(*Rewriting gadgets*) 
1477  41 
NORM :: "o => o" 
42 
norm :: "'a => 'a" 

0  43 

648
e27c9ec2b48b
FOLP/IFOLP.thy: tightening precedences to eliminate syntactic ambiguities.
lcp
parents:
283
diff
changeset

44 
(*** Proof Term Formers: precedence must exceed 50 ***) 
1477  45 
tt :: "p" 
46 
contr :: "p=>p" 

17480  47 
fst :: "p=>p" 
48 
snd :: "p=>p" 

1477  49 
pair :: "[p,p]=>p" ("(1<_,/_>)") 
50 
split :: "[p, [p,p]=>p] =>p" 

17480  51 
inl :: "p=>p" 
52 
inr :: "p=>p" 

1477  53 
when :: "[p, p=>p, p=>p]=>p" 
54 
lambda :: "(p => p) => p" (binder "lam " 55) 

41310  55 
App :: "[p,p]=>p" (infixl "`" 60) 
648
e27c9ec2b48b
FOLP/IFOLP.thy: tightening precedences to eliminate syntactic ambiguities.
lcp
parents:
283
diff
changeset

56 
alll :: "['a=>p]=>p" (binder "all " 55) 
41310  57 
app :: "[p,'a]=>p" (infixl "^" 55) 
1477  58 
exists :: "['a,p]=>p" ("(1[_,/_])") 
0  59 
xsplit :: "[p,['a,p]=>p]=>p" 
60 
ideq :: "'a=>p" 

61 
idpeel :: "[p,'a=>p]=>p" 

17480  62 
nrm :: p 
63 
NRM :: p 

0  64 

35113  65 
syntax "_Proof" :: "[p,o]=>prop" ("(_ /: _)" [51, 10] 5) 
66 

38800  67 
parse_translation {* 
68 
let fun proof_tr [p, P] = Const (@{const_syntax Proof}, dummyT) $ P $ p 

69 
in [(@{syntax_const "_Proof"}, proof_tr)] end 

17480  70 
*} 
71 

38800  72 
(*show_proofs = true displays the proof terms  they are ENORMOUS*) 
42616
92715b528e78
added Attrib.setup_config_XXX conveniences, with implicit setup of the background theory;
wenzelm
parents:
41310
diff
changeset

73 
ML {* val show_proofs = Attrib.setup_config_bool @{binding show_proofs} (K false) *} 
38800  74 

75 
print_translation (advanced) {* 

76 
let 

77 
fun proof_tr' ctxt [P, p] = 

78 
if Config.get ctxt show_proofs then Const (@{syntax_const "_Proof"}, dummyT) $ p $ P 

79 
else P 

80 
in [(@{const_syntax Proof}, proof_tr')] end 

81 
*} 

17480  82 

83 
axioms 

0  84 

85 
(**** Propositional logic ****) 

86 

87 
(*Equality*) 

88 
(* Like Intensional Equality in MLTT  but proofs distinct from terms *) 

89 

17480  90 
ieqI: "ideq(a) : a=a" 
91 
ieqE: "[ p : a=b; !!x. f(x) : P(x,x) ] ==> idpeel(p,f) : P(a,b)" 

0  92 

93 
(* Truth and Falsity *) 

94 

17480  95 
TrueI: "tt : True" 
96 
FalseE: "a:False ==> contr(a):P" 

0  97 

98 
(* Conjunction *) 

99 

17480  100 
conjI: "[ a:P; b:Q ] ==> <a,b> : P&Q" 
101 
conjunct1: "p:P&Q ==> fst(p):P" 

102 
conjunct2: "p:P&Q ==> snd(p):Q" 

0  103 

104 
(* Disjunction *) 

105 

17480  106 
disjI1: "a:P ==> inl(a):PQ" 
107 
disjI2: "b:Q ==> inr(b):PQ" 

108 
disjE: "[ a:PQ; !!x. x:P ==> f(x):R; !!x. x:Q ==> g(x):R 

109 
] ==> when(a,f,g):R" 

0  110 

111 
(* Implication *) 

112 

17480  113 
impI: "(!!x. x:P ==> f(x):Q) ==> lam x. f(x):P>Q" 
114 
mp: "[ f:P>Q; a:P ] ==> f`a:Q" 

0  115 

116 
(*Quantifiers*) 

117 

17480  118 
allI: "(!!x. f(x) : P(x)) ==> all x. f(x) : ALL x. P(x)" 
119 
spec: "(f:ALL x. P(x)) ==> f^x : P(x)" 

0  120 

17480  121 
exI: "p : P(x) ==> [x,p] : EX x. P(x)" 
122 
exE: "[ p: EX x. P(x); !!x u. u:P(x) ==> f(x,u) : R ] ==> xsplit(p,f):R" 

0  123 

124 
(**** Equality between proofs ****) 

125 

17480  126 
prefl: "a : P ==> a = a : P" 
127 
psym: "a = b : P ==> b = a : P" 

128 
ptrans: "[ a = b : P; b = c : P ] ==> a = c : P" 

0  129 

17480  130 
idpeelB: "[ !!x. f(x) : P(x,x) ] ==> idpeel(ideq(a),f) = f(a) : P(a,a)" 
0  131 

17480  132 
fstB: "a:P ==> fst(<a,b>) = a : P" 
133 
sndB: "b:Q ==> snd(<a,b>) = b : Q" 

134 
pairEC: "p:P&Q ==> p = <fst(p),snd(p)> : P&Q" 

0  135 

17480  136 
whenBinl: "[ a:P; !!x. x:P ==> f(x) : Q ] ==> when(inl(a),f,g) = f(a) : Q" 
137 
whenBinr: "[ b:P; !!x. x:P ==> g(x) : Q ] ==> when(inr(b),f,g) = g(b) : Q" 

138 
plusEC: "a:PQ ==> when(a,%x. inl(x),%y. inr(y)) = a : PQ" 

0  139 

17480  140 
applyB: "[ a:P; !!x. x:P ==> b(x) : Q ] ==> (lam x. b(x)) ` a = b(a) : Q" 
141 
funEC: "f:P ==> f = lam x. f`x : P" 

0  142 

17480  143 
specB: "[ !!x. f(x) : P(x) ] ==> (all x. f(x)) ^ a = f(a) : P(a)" 
0  144 

145 

146 
(**** Definitions ****) 

147 

17480  148 
not_def: "~P == P>False" 
149 
iff_def: "P<>Q == (P>Q) & (Q>P)" 

0  150 

151 
(*Unique existence*) 

17480  152 
ex1_def: "EX! x. P(x) == EX x. P(x) & (ALL y. P(y) > y=x)" 
0  153 

154 
(*Rewriting  special constants to flag normalized terms and formulae*) 

17480  155 
norm_eq: "nrm : norm(x) = x" 
156 
NORM_iff: "NRM : NORM(P) <> P" 

157 

26322  158 
(*** Sequentstyle elimination rules for & > and ALL ***) 
159 

36319  160 
schematic_lemma conjE: 
26322  161 
assumes "p:P&Q" 
162 
and "!!x y.[ x:P; y:Q ] ==> f(x,y):R" 

163 
shows "?a:R" 

164 
apply (rule assms(2)) 

165 
apply (rule conjunct1 [OF assms(1)]) 

166 
apply (rule conjunct2 [OF assms(1)]) 

167 
done 

168 

36319  169 
schematic_lemma impE: 
26322  170 
assumes "p:P>Q" 
171 
and "q:P" 

172 
and "!!x. x:Q ==> r(x):R" 

173 
shows "?p:R" 

174 
apply (rule assms mp)+ 

175 
done 

176 

36319  177 
schematic_lemma allE: 
26322  178 
assumes "p:ALL x. P(x)" 
179 
and "!!y. y:P(x) ==> q(y):R" 

180 
shows "?p:R" 

181 
apply (rule assms spec)+ 

182 
done 

183 

184 
(*Duplicates the quantifier; for use with eresolve_tac*) 

36319  185 
schematic_lemma all_dupE: 
26322  186 
assumes "p:ALL x. P(x)" 
187 
and "!!y z.[ y:P(x); z:ALL x. P(x) ] ==> q(y,z):R" 

188 
shows "?p:R" 

189 
apply (rule assms spec)+ 

190 
done 

191 

192 

193 
(*** Negation rules, which translate between ~P and P>False ***) 

194 

36319  195 
schematic_lemma notI: 
26322  196 
assumes "!!x. x:P ==> q(x):False" 
197 
shows "?p:~P" 

198 
unfolding not_def 

199 
apply (assumption  rule assms impI)+ 

200 
done 

201 

36319  202 
schematic_lemma notE: "p:~P \<Longrightarrow> q:P \<Longrightarrow> ?p:R" 
26322  203 
unfolding not_def 
204 
apply (drule (1) mp) 

205 
apply (erule FalseE) 

206 
done 

207 

208 
(*This is useful with the special implication rules for each kind of P. *) 

36319  209 
schematic_lemma not_to_imp: 
26322  210 
assumes "p:~P" 
211 
and "!!x. x:(P>False) ==> q(x):Q" 

212 
shows "?p:Q" 

213 
apply (assumption  rule assms impI notE)+ 

214 
done 

215 

216 
(* For substitution int an assumption P, reduce Q to P>Q, substitute into 

27150  217 
this implication, then apply impI to move P back into the assumptions.*) 
36319  218 
schematic_lemma rev_mp: "[ p:P; q:P > Q ] ==> ?p:Q" 
26322  219 
apply (assumption  rule mp)+ 
220 
done 

221 

222 

223 
(*Contrapositive of an inference rule*) 

36319  224 
schematic_lemma contrapos: 
26322  225 
assumes major: "p:~Q" 
226 
and minor: "!!y. y:P==>q(y):Q" 

227 
shows "?a:~P" 

228 
apply (rule major [THEN notE, THEN notI]) 

229 
apply (erule minor) 

230 
done 

231 

232 
(** Unique assumption tactic. 

233 
Ignores proof objects. 

234 
Fails unless one assumption is equal and exactly one is unifiable 

235 
**) 

236 

237 
ML {* 

238 
local 

239 
fun discard_proof (Const (@{const_name Proof}, _) $ P $ _) = P; 

240 
in 

241 
val uniq_assume_tac = 

242 
SUBGOAL 

243 
(fn (prem,i) => 

244 
let val hyps = map discard_proof (Logic.strip_assums_hyp prem) 

245 
and concl = discard_proof (Logic.strip_assums_concl prem) 

246 
in 

247 
if exists (fn hyp => hyp aconv concl) hyps 

29269
5c25a2012975
moved term order operations to structure TermOrd (cf. Pure/term_ord.ML);
wenzelm
parents:
27152
diff
changeset

248 
then case distinct (op =) (filter (fn hyp => Term.could_unify (hyp, concl)) hyps) of 
26322  249 
[_] => assume_tac i 
250 
 _ => no_tac 

251 
else no_tac 

252 
end); 

253 
end; 

254 
*} 

255 

256 

257 
(*** Modus Ponens Tactics ***) 

258 

259 
(*Finds P>Q and P in the assumptions, replaces implication by Q *) 

260 
ML {* 

261 
fun mp_tac i = eresolve_tac [@{thm notE}, make_elim @{thm mp}] i THEN assume_tac i 

262 
*} 

263 

264 
(*Like mp_tac but instantiates no variables*) 

265 
ML {* 

266 
fun int_uniq_mp_tac i = eresolve_tac [@{thm notE}, @{thm impE}] i THEN uniq_assume_tac i 

267 
*} 

268 

269 

270 
(*** Ifandonlyif ***) 

271 

36319  272 
schematic_lemma iffI: 
26322  273 
assumes "!!x. x:P ==> q(x):Q" 
274 
and "!!x. x:Q ==> r(x):P" 

275 
shows "?p:P<>Q" 

276 
unfolding iff_def 

277 
apply (assumption  rule assms conjI impI)+ 

278 
done 

279 

280 

281 
(*Observe use of rewrite_rule to unfold "<>" in metaassumptions (prems) *) 

282 

36319  283 
schematic_lemma iffE: 
26322  284 
assumes "p:P <> Q" 
285 
and "!!x y.[ x:P>Q; y:Q>P ] ==> q(x,y):R" 

286 
shows "?p:R" 

287 
apply (rule conjE) 

288 
apply (rule assms(1) [unfolded iff_def]) 

289 
apply (rule assms(2)) 

290 
apply assumption+ 

291 
done 

292 

293 
(* Destruct rules for <> similar to Modus Ponens *) 

294 

36319  295 
schematic_lemma iffD1: "[ p:P <> Q; q:P ] ==> ?p:Q" 
26322  296 
unfolding iff_def 
297 
apply (rule conjunct1 [THEN mp], assumption+) 

298 
done 

299 

36319  300 
schematic_lemma iffD2: "[ p:P <> Q; q:Q ] ==> ?p:P" 
26322  301 
unfolding iff_def 
302 
apply (rule conjunct2 [THEN mp], assumption+) 

303 
done 

304 

36319  305 
schematic_lemma iff_refl: "?p:P <> P" 
26322  306 
apply (rule iffI) 
307 
apply assumption+ 

308 
done 

309 

36319  310 
schematic_lemma iff_sym: "p:Q <> P ==> ?p:P <> Q" 
26322  311 
apply (erule iffE) 
312 
apply (rule iffI) 

313 
apply (erule (1) mp)+ 

314 
done 

315 

36319  316 
schematic_lemma iff_trans: "[ p:P <> Q; q:Q<> R ] ==> ?p:P <> R" 
26322  317 
apply (rule iffI) 
318 
apply (assumption  erule iffE  erule (1) impE)+ 

319 
done 

320 

321 
(*** Unique existence. NOTE THAT the following 2 quantifications 

322 
EX!x such that [EX!y such that P(x,y)] (sequential) 

323 
EX!x,y such that P(x,y) (simultaneous) 

324 
do NOT mean the same thing. The parser treats EX!x y.P(x,y) as sequential. 

325 
***) 

326 

36319  327 
schematic_lemma ex1I: 
26322  328 
assumes "p:P(a)" 
329 
and "!!x u. u:P(x) ==> f(u) : x=a" 

330 
shows "?p:EX! x. P(x)" 

331 
unfolding ex1_def 

332 
apply (assumption  rule assms exI conjI allI impI)+ 

333 
done 

334 

36319  335 
schematic_lemma ex1E: 
26322  336 
assumes "p:EX! x. P(x)" 
337 
and "!!x u v. [ u:P(x); v:ALL y. P(y) > y=x ] ==> f(x,u,v):R" 

338 
shows "?a : R" 

339 
apply (insert assms(1) [unfolded ex1_def]) 

340 
apply (erule exE conjE  assumption  rule assms(1))+ 

29305  341 
apply (erule assms(2), assumption) 
26322  342 
done 
343 

344 

345 
(*** <> congruence rules for simplification ***) 

346 

347 
(*Use iffE on a premise. For conj_cong, imp_cong, all_cong, ex_cong*) 

348 
ML {* 

349 
fun iff_tac prems i = 

350 
resolve_tac (prems RL [@{thm iffE}]) i THEN 

351 
REPEAT1 (eresolve_tac [asm_rl, @{thm mp}] i) 

352 
*} 

353 

36319  354 
schematic_lemma conj_cong: 
26322  355 
assumes "p:P <> P'" 
356 
and "!!x. x:P' ==> q(x):Q <> Q'" 

357 
shows "?p:(P&Q) <> (P'&Q')" 

358 
apply (insert assms(1)) 

359 
apply (assumption  rule iffI conjI  

360 
erule iffE conjE mp  tactic {* iff_tac @{thms assms} 1 *})+ 

361 
done 

362 

36319  363 
schematic_lemma disj_cong: 
26322  364 
"[ p:P <> P'; q:Q <> Q' ] ==> ?p:(PQ) <> (P'Q')" 
365 
apply (erule iffE disjE disjI1 disjI2  assumption  rule iffI  tactic {* mp_tac 1 *})+ 

366 
done 

367 

36319  368 
schematic_lemma imp_cong: 
26322  369 
assumes "p:P <> P'" 
370 
and "!!x. x:P' ==> q(x):Q <> Q'" 

371 
shows "?p:(P>Q) <> (P'>Q')" 

372 
apply (insert assms(1)) 

373 
apply (assumption  rule iffI impI  erule iffE  tactic {* mp_tac 1 *}  

374 
tactic {* iff_tac @{thms assms} 1 *})+ 

375 
done 

376 

36319  377 
schematic_lemma iff_cong: 
26322  378 
"[ p:P <> P'; q:Q <> Q' ] ==> ?p:(P<>Q) <> (P'<>Q')" 
379 
apply (erule iffE  assumption  rule iffI  tactic {* mp_tac 1 *})+ 

380 
done 

381 

36319  382 
schematic_lemma not_cong: 
26322  383 
"p:P <> P' ==> ?p:~P <> ~P'" 
384 
apply (assumption  rule iffI notI  tactic {* mp_tac 1 *}  erule iffE notE)+ 

385 
done 

386 

36319  387 
schematic_lemma all_cong: 
26322  388 
assumes "!!x. f(x):P(x) <> Q(x)" 
389 
shows "?p:(ALL x. P(x)) <> (ALL x. Q(x))" 

390 
apply (assumption  rule iffI allI  tactic {* mp_tac 1 *}  erule allE  

391 
tactic {* iff_tac @{thms assms} 1 *})+ 

392 
done 

393 

36319  394 
schematic_lemma ex_cong: 
26322  395 
assumes "!!x. f(x):P(x) <> Q(x)" 
396 
shows "?p:(EX x. P(x)) <> (EX x. Q(x))" 

397 
apply (erule exE  assumption  rule iffI exI  tactic {* mp_tac 1 *}  

398 
tactic {* iff_tac @{thms assms} 1 *})+ 

399 
done 

400 

401 
(*NOT PROVED 

402 
bind_thm ("ex1_cong", prove_goal (the_context ()) 

403 
"(!!x.f(x):P(x) <> Q(x)) ==> ?p:(EX! x.P(x)) <> (EX! x.Q(x))" 

404 
(fn prems => 

405 
[ (REPEAT (eresolve_tac [ex1E, spec RS mp] 1 ORELSE ares_tac [iffI,ex1I] 1 

406 
ORELSE mp_tac 1 

407 
ORELSE iff_tac prems 1)) ])) 

408 
*) 

409 

410 
(*** Equality rules ***) 

411 

412 
lemmas refl = ieqI 

413 

36319  414 
schematic_lemma subst: 
26322  415 
assumes prem1: "p:a=b" 
416 
and prem2: "q:P(a)" 

417 
shows "?p : P(b)" 

418 
apply (rule prem2 [THEN rev_mp]) 

419 
apply (rule prem1 [THEN ieqE]) 

420 
apply (rule impI) 

421 
apply assumption 

422 
done 

423 

36319  424 
schematic_lemma sym: "q:a=b ==> ?c:b=a" 
26322  425 
apply (erule subst) 
426 
apply (rule refl) 

427 
done 

428 

36319  429 
schematic_lemma trans: "[ p:a=b; q:b=c ] ==> ?d:a=c" 
26322  430 
apply (erule (1) subst) 
431 
done 

432 

433 
(** ~ b=a ==> ~ a=b **) 

36319  434 
schematic_lemma not_sym: "p:~ b=a ==> ?q:~ a=b" 
26322  435 
apply (erule contrapos) 
436 
apply (erule sym) 

437 
done 

438 

45594  439 
schematic_lemma ssubst: "p:b=a \<Longrightarrow> q:P(a) \<Longrightarrow> ?p:P(b)" 
440 
apply (drule sym) 

441 
apply (erule subst) 

442 
apply assumption 

443 
done 

26322  444 

445 
(*A special case of ex1E that would otherwise need quantifier expansion*) 

36319  446 
schematic_lemma ex1_equalsE: "[ p:EX! x. P(x); q:P(a); r:P(b) ] ==> ?d:a=b" 
26322  447 
apply (erule ex1E) 
448 
apply (rule trans) 

449 
apply (rule_tac [2] sym) 

450 
apply (assumption  erule spec [THEN mp])+ 

451 
done 

452 

453 
(** Polymorphic congruence rules **) 

454 

36319  455 
schematic_lemma subst_context: "[ p:a=b ] ==> ?d:t(a)=t(b)" 
26322  456 
apply (erule ssubst) 
457 
apply (rule refl) 

458 
done 

459 

36319  460 
schematic_lemma subst_context2: "[ p:a=b; q:c=d ] ==> ?p:t(a,c)=t(b,d)" 
26322  461 
apply (erule ssubst)+ 
462 
apply (rule refl) 

463 
done 

464 

36319  465 
schematic_lemma subst_context3: "[ p:a=b; q:c=d; r:e=f ] ==> ?p:t(a,c,e)=t(b,d,f)" 
26322  466 
apply (erule ssubst)+ 
467 
apply (rule refl) 

468 
done 

469 

470 
(*Useful with eresolve_tac for proving equalties from known equalities. 

471 
a = b 

472 
  

473 
c = d *) 

36319  474 
schematic_lemma box_equals: "[ p:a=b; q:a=c; r:b=d ] ==> ?p:c=d" 
26322  475 
apply (rule trans) 
476 
apply (rule trans) 

477 
apply (rule sym) 

478 
apply assumption+ 

479 
done 

480 

481 
(*Dual of box_equals: for proving equalities backwards*) 

36319  482 
schematic_lemma simp_equals: "[ p:a=c; q:b=d; r:c=d ] ==> ?p:a=b" 
26322  483 
apply (rule trans) 
484 
apply (rule trans) 

485 
apply (assumption  rule sym)+ 

486 
done 

487 

488 
(** Congruence rules for predicate letters **) 

489 

36319  490 
schematic_lemma pred1_cong: "p:a=a' ==> ?p:P(a) <> P(a')" 
26322  491 
apply (rule iffI) 
492 
apply (tactic {* DEPTH_SOLVE (atac 1 ORELSE eresolve_tac [@{thm subst}, @{thm ssubst}] 1) *}) 

493 
done 

494 

36319  495 
schematic_lemma pred2_cong: "[ p:a=a'; q:b=b' ] ==> ?p:P(a,b) <> P(a',b')" 
26322  496 
apply (rule iffI) 
497 
apply (tactic {* DEPTH_SOLVE (atac 1 ORELSE eresolve_tac [@{thm subst}, @{thm ssubst}] 1) *}) 

498 
done 

499 

36319  500 
schematic_lemma pred3_cong: "[ p:a=a'; q:b=b'; r:c=c' ] ==> ?p:P(a,b,c) <> P(a',b',c')" 
26322  501 
apply (rule iffI) 
502 
apply (tactic {* DEPTH_SOLVE (atac 1 ORELSE eresolve_tac [@{thm subst}, @{thm ssubst}] 1) *}) 

503 
done 

504 

27152
192954a9a549
changed pred_congs: merely cover pred1_cong pred2_cong pred3_cong;
wenzelm
parents:
27150
diff
changeset

505 
lemmas pred_congs = pred1_cong pred2_cong pred3_cong 
26322  506 

507 
(*special case for the equality predicate!*) 

45602  508 
lemmas eq_cong = pred2_cong [where P = "op ="] 
26322  509 

510 

511 
(*** Simplifications of assumed implications. 

512 
Roy Dyckhoff has proved that conj_impE, disj_impE, and imp_impE 

513 
used with mp_tac (restricted to atomic formulae) is COMPLETE for 

514 
intuitionistic propositional logic. See 

515 
R. Dyckhoff, Contractionfree sequent calculi for intuitionistic logic 

516 
(preprint, University of St Andrews, 1991) ***) 

517 

36319  518 
schematic_lemma conj_impE: 
26322  519 
assumes major: "p:(P&Q)>S" 
520 
and minor: "!!x. x:P>(Q>S) ==> q(x):R" 

521 
shows "?p:R" 

522 
apply (assumption  rule conjI impI major [THEN mp] minor)+ 

523 
done 

524 

36319  525 
schematic_lemma disj_impE: 
26322  526 
assumes major: "p:(PQ)>S" 
527 
and minor: "!!x y.[ x:P>S; y:Q>S ] ==> q(x,y):R" 

528 
shows "?p:R" 

529 
apply (tactic {* DEPTH_SOLVE (atac 1 ORELSE 

530 
resolve_tac [@{thm disjI1}, @{thm disjI2}, @{thm impI}, 

531 
@{thm major} RS @{thm mp}, @{thm minor}] 1) *}) 

532 
done 

533 

534 
(*Simplifies the implication. Classical version is stronger. 

535 
Still UNSAFE since Q must be provable  backtracking needed. *) 

36319  536 
schematic_lemma imp_impE: 
26322  537 
assumes major: "p:(P>Q)>S" 
538 
and r1: "!!x y.[ x:P; y:Q>S ] ==> q(x,y):Q" 

539 
and r2: "!!x. x:S ==> r(x):R" 

540 
shows "?p:R" 

541 
apply (assumption  rule impI major [THEN mp] r1 r2)+ 

542 
done 

543 

544 
(*Simplifies the implication. Classical version is stronger. 

545 
Still UNSAFE since ~P must be provable  backtracking needed. *) 

36319  546 
schematic_lemma not_impE: 
26322  547 
assumes major: "p:~P > S" 
548 
and r1: "!!y. y:P ==> q(y):False" 

549 
and r2: "!!y. y:S ==> r(y):R" 

550 
shows "?p:R" 

551 
apply (assumption  rule notI impI major [THEN mp] r1 r2)+ 

552 
done 

553 

554 
(*Simplifies the implication. UNSAFE. *) 

36319  555 
schematic_lemma iff_impE: 
26322  556 
assumes major: "p:(P<>Q)>S" 
557 
and r1: "!!x y.[ x:P; y:Q>S ] ==> q(x,y):Q" 

558 
and r2: "!!x y.[ x:Q; y:P>S ] ==> r(x,y):P" 

559 
and r3: "!!x. x:S ==> s(x):R" 

560 
shows "?p:R" 

561 
apply (assumption  rule iffI impI major [THEN mp] r1 r2 r3)+ 

562 
done 

563 

564 
(*What if (ALL x.~~P(x)) > ~~(ALL x.P(x)) is an assumption? UNSAFE*) 

36319  565 
schematic_lemma all_impE: 
26322  566 
assumes major: "p:(ALL x. P(x))>S" 
567 
and r1: "!!x. q:P(x)" 

568 
and r2: "!!y. y:S ==> r(y):R" 

569 
shows "?p:R" 

570 
apply (assumption  rule allI impI major [THEN mp] r1 r2)+ 

571 
done 

572 

573 
(*Unsafe: (EX x.P(x))>S is equivalent to ALL x.P(x)>S. *) 

36319  574 
schematic_lemma ex_impE: 
26322  575 
assumes major: "p:(EX x. P(x))>S" 
576 
and r: "!!y. y:P(a)>S ==> q(y):R" 

577 
shows "?p:R" 

578 
apply (assumption  rule exI impI major [THEN mp] r)+ 

579 
done 

580 

581 

36319  582 
schematic_lemma rev_cut_eq: 
26322  583 
assumes "p:a=b" 
584 
and "!!x. x:a=b ==> f(x):R" 

585 
shows "?p:R" 

586 
apply (rule assms)+ 

587 
done 

588 

589 
lemma thin_refl: "!!X. [p:x=x; PROP W] ==> PROP W" . 

590 

48891  591 
ML_file "hypsubst.ML" 
26322  592 

593 
ML {* 

42799  594 
structure Hypsubst = Hypsubst 
595 
( 

26322  596 
(*Take apart an equality judgement; otherwise raise Match!*) 
597 
fun dest_eq (Const (@{const_name Proof}, _) $ 

41310  598 
(Const (@{const_name eq}, _) $ t $ u) $ _) = (t, u); 
26322  599 

600 
val imp_intr = @{thm impI} 

601 

602 
(*etac rev_cut_eq moves an equality to be the last premise. *) 

603 
val rev_cut_eq = @{thm rev_cut_eq} 

604 

605 
val rev_mp = @{thm rev_mp} 

606 
val subst = @{thm subst} 

607 
val sym = @{thm sym} 

608 
val thin_refl = @{thm thin_refl} 

42799  609 
); 
26322  610 
open Hypsubst; 
611 
*} 

612 

48891  613 
ML_file "intprover.ML" 
26322  614 

615 

616 
(*** Rewrite rules ***) 

617 

36319  618 
schematic_lemma conj_rews: 
26322  619 
"?p1 : P & True <> P" 
620 
"?p2 : True & P <> P" 

621 
"?p3 : P & False <> False" 

622 
"?p4 : False & P <> False" 

623 
"?p5 : P & P <> P" 

624 
"?p6 : P & ~P <> False" 

625 
"?p7 : ~P & P <> False" 

626 
"?p8 : (P & Q) & R <> P & (Q & R)" 

627 
apply (tactic {* fn st => IntPr.fast_tac 1 st *})+ 

628 
done 

629 

36319  630 
schematic_lemma disj_rews: 
26322  631 
"?p1 : P  True <> True" 
632 
"?p2 : True  P <> True" 

633 
"?p3 : P  False <> P" 

634 
"?p4 : False  P <> P" 

635 
"?p5 : P  P <> P" 

636 
"?p6 : (P  Q)  R <> P  (Q  R)" 

637 
apply (tactic {* IntPr.fast_tac 1 *})+ 

638 
done 

639 

36319  640 
schematic_lemma not_rews: 
26322  641 
"?p1 : ~ False <> True" 
642 
"?p2 : ~ True <> False" 

643 
apply (tactic {* IntPr.fast_tac 1 *})+ 

644 
done 

645 

36319  646 
schematic_lemma imp_rews: 
26322  647 
"?p1 : (P > False) <> ~P" 
648 
"?p2 : (P > True) <> True" 

649 
"?p3 : (False > P) <> True" 

650 
"?p4 : (True > P) <> P" 

651 
"?p5 : (P > P) <> True" 

652 
"?p6 : (P > ~P) <> ~P" 

653 
apply (tactic {* IntPr.fast_tac 1 *})+ 

654 
done 

655 

36319  656 
schematic_lemma iff_rews: 
26322  657 
"?p1 : (True <> P) <> P" 
658 
"?p2 : (P <> True) <> P" 

659 
"?p3 : (P <> P) <> True" 

660 
"?p4 : (False <> P) <> ~P" 

661 
"?p5 : (P <> False) <> ~P" 

662 
apply (tactic {* IntPr.fast_tac 1 *})+ 

663 
done 

664 

36319  665 
schematic_lemma quant_rews: 
26322  666 
"?p1 : (ALL x. P) <> P" 
667 
"?p2 : (EX x. P) <> P" 

668 
apply (tactic {* IntPr.fast_tac 1 *})+ 

669 
done 

670 

671 
(*These are NOT supplied by default!*) 

36319  672 
schematic_lemma distrib_rews1: 
26322  673 
"?p1 : ~(PQ) <> ~P & ~Q" 
674 
"?p2 : P & (Q  R) <> P&Q  P&R" 

675 
"?p3 : (Q  R) & P <> Q&P  R&P" 

676 
"?p4 : (P  Q > R) <> (P > R) & (Q > R)" 

677 
apply (tactic {* IntPr.fast_tac 1 *})+ 

678 
done 

679 

36319  680 
schematic_lemma distrib_rews2: 
26322  681 
"?p1 : ~(EX x. NORM(P(x))) <> (ALL x. ~NORM(P(x)))" 
682 
"?p2 : ((EX x. NORM(P(x))) > Q) <> (ALL x. NORM(P(x)) > Q)" 

683 
"?p3 : (EX x. NORM(P(x))) & NORM(Q) <> (EX x. NORM(P(x)) & NORM(Q))" 

684 
"?p4 : NORM(Q) & (EX x. NORM(P(x))) <> (EX x. NORM(Q) & NORM(P(x)))" 

685 
apply (tactic {* IntPr.fast_tac 1 *})+ 

686 
done 

687 

688 
lemmas distrib_rews = distrib_rews1 distrib_rews2 

689 

36319  690 
schematic_lemma P_Imp_P_iff_T: "p:P ==> ?p:(P <> True)" 
26322  691 
apply (tactic {* IntPr.fast_tac 1 *}) 
692 
done 

693 

36319  694 
schematic_lemma not_P_imp_P_iff_F: "p:~P ==> ?p:(P <> False)" 
26322  695 
apply (tactic {* IntPr.fast_tac 1 *}) 
696 
done 

0  697 

698 
end 