src/HOL/HOL.thy
author wenzelm
Thu, 19 Oct 2023 16:31:17 +0200
changeset 78799 807b249f1061
parent 78794 c74fd21af246
child 78800 0b3700d31758
permissions -rw-r--r--
clarified syntax and order of parameters;
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
     1
(*  Title:      HOL/HOL.thy
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
     2
    Author:     Tobias Nipkow, Markus Wenzel, and Larry Paulson
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
     3
*)
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
     4
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
     5
section \<open>The basis of Higher-Order Logic\<close>
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
     6
15131
c69542757a4d New theory header syntax.
nipkow
parents: 15103
diff changeset
     7
theory HOL
70853
c92ae7b0f3f1 clarified sessions/directories;
wenzelm
parents: 70849
diff changeset
     8
imports Pure Tools.Code_Generator
46950
d0181abdbdac declare command keywords via theory header, including strict checking outside Pure;
wenzelm
parents: 46497
diff changeset
     9
keywords
52432
c03090937c3b tuned message -- more markup;
wenzelm
parents: 52230
diff changeset
    10
  "try" "solve_direct" "quickcheck" "print_coercions" "print_claset"
c03090937c3b tuned message -- more markup;
wenzelm
parents: 52230
diff changeset
    11
    "print_induct_rules" :: diag and
47657
1ba213363d0c moved modules with only vague relation to the code generator to theory HOL rather than theory Code_Generator
haftmann
parents: 46973
diff changeset
    12
  "quickcheck_params" :: thy_decl
71833
ff6f3b09b8b4 abbrevs for the Uniq quantifier; trying Sup_nat_def to allow zero (experimentally)
paulson <lp15@cam.ac.uk>
parents: 71827
diff changeset
    13
abbrevs "?<" = "\<exists>\<^sub>\<le>\<^sub>1"
15131
c69542757a4d New theory header syntax.
nipkow
parents: 15103
diff changeset
    14
begin
2260
b59781f2b809 added symbols syntax;
wenzelm
parents: 1674
diff changeset
    15
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    16
ML_file \<open>~~/src/Tools/misc_legacy.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    17
ML_file \<open>~~/src/Tools/try.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    18
ML_file \<open>~~/src/Tools/quickcheck.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    19
ML_file \<open>~~/src/Tools/solve_direct.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    20
ML_file \<open>~~/src/Tools/IsaPlanner/zipper.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    21
ML_file \<open>~~/src/Tools/IsaPlanner/isand.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    22
ML_file \<open>~~/src/Tools/IsaPlanner/rw_inst.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    23
ML_file \<open>~~/src/Provers/hypsubst.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    24
ML_file \<open>~~/src/Provers/splitter.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    25
ML_file \<open>~~/src/Provers/classical.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    26
ML_file \<open>~~/src/Provers/blast.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    27
ML_file \<open>~~/src/Provers/clasimp.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    28
ML_file \<open>~~/src/Tools/eqsubst.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    29
ML_file \<open>~~/src/Provers/quantifier1.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    30
ML_file \<open>~~/src/Tools/atomize_elim.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    31
ML_file \<open>~~/src/Tools/cong_tac.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    32
ML_file \<open>~~/src/Tools/intuitionistic.ML\<close> setup \<open>Intuitionistic.method_setup \<^binding>\<open>iprover\<close>\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    33
ML_file \<open>~~/src/Tools/project_rule.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    34
ML_file \<open>~~/src/Tools/subtyping.ML\<close>
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
    35
ML_file \<open>~~/src/Tools/case_product.ML\<close>
48891
c0eafbd55de3 prefer ML_file over old uses;
wenzelm
parents: 48776
diff changeset
    36
30165
6ee87f67d9cd moved generic intuitionistic prover to src/Tools/intuitionistic.ML;
wenzelm
parents: 30160
diff changeset
    37
67149
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    38
ML \<open>Plugin_Name.declare_setup \<^binding>\<open>extraction\<close>\<close>
58659
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    39
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    40
ML \<open>
67149
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    41
  Plugin_Name.declare_setup \<^binding>\<open>quickcheck_random\<close>;
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    42
  Plugin_Name.declare_setup \<^binding>\<open>quickcheck_exhaustive\<close>;
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    43
  Plugin_Name.declare_setup \<^binding>\<open>quickcheck_bounded_forall\<close>;
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    44
  Plugin_Name.declare_setup \<^binding>\<open>quickcheck_full_exhaustive\<close>;
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    45
  Plugin_Name.declare_setup \<^binding>\<open>quickcheck_narrowing\<close>;
58659
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    46
\<close>
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    47
ML \<open>
67149
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    48
  Plugin_Name.define_setup \<^binding>\<open>quickcheck\<close>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    49
   [\<^plugin>\<open>quickcheck_exhaustive\<close>,
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    50
    \<^plugin>\<open>quickcheck_random\<close>,
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    51
    \<^plugin>\<open>quickcheck_bounded_forall\<close>,
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    52
    \<^plugin>\<open>quickcheck_full_exhaustive\<close>,
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    53
    \<^plugin>\<open>quickcheck_narrowing\<close>]
58659
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    54
\<close>
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    55
6c9821c32dd5 Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents: 57964
diff changeset
    56
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
    57
subsection \<open>Primitive logic\<close>
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
    58
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    59
text \<open>
77172
816959264c32 isabelle update -u cite -l "";
wenzelm
parents: 75669
diff changeset
    60
The definition of the logic is based on Mike Gordon's technical report \<^cite>\<open>"Gordon-TR68"\<close> that
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    61
describes the first implementation of HOL. However, there are a number of differences.
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    62
In particular, we start with the definite description operator and introduce Hilbert's \<open>\<epsilon>\<close> operator
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    63
only much later. Moreover, axiom \<open>(P \<longrightarrow> Q) \<longrightarrow> (Q \<longrightarrow> P) \<longrightarrow> (P = Q)\<close> is derived from the other
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    64
axioms. The fact that this axiom is derivable was first noticed by Bruno Barras (for Mike Gordon's
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    65
line of HOL systems) and later independently by Alexander Maletzky (for Isabelle/HOL).
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    66
\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
    67
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
    68
subsubsection \<open>Core syntax\<close>
2260
b59781f2b809 added symbols syntax;
wenzelm
parents: 1674
diff changeset
    69
67149
e61557884799 prefer control symbol antiquotations;
wenzelm
parents: 67091
diff changeset
    70
setup \<open>Axclass.class_axiomatization (\<^binding>\<open>type\<close>, [])\<close>
36452
d37c6eed8117 renamed command 'defaultsort' to 'default_sort';
wenzelm
parents: 36365
diff changeset
    71
default_sort type
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
    72
setup \<open>Object_Logic.add_base_sort \<^sort>\<open>type\<close>\<close>
25460
b80087af2274 interpretation of typedecls: instantiation to class type
haftmann
parents: 25388
diff changeset
    73
70879
0b320e92485c tuned signature;
wenzelm
parents: 70853
diff changeset
    74
setup \<open>Proofterm.set_preproc (Proof_Rewrite_Rules.standard_preproc [])\<close>
70849
ef77ddd9cc6a setup preprocessing for HOL proofs;
wenzelm
parents: 70847
diff changeset
    75
55383
a416780523e2 more explicit axiomatization;
wenzelm
parents: 55239
diff changeset
    76
axiomatization where fun_arity: "OFCLASS('a \<Rightarrow> 'b, type_class)"
a416780523e2 more explicit axiomatization;
wenzelm
parents: 55239
diff changeset
    77
instance "fun" :: (type, type) type by (rule fun_arity)
a416780523e2 more explicit axiomatization;
wenzelm
parents: 55239
diff changeset
    78
a416780523e2 more explicit axiomatization;
wenzelm
parents: 55239
diff changeset
    79
axiomatization where itself_arity: "OFCLASS('a itself, type_class)"
a416780523e2 more explicit axiomatization;
wenzelm
parents: 55239
diff changeset
    80
instance itself :: (type) type by (rule itself_arity)
25460
b80087af2274 interpretation of typedecls: instantiation to class type
haftmann
parents: 25388
diff changeset
    81
7357
d0e16da40ea2 proper bootstrap of HOL theory and packages;
wenzelm
parents: 7238
diff changeset
    82
typedecl bool
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
    83
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    84
judgment Trueprop :: "bool \<Rightarrow> prop"  ("(_)" 5)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    85
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    86
axiomatization implies :: "[bool, bool] \<Rightarrow> bool"  (infixr "\<longrightarrow>" 25)
68973
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    87
  and eq :: "['a, 'a] \<Rightarrow> bool"
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    88
  and The :: "('a \<Rightarrow> bool) \<Rightarrow> 'a"
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    89
68973
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    90
notation (input)
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    91
  eq  (infixl "=" 50)
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    92
notation (output)
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    93
  eq  (infix "=" 50)
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    94
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    95
text \<open>The input syntax for \<open>eq\<close> is more permissive than the output syntax
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
    96
because of the large amount of material that relies on infixl.\<close>
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
    97
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    98
subsubsection \<open>Defined connectives and quantifiers\<close>
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
    99
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   100
definition True :: bool
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   101
  where "True \<equiv> ((\<lambda>x::bool. x) = (\<lambda>x. x))"
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   102
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   103
definition All :: "('a \<Rightarrow> bool) \<Rightarrow> bool"  (binder "\<forall>" 10)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   104
  where "All P \<equiv> (P = (\<lambda>x. True))"
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   105
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   106
definition Ex :: "('a \<Rightarrow> bool) \<Rightarrow> bool"  (binder "\<exists>" 10)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   107
  where "Ex P \<equiv> \<forall>Q. (\<forall>x. P x \<longrightarrow> Q) \<longrightarrow> Q"
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   108
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   109
definition False :: bool
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   110
  where "False \<equiv> (\<forall>P. P)"
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   111
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   112
definition Not :: "bool \<Rightarrow> bool"  ("\<not> _" [40] 40)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   113
  where not_def: "\<not> P \<equiv> P \<longrightarrow> False"
38795
848be46708dc formerly unnamed infix conjunction and disjunction now named HOL.conj and HOL.disj
haftmann
parents: 38786
diff changeset
   114
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   115
definition conj :: "[bool, bool] \<Rightarrow> bool"  (infixr "\<and>" 35)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   116
  where and_def: "P \<and> Q \<equiv> \<forall>R. (P \<longrightarrow> Q \<longrightarrow> R) \<longrightarrow> R"
38555
bd6359ed1636 deglobalized named HOL constants
haftmann
parents: 38547
diff changeset
   117
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   118
definition disj :: "[bool, bool] \<Rightarrow> bool"  (infixr "\<or>" 30)
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   119
  where or_def: "P \<or> Q \<equiv> \<forall>R. (P \<longrightarrow> R) \<longrightarrow> (Q \<longrightarrow> R) \<longrightarrow> R"
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   120
71827
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   121
definition Uniq :: "('a \<Rightarrow> bool) \<Rightarrow> bool"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   122
  where "Uniq P \<equiv> (\<forall>x y. P x \<longrightarrow> P y \<longrightarrow> y = x)"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   123
63909
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   124
definition Ex1 :: "('a \<Rightarrow> bool) \<Rightarrow> bool"
62151
dc4c9748a86e eliminated old defs;
wenzelm
parents: 61955
diff changeset
   125
  where "Ex1 P \<equiv> \<exists>x. P x \<and> (\<forall>y. P y \<longrightarrow> y = x)"
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   126
19656
09be06943252 tuned concrete syntax -- abbreviation/const_syntax;
wenzelm
parents: 19607
diff changeset
   127
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   128
subsubsection \<open>Additional concrete syntax\<close>
2260
b59781f2b809 added symbols syntax;
wenzelm
parents: 1674
diff changeset
   129
71827
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   130
syntax (ASCII) "_Uniq" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(4?< _./ _)" [0, 10] 10)
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   131
syntax "_Uniq" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(2\<exists>\<^sub>\<le>\<^sub>1 _./ _)" [0, 10] 10)
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   132
translations "\<exists>\<^sub>\<le>\<^sub>1x. P" \<rightleftharpoons> "CONST Uniq (\<lambda>x. P)"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   133
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   134
print_translation \<open>
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   135
 [Syntax_Trans.preserve_binder_abs_tr' \<^const_syntax>\<open>Uniq\<close> \<^syntax_const>\<open>_Uniq\<close>]
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   136
\<close> \<comment> \<open>to avoid eta-contraction of body\<close>
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   137
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   138
63909
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   139
syntax (ASCII)
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   140
  "_Ex1" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(3EX! _./ _)" [0, 10] 10)
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   141
syntax (input)
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   142
  "_Ex1" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(3?! _./ _)" [0, 10] 10)
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   143
syntax "_Ex1" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(3\<exists>!_./ _)" [0, 10] 10)
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   144
translations "\<exists>!x. P" \<rightleftharpoons> "CONST Ex1 (\<lambda>x. P)"
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   145
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   146
print_translation \<open>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   147
 [Syntax_Trans.preserve_binder_abs_tr' \<^const_syntax>\<open>Ex1\<close> \<^syntax_const>\<open>_Ex1\<close>]
63909
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   148
\<close> \<comment> \<open>to avoid eta-contraction of body\<close>
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   149
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   150
63912
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   151
syntax
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   152
  "_Not_Ex" :: "idts \<Rightarrow> bool \<Rightarrow> bool"  ("(3\<nexists>_./ _)" [0, 10] 10)
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   153
  "_Not_Ex1" :: "pttrn \<Rightarrow> bool \<Rightarrow> bool"  ("(3\<nexists>!_./ _)" [0, 10] 10)
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   154
translations
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   155
  "\<nexists>x. P" \<rightleftharpoons> "\<not> (\<exists>x. P)"
9f8325206465 clarified notation: iterated quantifier is negated as one chunk;
wenzelm
parents: 63909
diff changeset
   156
  "\<nexists>!x. P" \<rightleftharpoons> "\<not> (\<exists>!x. P)"
62522
d32c23d29968 abbreviations for \<nexists>;
wenzelm
parents: 62521
diff changeset
   157
d32c23d29968 abbreviations for \<nexists>;
wenzelm
parents: 62521
diff changeset
   158
68973
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
   159
abbreviation not_equal :: "['a, 'a] \<Rightarrow> bool"  (infix "\<noteq>" 50)
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   160
  where "x \<noteq> y \<equiv> \<not> (x = y)"
19656
09be06943252 tuned concrete syntax -- abbreviation/const_syntax;
wenzelm
parents: 19607
diff changeset
   161
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   162
notation (ASCII)
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   163
  Not  ("~ _" [40] 40) and
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   164
  conj  (infixr "&" 35) and
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   165
  disj  (infixr "|" 30) and
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   166
  implies  (infixr "-->" 25) and
68973
a1e26440efb8 tuned "=" syntax declarations; made "~=" uniformly "infix"
nipkow
parents: 68072
diff changeset
   167
  not_equal  (infix "~=" 50)
19656
09be06943252 tuned concrete syntax -- abbreviation/const_syntax;
wenzelm
parents: 19607
diff changeset
   168
09be06943252 tuned concrete syntax -- abbreviation/const_syntax;
wenzelm
parents: 19607
diff changeset
   169
abbreviation (iff)
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   170
  iff :: "[bool, bool] \<Rightarrow> bool"  (infixr "\<longleftrightarrow>" 25)
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   171
  where "A \<longleftrightarrow> B \<equiv> A = B"
19656
09be06943252 tuned concrete syntax -- abbreviation/const_syntax;
wenzelm
parents: 19607
diff changeset
   172
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   173
syntax "_The" :: "[pttrn, bool] \<Rightarrow> 'a"  ("(3THE _./ _)" [0, 10] 10)
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   174
translations "THE x. P" \<rightleftharpoons> "CONST The (\<lambda>x. P)"
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   175
print_translation \<open>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   176
  [(\<^const_syntax>\<open>The\<close>, fn _ => fn [Abs abs] =>
46125
00cd193a48dc improved case syntax: more careful treatment of position constraints, which enables PIDE markup;
wenzelm
parents: 45654
diff changeset
   177
      let val (x, t) = Syntax_Trans.atomic_abs_tr' abs
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   178
      in Syntax.const \<^syntax_const>\<open>_The\<close> $ x $ t end)]
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   179
\<close>  \<comment> \<open>To avoid eta-contraction of body\<close>
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   180
46125
00cd193a48dc improved case syntax: more careful treatment of position constraints, which enables PIDE markup;
wenzelm
parents: 45654
diff changeset
   181
nonterminal letbinds and letbind
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   182
syntax
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   183
  "_bind"       :: "[pttrn, 'a] \<Rightarrow> letbind"              ("(2_ =/ _)" 10)
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   184
  ""            :: "letbind \<Rightarrow> letbinds"                 ("_")
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   185
  "_binds"      :: "[letbind, letbinds] \<Rightarrow> letbinds"     ("_;/ _")
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   186
  "_Let"        :: "[letbinds, 'a] \<Rightarrow> 'a"                ("(let (_)/ in (_))" [0, 10] 10)
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   187
46125
00cd193a48dc improved case syntax: more careful treatment of position constraints, which enables PIDE markup;
wenzelm
parents: 45654
diff changeset
   188
nonterminal case_syn and cases_syn
00cd193a48dc improved case syntax: more careful treatment of position constraints, which enables PIDE markup;
wenzelm
parents: 45654
diff changeset
   189
syntax
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   190
  "_case_syntax" :: "['a, cases_syn] \<Rightarrow> 'b"  ("(case _ of/ _)" 10)
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   191
  "_case1" :: "['a, 'b] \<Rightarrow> case_syn"  ("(2_ \<Rightarrow>/ _)" 10)
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   192
  "" :: "case_syn \<Rightarrow> cases_syn"  ("_")
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   193
  "_case2" :: "[case_syn, cases_syn] \<Rightarrow> cases_syn"  ("_/ | _")
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   194
syntax (ASCII)
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   195
  "_case1" :: "['a, 'b] \<Rightarrow> case_syn"  ("(2_ =>/ _)" 10)
13763
f94b569cd610 added print translations tha avoid eta contraction for important binders.
nipkow
parents: 13723
diff changeset
   196
61955
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   197
notation (ASCII)
e96292f32c3c former "xsymbols" syntax is used by default, and ASCII replacement syntax with print mode "ASCII";
wenzelm
parents: 61941
diff changeset
   198
  All  (binder "ALL " 10) and
63909
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   199
  Ex  (binder "EX " 10)
2372
a2999e19703b fixed alternative quantifier symbol syntax;
wenzelm
parents: 2368
diff changeset
   200
62521
6383440f41a8 old HOL syntax is for input only;
wenzelm
parents: 62390
diff changeset
   201
notation (input)
21524
7843e2fd14a9 updated (binder) syntax/notation;
wenzelm
parents: 21504
diff changeset
   202
  All  (binder "! " 10) and
63909
cc15bd7c5396 clarified notation;
wenzelm
parents: 63575
diff changeset
   203
  Ex  (binder "? " 10)
7238
36e58620ffc8 replaced HOL_quantifiers flag by "HOL" print mode;
wenzelm
parents: 7220
diff changeset
   204
36e58620ffc8 replaced HOL_quantifiers flag by "HOL" print mode;
wenzelm
parents: 7220
diff changeset
   205
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   206
subsubsection \<open>Axioms and basic definitions\<close>
2260
b59781f2b809 added symbols syntax;
wenzelm
parents: 1674
diff changeset
   207
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   208
axiomatization where
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   209
  refl: "t = (t::'a)" and
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   210
  subst: "s = t \<Longrightarrow> P s \<Longrightarrow> P t" and
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   211
  ext: "(\<And>x::'a. (f x ::'b) = g x) \<Longrightarrow> (\<lambda>x. f x) = (\<lambda>x. g x)"
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   212
    \<comment> \<open>Extensionality is built into the meta-logic, and this rule expresses
15380
455cfa766dad proof of subst by S Merz
paulson
parents: 15363
diff changeset
   213
         a related property.  It is an eta-expanded version of the traditional
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   214
         rule, and similar to the ABS rule of HOL\<close> and
6289
062aa156a300 added a commment on the "ext" rule
paulson
parents: 6027
diff changeset
   215
11432
8a203ae6efe3 added "The" (definite description operator) (by Larry);
wenzelm
parents: 10489
diff changeset
   216
  the_eq_trivial: "(THE x. x = a) = (a::'a)"
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   217
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   218
axiomatization where
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   219
  impI: "(P \<Longrightarrow> Q) \<Longrightarrow> P \<longrightarrow> Q" and
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   220
  mp: "\<lbrakk>P \<longrightarrow> Q; P\<rbrakk> \<Longrightarrow> Q" and
15380
455cfa766dad proof of subst by S Merz
paulson
parents: 15363
diff changeset
   221
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   222
  True_or_False: "(P = True) \<or> (P = False)"
15380
455cfa766dad proof of subst by S Merz
paulson
parents: 15363
diff changeset
   223
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   224
definition If :: "bool \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a" ("(if (_)/ then (_)/ else (_))" [0, 0, 10] 10)
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   225
  where "If P x y \<equiv> (THE z::'a. (P = True \<longrightarrow> z = x) \<and> (P = False \<longrightarrow> z = y))"
923
ff1574a81019 new version of HOL with curried function application
clasohm
parents:
diff changeset
   226
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   227
definition Let :: "'a \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> 'b"
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   228
  where "Let s f \<equiv> f s"
38525
324219de6ee3 qualified constants Let and If
haftmann
parents: 37877
diff changeset
   229
324219de6ee3 qualified constants Let and If
haftmann
parents: 37877
diff changeset
   230
translations
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   231
  "_Let (_binds b bs) e"  \<rightleftharpoons> "_Let b (_Let bs e)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   232
  "let x = a in e"        \<rightleftharpoons> "CONST Let a (\<lambda>x. e)"
38525
324219de6ee3 qualified constants Let and If
haftmann
parents: 37877
diff changeset
   233
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   234
axiomatization undefined :: 'a
22481
79c2724c36b5 added class "default" and expansion axioms for undefined
haftmann
parents: 22473
diff changeset
   235
46973
d68798000e46 modernized axiomatization;
wenzelm
parents: 46950
diff changeset
   236
class default = fixes default :: 'a
4868
843a9f5b3c3d nonterminals;
wenzelm
parents: 4793
diff changeset
   237
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
   238
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   239
subsection \<open>Fundamental rules\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   240
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   241
subsubsection \<open>Equality\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   242
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   243
lemma sym: "s = t \<Longrightarrow> t = s"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   244
  by (erule subst) (rule refl)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   245
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   246
lemma ssubst: "t = s \<Longrightarrow> P s \<Longrightarrow> P t"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   247
  by (drule sym) (erule subst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   248
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   249
lemma trans: "\<lbrakk>r = s; s = t\<rbrakk> \<Longrightarrow> r = t"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   250
  by (erule subst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   251
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   252
lemma trans_sym [Pure.elim?]: "r = s \<Longrightarrow> t = s \<Longrightarrow> r = t"
40715
3ba17f07b23c lemma trans_sym allows single-step "normalization" in Isar, e.g. via moreover/ultimately;
wenzelm
parents: 40582
diff changeset
   253
  by (rule trans [OF _ sym])
3ba17f07b23c lemma trans_sym allows single-step "normalization" in Isar, e.g. via moreover/ultimately;
wenzelm
parents: 40582
diff changeset
   254
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   255
lemma meta_eq_to_obj_eq:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   256
  assumes "A \<equiv> B"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   257
  shows "A = B"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   258
  unfolding assms by (rule refl)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   259
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   260
text \<open>Useful with \<open>erule\<close> for proving equalities from known equalities.\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   261
     (* a = b
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   262
        |   |
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   263
        c = d   *)
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   264
lemma box_equals: "\<lbrakk>a = b; a = c; b = d\<rbrakk> \<Longrightarrow> c = d"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   265
  by (iprover intro: sym trans)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   266
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   267
text \<open>For calculational reasoning:\<close>
15524
2ef571f80a55 Moved oderings from HOL into the new Orderings.thy
nipkow
parents: 15481
diff changeset
   268
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   269
lemma forw_subst: "a = b \<Longrightarrow> P b \<Longrightarrow> P a"
15524
2ef571f80a55 Moved oderings from HOL into the new Orderings.thy
nipkow
parents: 15481
diff changeset
   270
  by (rule ssubst)
2ef571f80a55 Moved oderings from HOL into the new Orderings.thy
nipkow
parents: 15481
diff changeset
   271
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   272
lemma back_subst: "P a \<Longrightarrow> a = b \<Longrightarrow> P b"
15524
2ef571f80a55 Moved oderings from HOL into the new Orderings.thy
nipkow
parents: 15481
diff changeset
   273
  by (rule subst)
2ef571f80a55 Moved oderings from HOL into the new Orderings.thy
nipkow
parents: 15481
diff changeset
   274
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   275
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   276
subsubsection \<open>Congruence rules for application\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   277
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   278
text \<open>Similar to \<open>AP_THM\<close> in Gordon's HOL.\<close>
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   279
lemma fun_cong: "(f :: 'a \<Rightarrow> 'b) = g \<Longrightarrow> f x = g x"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   280
  by (iprover intro: refl elim: subst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   281
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   282
text \<open>Similar to \<open>AP_TERM\<close> in Gordon's HOL and FOL's \<open>subst_context\<close>.\<close>
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   283
lemma arg_cong: "x = y \<Longrightarrow> f x = f y"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   284
  by (iprover intro: refl elim: subst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   285
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   286
lemma arg_cong2: "\<lbrakk>a = b; c = d\<rbrakk> \<Longrightarrow> f a c = f b d"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   287
  by (iprover intro: refl elim: subst)
15655
157f3988f775 arg_cong2 by Norbert Voelker
paulson
parents: 15570
diff changeset
   288
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   289
lemma cong: "\<lbrakk>f = g; (x::'a) = y\<rbrakk> \<Longrightarrow> f x = g y"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   290
  by (iprover intro: refl elim: subst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   291
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   292
ML \<open>fun cong_tac ctxt = Cong_Tac.cong_tac ctxt @{thm cong}\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   293
32733
71618deaf777 moved generic cong_tac from HOL/Tools/datatype_aux.ML to Tools/cong_tac.ML, proper subgoal selection (failure, not exception);
wenzelm
parents: 32668
diff changeset
   294
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   295
subsubsection \<open>Equality of booleans -- iff\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   296
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   297
lemma iffD2: "\<lbrakk>P = Q; Q\<rbrakk> \<Longrightarrow> P"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   298
  by (erule ssubst)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   299
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   300
lemma rev_iffD2: "\<lbrakk>Q; P = Q\<rbrakk> \<Longrightarrow> P"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   301
  by (erule iffD2)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   302
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   303
lemma iffD1: "Q = P \<Longrightarrow> Q \<Longrightarrow> P"
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   304
  by (drule sym) (rule iffD2)
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   305
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   306
lemma rev_iffD1: "Q \<Longrightarrow> Q = P \<Longrightarrow> P"
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   307
  by (drule sym) (rule rev_iffD2)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   308
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   309
lemma iffE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   310
  assumes major: "P = Q"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   311
    and minor: "\<lbrakk>P \<longrightarrow> Q; Q \<longrightarrow> P\<rbrakk> \<Longrightarrow> R"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   312
  shows R
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
   313
  by (iprover intro: minor impI major [THEN iffD2] major [THEN iffD1])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   314
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   315
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   316
subsubsection \<open>True (1)\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   317
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   318
lemma TrueI: True
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   319
  unfolding True_def by (rule refl)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   320
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   321
lemma eqTrueE: "P = True \<Longrightarrow> P"
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   322
  by (erule iffD2) (rule TrueI)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   323
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   324
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   325
subsubsection \<open>Universal quantifier (1)\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   326
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   327
lemma spec: "\<forall>x::'a. P x \<Longrightarrow> P x"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   328
  unfolding All_def by (iprover intro: eqTrueE fun_cong)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   329
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   330
lemma allE:
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   331
  assumes major: "\<forall>x. P x" and minor: "P x \<Longrightarrow> R"
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   332
  shows R
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   333
  by (iprover intro: minor major [THEN spec])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   334
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   335
lemma all_dupE:
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   336
  assumes major: "\<forall>x. P x" and minor: "\<lbrakk>P x; \<forall>x. P x\<rbrakk> \<Longrightarrow> R"
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   337
  shows R
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   338
  by (iprover intro: minor major major [THEN spec])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   339
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   340
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   341
subsubsection \<open>False\<close>
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   342
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   343
text \<open>
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
   344
  Depends upon \<open>spec\<close>; it is impossible to do propositional
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   345
  logic before quantifiers!
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   346
\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   347
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   348
lemma FalseE: "False \<Longrightarrow> P"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   349
  unfolding False_def by (erule spec)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   350
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   351
lemma False_neq_True: "False = True \<Longrightarrow> P"
21504
9c97af4a1567 tuned proofs;
wenzelm
parents: 21502
diff changeset
   352
  by (erule eqTrueE [THEN FalseE])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   353
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   354
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   355
subsubsection \<open>Negation\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   356
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   357
lemma notI:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   358
  assumes "P \<Longrightarrow> False"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   359
  shows "\<not> P"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   360
  unfolding not_def by (iprover intro: impI assms)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   361
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   362
lemma False_not_True: "False \<noteq> True"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   363
  by (iprover intro: notI elim: False_neq_True)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   364
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   365
lemma True_not_False: "True \<noteq> False"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   366
  by (iprover intro: notI dest: sym elim: False_neq_True)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   367
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   368
lemma notE: "\<lbrakk>\<not> P; P\<rbrakk> \<Longrightarrow> R"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   369
  unfolding not_def
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   370
  by (iprover intro: mp [THEN FalseE])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   371
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   372
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   373
subsubsection \<open>Implication\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   374
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   375
lemma impE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   376
  assumes "P \<longrightarrow> Q" P "Q \<Longrightarrow> R"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   377
  shows R
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   378
  by (iprover intro: assms mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   379
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   380
text \<open>Reduces \<open>Q\<close> to \<open>P \<longrightarrow> Q\<close>, allowing substitution in \<open>P\<close>.\<close>
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   381
lemma rev_mp: "\<lbrakk>P; P \<longrightarrow> Q\<rbrakk> \<Longrightarrow> Q"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   382
  by (rule mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   383
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   384
lemma contrapos_nn:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   385
  assumes major: "\<not> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   386
    and minor: "P \<Longrightarrow> Q"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   387
  shows "\<not> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   388
  by (iprover intro: notI minor major [THEN notE])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   389
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   390
text \<open>Not used at all, but we already have the other 3 combinations.\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   391
lemma contrapos_pn:
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   392
  assumes major: "Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   393
    and minor: "P \<Longrightarrow> \<not> Q"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   394
  shows "\<not> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   395
  by (iprover intro: notI minor major notE)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   396
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   397
lemma not_sym: "t \<noteq> s \<Longrightarrow> s \<noteq> t"
21250
a268f6288fb6 moved lemma eq_neq_eq_imp_neq to HOL
haftmann
parents: 21218
diff changeset
   398
  by (erule contrapos_nn) (erule sym)
a268f6288fb6 moved lemma eq_neq_eq_imp_neq to HOL
haftmann
parents: 21218
diff changeset
   399
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   400
lemma eq_neq_eq_imp_neq: "\<lbrakk>x = a; a \<noteq> b; b = y\<rbrakk> \<Longrightarrow> x \<noteq> y"
21250
a268f6288fb6 moved lemma eq_neq_eq_imp_neq to HOL
haftmann
parents: 21218
diff changeset
   401
  by (erule subst, erule ssubst, assumption)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   402
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   403
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   404
subsubsection \<open>Disjunction (1)\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   405
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   406
lemma disjE:
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   407
  assumes major: "P \<or> Q"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   408
    and minorP: "P \<Longrightarrow> R"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   409
    and minorQ: "Q \<Longrightarrow> R"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   410
  shows R
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   411
  by (iprover intro: minorP minorQ impI
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   412
      major [unfolded or_def, THEN spec, THEN mp, THEN mp])
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   413
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   414
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   415
subsubsection \<open>Derivation of \<open>iffI\<close>\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   416
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   417
text \<open>In an intuitionistic version of HOL \<open>iffI\<close> needs to be an axiom.\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   418
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   419
lemma iffI:
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   420
  assumes "P \<Longrightarrow> Q" and "Q \<Longrightarrow> P"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   421
  shows "P = Q"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   422
proof (rule disjE[OF True_or_False[of P]])
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   423
  assume 1: "P = True"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   424
  note Q = assms(1)[OF eqTrueE[OF this]]
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   425
  from 1 show ?thesis
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   426
  proof (rule ssubst)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   427
    from True_or_False[of Q] show "True = Q"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   428
    proof (rule disjE)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   429
      assume "Q = True"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   430
      thus ?thesis by(rule sym)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   431
    next
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   432
      assume "Q = False"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   433
      with Q have False by (rule rev_iffD1)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   434
      thus ?thesis by (rule FalseE)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   435
    qed
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   436
  qed
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   437
next
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   438
  assume 2: "P = False"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   439
  thus ?thesis
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   440
  proof (rule ssubst)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   441
    from True_or_False[of Q] show "False = Q"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   442
    proof (rule disjE)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   443
      assume "Q = True"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   444
      from 2 assms(2)[OF eqTrueE[OF this]] have False by (rule iffD1)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   445
      thus ?thesis by (rule FalseE)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   446
    next
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   447
      assume "Q = False"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   448
      thus ?thesis by(rule sym)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   449
    qed
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   450
  qed
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   451
qed
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   452
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   453
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   454
subsubsection \<open>True (2)\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   455
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   456
lemma eqTrueI: "P \<Longrightarrow> P = True"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   457
  by (iprover intro: iffI TrueI)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   458
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   459
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   460
subsubsection \<open>Universal quantifier (2)\<close>
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   461
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   462
lemma allI:
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   463
  assumes "\<And>x::'a. P x"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   464
  shows "\<forall>x. P x"
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   465
  unfolding All_def by (iprover intro: ext eqTrueI assms)
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   466
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   467
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   468
subsubsection \<open>Existential quantifier\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   469
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   470
lemma exI: "P x \<Longrightarrow> \<exists>x::'a. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   471
  unfolding Ex_def by (iprover intro: allI allE impI mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   472
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   473
lemma exE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   474
  assumes major: "\<exists>x::'a. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   475
    and minor: "\<And>x. P x \<Longrightarrow> Q"
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   476
  shows "Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   477
  by (rule major [unfolded Ex_def, THEN spec, THEN mp]) (iprover intro: impI [THEN allI] minor)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   478
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   479
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   480
subsubsection \<open>Conjunction\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   481
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   482
lemma conjI: "\<lbrakk>P; Q\<rbrakk> \<Longrightarrow> P \<and> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   483
  unfolding and_def by (iprover intro: impI [THEN allI] mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   484
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   485
lemma conjunct1: "\<lbrakk>P \<and> Q\<rbrakk> \<Longrightarrow> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   486
  unfolding and_def by (iprover intro: impI dest: spec mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   487
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   488
lemma conjunct2: "\<lbrakk>P \<and> Q\<rbrakk> \<Longrightarrow> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   489
  unfolding and_def by (iprover intro: impI dest: spec mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   490
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   491
lemma conjE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   492
  assumes major: "P \<and> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   493
    and minor: "\<lbrakk>P; Q\<rbrakk> \<Longrightarrow> R"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   494
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   495
proof (rule minor)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   496
  show P by (rule major [THEN conjunct1])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   497
  show Q by (rule major [THEN conjunct2])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   498
qed
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   499
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   500
lemma context_conjI:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   501
  assumes P "P \<Longrightarrow> Q"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   502
  shows "P \<and> Q"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   503
  by (iprover intro: conjI assms)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   504
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   505
66893
ced164fe3bbd derived axiom iffI as a lemma (thanks to Alexander Maletzky)
nipkow
parents: 66836
diff changeset
   506
subsubsection \<open>Disjunction (2)\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   507
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   508
lemma disjI1: "P \<Longrightarrow> P \<or> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   509
  unfolding or_def by (iprover intro: allI impI mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   510
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   511
lemma disjI2: "Q \<Longrightarrow> P \<or> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   512
  unfolding or_def by (iprover intro: allI impI mp)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   513
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   514
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   515
subsubsection \<open>Classical logic\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   516
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   517
lemma classical:
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   518
  assumes "\<not> P \<Longrightarrow> P"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   519
  shows P
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   520
proof (rule True_or_False [THEN disjE])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   521
  show P if "P = True"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   522
    using that by (iprover intro: eqTrueE)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   523
  show P if "P = False"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   524
  proof (intro notI assms)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   525
    assume P
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   526
    with that show False
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   527
      by (iprover elim: subst)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   528
  qed
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   529
qed
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   530
45607
16b4f5774621 eliminated obsolete "standard";
wenzelm
parents: 45294
diff changeset
   531
lemmas ccontr = FalseE [THEN classical]
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   532
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   533
text \<open>\<open>notE\<close> with premises exchanged; it discharges \<open>\<not> R\<close> so that it can be used to
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   534
  make elimination rules.\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   535
lemma rev_notE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   536
  assumes premp: P
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   537
    and premnot: "\<not> R \<Longrightarrow> \<not> P"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   538
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   539
  by (iprover intro: ccontr notE [OF premnot premp])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   540
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   541
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   542
text \<open>Double negation law.\<close>
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   543
lemma notnotD: "\<not>\<not> P \<Longrightarrow> P"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   544
  by (iprover intro: ccontr notE )
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   545
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   546
lemma contrapos_pp:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   547
  assumes p1: Q
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   548
    and p2: "\<not> P \<Longrightarrow> \<not> Q"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   549
  shows P
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   550
  by (iprover intro: classical p1 p2 notE)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   551
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   552
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   553
subsubsection \<open>Unique existence\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   554
71827
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   555
lemma Uniq_I [intro?]:
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   556
  assumes "\<And>x y. \<lbrakk>P x; P y\<rbrakk> \<Longrightarrow> y = x"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   557
  shows "Uniq P"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   558
  unfolding Uniq_def by (iprover intro: assms allI impI)
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   559
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   560
lemma Uniq_D [dest?]: "\<lbrakk>Uniq P; P a; P b\<rbrakk> \<Longrightarrow> a=b"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   561
  unfolding Uniq_def by (iprover dest: spec mp)
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   562
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   563
lemma ex1I:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   564
  assumes "P a" "\<And>x. P x \<Longrightarrow> x = a"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   565
  shows "\<exists>!x. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   566
  unfolding Ex1_def by (iprover intro: assms exI conjI allI impI)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   567
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   568
text \<open>Sometimes easier to use: the premises have no shared variables. Safe!\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   569
lemma ex_ex1I:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   570
  assumes ex_prem: "\<exists>x. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   571
    and eq: "\<And>x y. \<lbrakk>P x; P y\<rbrakk> \<Longrightarrow> x = y"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   572
  shows "\<exists>!x. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   573
  by (iprover intro: ex_prem [THEN exE] ex1I eq)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   574
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   575
lemma ex1E:
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   576
  assumes major: "\<exists>!x. P x" and minor: "\<And>x. \<lbrakk>P x; \<forall>y. P y \<longrightarrow> y = x\<rbrakk> \<Longrightarrow> R"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   577
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   578
proof (rule major [unfolded Ex1_def, THEN exE])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   579
  show "\<And>x. P x \<and> (\<forall>y. P y \<longrightarrow> y = x) \<Longrightarrow> R"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   580
    by (iprover intro: minor elim: conjE)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   581
qed
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   582
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   583
lemma ex1_implies_ex: "\<exists>!x. P x \<Longrightarrow> \<exists>x. P x"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   584
  by (iprover intro: exI elim: ex1E)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   585
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   586
subsubsection \<open>Classical intro rules for disjunction and existential quantifiers\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   587
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   588
lemma disjCI:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   589
  assumes "\<not> Q \<Longrightarrow> P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   590
  shows "P \<or> Q"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   591
  by (rule classical) (iprover intro: assms disjI1 disjI2 notI elim: notE)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   592
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   593
lemma excluded_middle: "\<not> P \<or> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   594
  by (iprover intro: disjCI)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   595
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   596
text \<open>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   597
  case distinction as a natural deduction rule.
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   598
  Note that \<open>\<not> P\<close> is the second case, not the first.
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   599
\<close>
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
   600
lemma case_split [case_names True False]:
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   601
  assumes "P \<Longrightarrow> Q" "\<not> P \<Longrightarrow> Q"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   602
  shows Q
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   603
  using excluded_middle [of P]
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   604
    by (iprover intro: assms elim: disjE)
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
   605
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   606
text \<open>Classical implies (\<open>\<longrightarrow>\<close>) elimination.\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   607
lemma impCE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   608
  assumes major: "P \<longrightarrow> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   609
    and minor: "\<not> P \<Longrightarrow> R" "Q \<Longrightarrow> R"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   610
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   611
  using excluded_middle [of P]
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   612
  by (iprover intro: minor major [THEN mp] elim: disjE)+
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   613
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   614
text \<open>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   615
  This version of \<open>\<longrightarrow>\<close> elimination works on \<open>Q\<close> before \<open>P\<close>.  It works best for
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   616
  those cases in which \<open>P\<close> holds "almost everywhere".  Can't install as
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   617
  default: would break old proofs.
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   618
\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   619
lemma impCE':
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   620
  assumes major: "P \<longrightarrow> Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   621
    and minor: "Q \<Longrightarrow> R" "\<not> P \<Longrightarrow> R"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   622
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   623
  using assms by (elim impCE)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   624
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   625
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   626
text \<open>Classical \<open>\<longleftrightarrow>\<close> elimination.\<close>
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   627
lemma iffCE:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   628
  assumes major: "P = Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   629
    and minor: "\<lbrakk>P; Q\<rbrakk> \<Longrightarrow> R" "\<lbrakk>\<not> P; \<not> Q\<rbrakk> \<Longrightarrow> R"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   630
  shows R
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   631
  by (rule major [THEN iffE]) (iprover intro: minor elim: impCE notE)
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   632
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   633
lemma exCI:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   634
  assumes "\<forall>x. \<not> P x \<Longrightarrow> P a"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   635
  shows "\<exists>x. P x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   636
  by (rule ccontr) (iprover intro: assms exI allI notI notE [of "\<exists>x. P x"])
15411
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   637
1d195de59497 removal of HOL_Lemmas
paulson
parents: 15380
diff changeset
   638
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   639
subsubsection \<open>Intuitionistic Reasoning\<close>
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   640
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   641
lemma impE':
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   642
  assumes 1: "P \<longrightarrow> Q"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   643
    and 2: "Q \<Longrightarrow> R"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   644
    and 3: "P \<longrightarrow> Q \<Longrightarrow> P"
12937
0c4fd7529467 clarified syntax of ``long'' statements: fixes/assumes/shows;
wenzelm
parents: 12892
diff changeset
   645
  shows R
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   646
proof -
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   647
  from 3 and 1 have P .
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   648
  with 1 have Q by (rule impE)
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   649
  with 2 show R .
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   650
qed
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   651
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   652
lemma allE':
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   653
  assumes 1: "\<forall>x. P x"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   654
    and 2: "P x \<Longrightarrow> \<forall>x. P x \<Longrightarrow> Q"
12937
0c4fd7529467 clarified syntax of ``long'' statements: fixes/assumes/shows;
wenzelm
parents: 12892
diff changeset
   655
  shows Q
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   656
proof -
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   657
  from 1 have "P x" by (rule spec)
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   658
  from this and 1 show Q by (rule 2)
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   659
qed
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   660
12937
0c4fd7529467 clarified syntax of ``long'' statements: fixes/assumes/shows;
wenzelm
parents: 12892
diff changeset
   661
lemma notE':
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   662
  assumes 1: "\<not> P"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   663
    and 2: "\<not> P \<Longrightarrow> P"
12937
0c4fd7529467 clarified syntax of ``long'' statements: fixes/assumes/shows;
wenzelm
parents: 12892
diff changeset
   664
  shows R
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   665
proof -
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   666
  from 2 and 1 have P .
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   667
  with 1 show R by (rule notE)
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   668
qed
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   669
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   670
lemma TrueE: "True \<Longrightarrow> P \<Longrightarrow> P" .
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   671
lemma notFalseE: "\<not> False \<Longrightarrow> P \<Longrightarrow> P" .
22444
fb80fedd192d added safe intro rules for removing "True" subgoals as well as "~ False" ones.
dixon
parents: 22377
diff changeset
   672
22467
c9357ef01168 TrueElim and notTrueElim tested and added as safe elim rules.
dixon
parents: 22445
diff changeset
   673
lemmas [Pure.elim!] = disjE iffE FalseE conjE exE TrueE notFalseE
15801
d2f5ca3c048d superceded by Pure.thy and CPure.thy;
wenzelm
parents: 15676
diff changeset
   674
  and [Pure.intro!] = iffI conjI impI TrueI notI allI refl
d2f5ca3c048d superceded by Pure.thy and CPure.thy;
wenzelm
parents: 15676
diff changeset
   675
  and [Pure.elim 2] = allE notE' impE'
d2f5ca3c048d superceded by Pure.thy and CPure.thy;
wenzelm
parents: 15676
diff changeset
   676
  and [Pure.intro] = exI disjI2 disjI1
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   677
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   678
lemmas [trans] = trans
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   679
  and [sym] = sym not_sym
15801
d2f5ca3c048d superceded by Pure.thy and CPure.thy;
wenzelm
parents: 15676
diff changeset
   680
  and [Pure.elim?] = iffD1 iffD2 impE
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
   681
11438
3d9222b80989 declare trans [trans] (*overridden in theory Calculation*);
wenzelm
parents: 11432
diff changeset
   682
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   683
subsubsection \<open>Atomizing meta-level connectives\<close>
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
   684
28513
b0b30fd6c264 re-introduces axiom subst
haftmann
parents: 28400
diff changeset
   685
axiomatization where
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   686
  eq_reflection: "x = y \<Longrightarrow> x \<equiv> y"  \<comment> \<open>admissible axiom\<close>
28513
b0b30fd6c264 re-introduces axiom subst
haftmann
parents: 28400
diff changeset
   687
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   688
lemma atomize_all [atomize]: "(\<And>x. P x) \<equiv> Trueprop (\<forall>x. P x)"
12003
c09427e5f554 removed obsolete (rule equal_intr_rule);
wenzelm
parents: 11989
diff changeset
   689
proof
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   690
  assume "\<And>x. P x"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   691
  then show "\<forall>x. P x" ..
9488
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   692
next
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   693
  assume "\<forall>x. P x"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   694
  then show "\<And>x. P x" by (rule allE)
9488
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   695
qed
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   696
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   697
lemma atomize_imp [atomize]: "(A \<Longrightarrow> B) \<equiv> Trueprop (A \<longrightarrow> B)"
12003
c09427e5f554 removed obsolete (rule equal_intr_rule);
wenzelm
parents: 11989
diff changeset
   698
proof
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   699
  assume r: "A \<Longrightarrow> B"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   700
  show "A \<longrightarrow> B" by (rule impI) (rule r)
9488
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   701
next
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   702
  assume "A \<longrightarrow> B" and A
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
   703
  then show B by (rule mp)
9488
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   704
qed
f11bece4e2db added all_eq, imp_eq (for blast);
wenzelm
parents: 9352
diff changeset
   705
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   706
lemma atomize_not: "(A \<Longrightarrow> False) \<equiv> Trueprop (\<not> A)"
14749
9ccfd0f59e11 new atomize theorem
paulson
parents: 14690
diff changeset
   707
proof
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   708
  assume r: "A \<Longrightarrow> False"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   709
  show "\<not> A" by (rule notI) (rule r)
14749
9ccfd0f59e11 new atomize theorem
paulson
parents: 14690
diff changeset
   710
next
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   711
  assume "\<not> A" and A
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
   712
  then show False by (rule notE)
14749
9ccfd0f59e11 new atomize theorem
paulson
parents: 14690
diff changeset
   713
qed
9ccfd0f59e11 new atomize theorem
paulson
parents: 14690
diff changeset
   714
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   715
lemma atomize_eq [atomize, code]: "(x \<equiv> y) \<equiv> Trueprop (x = y)"
12003
c09427e5f554 removed obsolete (rule equal_intr_rule);
wenzelm
parents: 11989
diff changeset
   716
proof
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   717
  assume "x \<equiv> y"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   718
  show "x = y" by (unfold \<open>x \<equiv> y\<close>) (rule refl)
10432
3dfbc913d184 added axclass inverse and consts inverse, divide (infix "/");
wenzelm
parents: 10383
diff changeset
   719
next
3dfbc913d184 added axclass inverse and consts inverse, divide (infix "/");
wenzelm
parents: 10383
diff changeset
   720
  assume "x = y"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   721
  then show "x \<equiv> y" by (rule eq_reflection)
10432
3dfbc913d184 added axclass inverse and consts inverse, divide (infix "/");
wenzelm
parents: 10383
diff changeset
   722
qed
3dfbc913d184 added axclass inverse and consts inverse, divide (infix "/");
wenzelm
parents: 10383
diff changeset
   723
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   724
lemma atomize_conj [atomize]: "(A &&& B) \<equiv> Trueprop (A \<and> B)"
12003
c09427e5f554 removed obsolete (rule equal_intr_rule);
wenzelm
parents: 11989
diff changeset
   725
proof
28856
5e009a80fe6d Pure syntax: more coherent treatment of aprop, permanent TERM and &&&;
wenzelm
parents: 28741
diff changeset
   726
  assume conj: "A &&& B"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   727
  show "A \<and> B"
19121
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   728
  proof (rule conjI)
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   729
    from conj show A by (rule conjunctionD1)
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   730
    from conj show B by (rule conjunctionD2)
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   731
  qed
11953
f98623fdf6ef atomize_conj;
wenzelm
parents: 11824
diff changeset
   732
next
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   733
  assume conj: "A \<and> B"
28856
5e009a80fe6d Pure syntax: more coherent treatment of aprop, permanent TERM and &&&;
wenzelm
parents: 28741
diff changeset
   734
  show "A &&& B"
19121
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   735
  proof -
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   736
    from conj show A ..
d7fd5415a781 simplified Pure conjunction;
wenzelm
parents: 19039
diff changeset
   737
    from conj show B ..
11953
f98623fdf6ef atomize_conj;
wenzelm
parents: 11824
diff changeset
   738
  qed
f98623fdf6ef atomize_conj;
wenzelm
parents: 11824
diff changeset
   739
qed
f98623fdf6ef atomize_conj;
wenzelm
parents: 11824
diff changeset
   740
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   741
lemmas [symmetric, rulify] = atomize_all atomize_imp
18832
6ab4de872a70 declare 'defn' rules;
wenzelm
parents: 18757
diff changeset
   742
  and [symmetric, defn] = atomize_all atomize_imp atomize_eq
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   743
11750
3e400964893e judgment Trueprop;
wenzelm
parents: 11724
diff changeset
   744
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   745
subsubsection \<open>Atomizing elimination rules\<close>
26580
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   746
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   747
lemma atomize_exL[atomize_elim]: "(\<And>x. P x \<Longrightarrow> Q) \<equiv> ((\<exists>x. P x) \<Longrightarrow> Q)"
75669
43f5dfb7fa35 tuned (some HOL lints, by Yecine Megdiche);
Fabian Huch <huch@in.tum.de>
parents: 74741
diff changeset
   748
  by (rule equal_intr_rule) iprover+
26580
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   749
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   750
lemma atomize_conjL[atomize_elim]: "(A \<Longrightarrow> B \<Longrightarrow> C) \<equiv> (A \<and> B \<Longrightarrow> C)"
75669
43f5dfb7fa35 tuned (some HOL lints, by Yecine Megdiche);
Fabian Huch <huch@in.tum.de>
parents: 74741
diff changeset
   751
  by (rule equal_intr_rule) iprover+
26580
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   752
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   753
lemma atomize_disjL[atomize_elim]: "((A \<Longrightarrow> C) \<Longrightarrow> (B \<Longrightarrow> C) \<Longrightarrow> C) \<equiv> ((A \<or> B \<Longrightarrow> C) \<Longrightarrow> C)"
75669
43f5dfb7fa35 tuned (some HOL lints, by Yecine Megdiche);
Fabian Huch <huch@in.tum.de>
parents: 74741
diff changeset
   754
  by (rule equal_intr_rule) iprover+
26580
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   755
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   756
lemma atomize_elimL[atomize_elim]: "(\<And>B. (A \<Longrightarrow> B) \<Longrightarrow> B) \<equiv> Trueprop A" ..
26580
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   757
c3e597a476fd Generic conversion and tactic "atomize_elim" to convert elimination rules
krauss
parents: 26555
diff changeset
   758
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   759
subsection \<open>Package setup\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   760
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
   761
ML_file \<open>Tools/hologic.ML\<close>
70847
e62d5433bb47 early setup of proof preprocessing;
wenzelm
parents: 70486
diff changeset
   762
ML_file \<open>Tools/rewrite_hol_proof.ML\<close>
51314
eac4bb5adbf9 just one HOLogic.Trueprop_conv, with regular exception CTERM;
wenzelm
parents: 51304
diff changeset
   763
70879
0b320e92485c tuned signature;
wenzelm
parents: 70853
diff changeset
   764
setup \<open>Proofterm.set_preproc (Proof_Rewrite_Rules.standard_preproc Rewrite_HOL_Proof.rews)\<close>
70849
ef77ddd9cc6a setup preprocessing for HOL proofs;
wenzelm
parents: 70847
diff changeset
   765
51314
eac4bb5adbf9 just one HOLogic.Trueprop_conv, with regular exception CTERM;
wenzelm
parents: 51304
diff changeset
   766
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   767
subsubsection \<open>Sledgehammer setup\<close>
35828
46cfc4b8112e now use "Named_Thms" for "noatp", and renamed "noatp" to "no_atp"
blanchet
parents: 35808
diff changeset
   768
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   769
text \<open>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   770
  Theorems blacklisted to Sledgehammer. These theorems typically produce clauses
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   771
  that are prolific (match too many equality or membership literals) and relate to
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   772
  seldom-used facts. Some duplicate other rules.
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   773
\<close>
35828
46cfc4b8112e now use "Named_Thms" for "noatp", and renamed "noatp" to "no_atp"
blanchet
parents: 35808
diff changeset
   774
57963
cb67fac9bd89 updated to named_theorems;
wenzelm
parents: 57962
diff changeset
   775
named_theorems no_atp "theorems that should be filtered out by Sledgehammer"
35828
46cfc4b8112e now use "Named_Thms" for "noatp", and renamed "noatp" to "no_atp"
blanchet
parents: 35808
diff changeset
   776
46cfc4b8112e now use "Named_Thms" for "noatp", and renamed "noatp" to "no_atp"
blanchet
parents: 35808
diff changeset
   777
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   778
subsubsection \<open>Classical Reasoner setup\<close>
9529
d9434a9277a4 lemmas atomize = all_eq imp_eq;
wenzelm
parents: 9488
diff changeset
   779
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   780
lemma imp_elim: "P \<longrightarrow> Q \<Longrightarrow> (\<not> R \<Longrightarrow> P) \<Longrightarrow> (Q \<Longrightarrow> R) \<Longrightarrow> R"
26411
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   781
  by (rule classical) iprover
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   782
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   783
lemma swap: "\<not> P \<Longrightarrow> (\<not> R \<Longrightarrow> P) \<Longrightarrow> R"
26411
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   784
  by (rule classical) iprover
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   785
62958
b41c1cb5e251 Type_Infer.object_logic controls improvement of type inference result;
wenzelm
parents: 62913
diff changeset
   786
lemma thin_refl: "\<lbrakk>x = x; PROP W\<rbrakk> \<Longrightarrow> PROP W" .
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   787
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   788
ML \<open>
42799
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   789
structure Hypsubst = Hypsubst
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   790
(
21218
38013c3a77a2 tuned hypsubst setup;
wenzelm
parents: 21210
diff changeset
   791
  val dest_eq = HOLogic.dest_eq
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   792
  val dest_Trueprop = HOLogic.dest_Trueprop
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   793
  val dest_imp = HOLogic.dest_imp
26411
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   794
  val eq_reflection = @{thm eq_reflection}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   795
  val rev_eq_reflection = @{thm meta_eq_to_obj_eq}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   796
  val imp_intr = @{thm impI}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   797
  val rev_mp = @{thm rev_mp}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   798
  val subst = @{thm subst}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   799
  val sym = @{thm sym}
22129
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
   800
  val thin_refl = @{thm thin_refl};
42799
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   801
);
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
   802
open Hypsubst;
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   803
42799
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   804
structure Classical = Classical
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   805
(
26411
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   806
  val imp_elim = @{thm imp_elim}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   807
  val not_elim = @{thm notE}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   808
  val swap = @{thm swap}
cd74690f3bfb pass imp_elim, swap to classical prover;
wenzelm
parents: 25966
diff changeset
   809
  val classical = @{thm classical}
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   810
  val sizef = Drule.size_of_thm
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   811
  val hyp_subst_tacs = [Hypsubst.hyp_subst_tac]
42799
4e33894aec6d modernized functor names;
wenzelm
parents: 42795
diff changeset
   812
);
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
   813
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   814
structure Basic_Classical: BASIC_CLASSICAL = Classical;
33308
cf62d1690d04 separate ResBlacklist, based on scalable persistent data -- avoids inefficient hashing later on;
wenzelm
parents: 33185
diff changeset
   815
open Basic_Classical;
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   816
\<close>
22129
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
   817
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   818
setup \<open>
35389
2be5440f7271 tuned hyp_subst_tac';
wenzelm
parents: 35364
diff changeset
   819
  (*prevent substitution on bool*)
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   820
  let
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   821
    fun non_bool_eq (\<^const_name>\<open>HOL.eq\<close>, Type (_, [T, _])) = T <> \<^typ>\<open>bool\<close>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   822
      | non_bool_eq _ = false;
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   823
    fun hyp_subst_tac' ctxt =
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   824
      SUBGOAL (fn (goal, i) =>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   825
        if Term.exists_Const non_bool_eq goal
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   826
        then Hypsubst.hyp_subst_tac ctxt i
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   827
        else no_tac);
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   828
  in
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   829
    Context_Rules.addSWrapper (fn ctxt => fn tac => hyp_subst_tac' ctxt ORELSE' tac)
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
   830
  end
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   831
\<close>
21009
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   832
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   833
declare iffI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   834
  and notI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   835
  and impI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   836
  and disjCI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   837
  and conjI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   838
  and TrueI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   839
  and refl [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   840
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   841
declare iffCE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   842
  and FalseE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   843
  and impCE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   844
  and disjE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   845
  and conjE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   846
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   847
declare ex_ex1I [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   848
  and allI [intro!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   849
  and exI [intro]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   850
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   851
declare exE [elim!]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   852
  allE [elim]
0eae3fb48936 lifted claset setup from ML to Isar level
haftmann
parents: 20973
diff changeset
   853
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   854
ML \<open>val HOL_cs = claset_of \<^context>\<close>
19162
67436e2a16df Added setup for "atpset" (a rule set for ATPs).
mengj
parents: 19138
diff changeset
   855
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   856
lemma contrapos_np: "\<not> Q \<Longrightarrow> (\<not> P \<Longrightarrow> Q) \<Longrightarrow> P"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   857
  by (erule swap)
10383
a092ae7bb2a6 "atomize" for classical tactics;
wenzelm
parents: 9970
diff changeset
   858
18689
a50587cd8414 prefer ex1I over ex_ex1I in single-step reasoning;
wenzelm
parents: 18595
diff changeset
   859
declare ex_ex1I [rule del, intro! 2]
a50587cd8414 prefer ex1I over ex_ex1I in single-step reasoning;
wenzelm
parents: 18595
diff changeset
   860
  and ex1I [intro]
a50587cd8414 prefer ex1I over ex_ex1I in single-step reasoning;
wenzelm
parents: 18595
diff changeset
   861
41865
4e8483cc2cc5 declare ext [intro]: Extensionality now available by default
paulson
parents: 41827
diff changeset
   862
declare ext [intro]
4e8483cc2cc5 declare ext [intro]: Extensionality now available by default
paulson
parents: 41827
diff changeset
   863
12386
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   864
lemmas [intro?] = ext
9c38ec9eca1c tuned declarations (rules, sym, etc.);
wenzelm
parents: 12354
diff changeset
   865
  and [elim?] = ex1_implies_ex
11977
2e7c54b86763 tuned declaration of rules;
wenzelm
parents: 11953
diff changeset
   866
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   867
text \<open>Better than \<open>ex1E\<close> for classical reasoner: needs no quantifier duplication!\<close>
20973
0b8e436ed071 cleaned up HOL bootstrap
haftmann
parents: 20944
diff changeset
   868
lemma alt_ex1E [elim!]:
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   869
  assumes major: "\<exists>!x. P x"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   870
    and minor: "\<And>x. \<lbrakk>P x; \<forall>y y'. P y \<and> P y' \<longrightarrow> y = y'\<rbrakk> \<Longrightarrow> R"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   871
  shows R
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   872
proof (rule ex1E [OF major minor])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   873
  show "\<forall>y y'. P y \<and> P y' \<longrightarrow> y = y'" if "P x" and \<section>: "\<forall>y. P y \<longrightarrow> y = x" for x
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   874
    using \<open>P x\<close> \<section> \<section> by fast
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   875
qed assumption
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
   876
71827
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   877
text \<open>And again using Uniq\<close>
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   878
lemma alt_ex1E':
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   879
  assumes  "\<exists>!x. P x" "\<And>x. \<lbrakk>P x; \<exists>\<^sub>\<le>\<^sub>1x. P x\<rbrakk> \<Longrightarrow> R"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   880
  shows R
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   881
  using assms unfolding Uniq_def by fast
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   882
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   883
lemma ex1_iff_ex_Uniq: "(\<exists>!x. P x) \<longleftrightarrow> (\<exists>x. P x) \<and> (\<exists>\<^sub>\<le>\<^sub>1x. P x)"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   884
  unfolding Uniq_def by fast
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   885
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   886
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   887
ML \<open>
42477
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   888
  structure Blast = Blast
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   889
  (
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   890
    structure Classical = Classical
74383
107941e8fa01 clarified antiquotations;
wenzelm
parents: 71989
diff changeset
   891
    val Trueprop_const = dest_Const \<^Const>\<open>Trueprop\<close>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   892
    val equality_name = \<^const_name>\<open>HOL.eq\<close>
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
   893
    val not_name = \<^const_name>\<open>Not\<close>
42477
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   894
    val notE = @{thm notE}
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   895
    val ccontr = @{thm ccontr}
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   896
    val hyp_subst_tac = Hypsubst.blast_hyp_subst_tac
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   897
  );
52fa26b6c524 simplified Blast setup;
wenzelm
parents: 42459
diff changeset
   898
  val blast_tac = Blast.blast_tac;
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   899
\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   900
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   901
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   902
subsubsection \<open>THE: definite description operator\<close>
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   903
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   904
lemma the_equality [intro]:
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   905
  assumes "P a"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   906
    and "\<And>x. P x \<Longrightarrow> x = a"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   907
  shows "(THE x. P x) = a"
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   908
  by (blast intro: assms trans [OF arg_cong [where f=The] the_eq_trivial])
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   909
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   910
lemma theI:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   911
  assumes "P a"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   912
    and "\<And>x. P x \<Longrightarrow> x = a"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   913
  shows "P (THE x. P x)"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   914
  by (iprover intro: assms the_equality [THEN ssubst])
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   915
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   916
lemma theI': "\<exists>!x. P x \<Longrightarrow> P (THE x. P x)"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   917
  by (blast intro: theI)
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   918
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   919
text \<open>Easier to apply than \<open>theI\<close>: only one occurrence of \<open>P\<close>.\<close>
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   920
lemma theI2:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   921
  assumes "P a" "\<And>x. P x \<Longrightarrow> x = a" "\<And>x. P x \<Longrightarrow> Q x"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   922
  shows "Q (THE x. P x)"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   923
  by (iprover intro: assms theI)
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   924
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   925
lemma the1I2:
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   926
  assumes "\<exists>!x. P x" "\<And>x. P x \<Longrightarrow> Q x"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   927
  shows "Q (THE x. P x)"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
   928
  by (iprover intro: assms(2) theI2[where P=P and Q=Q] ex1E[OF assms(1)] elim: allE impE)
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   929
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   930
lemma the1_equality [elim?]: "\<lbrakk>\<exists>!x. P x; P a\<rbrakk> \<Longrightarrow> (THE x. P x) = a"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   931
  by blast
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   932
71827
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   933
lemma the1_equality': "\<lbrakk>\<exists>\<^sub>\<le>\<^sub>1x. P x; P a\<rbrakk> \<Longrightarrow> (THE x. P x) = a"
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   934
  unfolding Uniq_def by blast
5e315defb038 the Uniq quantifier
paulson <lp15@cam.ac.uk>
parents: 71608
diff changeset
   935
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   936
lemma the_sym_eq_trivial: "(THE y. x = y) = x"
59504
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   937
  by blast
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   938
8c6747dba731 New lemmas and a bit of tidying up.
paulson <lp15@cam.ac.uk>
parents: 59028
diff changeset
   939
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
   940
subsubsection \<open>Simplifier\<close>
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
   941
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   942
lemma eta_contract_eq: "(\<lambda>s. f s) = f" ..
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
   943
71918
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
   944
lemma subst_all:
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
   945
  \<open>(\<And>x. x = a \<Longrightarrow> PROP P x) \<equiv> PROP P a\<close>
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
   946
  \<open>(\<And>x. a = x \<Longrightarrow> PROP P x) \<equiv> PROP P a\<close>
71959
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   947
proof -
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   948
  show \<open>(\<And>x. x = a \<Longrightarrow> PROP P x) \<equiv> PROP P a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   949
  proof (rule equal_intr_rule)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   950
    assume *: \<open>\<And>x. x = a \<Longrightarrow> PROP P x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   951
    show \<open>PROP P a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   952
      by (rule *) (rule refl)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   953
  next
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   954
    fix x
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   955
    assume \<open>PROP P a\<close> and \<open>x = a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   956
    from \<open>x = a\<close> have \<open>x \<equiv> a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   957
      by (rule eq_reflection)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   958
    with \<open>PROP P a\<close> show \<open>PROP P x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   959
      by simp
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   960
  qed
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   961
  show \<open>(\<And>x. a = x \<Longrightarrow> PROP P x) \<equiv> PROP P a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   962
  proof (rule equal_intr_rule)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   963
    assume *: \<open>\<And>x. a = x \<Longrightarrow> PROP P x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   964
    show \<open>PROP P a\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   965
      by (rule *) (rule refl)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   966
  next
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   967
    fix x
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   968
    assume \<open>PROP P a\<close> and \<open>a = x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   969
    from \<open>a = x\<close> have \<open>a \<equiv> x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   970
      by (rule eq_reflection)
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   971
    with \<open>PROP P a\<close> show \<open>PROP P x\<close>
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   972
      by simp
ee2c7f0dd1be prefer single name
haftmann
parents: 71918
diff changeset
   973
  qed
71918
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
   974
qed
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
   975
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
   976
lemma simp_thms:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   977
  shows not_not: "(\<not> \<not> P) = P"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   978
  and Not_eq_iff: "((\<not> P) = (\<not> Q)) = (P = Q)"
12937
0c4fd7529467 clarified syntax of ``long'' statements: fixes/assumes/shows;
wenzelm
parents: 12892
diff changeset
   979
  and
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   980
    "(P \<noteq> Q) = (P = (\<not> Q))"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   981
    "(P \<or> \<not>P) = True"    "(\<not> P \<or> P) = True"
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
   982
    "(x = x) = True"
32068
98acc234d683 tuned code annotations
haftmann
parents: 31998
diff changeset
   983
  and not_True_eq_False [code]: "(\<not> True) = False"
98acc234d683 tuned code annotations
haftmann
parents: 31998
diff changeset
   984
  and not_False_eq_True [code]: "(\<not> False) = True"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   985
  and
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   986
    "(\<not> P) \<noteq> P"  "P \<noteq> (\<not> P)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   987
    "(True = P) = P"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   988
  and eq_True: "(P = True) = P"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   989
  and "(False = P) = (\<not> P)"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   990
  and eq_False: "(P = False) = (\<not> P)"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
   991
  and
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   992
    "(True \<longrightarrow> P) = P"  "(False \<longrightarrow> P) = True"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   993
    "(P \<longrightarrow> True) = True"  "(P \<longrightarrow> P) = True"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   994
    "(P \<longrightarrow> False) = (\<not> P)"  "(P \<longrightarrow> \<not> P) = (\<not> P)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   995
    "(P \<and> True) = P"  "(True \<and> P) = P"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   996
    "(P \<and> False) = False"  "(False \<and> P) = False"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   997
    "(P \<and> P) = P"  "(P \<and> (P \<and> Q)) = (P \<and> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   998
    "(P \<and> \<not> P) = False"    "(\<not> P \<and> P) = False"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
   999
    "(P \<or> True) = True"  "(True \<or> P) = True"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1000
    "(P \<or> False) = P"  "(False \<or> P) = P"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1001
    "(P \<or> P) = P"  "(P \<or> (P \<or> Q)) = (P \<or> Q)" and
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1002
    "(\<forall>x. P) = P"  "(\<exists>x. P) = P"  "\<exists>x. x = t"  "\<exists>x. t = x"
31166
a90fe83f58ea "{x. P x & x=t & Q x}" is now rewritten to "if P t & Q t then {t} else {}"
nipkow
parents: 31156
diff changeset
  1003
  and
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1004
    "\<And>P. (\<exists>x. x = t \<and> P x) = P t"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1005
    "\<And>P. (\<exists>x. t = x \<and> P x) = P t"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1006
    "\<And>P. (\<forall>x. x = t \<longrightarrow> P x) = P t"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1007
    "\<And>P. (\<forall>x. t = x \<longrightarrow> P x) = P t"
66109
e034a563ed7d added simp rules
nipkow
parents: 63912
diff changeset
  1008
    "(\<forall>x. x \<noteq> t) = False"  "(\<forall>x. t \<noteq> x) = False"
17589
58eeffd73be1 renamed rules to iprover
nipkow
parents: 17459
diff changeset
  1009
  by (blast, blast, blast, blast, blast, iprover+)
13421
8fcdf4a26468 simplified locale predicates;
wenzelm
parents: 13412
diff changeset
  1010
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1011
lemma disj_absorb: "A \<or> A \<longleftrightarrow> A"
14201
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1012
  by blast
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1013
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1014
lemma disj_left_absorb: "A \<or> (A \<or> B) \<longleftrightarrow> A \<or> B"
14201
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1015
  by blast
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1016
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1017
lemma conj_absorb: "A \<and> A \<longleftrightarrow> A"
14201
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1018
  by blast
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1019
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1020
lemma conj_left_absorb: "A \<and> (A \<and> B) \<longleftrightarrow> A \<and> B"
14201
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1021
  by blast
7ad7ab89c402 some basic new lemmas
paulson
parents: 13764
diff changeset
  1022
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1023
lemma eq_ac:
57512
cc97b347b301 reduced name variants for assoc and commute on plus and mult
haftmann
parents: 56941
diff changeset
  1024
  shows eq_commute: "a = b \<longleftrightarrow> b = a"
cc97b347b301 reduced name variants for assoc and commute on plus and mult
haftmann
parents: 56941
diff changeset
  1025
    and iff_left_commute: "(P \<longleftrightarrow> (Q \<longleftrightarrow> R)) \<longleftrightarrow> (Q \<longleftrightarrow> (P \<longleftrightarrow> R))"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1026
    and iff_assoc: "((P \<longleftrightarrow> Q) \<longleftrightarrow> R) \<longleftrightarrow> (P \<longleftrightarrow> (Q \<longleftrightarrow> R))"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1027
  by (iprover, blast+)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1028
57512
cc97b347b301 reduced name variants for assoc and commute on plus and mult
haftmann
parents: 56941
diff changeset
  1029
lemma neq_commute: "a \<noteq> b \<longleftrightarrow> b \<noteq> a" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1030
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1031
lemma conj_comms:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1032
  shows conj_commute: "P \<and> Q \<longleftrightarrow> Q \<and> P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1033
    and conj_left_commute: "P \<and> (Q \<and> R) \<longleftrightarrow> Q \<and> (P \<and> R)" by iprover+
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1034
lemma conj_assoc: "(P \<and> Q) \<and> R \<longleftrightarrow> P \<and> (Q \<and> R)" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1035
19174
df9de25e87b3 moved the "use" directive
paulson
parents: 19162
diff changeset
  1036
lemmas conj_ac = conj_commute conj_left_commute conj_assoc
df9de25e87b3 moved the "use" directive
paulson
parents: 19162
diff changeset
  1037
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1038
lemma disj_comms:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1039
  shows disj_commute: "P \<or> Q \<longleftrightarrow> Q \<or> P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1040
    and disj_left_commute: "P \<or> (Q \<or> R) \<longleftrightarrow> Q \<or> (P \<or> R)" by iprover+
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1041
lemma disj_assoc: "(P \<or> Q) \<or> R \<longleftrightarrow> P \<or> (Q \<or> R)" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1042
19174
df9de25e87b3 moved the "use" directive
paulson
parents: 19162
diff changeset
  1043
lemmas disj_ac = disj_commute disj_left_commute disj_assoc
df9de25e87b3 moved the "use" directive
paulson
parents: 19162
diff changeset
  1044
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1045
lemma conj_disj_distribL: "P \<and> (Q \<or> R) \<longleftrightarrow> P \<and> Q \<or> P \<and> R" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1046
lemma conj_disj_distribR: "(P \<or> Q) \<and> R \<longleftrightarrow> P \<and> R \<or> Q \<and> R" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1047
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1048
lemma disj_conj_distribL: "P \<or> (Q \<and> R) \<longleftrightarrow> (P \<or> Q) \<and> (P \<or> R)" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1049
lemma disj_conj_distribR: "(P \<and> Q) \<or> R \<longleftrightarrow> (P \<or> R) \<and> (Q \<or> R)" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1050
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1051
lemma imp_conjR: "(P \<longrightarrow> (Q \<and> R)) = ((P \<longrightarrow> Q) \<and> (P \<longrightarrow> R))" by iprover
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1052
lemma imp_conjL: "((P \<and> Q) \<longrightarrow> R) = (P \<longrightarrow> (Q \<longrightarrow> R))" by iprover
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1053
lemma imp_disjL: "((P \<or> Q) \<longrightarrow> R) = ((P \<longrightarrow> R) \<and> (Q \<longrightarrow> R))" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1054
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1055
text \<open>These two are specialized, but \<open>imp_disj_not1\<close> is useful in \<open>Auth/Yahalom\<close>.\<close>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1056
lemma imp_disj_not1: "(P \<longrightarrow> Q \<or> R) \<longleftrightarrow> (\<not> Q \<longrightarrow> P \<longrightarrow> R)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1057
lemma imp_disj_not2: "(P \<longrightarrow> Q \<or> R) \<longleftrightarrow> (\<not> R \<longrightarrow> P \<longrightarrow> Q)" by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1058
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1059
lemma imp_disj1: "((P \<longrightarrow> Q) \<or> R) \<longleftrightarrow> (P \<longrightarrow> Q \<or> R)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1060
lemma imp_disj2: "(Q \<or> (P \<longrightarrow> R)) \<longleftrightarrow> (P \<longrightarrow> Q \<or> R)" by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1061
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1062
lemma imp_cong: "(P = P') \<Longrightarrow> (P' \<Longrightarrow> (Q = Q')) \<Longrightarrow> ((P \<longrightarrow> Q) \<longleftrightarrow> (P' \<longrightarrow> Q'))"
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1063
  by iprover
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1064
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1065
lemma de_Morgan_disj: "\<not> (P \<or> Q) \<longleftrightarrow> \<not> P \<and> \<not> Q" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1066
lemma de_Morgan_conj: "\<not> (P \<and> Q) \<longleftrightarrow> \<not> P \<or> \<not> Q" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1067
lemma not_imp: "\<not> (P \<longrightarrow> Q) \<longleftrightarrow> P \<and> \<not> Q" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1068
lemma not_iff: "P \<noteq> Q \<longleftrightarrow> (P \<longleftrightarrow> \<not> Q)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1069
lemma disj_not1: "\<not> P \<or> Q \<longleftrightarrow> (P \<longrightarrow> Q)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1070
lemma disj_not2: "P \<or> \<not> Q \<longleftrightarrow> (Q \<longrightarrow> P)" by blast  \<comment> \<open>changes orientation :-(\<close>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1071
lemma imp_conv_disj: "(P \<longrightarrow> Q) \<longleftrightarrow> (\<not> P) \<or> Q" by blast
63561
fba08009ff3e add lemmas contributed by Peter Gammie
Andreas Lochbihler
parents: 62958
diff changeset
  1072
lemma disj_imp: "P \<or> Q \<longleftrightarrow> \<not> P \<longrightarrow> Q" by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1073
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1074
lemma iff_conv_conj_imp: "(P \<longleftrightarrow> Q) \<longleftrightarrow> (P \<longrightarrow> Q) \<and> (Q \<longrightarrow> P)" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1075
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1076
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1077
lemma cases_simp: "(P \<longrightarrow> Q) \<and> (\<not> P \<longrightarrow> Q) \<longleftrightarrow> Q"
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1078
  \<comment> \<open>Avoids duplication of subgoals after \<open>if_split\<close>, when the true and false\<close>
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1079
  \<comment> \<open>cases boil down to the same thing.\<close>
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1080
  by blast
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1081
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1082
lemma not_all: "\<not> (\<forall>x. P x) \<longleftrightarrow> (\<exists>x. \<not> P x)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1083
lemma imp_all: "((\<forall>x. P x) \<longrightarrow> Q) \<longleftrightarrow> (\<exists>x. P x \<longrightarrow> Q)" by blast
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1084
lemma not_ex: "\<not> (\<exists>x. P x) \<longleftrightarrow> (\<forall>x. \<not> P x)" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1085
lemma imp_ex: "((\<exists>x. P x) \<longrightarrow> Q) \<longleftrightarrow> (\<forall>x. P x \<longrightarrow> Q)" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1086
lemma all_not_ex: "(\<forall>x. P x) \<longleftrightarrow> \<not> (\<exists>x. \<not> P x)" by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1087
35828
46cfc4b8112e now use "Named_Thms" for "noatp", and renamed "noatp" to "no_atp"
blanchet
parents: 35808
diff changeset
  1088
declare All_def [no_atp]
24286
7619080e49f0 ATP blacklisting is now in theory data, attribute noatp
paulson
parents: 24280
diff changeset
  1089
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1090
lemma ex_disj_distrib: "(\<exists>x. P x \<or> Q x) \<longleftrightarrow> (\<exists>x. P x) \<or> (\<exists>x. Q x)" by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1091
lemma all_conj_distrib: "(\<forall>x. P x \<and> Q x) \<longleftrightarrow> (\<forall>x. P x) \<and> (\<forall>x. Q x)" by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1092
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1093
text \<open>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1094
  \<^medskip> The \<open>\<and>\<close> congruence rule: not included by default!
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1095
  May slow rewrite proofs down by as much as 50\%\<close>
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1096
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1097
lemma conj_cong: "P = P' \<Longrightarrow> (P' \<Longrightarrow> Q = Q') \<Longrightarrow> (P \<and> Q) = (P' \<and> Q')"
17589
58eeffd73be1 renamed rules to iprover
nipkow
parents: 17459
diff changeset
  1098
  by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1099
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1100
lemma rev_conj_cong: "Q = Q' \<Longrightarrow> (Q' \<Longrightarrow> P = P') \<Longrightarrow> (P \<and> Q) = (P' \<and> Q')"
17589
58eeffd73be1 renamed rules to iprover
nipkow
parents: 17459
diff changeset
  1101
  by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1102
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1103
text \<open>The \<open>|\<close> congruence rule: not included by default!\<close>
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1104
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1105
lemma disj_cong: "P = P' \<Longrightarrow> (\<not> P' \<Longrightarrow> Q = Q') \<Longrightarrow> (P \<or> Q) = (P' \<or> Q')"
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1106
  by blast
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1107
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1108
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1109
text \<open>\<^medskip> if-then-else rules\<close>
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1110
32068
98acc234d683 tuned code annotations
haftmann
parents: 31998
diff changeset
  1111
lemma if_True [code]: "(if True then x else y) = x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1112
  unfolding If_def by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1113
32068
98acc234d683 tuned code annotations
haftmann
parents: 31998
diff changeset
  1114
lemma if_False [code]: "(if False then x else y) = y"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1115
  unfolding If_def by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1116
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1117
lemma if_P: "P \<Longrightarrow> (if P then x else y) = x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1118
  unfolding If_def by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1119
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1120
lemma if_not_P: "\<not> P \<Longrightarrow> (if P then x else y) = y"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1121
  unfolding If_def by blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1122
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1123
lemma if_split: "P (if Q then x else y) = ((Q \<longrightarrow> P x) \<and> (\<not> Q \<longrightarrow> P y))"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1124
proof (rule case_split [of Q])
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1125
  show ?thesis if Q
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1126
    using that by (simplesubst if_P) blast+
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1127
  show ?thesis if "\<not> Q"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1128
    using that by (simplesubst if_not_P) blast+
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1129
qed
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1130
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1131
lemma if_split_asm: "P (if Q then x else y) = (\<not> ((Q \<and> \<not> P x) \<or> (\<not> Q \<and> \<not> P y)))"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1132
  by (simplesubst if_split) blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1133
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1134
lemmas if_splits [no_atp] = if_split if_split_asm
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1135
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1136
lemma if_cancel: "(if c then x else x) = x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1137
  by (simplesubst if_split) blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1138
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1139
lemma if_eq_cancel: "(if x = y then y else x) = x"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1140
  by (simplesubst if_split) blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1141
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1142
lemma if_bool_eq_conj: "(if P then Q else R) = ((P \<longrightarrow> Q) \<and> (\<not> P \<longrightarrow> R))"
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1143
  \<comment> \<open>This form is useful for expanding \<open>if\<close>s on the RIGHT of the \<open>\<Longrightarrow>\<close> symbol.\<close>
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1144
  by (rule if_split)
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1145
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1146
lemma if_bool_eq_disj: "(if P then Q else R) = ((P \<and> Q) \<or> (\<not> P \<and> R))"
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1147
  \<comment> \<open>And this form is useful for expanding \<open>if\<close>s on the LEFT.\<close>
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1148
  by (simplesubst if_split) blast
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1149
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1150
lemma Eq_TrueI: "P \<Longrightarrow> P \<equiv> True" unfolding atomize_eq by iprover
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1151
lemma Eq_FalseI: "\<not> P \<Longrightarrow> P \<equiv> False" unfolding atomize_eq by iprover
12281
3bd113b8f7a6 converted simp lemmas;
wenzelm
parents: 12256
diff changeset
  1152
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1153
text \<open>\<^medskip> let rules for simproc\<close>
15423
761a4f8e6ad6 added simproc for Let
schirmer
parents: 15411
diff changeset
  1154
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1155
lemma Let_folded: "f x \<equiv> g x \<Longrightarrow> Let x f \<equiv> Let x g"
15423
761a4f8e6ad6 added simproc for Let
schirmer
parents: 15411
diff changeset
  1156
  by (unfold Let_def)
761a4f8e6ad6 added simproc for Let
schirmer
parents: 15411
diff changeset
  1157
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1158
lemma Let_unfold: "f x \<equiv> g \<Longrightarrow> Let x f \<equiv> g"
15423
761a4f8e6ad6 added simproc for Let
schirmer
parents: 15411
diff changeset
  1159
  by (unfold Let_def)
761a4f8e6ad6 added simproc for Let
schirmer
parents: 15411
diff changeset
  1160
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1161
text \<open>
16999
307b2ec590ff Turned simp_implies into binary operator.
ballarin
parents: 16775
diff changeset
  1162
  The following copy of the implication operator is useful for
307b2ec590ff Turned simp_implies into binary operator.
ballarin
parents: 16775
diff changeset
  1163
  fine-tuning congruence rules.  It instructs the simplifier to simplify
307b2ec590ff Turned simp_implies into binary operator.
ballarin
parents: 16775
diff changeset
  1164
  its premise.
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1165
\<close>
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1166
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1167
definition simp_implies :: "prop \<Rightarrow> prop \<Rightarrow> prop"  (infixr "=simp=>" 1)
67399
eab6ce8368fa ran isabelle update_op on all sources
nipkow
parents: 67299
diff changeset
  1168
  where "simp_implies \<equiv> (\<Longrightarrow>)"
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1169
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1170
lemma simp_impliesI:
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1171
  assumes PQ: "(PROP P \<Longrightarrow> PROP Q)"
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1172
  shows "PROP P =simp=> PROP Q"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1173
  unfolding simp_implies_def
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1174
  by (iprover intro: PQ)
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1175
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1176
lemma simp_impliesE:
25388
5cd130251825 tuned specifications of 'notation';
wenzelm
parents: 25297
diff changeset
  1177
  assumes PQ: "PROP P =simp=> PROP Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1178
    and P: "PROP P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1179
    and QR: "PROP Q \<Longrightarrow> PROP R"
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1180
  shows "PROP R"
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1181
  by (iprover intro: QR P PQ [unfolded simp_implies_def])
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1182
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1183
lemma simp_implies_cong:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1184
  assumes PP' :"PROP P \<equiv> PROP P'"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1185
    and P'QQ': "PROP P' \<Longrightarrow> (PROP Q \<equiv> PROP Q')"
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1186
  shows "(PROP P =simp=> PROP Q) \<equiv> (PROP P' =simp=> PROP Q')"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1187
  unfolding simp_implies_def
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1188
proof (rule equal_intr_rule)
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1189
  assume PQ: "PROP P \<Longrightarrow> PROP Q"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1190
    and P': "PROP P'"
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1191
  from PP' [symmetric] and P' have "PROP P"
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1192
    by (rule equal_elim_rule1)
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1193
  then have "PROP Q" by (rule PQ)
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1194
  with P'QQ' [OF P'] show "PROP Q'" by (rule equal_elim_rule1)
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1195
next
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1196
  assume P'Q': "PROP P' \<Longrightarrow> PROP Q'"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1197
    and P: "PROP P"
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1198
  from PP' and P have P': "PROP P'" by (rule equal_elim_rule1)
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1199
  then have "PROP Q'" by (rule P'Q')
16633
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1200
  with P'QQ' [OF P', symmetric] show "PROP Q"
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1201
    by (rule equal_elim_rule1)
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1202
qed
208ebc9311f2 Implemented trick (due to Tobias Nipkow) for fine-tuning simplification
berghofe
parents: 16587
diff changeset
  1203
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1204
lemma uncurry:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1205
  assumes "P \<longrightarrow> Q \<longrightarrow> R"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1206
  shows "P \<and> Q \<longrightarrow> R"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1207
  using assms by blast
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1208
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1209
lemma iff_allI:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1210
  assumes "\<And>x. P x = Q x"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1211
  shows "(\<forall>x. P x) = (\<forall>x. Q x)"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1212
  using assms by blast
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1213
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1214
lemma iff_exI:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1215
  assumes "\<And>x. P x = Q x"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1216
  shows "(\<exists>x. P x) = (\<exists>x. Q x)"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1217
  using assms by blast
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1218
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1219
lemma all_comm: "(\<forall>x y. P x y) = (\<forall>y x. P x y)"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1220
  by blast
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1221
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1222
lemma ex_comm: "(\<exists>x y. P x y) = (\<exists>y x. P x y)"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1223
  by blast
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1224
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1225
ML_file \<open>Tools/simpdata.ML\<close>
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1226
ML \<open>open Simpdata\<close>
42455
6702c984bf5a modernized Quantifier1 simproc setup;
wenzelm
parents: 42453
diff changeset
  1227
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1228
setup \<open>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1229
  map_theory_simpset (put_simpset HOL_basic_ss) #>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1230
  Simplifier.method_setup Splitter.split_modifiers
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1231
\<close>
42455
6702c984bf5a modernized Quantifier1 simproc setup;
wenzelm
parents: 42453
diff changeset
  1232
71886
4f4695757980 better closeup and more consistent terminology
haftmann
parents: 71842
diff changeset
  1233
simproc_setup defined_Ex ("\<exists>x. P x") = \<open>K Quantifier1.rearrange_Ex\<close>
4f4695757980 better closeup and more consistent terminology
haftmann
parents: 71842
diff changeset
  1234
simproc_setup defined_All ("\<forall>x. P x") = \<open>K Quantifier1.rearrange_All\<close>
71914
3867734b9a40 install simproc but deactivate by default
haftmann
parents: 71886
diff changeset
  1235
simproc_setup defined_all("\<And>x. PROP P x") = \<open>K Quantifier1.rearrange_all\<close>
3867734b9a40 install simproc but deactivate by default
haftmann
parents: 71886
diff changeset
  1236
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1237
text \<open>Simproc for proving \<open>(y = x) \<equiv> False\<close> from premise \<open>\<not> (x = y)\<close>:\<close>
24035
74c032aea9ed simplified ResAtpset via NamedThmsFun;
wenzelm
parents: 23948
diff changeset
  1238
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1239
simproc_setup neq ("x = y") = \<open>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1240
  let
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1241
    val neq_to_EQ_False = @{thm not_sym} RS @{thm Eq_FalseI};
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1242
    fun is_neq eq lhs rhs thm =
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1243
      (case Thm.prop_of thm of
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1244
        _ $ (Not $ (eq' $ l' $ r')) =>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1245
          Not = HOLogic.Not andalso eq' = eq andalso
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1246
          r' aconv lhs andalso l' aconv rhs
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1247
      | _ => false);
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1248
    fun proc ss ct =
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1249
      (case Thm.term_of ct of
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1250
        eq $ lhs $ rhs =>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1251
          (case find_first (is_neq eq lhs rhs) (Simplifier.prems_of ss) of
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1252
            SOME thm => SOME (thm RS neq_to_EQ_False)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1253
          | NONE => NONE)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1254
       | _ => NONE);
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1255
  in K proc end
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1256
\<close>
24035
74c032aea9ed simplified ResAtpset via NamedThmsFun;
wenzelm
parents: 23948
diff changeset
  1257
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1258
simproc_setup let_simp ("Let x f") = \<open>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1259
  let
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1260
    fun count_loose (Bound i) k = if i >= k then 1 else 0
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1261
      | count_loose (s $ t) k = count_loose s k + count_loose t k
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1262
      | count_loose (Abs (_, _, t)) k = count_loose  t (k + 1)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1263
      | count_loose _ _ = 0;
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1264
    fun is_trivial_let (Const (\<^const_name>\<open>Let\<close>, _) $ x $ t) =
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1265
      (case t of
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1266
        Abs (_, _, t') => count_loose t' 0 <= 1
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1267
      | _ => true);
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1268
  in
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1269
    K (fn ctxt => fn ct =>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1270
      if is_trivial_let (Thm.term_of ct)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1271
      then SOME @{thm Let_def} (*no or one ocurrence of bound variable*)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1272
      else
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1273
        let (*Norbert Schirmer's case*)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1274
          val t = Thm.term_of ct;
70326
wenzelm
parents: 69605
diff changeset
  1275
          val (t', ctxt') = yield_singleton (Variable.import_terms false) t ctxt;
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1276
        in
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1277
          Option.map (hd o Variable.export ctxt' ctxt o single)
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1278
            (case t' of Const (\<^const_name>\<open>Let\<close>,_) $ x $ f => (* x and f are already in normal form *)
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1279
              if is_Free x orelse is_Bound x orelse is_Const x
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1280
              then SOME @{thm Let_def}
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1281
              else
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1282
                let
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1283
                  val n = case f of (Abs (x, _, _)) => x | _ => "x";
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1284
                  val cx = Thm.cterm_of ctxt x;
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1285
                  val xT = Thm.typ_of_cterm cx;
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1286
                  val cf = Thm.cterm_of ctxt f;
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1287
                  val fx_g = Simplifier.rewrite ctxt (Thm.apply cf cx);
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1288
                  val (_ $ _ $ g) = Thm.prop_of fx_g;
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1289
                  val g' = abstract_over (x, g);
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1290
                  val abs_g'= Abs (n, xT, g');
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1291
                in
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1292
                  if g aconv g' then
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1293
                    let
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1294
                      val rl =
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1295
                        infer_instantiate ctxt [(("f", 0), cf), (("x", 0), cx)] @{thm Let_unfold};
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1296
                    in SOME (rl OF [fx_g]) end
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1297
                  else if (Envir.beta_eta_contract f) aconv (Envir.beta_eta_contract abs_g')
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1298
                  then NONE (*avoid identity conversion*)
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1299
                  else
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1300
                    let
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1301
                      val g'x = abs_g' $ x;
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1302
                      val g_g'x = Thm.symmetric (Thm.beta_conversion false (Thm.cterm_of ctxt g'x));
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1303
                      val rl =
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1304
                        @{thm Let_folded} |> infer_instantiate ctxt
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1305
                          [(("f", 0), Thm.cterm_of ctxt f),
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1306
                           (("x", 0), cx),
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1307
                           (("g", 0), Thm.cterm_of ctxt abs_g')];
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1308
                    in SOME (rl OF [Thm.transitive fx_g g_g'x]) end
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1309
                end
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1310
            | _ => NONE)
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1311
        end)
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1312
  end
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1313
\<close>
24035
74c032aea9ed simplified ResAtpset via NamedThmsFun;
wenzelm
parents: 23948
diff changeset
  1314
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1315
lemma True_implies_equals: "(True \<Longrightarrow> PROP P) \<equiv> PROP P"
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1316
proof
23389
aaca6a8e5414 tuned proofs: avoid implicit prems;
wenzelm
parents: 23263
diff changeset
  1317
  assume "True \<Longrightarrow> PROP P"
aaca6a8e5414 tuned proofs: avoid implicit prems;
wenzelm
parents: 23263
diff changeset
  1318
  from this [OF TrueI] show "PROP P" .
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1319
next
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1320
  assume "PROP P"
23389
aaca6a8e5414 tuned proofs: avoid implicit prems;
wenzelm
parents: 23263
diff changeset
  1321
  then show "PROP P" .
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1322
qed
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1323
59864
c777743294e1 added lemmas
nipkow
parents: 59779
diff changeset
  1324
lemma implies_True_equals: "(PROP P \<Longrightarrow> True) \<equiv> Trueprop True"
61169
4de9ff3ea29a tuned proofs -- less legacy;
wenzelm
parents: 61144
diff changeset
  1325
  by standard (intro TrueI)
59864
c777743294e1 added lemmas
nipkow
parents: 59779
diff changeset
  1326
c777743294e1 added lemmas
nipkow
parents: 59779
diff changeset
  1327
lemma False_implies_equals: "(False \<Longrightarrow> P) \<equiv> Trueprop True"
61169
4de9ff3ea29a tuned proofs -- less legacy;
wenzelm
parents: 61144
diff changeset
  1328
  by standard simp_all
59864
c777743294e1 added lemmas
nipkow
parents: 59779
diff changeset
  1329
71842
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1330
(* It seems that making this a simp rule is slower than using the simproc below *)
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1331
lemma implies_False_swap:
71842
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1332
  "(False \<Longrightarrow> PROP P \<Longrightarrow> PROP Q) \<equiv> (PROP P \<Longrightarrow> False \<Longrightarrow> PROP Q)"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1333
  by (rule swap_prems_eq)
60169
5ef8ed685965 swap False to the right in assumptions to be eliminated at the right end
nipkow
parents: 60151
diff changeset
  1334
71842
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1335
ML \<open>
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1336
fun eliminate_false_implies ct =
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1337
  let
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1338
    val (prems, concl) = Logic.strip_horn (Thm.term_of ct)
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1339
    fun go n =
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1340
      if n > 1 then
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1341
        Conv.rewr_conv @{thm Pure.swap_prems_eq}
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1342
        then_conv Conv.arg_conv (go (n - 1))
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1343
        then_conv Conv.rewr_conv @{thm HOL.implies_True_equals}
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1344
      else
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1345
        Conv.rewr_conv @{thm HOL.False_implies_equals}
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1346
  in
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1347
    case concl of
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1348
      Const (@{const_name HOL.Trueprop}, _) $ _ => SOME (go (length prems) ct)
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1349
    | _ => NONE
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1350
  end
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1351
\<close>
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1352
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1353
simproc_setup eliminate_false_implies ("False \<Longrightarrow> PROP P") = \<open>K (K eliminate_false_implies)\<close>
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1354
db120661dded new HOL simproc: eliminate_false_implies
Manuel Eberl <eberlm@in.tum.de>
parents: 71833
diff changeset
  1355
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1356
lemma ex_simps:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1357
  "\<And>P Q. (\<exists>x. P x \<and> Q)   = ((\<exists>x. P x) \<and> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1358
  "\<And>P Q. (\<exists>x. P \<and> Q x)   = (P \<and> (\<exists>x. Q x))"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1359
  "\<And>P Q. (\<exists>x. P x \<or> Q)   = ((\<exists>x. P x) \<or> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1360
  "\<And>P Q. (\<exists>x. P \<or> Q x)   = (P \<or> (\<exists>x. Q x))"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1361
  "\<And>P Q. (\<exists>x. P x \<longrightarrow> Q) = ((\<forall>x. P x) \<longrightarrow> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1362
  "\<And>P Q. (\<exists>x. P \<longrightarrow> Q x) = (P \<longrightarrow> (\<exists>x. Q x))"
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1363
  \<comment> \<open>Miniscoping: pushing in existential quantifiers.\<close>
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1364
  by (iprover | blast)+
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1365
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1366
lemma all_simps:
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1367
  "\<And>P Q. (\<forall>x. P x \<and> Q)   = ((\<forall>x. P x) \<and> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1368
  "\<And>P Q. (\<forall>x. P \<and> Q x)   = (P \<and> (\<forall>x. Q x))"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1369
  "\<And>P Q. (\<forall>x. P x \<or> Q)   = ((\<forall>x. P x) \<or> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1370
  "\<And>P Q. (\<forall>x. P \<or> Q x)   = (P \<or> (\<forall>x. Q x))"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1371
  "\<And>P Q. (\<forall>x. P x \<longrightarrow> Q) = ((\<exists>x. P x) \<longrightarrow> Q)"
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1372
  "\<And>P Q. (\<forall>x. P \<longrightarrow> Q x) = (P \<longrightarrow> (\<forall>x. Q x))"
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1373
  \<comment> \<open>Miniscoping: pushing in universal quantifiers.\<close>
21151
25bd46916c12 simplified reasoning tools setup
haftmann
parents: 21112
diff changeset
  1374
  by (iprover | blast)+
15481
fc075ae929e4 the new subst tactic, by Lucas Dixon
paulson
parents: 15423
diff changeset
  1375
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1376
lemmas [simp] =
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1377
  triv_forall_equality  \<comment> \<open>prunes params\<close>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1378
  True_implies_equals implies_True_equals  \<comment> \<open>prune \<open>True\<close> in asms\<close>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1379
  False_implies_equals  \<comment> \<open>prune \<open>False\<close> in asms\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1380
  if_True
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1381
  if_False
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1382
  if_cancel
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1383
  if_eq_cancel
67443
3abf6a722518 standardized towards new-style formal comments: isabelle update_comments;
wenzelm
parents: 67405
diff changeset
  1384
  imp_disjL \<comment> \<open>In general it seems wrong to add distributive laws by default: they
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1385
    might cause exponential blow-up.  But \<open>imp_disjL\<close> has been in for a while
20973
0b8e436ed071 cleaned up HOL bootstrap
haftmann
parents: 20944
diff changeset
  1386
    and cannot be removed without affecting existing proofs.  Moreover,
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1387
    rewriting by \<open>(P \<or> Q \<longrightarrow> R) = ((P \<longrightarrow> R) \<and> (Q \<longrightarrow> R))\<close> might be justified on the
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1388
    grounds that it allows simplification of \<open>R\<close> in the two cases.\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1389
  conj_assoc
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1390
  disj_assoc
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1391
  de_Morgan_conj
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1392
  de_Morgan_disj
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1393
  imp_disj1
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1394
  imp_disj2
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1395
  not_imp
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1396
  disj_not1
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1397
  not_all
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1398
  not_ex
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1399
  cases_simp
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1400
  the_eq_trivial
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1401
  the_sym_eq_trivial
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1402
  ex_simps
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1403
  all_simps
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1404
  simp_thms
71918
4e0a58818edc more simp rules
haftmann
parents: 71914
diff changeset
  1405
  subst_all
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1406
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1407
lemmas [cong] = imp_cong simp_implies_cong
62390
842917225d56 more canonical names
nipkow
parents: 62151
diff changeset
  1408
lemmas [split] = if_split
20973
0b8e436ed071 cleaned up HOL bootstrap
haftmann
parents: 20944
diff changeset
  1409
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1410
ML \<open>val HOL_ss = simpset_of \<^context>\<close>
20973
0b8e436ed071 cleaned up HOL bootstrap
haftmann
parents: 20944
diff changeset
  1411
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1412
text \<open>Simplifies \<open>x\<close> assuming \<open>c\<close> and \<open>y\<close> assuming \<open>\<not> c\<close>.\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1413
lemma if_cong:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1414
  assumes "b = c"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1415
    and "c \<Longrightarrow> x = u"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1416
    and "\<not> c \<Longrightarrow> y = v"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1417
  shows "(if b then x else y) = (if c then u else v)"
38525
324219de6ee3 qualified constants Let and If
haftmann
parents: 37877
diff changeset
  1418
  using assms by simp
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1419
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1420
text \<open>Prevents simplification of \<open>x\<close> and \<open>y\<close>:
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1421
  faster and allows the execution of functional programs.\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1422
lemma if_weak_cong [cong]:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1423
  assumes "b = c"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1424
  shows "(if b then x else y) = (if c then x else y)"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1425
  using assms by (rule arg_cong)
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1426
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1427
text \<open>Prevents simplification of t: much faster\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1428
lemma let_weak_cong:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1429
  assumes "a = b"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1430
  shows "(let x = a in t x) = (let x = b in t x)"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1431
  using assms by (rule arg_cong)
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1432
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1433
text \<open>To tidy up the result of a simproc.  Only the RHS will be simplified.\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1434
lemma eq_cong2:
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1435
  assumes "u = u'"
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1436
  shows "(t \<equiv> u) \<equiv> (t \<equiv> u')"
23553
af8ae54238f5 use hologic.ML in basic HOL context;
wenzelm
parents: 23530
diff changeset
  1437
  using assms by simp
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1438
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1439
lemma if_distrib: "f (if c then x else y) = (if c then f x else f y)"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1440
  by simp
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1441
68072
493b818e8e10 added Johannes' generalizations Modules.thy and Vector_Spaces.thy; adapted HOL and HOL-Analysis accordingly
immler
parents: 67719
diff changeset
  1442
lemma if_distribR: "(if b then f else g) x = (if b then f x else g x)"
493b818e8e10 added Johannes' generalizations Modules.thy and Vector_Spaces.thy; adapted HOL and HOL-Analysis accordingly
immler
parents: 67719
diff changeset
  1443
  by simp
493b818e8e10 added Johannes' generalizations Modules.thy and Vector_Spaces.thy; adapted HOL and HOL-Analysis accordingly
immler
parents: 67719
diff changeset
  1444
67673
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1445
lemma all_if_distrib: "(\<forall>x. if x = a then P x else Q x) \<longleftrightarrow> P a \<and> (\<forall>x. x\<noteq>a \<longrightarrow> Q x)"
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1446
  by auto
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1447
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1448
lemma ex_if_distrib: "(\<exists>x. if x = a then P x else Q x) \<longleftrightarrow> P a \<or> (\<exists>x. x\<noteq>a \<and> Q x)"
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1449
  by auto
c8caefb20564 lots of new material, ultimately related to measure theory
paulson <lp15@cam.ac.uk>
parents: 67443
diff changeset
  1450
67719
bffb7482faaa new material on matrices, etc., and consolidating duplicate results about of_nat
paulson <lp15@cam.ac.uk>
parents: 67673
diff changeset
  1451
lemma if_if_eq_conj: "(if P then if Q then x else y else y) = (if P \<and> Q then x else y)"
bffb7482faaa new material on matrices, etc., and consolidating duplicate results about of_nat
paulson <lp15@cam.ac.uk>
parents: 67673
diff changeset
  1452
  by simp
bffb7482faaa new material on matrices, etc., and consolidating duplicate results about of_nat
paulson <lp15@cam.ac.uk>
parents: 67673
diff changeset
  1453
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1454
text \<open>As a simplification rule, it replaces all function equalities by
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1455
  first-order equalities.\<close>
44277
bcb696533579 moved fundamental lemma fun_eq_iff to theory HOL; tuned whitespace
haftmann
parents: 44121
diff changeset
  1456
lemma fun_eq_iff: "f = g \<longleftrightarrow> (\<forall>x. f x = g x)"
bcb696533579 moved fundamental lemma fun_eq_iff to theory HOL; tuned whitespace
haftmann
parents: 44121
diff changeset
  1457
  by auto
bcb696533579 moved fundamental lemma fun_eq_iff to theory HOL; tuned whitespace
haftmann
parents: 44121
diff changeset
  1458
17459
9a3925c07392 added code generator setup (from Main.thy);
wenzelm
parents: 17404
diff changeset
  1459
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1460
subsubsection \<open>Generic cases and induction\<close>
17459
9a3925c07392 added code generator setup (from Main.thy);
wenzelm
parents: 17404
diff changeset
  1461
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1462
text \<open>Rule projections:\<close>
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1463
ML \<open>
32172
c4e55f30d527 renamed functor ProjectRuleFun to Project_Rule;
wenzelm
parents: 32171
diff changeset
  1464
structure Project_Rule = Project_Rule
25388
5cd130251825 tuned specifications of 'notation';
wenzelm
parents: 25297
diff changeset
  1465
(
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1466
  val conjunct1 = @{thm conjunct1}
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1467
  val conjunct2 = @{thm conjunct2}
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1468
  val mp = @{thm mp}
59929
wenzelm
parents: 59864
diff changeset
  1469
);
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1470
\<close>
17459
9a3925c07392 added code generator setup (from Main.thy);
wenzelm
parents: 17404
diff changeset
  1471
59940
087d81f5213e local setup of induction tools, with restricted access to auxiliary consts;
wenzelm
parents: 59929
diff changeset
  1472
context
087d81f5213e local setup of induction tools, with restricted access to auxiliary consts;
wenzelm
parents: 59929
diff changeset
  1473
begin
087d81f5213e local setup of induction tools, with restricted access to auxiliary consts;
wenzelm
parents: 59929
diff changeset
  1474
59990
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1475
qualified definition "induct_forall P \<equiv> \<forall>x. P x"
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1476
qualified definition "induct_implies A B \<equiv> A \<longrightarrow> B"
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1477
qualified definition "induct_equal x y \<equiv> x = y"
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1478
qualified definition "induct_conj A B \<equiv> A \<and> B"
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1479
qualified definition "induct_true \<equiv> True"
a81dc82ecba3 clarified keyword 'qualified' in accordance to a similar keyword from Haskell (despite unrelated Binding.qualified in Isabelle/ML);
wenzelm
parents: 59970
diff changeset
  1480
qualified definition "induct_false \<equiv> False"
35416
d8d7d1b785af replaced a couple of constsdefs by definitions (also some old primrecs by modern ones)
haftmann
parents: 35115
diff changeset
  1481
59929
wenzelm
parents: 59864
diff changeset
  1482
lemma induct_forall_eq: "(\<And>x. P x) \<equiv> Trueprop (induct_forall (\<lambda>x. P x))"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1483
  by (unfold atomize_all induct_forall_def)
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1484
59929
wenzelm
parents: 59864
diff changeset
  1485
lemma induct_implies_eq: "(A \<Longrightarrow> B) \<equiv> Trueprop (induct_implies A B)"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1486
  by (unfold atomize_imp induct_implies_def)
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1487
59929
wenzelm
parents: 59864
diff changeset
  1488
lemma induct_equal_eq: "(x \<equiv> y) \<equiv> Trueprop (induct_equal x y)"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1489
  by (unfold atomize_eq induct_equal_def)
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1490
59929
wenzelm
parents: 59864
diff changeset
  1491
lemma induct_conj_eq: "(A &&& B) \<equiv> Trueprop (induct_conj A B)"
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1492
  by (unfold atomize_conj induct_conj_def)
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1493
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1494
lemmas induct_atomize' = induct_forall_eq induct_implies_eq induct_conj_eq
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1495
lemmas induct_atomize = induct_atomize' induct_equal_eq
45607
16b4f5774621 eliminated obsolete "standard";
wenzelm
parents: 45294
diff changeset
  1496
lemmas induct_rulify' [symmetric] = induct_atomize'
16b4f5774621 eliminated obsolete "standard";
wenzelm
parents: 45294
diff changeset
  1497
lemmas induct_rulify [symmetric] = induct_atomize
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1498
lemmas induct_rulify_fallback =
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1499
  induct_forall_def induct_implies_def induct_equal_def induct_conj_def
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1500
  induct_true_def induct_false_def
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1501
11989
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1502
lemma induct_forall_conj: "induct_forall (\<lambda>x. induct_conj (A x) (B x)) =
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1503
    induct_conj (induct_forall A) (induct_forall B)"
17589
58eeffd73be1 renamed rules to iprover
nipkow
parents: 17459
diff changeset
  1504
  by (unfold induct_forall_def induct_conj_def) iprover
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1505
11989
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1506
lemma induct_implies_conj: "induct_implies C (induct_conj A B) =
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1507
    induct_conj (induct_implies C A) (induct_implies C B)"
17589
58eeffd73be1 renamed rules to iprover
nipkow
parents: 17459
diff changeset
  1508
  by (unfold induct_implies_def induct_conj_def) iprover
11989
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1509
59929
wenzelm
parents: 59864
diff changeset
  1510
lemma induct_conj_curry: "(induct_conj A B \<Longrightarrow> PROP C) \<equiv> (A \<Longrightarrow> B \<Longrightarrow> PROP C)"
13598
8bc77b17f59f Fixed problem with induct_conj_curry: variable C should have type prop.
berghofe
parents: 13596
diff changeset
  1511
proof
59929
wenzelm
parents: 59864
diff changeset
  1512
  assume r: "induct_conj A B \<Longrightarrow> PROP C"
wenzelm
parents: 59864
diff changeset
  1513
  assume ab: A B
wenzelm
parents: 59864
diff changeset
  1514
  show "PROP C" by (rule r) (simp add: induct_conj_def ab)
13598
8bc77b17f59f Fixed problem with induct_conj_curry: variable C should have type prop.
berghofe
parents: 13596
diff changeset
  1515
next
59929
wenzelm
parents: 59864
diff changeset
  1516
  assume r: "A \<Longrightarrow> B \<Longrightarrow> PROP C"
wenzelm
parents: 59864
diff changeset
  1517
  assume ab: "induct_conj A B"
wenzelm
parents: 59864
diff changeset
  1518
  show "PROP C" by (rule r) (simp_all add: ab [unfolded induct_conj_def])
13598
8bc77b17f59f Fixed problem with induct_conj_curry: variable C should have type prop.
berghofe
parents: 13596
diff changeset
  1519
qed
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1520
11989
d4bcba4e080e renamed inductive_XXX to induct_XXX;
wenzelm
parents: 11977
diff changeset
  1521
lemmas induct_conj = induct_forall_conj induct_implies_conj induct_conj_curry
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1522
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1523
lemma induct_trueI: "induct_true"
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1524
  by (simp add: induct_true_def)
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1525
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1526
text \<open>Method setup.\<close>
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1527
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1528
ML_file \<open>~~/src/Tools/induct.ML\<close>
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1529
ML \<open>
32171
220abde9962b renamed functor InductFun to Induct;
wenzelm
parents: 32149
diff changeset
  1530
structure Induct = Induct
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1531
(
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1532
  val cases_default = @{thm case_split}
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1533
  val atomize = @{thms induct_atomize}
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1534
  val rulify = @{thms induct_rulify'}
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1535
  val rulify_fallback = @{thms induct_rulify_fallback}
34988
cca208c8d619 Added setup for simplification of equality constraints in cases rules.
berghofe
parents: 34917
diff changeset
  1536
  val equal_def = @{thm induct_equal_def}
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1537
  fun dest_def (Const (\<^const_name>\<open>induct_equal\<close>, _) $ t $ u) = SOME (t, u)
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1538
    | dest_def _ = NONE
58957
c9e744ea8a38 proper context for match_tac etc.;
wenzelm
parents: 58956
diff changeset
  1539
  fun trivial_tac ctxt = match_tac ctxt @{thms induct_trueI}
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1540
)
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1541
\<close>
11824
f4c1882dde2c setup generic cases and induction (from Inductive.thy);
wenzelm
parents: 11770
diff changeset
  1542
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1543
ML_file \<open>~~/src/Tools/induction.ML\<close>
45014
0e847655b2d8 New proof method "induction" that gives induction hypotheses the name IH.
nipkow
parents: 44921
diff changeset
  1544
78799
807b249f1061 clarified syntax and order of parameters;
wenzelm
parents: 78794
diff changeset
  1545
simproc_setup passive swap_induct_false ("induct_false \<Longrightarrow> PROP P \<Longrightarrow> PROP Q") =
78794
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1546
  \<open>fn _ => fn _ => fn ct =>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1547
    (case Thm.term_of ct of
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1548
      _ $ (P as _ $ \<^Const_>\<open>induct_false\<close>) $ (_ $ Q $ _) =>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1549
        if P <> Q then SOME Drule.swap_prems_eq else NONE
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1550
    | _ => NONE)\<close>
78799
807b249f1061 clarified syntax and order of parameters;
wenzelm
parents: 78794
diff changeset
  1551
807b249f1061 clarified syntax and order of parameters;
wenzelm
parents: 78794
diff changeset
  1552
simproc_setup passive induct_equal_conj_curry ("induct_conj P Q \<Longrightarrow> PROP R") =
78794
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1553
  \<open>fn _ => fn _ => fn ct =>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1554
    (case Thm.term_of ct of
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1555
      _ $ (_ $ P) $ _ =>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1556
        let
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1557
          fun is_conj \<^Const_>\<open>induct_conj for P Q\<close> = is_conj P andalso is_conj Q
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1558
            | is_conj \<^Const_>\<open>induct_equal _ for _ _\<close> = true
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1559
            | is_conj \<^Const_>\<open>induct_true\<close> = true
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1560
            | is_conj \<^Const_>\<open>induct_false\<close> = true
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1561
            | is_conj _ = false
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1562
        in if is_conj P then SOME @{thm induct_conj_curry} else NONE end
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1563
      | _ => NONE)\<close>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1564
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1565
declaration \<open>
78794
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1566
  K (Induct.map_simpset (fn ss => ss
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1567
      addsimprocs [\<^simproc>\<open>swap_induct_false\<close>, \<^simproc>\<open>induct_equal_conj_curry\<close>]
54742
7a86358a3c0b proper context for basic Simplifier operations: rewrite_rule, rewrite_goals_rule, rewrite_goals_tac etc.;
wenzelm
parents: 53146
diff changeset
  1568
    |> Simplifier.set_mksimps (fn ctxt =>
78794
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1569
      Simpdata.mksimps Simpdata.mksimps_pairs ctxt #>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1570
      map (rewrite_rule ctxt (map Thm.symmetric @{thms induct_rulify_fallback})))))
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1571
\<close>
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1572
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1573
text \<open>Pre-simplification of induction and cases rules\<close>
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1574
59929
wenzelm
parents: 59864
diff changeset
  1575
lemma [induct_simp]: "(\<And>x. induct_equal x t \<Longrightarrow> PROP P x) \<equiv> PROP P t"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1576
  unfolding induct_equal_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1577
proof
59929
wenzelm
parents: 59864
diff changeset
  1578
  assume r: "\<And>x. x = t \<Longrightarrow> PROP P x"
wenzelm
parents: 59864
diff changeset
  1579
  show "PROP P t" by (rule r [OF refl])
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1580
next
59929
wenzelm
parents: 59864
diff changeset
  1581
  fix x
wenzelm
parents: 59864
diff changeset
  1582
  assume "PROP P t" "x = t"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1583
  then show "PROP P x" by simp
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1584
qed
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1585
59929
wenzelm
parents: 59864
diff changeset
  1586
lemma [induct_simp]: "(\<And>x. induct_equal t x \<Longrightarrow> PROP P x) \<equiv> PROP P t"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1587
  unfolding induct_equal_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1588
proof
59929
wenzelm
parents: 59864
diff changeset
  1589
  assume r: "\<And>x. t = x \<Longrightarrow> PROP P x"
wenzelm
parents: 59864
diff changeset
  1590
  show "PROP P t" by (rule r [OF refl])
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1591
next
59929
wenzelm
parents: 59864
diff changeset
  1592
  fix x
wenzelm
parents: 59864
diff changeset
  1593
  assume "PROP P t" "t = x"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1594
  then show "PROP P x" by simp
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1595
qed
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1596
59929
wenzelm
parents: 59864
diff changeset
  1597
lemma [induct_simp]: "(induct_false \<Longrightarrow> P) \<equiv> Trueprop induct_true"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1598
  unfolding induct_false_def induct_true_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1599
  by (iprover intro: equal_intr_rule)
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1600
59929
wenzelm
parents: 59864
diff changeset
  1601
lemma [induct_simp]: "(induct_true \<Longrightarrow> PROP P) \<equiv> PROP P"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1602
  unfolding induct_true_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1603
proof
59929
wenzelm
parents: 59864
diff changeset
  1604
  assume "True \<Longrightarrow> PROP P"
wenzelm
parents: 59864
diff changeset
  1605
  then show "PROP P" using TrueI .
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1606
next
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1607
  assume "PROP P"
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1608
  then show "PROP P" .
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1609
qed
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1610
59929
wenzelm
parents: 59864
diff changeset
  1611
lemma [induct_simp]: "(PROP P \<Longrightarrow> induct_true) \<equiv> Trueprop induct_true"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1612
  unfolding induct_true_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1613
  by (iprover intro: equal_intr_rule)
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1614
62958
b41c1cb5e251 Type_Infer.object_logic controls improvement of type inference result;
wenzelm
parents: 62913
diff changeset
  1615
lemma [induct_simp]: "(\<And>x::'a::{}. induct_true) \<equiv> Trueprop induct_true"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1616
  unfolding induct_true_def
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1617
  by (iprover intro: equal_intr_rule)
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1618
59929
wenzelm
parents: 59864
diff changeset
  1619
lemma [induct_simp]: "induct_implies induct_true P \<equiv> P"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1620
  by (simp add: induct_implies_def induct_true_def)
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1621
59929
wenzelm
parents: 59864
diff changeset
  1622
lemma [induct_simp]: "x = x \<longleftrightarrow> True"
34908
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1623
  by (rule simp_thms)
d546e75631bb Added setup for simplification of equality constraints in induction rules.
berghofe
parents: 34294
diff changeset
  1624
59940
087d81f5213e local setup of induction tools, with restricted access to auxiliary consts;
wenzelm
parents: 59929
diff changeset
  1625
end
18457
356a9f711899 structure ProjectRule;
wenzelm
parents: 17992
diff changeset
  1626
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1627
ML_file \<open>~~/src/Tools/induct_tacs.ML\<close>
27126
3ede9103de8e eliminated obsolete case_split_thm -- use case_split;
wenzelm
parents: 27107
diff changeset
  1628
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1629
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1630
subsubsection \<open>Coherent logic\<close>
28325
0b6b83ec8458 Added setup for coherent logic prover.
berghofe
parents: 28227
diff changeset
  1631
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1632
ML_file \<open>~~/src/Tools/coherent.ML\<close>
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1633
ML \<open>
32734
06c13b2e562e misc tuning and modernization;
wenzelm
parents: 32733
diff changeset
  1634
structure Coherent = Coherent
28325
0b6b83ec8458 Added setup for coherent logic prover.
berghofe
parents: 28227
diff changeset
  1635
(
55632
0f9d03649a9c modernized tool setup;
wenzelm
parents: 55385
diff changeset
  1636
  val atomize_elimL = @{thm atomize_elimL};
0f9d03649a9c modernized tool setup;
wenzelm
parents: 55385
diff changeset
  1637
  val atomize_exL = @{thm atomize_exL};
0f9d03649a9c modernized tool setup;
wenzelm
parents: 55385
diff changeset
  1638
  val atomize_conjL = @{thm atomize_conjL};
0f9d03649a9c modernized tool setup;
wenzelm
parents: 55385
diff changeset
  1639
  val atomize_disjL = @{thm atomize_disjL};
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1640
  val operator_names = [\<^const_name>\<open>HOL.disj\<close>, \<^const_name>\<open>HOL.conj\<close>, \<^const_name>\<open>Ex\<close>];
28325
0b6b83ec8458 Added setup for coherent logic prover.
berghofe
parents: 28227
diff changeset
  1641
);
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1642
\<close>
28325
0b6b83ec8458 Added setup for coherent logic prover.
berghofe
parents: 28227
diff changeset
  1643
0b6b83ec8458 Added setup for coherent logic prover.
berghofe
parents: 28227
diff changeset
  1644
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1645
subsubsection \<open>Reorienting equalities\<close>
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1646
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1647
ML \<open>
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1648
signature REORIENT_PROC =
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1649
sig
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1650
  val add : (term -> bool) -> theory -> theory
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1651
  val proc : Proof.context -> cterm -> thm option
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1652
end;
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1653
33523
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1654
structure Reorient_Proc : REORIENT_PROC =
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1655
struct
33523
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1656
  structure Data = Theory_Data
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1657
  (
33523
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1658
    type T = ((term -> bool) * stamp) list;
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1659
    val empty = [];
67405
e9ab4ad7bd15 uniform use of Standard ML op-infix -- eliminated warnings;
wenzelm
parents: 67399
diff changeset
  1660
    fun merge data : T = Library.merge (eq_snd (op =)) data;
33523
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1661
  );
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1662
  fun add m = Data.map (cons (m, stamp ()));
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1663
  fun matches thy t = exists (fn (m, _) => m t) (Data.get thy);
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1664
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1665
  val meta_reorient = @{thm eq_commute [THEN eq_reflection]};
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1666
  fun proc ctxt ct =
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1667
    let
42361
23f352990944 modernized structure Proof_Context;
wenzelm
parents: 42284
diff changeset
  1668
      val thy = Proof_Context.theory_of ctxt;
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1669
    in
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1670
      case Thm.term_of ct of
33523
96730ad673be modernized structure Reorient_Proc;
wenzelm
parents: 33369
diff changeset
  1671
        (_ $ t $ u) => if matches thy u then NONE else SOME meta_reorient
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1672
      | _ => NONE
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1673
    end;
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1674
end;
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1675
\<close>
31024
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1676
0fdf666e08bf reimplement reorientation simproc using theory data
huffman
parents: 30980
diff changeset
  1677
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1678
subsection \<open>Other simple lemmas and lemma duplicates\<close>
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1679
74741
6e1fad4f602b added eq_iff_swap for creating symmetric variants of thms; applied it in List.
nipkow
parents: 74561
diff changeset
  1680
lemma eq_iff_swap: "(x = y \<longleftrightarrow> P) \<Longrightarrow> (y = x \<longleftrightarrow> P)"
6e1fad4f602b added eq_iff_swap for creating symmetric variants of thms; applied it in List.
nipkow
parents: 74561
diff changeset
  1681
by blast
6e1fad4f602b added eq_iff_swap for creating symmetric variants of thms; applied it in List.
nipkow
parents: 74561
diff changeset
  1682
68975
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1683
lemma all_cong1: "(\<And>x. P x = P' x) \<Longrightarrow> (\<forall>x. P x) = (\<forall>x. P' x)"
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1684
  by auto
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1685
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1686
lemma ex_cong1: "(\<And>x. P x = P' x) \<Longrightarrow> (\<exists>x. P x) = (\<exists>x. P' x)"
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1687
  by auto
5ce4d117cea7 A few new results, elimination of duplicates and more use of "pairwise"
paulson <lp15@cam.ac.uk>
parents: 68072
diff changeset
  1688
67091
1393c2340eec more symbols;
wenzelm
parents: 66893
diff changeset
  1689
lemma all_cong: "(\<And>x. Q x \<Longrightarrow> P x = P' x) \<Longrightarrow> (\<forall>x. Q x \<longrightarrow> P x) = (\<forall>x. Q x \<longrightarrow> P' x)"
66836
4eb431c3f974 tuned imports
haftmann
parents: 66251
diff changeset
  1690
  by auto
4eb431c3f974 tuned imports
haftmann
parents: 66251
diff changeset
  1691
67091
1393c2340eec more symbols;
wenzelm
parents: 66893
diff changeset
  1692
lemma ex_cong: "(\<And>x. Q x \<Longrightarrow> P x = P' x) \<Longrightarrow> (\<exists>x. Q x \<and> P x) = (\<exists>x. Q x \<and> P' x)"
66836
4eb431c3f974 tuned imports
haftmann
parents: 66251
diff changeset
  1693
  by auto
4eb431c3f974 tuned imports
haftmann
parents: 66251
diff changeset
  1694
60759
36d9f215c982 more symbols;
wenzelm
parents: 60758
diff changeset
  1695
lemma ex1_eq [iff]: "\<exists>!x. x = t" "\<exists>!x. t = x"
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1696
  by blast+
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1697
71608
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1698
lemma choice_eq: "(\<forall>x. \<exists>!y. P x y) = (\<exists>!f. \<forall>x. P x (f x))" (is "?lhs = ?rhs")
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1699
proof (intro iffI allI)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1700
  assume L: ?lhs
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1701
  then have \<section>: "\<forall>x. P x (THE y. P x y)"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1702
    by (best intro: theI')
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1703
  show ?rhs
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1704
    by (rule ex1I) (use L \<section> in \<open>fast+\<close>)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1705
next
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1706
  fix x
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1707
  assume R: ?rhs
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1708
  then obtain f where f: "\<forall>x. P x (f x)" and f1: "\<And>y. (\<forall>x. P x (y x)) \<Longrightarrow> y = f"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1709
    by (blast elim: ex1E)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1710
  show "\<exists>!y. P x y"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1711
  proof (rule ex1I)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1712
    show "P x (f x)"
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1713
      using f by blast
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1714
    show "y = f x" if "P x y" for y
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1715
    proof -
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1716
      have "P z (if z = x then y else f z)" for z
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1717
        using f that by (auto split: if_split)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1718
      with f1 [of "\<lambda>z. if z = x then y else f z"] f
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1719
      show ?thesis
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1720
        by (auto simp add: split: if_split_asm dest: fun_cong)
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1721
    qed
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1722
  qed
856c68ab6f13 structured a lot of ancient, horrible proofs
paulson <lp15@cam.ac.uk>
parents: 71517
diff changeset
  1723
qed
20944
34b2c1bb7178 cleanup basic HOL bootstrap
haftmann
parents: 20833
diff changeset
  1724
22218
30a8890d2967 dropped lemma duplicates in HOL.thy
haftmann
parents: 22129
diff changeset
  1725
lemmas eq_sym_conv = eq_commute
30a8890d2967 dropped lemma duplicates in HOL.thy
haftmann
parents: 22129
diff changeset
  1726
23037
6c72943a71b1 added a set of NNF normalization lemmas and nnf_conv
chaieb
parents: 22993
diff changeset
  1727
lemma nnf_simps:
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1728
  "(\<not> (P \<and> Q)) = (\<not> P \<or> \<not> Q)"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1729
  "(\<not> (P \<or> Q)) = (\<not> P \<and> \<not> Q)"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1730
  "(P \<longrightarrow> Q) = (\<not> P \<or> Q)"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1731
  "(P = Q) = ((P \<and> Q) \<or> (\<not> P \<and> \<not> Q))"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1732
  "(\<not> (P = Q)) = ((P \<and> \<not> Q) \<or> (\<not> P \<and> Q))"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1733
  "(\<not> \<not> P) = P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1734
  by blast+
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1735
23037
6c72943a71b1 added a set of NNF normalization lemmas and nnf_conv
chaieb
parents: 22993
diff changeset
  1736
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1737
subsection \<open>Basic ML bindings\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1738
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1739
ML \<open>
22129
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1740
val FalseE = @{thm FalseE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1741
val Let_def = @{thm Let_def}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1742
val TrueI = @{thm TrueI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1743
val allE = @{thm allE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1744
val allI = @{thm allI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1745
val all_dupE = @{thm all_dupE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1746
val arg_cong = @{thm arg_cong}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1747
val box_equals = @{thm box_equals}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1748
val ccontr = @{thm ccontr}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1749
val classical = @{thm classical}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1750
val conjE = @{thm conjE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1751
val conjI = @{thm conjI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1752
val conjunct1 = @{thm conjunct1}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1753
val conjunct2 = @{thm conjunct2}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1754
val disjCI = @{thm disjCI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1755
val disjE = @{thm disjE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1756
val disjI1 = @{thm disjI1}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1757
val disjI2 = @{thm disjI2}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1758
val eq_reflection = @{thm eq_reflection}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1759
val ex1E = @{thm ex1E}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1760
val ex1I = @{thm ex1I}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1761
val ex1_implies_ex = @{thm ex1_implies_ex}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1762
val exE = @{thm exE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1763
val exI = @{thm exI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1764
val excluded_middle = @{thm excluded_middle}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1765
val ext = @{thm ext}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1766
val fun_cong = @{thm fun_cong}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1767
val iffD1 = @{thm iffD1}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1768
val iffD2 = @{thm iffD2}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1769
val iffI = @{thm iffI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1770
val impE = @{thm impE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1771
val impI = @{thm impI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1772
val meta_eq_to_obj_eq = @{thm meta_eq_to_obj_eq}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1773
val mp = @{thm mp}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1774
val notE = @{thm notE}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1775
val notI = @{thm notI}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1776
val not_all = @{thm not_all}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1777
val not_ex = @{thm not_ex}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1778
val not_iff = @{thm not_iff}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1779
val not_not = @{thm not_not}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1780
val not_sym = @{thm not_sym}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1781
val refl = @{thm refl}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1782
val rev_mp = @{thm rev_mp}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1783
val spec = @{thm spec}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1784
val ssubst = @{thm ssubst}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1785
val subst = @{thm subst}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1786
val sym = @{thm sym}
bb2203c93316 tuned ML setup;
wenzelm
parents: 21671
diff changeset
  1787
val trans = @{thm trans}
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1788
\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1789
70486
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1790
locale cnf
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1791
begin
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1792
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1793
lemma clause2raw_notE: "\<lbrakk>P; \<not>P\<rbrakk> \<Longrightarrow> False" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1794
lemma clause2raw_not_disj: "\<lbrakk>\<not> P; \<not> Q\<rbrakk> \<Longrightarrow> \<not> (P \<or> Q)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1795
lemma clause2raw_not_not: "P \<Longrightarrow> \<not>\<not> P" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1796
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1797
lemma iff_refl: "(P::bool) = P" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1798
lemma iff_trans: "[| (P::bool) = Q; Q = R |] ==> P = R" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1799
lemma conj_cong: "[| P = P'; Q = Q' |] ==> (P \<and> Q) = (P' \<and> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1800
lemma disj_cong: "[| P = P'; Q = Q' |] ==> (P \<or> Q) = (P' \<or> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1801
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1802
lemma make_nnf_imp: "[| (\<not>P) = P'; Q = Q' |] ==> (P \<longrightarrow> Q) = (P' \<or> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1803
lemma make_nnf_iff: "[| P = P'; (\<not>P) = NP; Q = Q'; (\<not>Q) = NQ |] ==> (P = Q) = ((P' \<or> NQ) \<and> (NP \<or> Q'))" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1804
lemma make_nnf_not_false: "(\<not>False) = True" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1805
lemma make_nnf_not_true: "(\<not>True) = False" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1806
lemma make_nnf_not_conj: "[| (\<not>P) = P'; (\<not>Q) = Q' |] ==> (\<not>(P \<and> Q)) = (P' \<or> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1807
lemma make_nnf_not_disj: "[| (\<not>P) = P'; (\<not>Q) = Q' |] ==> (\<not>(P \<or> Q)) = (P' \<and> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1808
lemma make_nnf_not_imp: "[| P = P'; (\<not>Q) = Q' |] ==> (\<not>(P \<longrightarrow> Q)) = (P' \<and> Q')" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1809
lemma make_nnf_not_iff: "[| P = P'; (\<not>P) = NP; Q = Q'; (\<not>Q) = NQ |] ==> (\<not>(P = Q)) = ((P' \<or> Q') \<and> (NP \<or> NQ))" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1810
lemma make_nnf_not_not: "P = P' ==> (\<not>\<not>P) = P'" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1811
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1812
lemma simp_TF_conj_True_l: "[| P = True; Q = Q' |] ==> (P \<and> Q) = Q'" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1813
lemma simp_TF_conj_True_r: "[| P = P'; Q = True |] ==> (P \<and> Q) = P'" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1814
lemma simp_TF_conj_False_l: "P = False ==> (P \<and> Q) = False" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1815
lemma simp_TF_conj_False_r: "Q = False ==> (P \<and> Q) = False" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1816
lemma simp_TF_disj_True_l: "P = True ==> (P \<or> Q) = True" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1817
lemma simp_TF_disj_True_r: "Q = True ==> (P \<or> Q) = True" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1818
lemma simp_TF_disj_False_l: "[| P = False; Q = Q' |] ==> (P \<or> Q) = Q'" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1819
lemma simp_TF_disj_False_r: "[| P = P'; Q = False |] ==> (P \<or> Q) = P'" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1820
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1821
lemma make_cnf_disj_conj_l: "[| (P \<or> R) = PR; (Q \<or> R) = QR |] ==> ((P \<and> Q) \<or> R) = (PR \<and> QR)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1822
lemma make_cnf_disj_conj_r: "[| (P \<or> Q) = PQ; (P \<or> R) = PR |] ==> (P \<or> (Q \<and> R)) = (PQ \<and> PR)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1823
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1824
lemma make_cnfx_disj_ex_l: "((\<exists>(x::bool). P x) \<or> Q) = (\<exists>x. P x \<or> Q)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1825
lemma make_cnfx_disj_ex_r: "(P \<or> (\<exists>(x::bool). Q x)) = (\<exists>x. P \<or> Q x)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1826
lemma make_cnfx_newlit: "(P \<or> Q) = (\<exists>x. (P \<or> x) \<and> (Q \<or> \<not>x))" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1827
lemma make_cnfx_ex_cong: "(\<forall>(x::bool). P x = Q x) \<Longrightarrow> (\<exists>x. P x) = (\<exists>x. Q x)" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1828
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1829
lemma weakening_thm: "[| P; Q |] ==> Q" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1830
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1831
lemma cnftac_eq_imp: "[| P = Q; P |] ==> Q" by auto
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1832
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1833
end
1dc3514c1719 prefer named lemmas -- more compact proofterms;
wenzelm
parents: 70326
diff changeset
  1834
69605
a96320074298 isabelle update -u path_cartouches;
wenzelm
parents: 69597
diff changeset
  1835
ML_file \<open>Tools/cnf.ML\<close>
55239
97921d23ebe3 more standard file/module names;
wenzelm
parents: 54890
diff changeset
  1836
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  1837
61799
4cf66f21b764 isabelle update_cartouches -c -t;
wenzelm
parents: 61378
diff changeset
  1838
section \<open>\<open>NO_MATCH\<close> simproc\<close>
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1839
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1840
text \<open>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1841
  The simplification procedure can be used to avoid simplification of terms
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1842
  of a certain form.
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1843
\<close>
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1844
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1845
definition NO_MATCH :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1846
  where "NO_MATCH pat val \<equiv> True"
58830
e05c620eceeb disable coercions for NO_MATCH
hoelzl
parents: 58826
diff changeset
  1847
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1848
lemma NO_MATCH_cong[cong]: "NO_MATCH pat val = NO_MATCH pat val"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1849
  by (rule refl)
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1850
58830
e05c620eceeb disable coercions for NO_MATCH
hoelzl
parents: 58826
diff changeset
  1851
declare [[coercion_args NO_MATCH - -]]
e05c620eceeb disable coercions for NO_MATCH
hoelzl
parents: 58826
diff changeset
  1852
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1853
simproc_setup NO_MATCH ("NO_MATCH pat val") = \<open>K (fn ctxt => fn ct =>
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1854
  let
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1855
    val thy = Proof_Context.theory_of ctxt
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1856
    val dest_binop = Term.dest_comb #> apfst (Term.dest_comb #> snd)
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1857
    val m = Pattern.matches thy (dest_binop (Thm.term_of ct))
78099
4d9349989d94 more uniform simproc_setup: avoid vacuous abstraction over morphism, which sometimes captures context values in its functional closure;
wenzelm
parents: 77172
diff changeset
  1858
  in if m then NONE else SOME @{thm NO_MATCH_def} end)
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1859
\<close>
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1860
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1861
text \<open>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1862
  This setup ensures that a rewrite rule of the form \<^term>\<open>NO_MATCH pat val \<Longrightarrow> t\<close>
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1863
  is only applied, if the pattern \<open>pat\<close> does not match the value \<open>val\<close>.
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1864
\<close>
58775
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1865
9cd64a66a765 move NO_MATCH simproc from the AFP entry Graph_Theory to HOL
hoelzl
parents: 58659
diff changeset
  1866
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1867
text\<open>
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1868
  Tagging a premise of a simp rule with ASSUMPTION forces the simplifier
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1869
  not to simplify the argument and to solve it by an assumption.
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1870
\<close>
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1871
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1872
definition ASSUMPTION :: "bool \<Rightarrow> bool"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1873
  where "ASSUMPTION A \<equiv> A"
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1874
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1875
lemma ASSUMPTION_cong[cong]: "ASSUMPTION A = ASSUMPTION A"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1876
  by (rule refl)
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1877
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1878
lemma ASSUMPTION_I: "A \<Longrightarrow> ASSUMPTION A"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1879
  by (simp add: ASSUMPTION_def)
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1880
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1881
lemma ASSUMPTION_D: "ASSUMPTION A \<Longrightarrow> A"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1882
  by (simp add: ASSUMPTION_def)
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1883
61222
05d28dc76e5c isabelle update_cartouches;
wenzelm
parents: 61202
diff changeset
  1884
setup \<open>
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1885
let
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1886
  val asm_sol = mk_solver "ASSUMPTION" (fn ctxt =>
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1887
    resolve_tac ctxt [@{thm ASSUMPTION_I}] THEN'
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1888
    resolve_tac ctxt (Simplifier.prems_of ctxt))
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1889
in
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1890
  map_theory_simpset (fn ctxt => Simplifier.addSolver (ctxt,asm_sol))
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1891
end
61222
05d28dc76e5c isabelle update_cartouches;
wenzelm
parents: 61202
diff changeset
  1892
\<close>
61202
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1893
9e37178084c5 Added new simplifier predicate ASSUMPTION
nipkow
parents: 61169
diff changeset
  1894
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1895
subsection \<open>Code generator setup\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1896
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1897
subsubsection \<open>Generic code generator preprocessor setup\<close>
31151
1c64b0827ee8 rewrite op = == eq handled by simproc
haftmann
parents: 31132
diff changeset
  1898
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1899
lemma conj_left_cong: "P \<longleftrightarrow> Q \<Longrightarrow> P \<and> R \<longleftrightarrow> Q \<and> R"
53146
3a93bc5d3370 congruence rules for code_simp to mimic typical non-strict behaviour of conj and disj
haftmann
parents: 52654
diff changeset
  1900
  by (fact arg_cong)
3a93bc5d3370 congruence rules for code_simp to mimic typical non-strict behaviour of conj and disj
haftmann
parents: 52654
diff changeset
  1901
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1902
lemma disj_left_cong: "P \<longleftrightarrow> Q \<Longrightarrow> P \<or> R \<longleftrightarrow> Q \<or> R"
53146
3a93bc5d3370 congruence rules for code_simp to mimic typical non-strict behaviour of conj and disj
haftmann
parents: 52654
diff changeset
  1903
  by (fact arg_cong)
3a93bc5d3370 congruence rules for code_simp to mimic typical non-strict behaviour of conj and disj
haftmann
parents: 52654
diff changeset
  1904
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1905
setup \<open>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1906
  Code_Preproc.map_pre (put_simpset HOL_basic_ss) #>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1907
  Code_Preproc.map_post (put_simpset HOL_basic_ss) #>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1908
  Code_Simp.map_ss (put_simpset HOL_basic_ss #>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1909
  Simplifier.add_cong @{thm conj_left_cong} #>
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1910
  Simplifier.add_cong @{thm disj_left_cong})
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1911
\<close>
31151
1c64b0827ee8 rewrite op = == eq handled by simproc
haftmann
parents: 31132
diff changeset
  1912
53146
3a93bc5d3370 congruence rules for code_simp to mimic typical non-strict behaviour of conj and disj
haftmann
parents: 52654
diff changeset
  1913
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1914
subsubsection \<open>Equality\<close>
24844
98c006a30218 certificates for code generator case expressions
haftmann
parents: 24842
diff changeset
  1915
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1916
class equal =
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1917
  fixes equal :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1918
  assumes equal_eq: "equal x y \<longleftrightarrow> x = y"
26513
6f306c8c2c54 explicit class "eq" for operational equality
haftmann
parents: 26496
diff changeset
  1919
begin
6f306c8c2c54 explicit class "eq" for operational equality
haftmann
parents: 26496
diff changeset
  1920
67399
eab6ce8368fa ran isabelle update_op on all sources
nipkow
parents: 67299
diff changeset
  1921
lemma equal: "equal = (=)"
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1922
  by (rule ext equal_eq)+
28346
b8390cd56b8f discontinued special treatment of op = vs. eq_class.eq
haftmann
parents: 28325
diff changeset
  1923
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1924
lemma equal_refl: "equal x x \<longleftrightarrow> True"
75669
43f5dfb7fa35 tuned (some HOL lints, by Yecine Megdiche);
Fabian Huch <huch@in.tum.de>
parents: 74741
diff changeset
  1925
  unfolding equal by (rule iffI TrueI refl)+
28346
b8390cd56b8f discontinued special treatment of op = vs. eq_class.eq
haftmann
parents: 28325
diff changeset
  1926
67399
eab6ce8368fa ran isabelle update_op on all sources
nipkow
parents: 67299
diff changeset
  1927
lemma eq_equal: "(=) \<equiv> equal"
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1928
  by (rule eq_reflection) (rule ext, rule ext, rule sym, rule equal_eq)
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1929
26513
6f306c8c2c54 explicit class "eq" for operational equality
haftmann
parents: 26496
diff changeset
  1930
end
6f306c8c2c54 explicit class "eq" for operational equality
haftmann
parents: 26496
diff changeset
  1931
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1932
declare eq_equal [symmetric, code_post]
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1933
declare eq_equal [code]
30966
55104c664185 avoid local [code]
haftmann
parents: 30947
diff changeset
  1934
78799
807b249f1061 clarified syntax and order of parameters;
wenzelm
parents: 78794
diff changeset
  1935
simproc_setup passive equal (HOL.eq) =
78794
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1936
  \<open>fn _ => fn _ => fn ct =>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1937
    (case Thm.term_of ct of
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1938
      Const (_, Type (\<^type_name>\<open>fun\<close>, [Type _, _])) => SOME @{thm eq_equal}
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1939
    | _ => NONE)\<close>
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1940
c74fd21af246 clarified simproc_setup (passive);
wenzelm
parents: 78099
diff changeset
  1941
setup \<open>Code_Preproc.map_pre (fn ctxt => ctxt addsimprocs [\<^simproc>\<open>equal\<close>])\<close>
31151
1c64b0827ee8 rewrite op = == eq handled by simproc
haftmann
parents: 31132
diff changeset
  1942
30966
55104c664185 avoid local [code]
haftmann
parents: 30947
diff changeset
  1943
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1944
subsubsection \<open>Generic code generator foundation\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1945
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1946
text \<open>Datatype \<^typ>\<open>bool\<close>\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1947
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1948
code_datatype True False
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1949
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1950
lemma [code]:
33185
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1951
  shows "False \<and> P \<longleftrightarrow> False"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1952
    and "True \<and> P \<longleftrightarrow> P"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1953
    and "P \<and> False \<longleftrightarrow> False"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1954
    and "P \<and> True \<longleftrightarrow> P"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1955
  by simp_all
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1956
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1957
lemma [code]:
33185
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1958
  shows "False \<or> P \<longleftrightarrow> P"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1959
    and "True \<or> P \<longleftrightarrow> True"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1960
    and "P \<or> False \<longleftrightarrow> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1961
    and "P \<or> True \<longleftrightarrow> True"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1962
  by simp_all
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1963
33185
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1964
lemma [code]:
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1965
  shows "(False \<longrightarrow> P) \<longleftrightarrow> True"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1966
    and "(True \<longrightarrow> P) \<longleftrightarrow> P"
247f6c6969d9 tuned code setup for primitive boolean connectors
haftmann
parents: 33084
diff changeset
  1967
    and "(P \<longrightarrow> False) \<longleftrightarrow> \<not> P"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1968
    and "(P \<longrightarrow> True) \<longleftrightarrow> True"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1969
  by simp_all
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  1970
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  1971
text \<open>More about \<^typ>\<open>prop\<close>\<close>
39421
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1972
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1973
lemma [code nbe]:
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  1974
  shows "(True \<Longrightarrow> PROP Q) \<equiv> PROP Q"
39421
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1975
    and "(PROP Q \<Longrightarrow> True) \<equiv> Trueprop True"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1976
    and "(P \<Longrightarrow> R) \<equiv> Trueprop (P \<longrightarrow> R)"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1977
  by (auto intro!: equal_intr_rule)
39421
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1978
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1979
lemma Trueprop_code [code]: "Trueprop True \<equiv> Code_Generator.holds"
39421
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1980
  by (auto intro!: equal_intr_rule holds)
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1981
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1982
declare Trueprop_code [symmetric, code_post]
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1983
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  1984
text \<open>Equality\<close>
39421
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1985
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1986
declare simp_thms(6) [code nbe]
b6a77cffc231 introduced "holds" as synthetic datatype constructor for "prop"; moved Pure code generator setup to Code_Generator.thy
haftmann
parents: 39403
diff changeset
  1987
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  1988
instantiation itself :: (type) equal
31132
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1989
begin
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1990
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1991
definition equal_itself :: "'a itself \<Rightarrow> 'a itself \<Rightarrow> bool"
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1992
  where "equal_itself x y \<longleftrightarrow> x = y"
31132
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1993
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1994
instance
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1995
  by standard (fact equal_itself_def)
31132
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1996
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1997
end
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  1998
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  1999
lemma equal_itself_code [code]: "equal TYPE('a) TYPE('a) \<longleftrightarrow> True"
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  2000
  by (simp add: equal)
31132
bfafc204042a itself is instance of eq
haftmann
parents: 31125
diff changeset
  2001
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2002
setup \<open>Sign.add_const_constraint (\<^const_name>\<open>equal\<close>, SOME \<^typ>\<open>'a::type \<Rightarrow> 'a \<Rightarrow> bool\<close>)\<close>
31956
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2003
67399
eab6ce8368fa ran isabelle update_op on all sources
nipkow
parents: 67299
diff changeset
  2004
lemma equal_alias_cert: "OFCLASS('a, equal_class) \<equiv> (((=) :: 'a \<Rightarrow> 'a \<Rightarrow> bool) \<equiv> equal)"
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  2005
  (is "?ofclass \<equiv> ?equal")
31956
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2006
proof
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2007
  assume "PROP ?ofclass"
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  2008
  show "PROP ?equal"
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2009
    by (tactic \<open>ALLGOALS (resolve_tac \<^context> [Thm.unconstrainT @{thm eq_equal}])\<close>)
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2010
      (fact \<open>PROP ?ofclass\<close>)
31956
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2011
next
38857
97775f3e8722 renamed class/constant eq to equal; tuned some instantiations
haftmann
parents: 38795
diff changeset
  2012
  assume "PROP ?equal"
31956
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2013
  show "PROP ?ofclass" proof
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2014
  qed (simp add: \<open>PROP ?equal\<close>)
31956
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2015
qed
c3844c4d0c2c more accurate certificates for constant aliasses
haftmann
parents: 31902
diff changeset
  2016
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2017
setup \<open>Sign.add_const_constraint (\<^const_name>\<open>equal\<close>, SOME \<^typ>\<open>'a::equal \<Rightarrow> 'a \<Rightarrow> bool\<close>)\<close>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2018
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2019
setup \<open>Nbe.add_const_alias @{thm equal_alias_cert}\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2020
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2021
text \<open>Cases\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2022
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2023
lemma Let_case_cert:
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2024
  assumes "CASE \<equiv> (\<lambda>x. Let x f)"
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2025
  shows "CASE x \<equiv> f x"
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2026
  using assms by simp_all
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2027
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2028
setup \<open>
66251
cd935b7cb3fb proper concept of code declaration wrt. atomicity and Isar declarations
haftmann
parents: 66109
diff changeset
  2029
  Code.declare_case_global @{thm Let_case_cert} #>
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2030
  Code.declare_undefined_global \<^const_name>\<open>undefined\<close>
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2031
\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2032
54890
cb892d835803 fundamental treatment of undefined vs. universally partial replaces code_abort
haftmann
parents: 54742
diff changeset
  2033
declare [[code abort: undefined]]
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2034
38972
cd747b068311 tuned text segment
haftmann
parents: 38944
diff changeset
  2035
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2036
subsubsection \<open>Generic code generator target languages\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2037
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2038
text \<open>type \<^typ>\<open>bool\<close>\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2039
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2040
code_printing
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2041
  type_constructor bool \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2042
    (SML) "bool" and (OCaml) "bool" and (Haskell) "Bool" and (Scala) "Boolean"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2043
| constant True \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2044
    (SML) "true" and (OCaml) "true" and (Haskell) "True" and (Scala) "true"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2045
| constant False \<rightharpoonup>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2046
    (SML) "false" and (OCaml) "false" and (Haskell) "False" and (Scala) "false"
34294
19c1fd52d6c9 a primitive scala serializer
haftmann
parents: 34209
diff changeset
  2047
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2048
code_reserved SML
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2049
  bool true false
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2050
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2051
code_reserved OCaml
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2052
  bool
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2053
34294
19c1fd52d6c9 a primitive scala serializer
haftmann
parents: 34209
diff changeset
  2054
code_reserved Scala
19c1fd52d6c9 a primitive scala serializer
haftmann
parents: 34209
diff changeset
  2055
  Boolean
19c1fd52d6c9 a primitive scala serializer
haftmann
parents: 34209
diff changeset
  2056
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2057
code_printing
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2058
  constant Not \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2059
    (SML) "not" and (OCaml) "not" and (Haskell) "not" and (Scala) "'! _"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2060
| constant HOL.conj \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2061
    (SML) infixl 1 "andalso" and (OCaml) infixl 3 "&&" and (Haskell) infixr 3 "&&" and (Scala) infixl 3 "&&"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2062
| constant HOL.disj \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2063
    (SML) infixl 0 "orelse" and (OCaml) infixl 2 "||" and (Haskell) infixl 2 "||" and (Scala) infixl 1 "||"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2064
| constant HOL.implies \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2065
    (SML) "!(if (_)/ then (_)/ else true)"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2066
    and (OCaml) "!(if (_)/ then (_)/ else true)"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2067
    and (Haskell) "!(if (_)/ then (_)/ else True)"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2068
    and (Scala) "!(if ((_))/ (_)/ else true)"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2069
| constant If \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2070
    (SML) "!(if (_)/ then (_)/ else (_))"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2071
    and (OCaml) "!(if (_)/ then (_)/ else (_))"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2072
    and (Haskell) "!(if (_)/ then (_)/ else (_))"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2073
    and (Scala) "!(if ((_))/ (_)/ else (_))"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2074
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2075
code_reserved SML
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2076
  not
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2077
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2078
code_reserved OCaml
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2079
  not
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2080
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2081
code_identifier
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2082
  code_module Pure \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2083
    (SML) HOL and (OCaml) HOL and (Haskell) HOL and (Scala) HOL
39026
962d12bc546c avoid cyclic modules
haftmann
parents: 38972
diff changeset
  2084
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  2085
text \<open>Using built-in Haskell equality.\<close>
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2086
code_printing
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2087
  type_class equal \<rightharpoonup> (Haskell) "Eq"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2088
| constant HOL.equal \<rightharpoonup> (Haskell) infix 4 "=="
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2089
| constant HOL.eq \<rightharpoonup> (Haskell) infix 4 "=="
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2090
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  2091
text \<open>\<open>undefined\<close>\<close>
52435
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2092
code_printing
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2093
  constant undefined \<rightharpoonup>
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2094
    (SML) "!(raise/ Fail/ \"undefined\")"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2095
    and (OCaml) "failwith/ \"undefined\""
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2096
    and (Haskell) "error/ \"undefined\""
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2097
    and (Scala) "!sys.error(\"undefined\")"
6646bb548c6b migration from code_(const|type|class|instance) to code_printing and from code_module to code_identifier
haftmann
parents: 52432
diff changeset
  2098
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2099
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2100
subsubsection \<open>Evaluation and normalization by evaluation\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2101
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2102
method_setup eval = \<open>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2103
  let
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2104
    fun eval_tac ctxt =
74536
7d05d44ff9a9 clarified context;
wenzelm
parents: 74383
diff changeset
  2105
      let val conv = Code_Runtime.dynamic_holds_conv
58839
ccda99401bc8 eliminated aliases;
wenzelm
parents: 58830
diff changeset
  2106
      in
74536
7d05d44ff9a9 clarified context;
wenzelm
parents: 74383
diff changeset
  2107
        CONVERSION (Conv.params_conv ~1 (Conv.concl_conv ~1 o conv) ctxt) THEN'
59498
50b60f501b05 proper context for resolve_tac, eresolve_tac, dresolve_tac, forward_tac etc.;
wenzelm
parents: 59028
diff changeset
  2108
        resolve_tac ctxt [TrueI]
58839
ccda99401bc8 eliminated aliases;
wenzelm
parents: 58830
diff changeset
  2109
      end
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2110
  in
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2111
    Scan.succeed (SIMPLE_METHOD' o eval_tac)
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2112
  end
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2113
\<close> "solve goal by evaluation"
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2114
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2115
method_setup normalization = \<open>
46190
a42c5f23109f more conventional eval_tac vs. method_setup "eval";
wenzelm
parents: 46161
diff changeset
  2116
  Scan.succeed (fn ctxt =>
a42c5f23109f more conventional eval_tac vs. method_setup "eval";
wenzelm
parents: 46161
diff changeset
  2117
    SIMPLE_METHOD'
a42c5f23109f more conventional eval_tac vs. method_setup "eval";
wenzelm
parents: 46161
diff changeset
  2118
      (CHANGED_PROP o
55757
9fc71814b8c1 prefer proof context over background theory
haftmann
parents: 55632
diff changeset
  2119
        (CONVERSION (Nbe.dynamic_conv ctxt)
59498
50b60f501b05 proper context for resolve_tac, eresolve_tac, dresolve_tac, forward_tac etc.;
wenzelm
parents: 59028
diff changeset
  2120
          THEN_ALL_NEW (TRY o resolve_tac ctxt [TrueI]))))
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2121
\<close> "solve goal by normalization"
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2122
31902
862ae16a799d renamed NamedThmsFun to Named_Thms;
wenzelm
parents: 31804
diff changeset
  2123
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2124
subsection \<open>Counterexample Search Units\<close>
33084
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2125
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2126
subsubsection \<open>Quickcheck\<close>
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2127
33084
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2128
quickcheck_params [size = 5, iterations = 50]
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2129
30929
d9343c0aac11 code generator bootstrap theory src/Tools/Code_Generator.thy
haftmann
parents: 30927
diff changeset
  2130
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2131
subsubsection \<open>Nitpick setup\<close>
30309
188f0658af9f Added a "nitpick_maybe" symbol, which is used by Nitpick. This will go away once Nitpick is part of HOL.
blanchet
parents: 30254
diff changeset
  2132
59028
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2133
named_theorems nitpick_unfold "alternative definitions of constants as needed by Nitpick"
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2134
  and nitpick_simp "equational specification of constants as needed by Nitpick"
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2135
  and nitpick_psimp "partial equational specification of constants as needed by Nitpick"
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2136
  and nitpick_choice_spec "choice specification of constants as needed by Nitpick"
30980
fe0855471964 misc cleanup of auto_solve and quickcheck:
wenzelm
parents: 30970
diff changeset
  2137
41792
ff3cb0c418b7 renamed "nitpick\_def" to "nitpick_unfold" to reflect its new semantics
blanchet
parents: 41636
diff changeset
  2138
declare if_bool_eq_conj [nitpick_unfold, no_atp]
63575
b9bd9e61fd63 misc tuning and modernization;
wenzelm
parents: 63561
diff changeset
  2139
  and if_bool_eq_disj [no_atp]
41792
ff3cb0c418b7 renamed "nitpick\_def" to "nitpick_unfold" to reflect its new semantics
blanchet
parents: 41636
diff changeset
  2140
29863
dadad1831e9d Added "nitpick_const_simps" and "nitpick_ind_intros" attributes for theorems;
blanchet
parents: 29608
diff changeset
  2141
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2142
subsection \<open>Preprocessing for the predicate compiler\<close>
33084
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2143
59028
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2144
named_theorems code_pred_def "alternative definitions of constants for the Predicate Compiler"
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2145
  and code_pred_inline "inlining definitions for the Predicate Compiler"
df7476e79558 named_theorems: multiple args;
wenzelm
parents: 58963
diff changeset
  2146
  and code_pred_simp "simplification rules for the optimisations in the Predicate Compiler"
33084
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2147
cd1579e0997a turned off old quickcheck
haftmann
parents: 33056
diff changeset
  2148
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2149
subsection \<open>Legacy tactics and ML bindings\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  2150
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2151
ML \<open>
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2152
  (* combination of (spec RS spec RS ...(j times) ... spec RS mp) *)
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2153
  local
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2154
    fun wrong_prem (Const (\<^const_name>\<open>All\<close>, _) $ Abs (_, _, t)) = wrong_prem t
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2155
      | wrong_prem (Bound _) = true
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2156
      | wrong_prem _ = false;
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2157
    val filter_right = filter (not o wrong_prem o HOLogic.dest_Trueprop o hd o Thm.prems_of);
61914
16bfe0a6702d stripped some legacy
haftmann
parents: 61799
diff changeset
  2158
    fun smp i = funpow i (fn m => filter_right ([spec] RL m)) [mp];
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2159
  in
59498
50b60f501b05 proper context for resolve_tac, eresolve_tac, dresolve_tac, forward_tac etc.;
wenzelm
parents: 59028
diff changeset
  2160
    fun smp_tac ctxt j = EVERY' [dresolve_tac ctxt (smp j), assume_tac ctxt];
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2161
  end;
22839
ede26eb5e549 dropped HOL.ML
haftmann
parents: 22744
diff changeset
  2162
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2163
  local
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2164
    val nnf_ss =
69593
3dda49e08b9d isabelle update -u control_cartouches;
wenzelm
parents: 69216
diff changeset
  2165
      simpset_of (put_simpset HOL_basic_ss \<^context> addsimps @{thms simp_thms nnf_simps});
58826
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2166
  in
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2167
    fun nnf_conv ctxt = Simplifier.rewrite (put_simpset nnf_ss ctxt);
2ed2eaabe3df modernized setup;
wenzelm
parents: 58775
diff changeset
  2168
  end
60758
d8d85a8172b5 isabelle update_cartouches;
wenzelm
parents: 60183
diff changeset
  2169
\<close>
21671
f7d652ffef09 removed legacy ML bindings;
wenzelm
parents: 21547
diff changeset
  2170
38866
8ffb9f541285 hide all-too-popular constant name eq
haftmann
parents: 38864
diff changeset
  2171
hide_const (open) eq equal
8ffb9f541285 hide all-too-popular constant name eq
haftmann
parents: 38864
diff changeset
  2172
14357
e49d5d5ae66a print translation for ALL x <= n. P x
kleing
parents: 14295
diff changeset
  2173
end