Dataset Viewer
theory_file
stringlengths 3
95
| lemma_name
stringlengths 5
250
| lemma_command
stringlengths 15
21.3k
⌀ | lemma_object
stringlengths 5
62.8k
| template
stringlengths 7
63.6k
| symbols
sequencelengths 0
101
| defs
sequencelengths 0
83
| input
stringlengths 15
62.8k
| output
stringlengths 24
63.6k
|
|---|---|---|---|---|---|---|---|---|
Differential_Dynamic_Logic/Syntax
|
Syntax.fsafe_Context_simps
| null |
fsafe (InContext ?C ?p) = fsafe ?p
|
?H1 (?H2 x_1 x_2) = ?H1 x_2
|
[
"Syntax.formula.InContext",
"Syntax.fsafe"
] |
[
"datatype ('a, 'b, 'c) hp =\n\\<comment> \\<open>Variables standing for programs, given meaning by the interpretation.\\<close>\n Pvar 'c (\"$\\<alpha>\")\n\\<comment> \\<open>Assignment to a real-valued variable \\<open>x := \\<theta>\\<close>\\<close>\n| Assign 'c \"('a, 'c) trm\" (infixr \":=\" 10)\n\\<comment> \\<open>Assignment to a differential variable\\<close>\n| DiffAssign 'c \"('a, 'c) trm\"\n\\<comment> \\<open>Program \\<open>?\\<phi>\\<close> succeeds iff \\<open>\\<phi>\\<close> holds in current state.\\<close>\n| Test \"('a, 'b, 'c) formula\" (\"?\")\n\\<comment> \\<open>An ODE program is an ODE system with some evolution domain.\\<close>\n| EvolveODE \"('a, 'c) ODE\" \"('a, 'b, 'c) formula\"\n\\<comment> \\<open>Non-deterministic choice between two programs \\<open>a\\<close> and \\<open>b\\<close>\\<close>\n| Choice \"('a, 'b, 'c) hp\" \"('a, 'b, 'c) hp\" (infixl \"\\<union>\\<union>\" 10)\n\\<comment> \\<open>Sequential composition of two programs \\<open>a\\<close> and \\<open>b\\<close>\\<close>\n| Sequence \"('a, 'b, 'c) hp\" \"('a, 'b, 'c) hp\" (infixr \";;\" 8)\n\\<comment> \\<open>Nondeterministic repetition of a program \\<open>a\\<close>, zero or more times.\\<close>\n| Loop \"('a, 'b, 'c) hp\" (\"_**\")\n\nand ('a, 'b, 'c) formula =\n Geq \"('a, 'c) trm\" \"('a, 'c) trm\"\n| Prop 'c \"'c \\<Rightarrow> ('a, 'c) trm\" (\"$\\<phi>\")\n| Not \"('a, 'b, 'c) formula\" (\"!\")\n| And \"('a, 'b, 'c) formula\" \"('a, 'b, 'c) formula\" (infixl \"&&\" 8)\n| Exists 'c \"('a, 'b, 'c) formula\"\n\\<comment> \\<open>\\<open>\\<langle>\\<alpha>\\<rangle>\\<phi>\\<close> iff exists run of \\<open>\\<alpha>\\<close> where \\<open>\\<phi>\\<close> is True in end state\\<close>\n| Diamond \"('a, 'b, 'c) hp\" \"('a, 'b, 'c) formula\" (\"(\\<langle> _ \\<rangle> _)\" 10)\n\\<comment> \\<open>Contexts \\<open>C\\<close> are symbols standing for functions from (the semantics of) formulas to\\<close>\n\\<comment> \\<open>(the semantics of) formulas, thus \\<open>C(\\<phi>)\\<close> is another formula. While not necessary\\<close>\n\\<comment> \\<open>in terms of expressiveness, contexts allow for more efficient reasoning principles.\\<close>\n| InContext 'b \"('a, 'b, 'c) formula\"\n \n\\<comment> \\<open>Derived forms\\<close>"
] |
###lemma
fsafe (InContext ?C ?p) = fsafe ?p
|
###output
?H1 (?H2 x_1 x_2) = ?H1 x_2
###end
|
Affine_Arithmetic/Straight_Line_Program
|
Straight_Line_Program.comparator_floatarith_simps(283)
| null |
comparator_floatarith (floatarith.Floor ?x) (floatarith.Powr ?yo ?yp) = Gt
|
?H1 (?H2 x_1) (?H3 x_2 x_3) = ?H4
|
[
"Comparator.order.Gt",
"Approximation.floatarith.Powr",
"Approximation.floatarith.Floor",
"Straight_Line_Program.comparator_floatarith"
] |
[
"datatype floatarith\n = Add floatarith floatarith\n | Minus floatarith\n | Mult floatarith floatarith\n | Inverse floatarith\n | Cos floatarith\n | Arctan floatarith\n | Abs floatarith\n | Max floatarith floatarith\n | Min floatarith floatarith\n | Pi\n | Sqrt floatarith\n | Exp floatarith\n | Powr floatarith floatarith\n | Ln floatarith\n | Power floatarith nat\n | Floor floatarith\n | Var nat\n | Num float",
"datatype floatarith\n = Add floatarith floatarith\n | Minus floatarith\n | Mult floatarith floatarith\n | Inverse floatarith\n | Cos floatarith\n | Arctan floatarith\n | Abs floatarith\n | Max floatarith floatarith\n | Min floatarith floatarith\n | Pi\n | Sqrt floatarith\n | Exp floatarith\n | Powr floatarith floatarith\n | Ln floatarith\n | Power floatarith nat\n | Floor floatarith\n | Var nat\n | Num float"
] |
###lemma
comparator_floatarith (floatarith.Floor ?x) (floatarith.Powr ?yo ?yp) = Gt
|
###output
?H1 (?H2 x_1) (?H3 x_2 x_3) = ?H4
###end
|
First_Order_Terms/Subsumption
|
Subsumption.subsumeseq_term_trans
|
lemma subsumeseq_term_trans:
fixes s t u :: "('a, 'b) term"
assumes "s \<le>\<cdot> t" and "t \<le>\<cdot> u"
shows "s \<le>\<cdot> u"
|
?s \<le>\<cdot> ?t \<Longrightarrow> ?t \<le>\<cdot> ?u \<Longrightarrow> ?s \<le>\<cdot> ?u
|
\<lbrakk>?H1 x_1 x_2; ?H1 x_2 x_3\<rbrakk> \<Longrightarrow> ?H1 x_1 x_3
|
[
"Subsumption.subsumeseq_term"
] |
[] |
###lemma
?s \<le>\<cdot> ?t \<Longrightarrow> ?t \<le>\<cdot> ?u \<Longrightarrow> ?s \<le>\<cdot> ?u
|
###output
\<lbrakk>?H1 x_1 x_2; ?H1 x_2 x_3\<rbrakk> \<Longrightarrow> ?H1 x_1 x_3
###end
|
Tarskis_Geometry/Projective
|
Projective.proj2_abs_mult_rep
|
lemma proj2_abs_mult_rep:
assumes "c \<noteq> 0"
shows "proj2_abs (c *\<^sub>R proj2_rep x) = x"
|
?c \<noteq> 0 \<Longrightarrow> proj2_abs (?c *\<^sub>R proj2_rep ?x) = ?x
|
x_1 \<noteq> ?H1 \<Longrightarrow> ?H2 (?H3 x_1 (?H4 x_2)) = x_2
|
[
"Projective.proj2_rep",
"Real_Vector_Spaces.scaleR_class.scaleR",
"Projective.proj2_abs",
"Groups.zero_class.zero"
] |
[
"definition proj2_rep :: \"proj2 \\<Rightarrow> real^3\" where\n \"proj2_rep x \\<equiv> \\<some> v. v \\<in> Rep_proj2 x\"",
"class scaleR =\n fixes scaleR :: \"real \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixr \"*\\<^sub>R\" 75)\nbegin",
"definition proj2_abs :: \"real^3 \\<Rightarrow> proj2\" where\n \"proj2_abs v \\<equiv> Abs_proj2 (real_vector.proportionality `` {v})\"",
"class zero =\n fixes zero :: 'a (\"0\")"
] |
###lemma
?c \<noteq> 0 \<Longrightarrow> proj2_abs (?c *\<^sub>R proj2_rep ?x) = ?x
|
###output
x_1 \<noteq> ?H1 \<Longrightarrow> ?H2 (?H3 x_1 (?H4 x_2)) = x_2
###end
|
Refine_Imperative_HOL/Sepref_HOL_Bindings
|
Sepref_HOL_Bindings.p2prop(2)
|
lemma p2prop:
"left_unique P = IS_LEFT_UNIQUE (p2rel P)"
"right_unique P = IS_RIGHT_UNIQUE (p2rel P)"
"left_total P = IS_LEFT_TOTAL (p2rel P)"
"right_total P = IS_RIGHT_TOTAL (p2rel P)"
"bi_unique P \<longleftrightarrow> left_unique P \<and> right_unique P"
|
right_unique ?P = single_valued (p2rel ?P)
|
?H1 x_1 = ?H2 (?H3 x_1)
|
[
"Relators.p2rel",
"Relation.single_valued",
"Transfer.right_unique"
] |
[
"definition single_valued :: \"('a \\<times> 'b) set \\<Rightarrow> bool\"\n where \"single_valued r \\<longleftrightarrow> (\\<forall>x y. (x, y) \\<in> r \\<longrightarrow> (\\<forall>z. (x, z) \\<in> r \\<longrightarrow> y = z))\"",
"definition right_unique :: \"('a \\<Rightarrow> 'b \\<Rightarrow> bool) \\<Rightarrow> bool\"\n where \"right_unique R \\<longleftrightarrow> (\\<forall>x y z. R x y \\<longrightarrow> R x z \\<longrightarrow> y = z)\""
] |
###lemma
right_unique ?P = single_valued (p2rel ?P)
|
###output
?H1 x_1 = ?H2 (?H3 x_1)
###end
|
Topological_Semantics/boolean_algebra
|
boolean_algebra.L13
|
lemma L13: "A \<^bold>\<and> \<^bold>\<top> \<^bold>= A"
|
(?A::?'a \<Rightarrow> bool) \<^bold>\<and> \<^bold>\<top> \<^bold>= ?A
|
(?H1::(?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> bool) ((?H2::(?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) (x_1::?'a \<Rightarrow> bool) (?H3::?'a \<Rightarrow> bool)) x_1
|
[
"boolean_algebra.top",
"boolean_algebra.meet",
"boolean_algebra.setequ"
] |
[
"definition top::\"'w \\<sigma>\" (\"\\<^bold>\\<top>\") \n where \"\\<^bold>\\<top> \\<equiv> \\<lambda>w. True\" \\<comment>\\<open> universe \\<close>",
"definition meet::\"'w \\<sigma> \\<Rightarrow> 'w \\<sigma> \\<Rightarrow> 'w \\<sigma>\" (infixr \"\\<^bold>\\<and>\" 54) \n where \"A \\<^bold>\\<and> B \\<equiv> \\<lambda>p. (A p) \\<and> (B p)\" \\<comment>\\<open> intersection \\<close>",
"definition setequ::\"'w \\<sigma> \\<Rightarrow> 'w \\<sigma> \\<Rightarrow> bool\" (infixr \"\\<^bold>=\" 45) \n where \"A \\<^bold>= B \\<equiv> \\<forall>p. A p \\<longleftrightarrow> B p\""
] |
###lemma
(?A::?'a \<Rightarrow> bool) \<^bold>\<and> \<^bold>\<top> \<^bold>= ?A
|
###output
(?H1::(?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> bool) ((?H2::(?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) (x_1::?'a \<Rightarrow> bool) (?H3::?'a \<Rightarrow> bool)) x_1
###end
|
JinjaThreads/Compiler/Execs
|
Execs.wf_ciD2_ci_app
|
lemma wf_ciD2_ci_app:
"ci_app ci ins P h stk loc C M pc frs \<Longrightarrow> check_instr' ins P h stk loc C M pc frs"
|
ci_app ?ci ?ins ?P ?h ?stk ?loc ?C ?M ?pc ?frs \<Longrightarrow> check_instr' ?ins ?P ?h ?stk ?loc ?C ?M ?pc ?frs
|
?H1 x_1 x_2 x_3 x_4 x_5 x_6 x_7 x_8 x_9 x_10 \<Longrightarrow> ?H2 x_2 x_3 x_4 x_5 x_6 x_7 x_8 x_9 x_10
|
[
"Execs.check_instr'",
"Execs.check_instr.ci_app"
] |
[] |
###lemma
ci_app ?ci ?ins ?P ?h ?stk ?loc ?C ?M ?pc ?frs \<Longrightarrow> check_instr' ?ins ?P ?h ?stk ?loc ?C ?M ?pc ?frs
|
###output
?H1 x_1 x_2 x_3 x_4 x_5 x_6 x_7 x_8 x_9 x_10 \<Longrightarrow> ?H2 x_2 x_3 x_4 x_5 x_6 x_7 x_8 x_9 x_10
###end
|
Word_Lib/Many_More
|
Many_More.nat_iffs(2)
| null |
?n \<le> ?m + ?n
|
x_1 \<le> ?H1 x_2 x_1
|
[
"Groups.plus_class.plus"
] |
[
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)"
] |
###lemma
?n \<le> ?m + ?n
|
###output
x_1 \<le> ?H1 x_2 x_1
###end
|
Resolution_FOL/Resolution
|
Resolution.ground_vars\<^sub>t
| null |
ground\<^sub>t ?t \<Longrightarrow> vars\<^sub>t ?t = {}
|
?H1 x_1 \<Longrightarrow> ?H2 x_1 = ?H3
|
[
"Set.empty",
"Resolution.vars\\<^sub>t",
"TermsAndLiterals.ground\\<^sub>t"
] |
[
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"fun vars\\<^sub>t :: \"fterm \\<Rightarrow> var_sym set\" where\n \"vars\\<^sub>t (Var x) = {x}\"\n| \"vars\\<^sub>t (Fun f ts) = (\\<Union>t \\<in> set ts. vars\\<^sub>t t)\"",
"fun ground\\<^sub>t :: \"fterm \\<Rightarrow> bool\" where\n \"ground\\<^sub>t (Var x) \\<longleftrightarrow> False\"\n| \"ground\\<^sub>t (Fun f ts) \\<longleftrightarrow> (\\<forall>t \\<in> set ts. ground\\<^sub>t t)\""
] |
###lemma
ground\<^sub>t ?t \<Longrightarrow> vars\<^sub>t ?t = {}
|
###output
?H1 x_1 \<Longrightarrow> ?H2 x_1 = ?H3
###end
|
Linear_Recurrences/Partial_Fraction_Decomposition
|
Partial_Fraction_Decomposition.snd_poly_pfd_simple
|
lemma snd_poly_pfd_simple:
"map (map (\<lambda>c. [:c :: 'a :: field_gcd:])) (snd (poly_pfd_simple x cs)) =
(snd (partial_fraction_decomposition x (map (\<lambda>(c,n). ([:1,-c:],n)) cs)))"
|
map (map (\<lambda>c. [:c:])) (snd (poly_pfd_simple ?x ?cs)) = snd (partial_fraction_decomposition ?x (map (\<lambda>(c, n). ([:1::?'a, - c:], n)) ?cs))
|
?H1 (?H2 (\<lambda>y_0. ?H3 y_0 ?H4)) (?H5 (?H6 x_1 x_2)) = ?H7 (?H8 x_1 (?H9 (?H10 (\<lambda>y_1. Pair (?H3 ?H11 (?H3 (?H12 y_1) ?H4)))) x_2))
|
[
"Groups.uminus_class.uminus",
"Groups.one_class.one",
"Product_Type.prod.case_prod",
"Partial_Fraction_Decomposition.partial_fraction_decomposition",
"Partial_Fraction_Decomposition.poly_pfd_simple",
"Product_Type.prod.snd",
"Groups.zero_class.zero",
"Polynomial.pCons",
"List.list.map"
] |
[
"class uminus =\n fixes uminus :: \"'a \\<Rightarrow> 'a\" (\"- _\" [81] 80)",
"class one =\n fixes one :: 'a (\"1\")",
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"definition partial_fraction_decomposition :: \n \"'a :: euclidean_ring_gcd \\<Rightarrow> ('a \\<times> nat) list \\<Rightarrow> 'a \\<times> 'a list list\" where\n \"partial_fraction_decomposition x ys = (if ys = [] then (x, []) else\n (let zs = [let (y, n) = ys ! i\n in normalise_decomp (decompose x (map (\\<lambda>(y,n). y ^ Suc n) ys) ! i) y (Suc n). \n i \\<leftarrow> [0..<length ys]]\n in (sum_list (map fst zs), map snd zs)))\"",
"definition poly_pfd_simple where\n \"poly_pfd_simple x cs = (if cs = [] then (x, []) else\n (let zs = [let (c, n) = cs ! i\n in normalise_decomp_poly (decompose x \n (map (\\<lambda>(c,n). [:1,-c:] ^ Suc n) cs) ! i) [:1,-c:] (n+1). \n i \\<leftarrow> [0..<length cs]]\n in (sum_list (map fst zs), map (map (\\<lambda>p. coeff p 0) \\<circ> snd) zs)))\"",
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"class zero =\n fixes zero :: 'a (\"0\")",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
map (map (\<lambda>c. [:c:])) (snd (poly_pfd_simple ?x ?cs)) = snd (partial_fraction_decomposition ?x (map (\<lambda>(c, n). ([:1::?'a, - c:], n)) ?cs))
|
###output
?H1 (?H2 (\<lambda>y_0. ?H3 y_0 ?H4)) (?H5 (?H6 x_1 x_2)) = ?H7 (?H8 x_1 (?H9 (?H10 (\<lambda>y_1. Pair (?H3 ?H11 (?H3 (?H12 y_1) ?H4)))) x_2))
###end
|
Ordinary_Differential_Equations/Numerics/Transfer_ODE
|
Transfer_ODE.solves_ode_transfer
|
lemma solves_ode_transfer[transfer_rule]:
"(((=) ===> A) ===> ((=) ===> A ===> A) ===> rel_set (=) ===> rel_set A ===> (=)) (solves_ode) (solves_ode)"
if [transfer_rule]:
"A 0 0" "bi_unique A" "bi_total A" "(rel_set A ===> (=)) open open"
"((=) ===> A ===> A) (*\<^sub>R) (*\<^sub>R)"
"(A ===> A ===> A) (+) (+)"
"(A ===> A ===> A) (-) (-)"
"(A ===> (=)) norm norm"
|
?A (0::?'a) (0::?'b) \<Longrightarrow> bi_unique ?A \<Longrightarrow> bi_total ?A \<Longrightarrow> rel_fun (rel_set ?A) (=) open open \<Longrightarrow> rel_fun (=) (rel_fun ?A ?A) (*\<^sub>R) (*\<^sub>R) \<Longrightarrow> rel_fun ?A (rel_fun ?A ?A) (+) (+) \<Longrightarrow> rel_fun ?A (rel_fun ?A ?A) (-) (-) \<Longrightarrow> rel_fun ?A (=) norm norm \<Longrightarrow> rel_fun (rel_fun (=) ?A) (rel_fun (rel_fun (=) (rel_fun ?A ?A)) (rel_fun (rel_set (=)) (rel_fun (rel_set ?A) (=)))) (solves_ode) (solves_ode)
|
\<lbrakk>x_1 ?H1 ?H2; ?H3 x_1; ?H4 x_1; ?H5 (?H6 x_1) (=) ?H7 ?H8; ?H9 (=) (?H10 x_1 x_1) ?H11 ?H12; ?H13 x_1 (?H10 x_1 x_1) ?H14 ?H15; ?H13 x_1 (?H10 x_1 x_1) ?H16 ?H17; ?H18 x_1 (=) ?H19 ?H20\<rbrakk> \<Longrightarrow> ?H21 (?H22 (=) x_1) (?H23 (?H9 (=) (?H10 x_1 x_1)) (?H24 (?H25 (=)) (?H5 (?H6 x_1) (=)))) ?H26 ?H27
|
[
"Initial_Value_Problem.solves_ode",
"Real_Vector_Spaces.norm_class.norm",
"Groups.minus_class.minus",
"Groups.plus_class.plus",
"Real_Vector_Spaces.scaleR_class.scaleR",
"Topological_Spaces.open_class.open",
"BNF_Def.rel_set",
"BNF_Def.rel_fun",
"Transfer.bi_total",
"Transfer.bi_unique",
"Groups.zero_class.zero"
] |
[
"class norm =\n fixes norm :: \"'a \\<Rightarrow> real\"",
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)",
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)",
"class scaleR =\n fixes scaleR :: \"real \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixr \"*\\<^sub>R\" 75)\nbegin",
"class \"open\" =\n fixes \"open\" :: \"'a set \\<Rightarrow> bool\"",
"definition rel_set :: \"('a \\<Rightarrow> 'b \\<Rightarrow> bool) \\<Rightarrow> 'a set \\<Rightarrow> 'b set \\<Rightarrow> bool\"\n where \"rel_set R = (\\<lambda>A B. (\\<forall>x\\<in>A. \\<exists>y\\<in>B. R x y) \\<and> (\\<forall>y\\<in>B. \\<exists>x\\<in>A. R x y))\"",
"definition\n rel_fun :: \"('a \\<Rightarrow> 'c \\<Rightarrow> bool) \\<Rightarrow> ('b \\<Rightarrow> 'd \\<Rightarrow> bool) \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> ('c \\<Rightarrow> 'd) \\<Rightarrow> bool\"\nwhere\n \"rel_fun A B = (\\<lambda>f g. \\<forall>x y. A x y \\<longrightarrow> B (f x) (g y))\"",
"definition bi_total :: \"('a \\<Rightarrow> 'b \\<Rightarrow> bool) \\<Rightarrow> bool\"\n where \"bi_total R \\<longleftrightarrow> (\\<forall>x. \\<exists>y. R x y) \\<and> (\\<forall>y. \\<exists>x. R x y)\"",
"definition bi_unique :: \"('a \\<Rightarrow> 'b \\<Rightarrow> bool) \\<Rightarrow> bool\"\n where \"bi_unique R \\<longleftrightarrow>\n (\\<forall>x y z. R x y \\<longrightarrow> R x z \\<longrightarrow> y = z) \\<and>\n (\\<forall>x y z. R x z \\<longrightarrow> R y z \\<longrightarrow> x = y)\"",
"class zero =\n fixes zero :: 'a (\"0\")"
] |
###lemma
?A (0::?'a) (0::?'b) \<Longrightarrow> bi_unique ?A \<Longrightarrow> bi_total ?A \<Longrightarrow> rel_fun (rel_set ?A) (=) open open \<Longrightarrow> rel_fun (=) (rel_fun ?A ?A) (*\<^sub>R) (*\<^sub>R) \<Longrightarrow> rel_fun ?A (rel_fun ?A ?A) (+) (+) \<Longrightarrow> rel_fun ?A (rel_fun ?A ?A) (-) (-) \<Longrightarrow> rel_fun ?A (=) norm norm \<Longrightarrow> rel_fun (rel_fun (=) ?A) (rel_fun (rel_fun (=) (rel_fun ?A ?A)) (rel_fun (rel_set (=)) (rel_fun (rel_set ?A) (=)))) (solves_ode) (solves_ode)
|
###output
\<lbrakk>x_1 ?H1 ?H2; ?H3 x_1; ?H4 x_1; ?H5 (?H6 x_1) (=) ?H7 ?H8; ?H9 (=) (?H10 x_1 x_1) ?H11 ?H12; ?H13 x_1 (?H10 x_1 x_1) ?H14 ?H15; ?H13 x_1 (?H10 x_1 x_1) ?H16 ?H17; ?H18 x_1 (=) ?H19 ?H20\<rbrakk> \<Longrightarrow> ?H21 (?H22 (=) x_1) (?H23 (?H9 (=) (?H10 x_1 x_1)) (?H24 (?H25 (=)) (?H5 (?H6 x_1) (=)))) ?H26 ?H27
###end
|
UTP/utp/utp_pred_laws
|
utp_pred_laws.cond_distr
|
lemma cond_distr: "(P \<triangleleft> b \<triangleright> (Q \<triangleleft> c \<triangleright> R)) = ((P \<triangleleft> b \<triangleright> Q) \<triangleleft> c \<triangleright> (P \<triangleleft> b \<triangleright> R))"
|
?P \<triangleleft> ?b \<triangleright> (?Q \<triangleleft> ?c \<triangleright> ?R) = ?P \<triangleleft> ?b \<triangleright> ?Q \<triangleleft> ?c \<triangleright> (?P \<triangleleft> ?b \<triangleright> ?R)
|
?H1 x_1 x_2 (?H1 x_3 x_4 x_5) = ?H1 (?H1 x_1 x_2 x_3) x_4 (?H1 x_1 x_2 x_5)
|
[
"utp_expr.cond"
] |
[] |
###lemma
?P \<triangleleft> ?b \<triangleright> (?Q \<triangleleft> ?c \<triangleright> ?R) = ?P \<triangleleft> ?b \<triangleright> ?Q \<triangleleft> ?c \<triangleright> (?P \<triangleleft> ?b \<triangleright> ?R)
|
###output
?H1 x_1 x_2 (?H1 x_3 x_4 x_5) = ?H1 (?H1 x_1 x_2 x_3) x_4 (?H1 x_1 x_2 x_5)
###end
|
FOL_Seq_Calc3/Prover
|
Prover.trim_enabled
| null |
?s \<in> UNIV \<Longrightarrow> Prover.fair ?rs \<Longrightarrow> enabled (shd (trim ?rs ?s)) ?s
|
\<lbrakk>x_1 \<in> ?H1; ?H2 x_2\<rbrakk> \<Longrightarrow> ?H3 (?H4 (?H5 x_2 x_1)) x_1
|
[
"Prover.trim",
"Stream.stream.shd",
"Prover.enabled",
"Prover.fair",
"Set.UNIV"
] |
[
"codatatype (sset: 'a) stream =\n SCons (shd: 'a) (stl: \"'a stream\") (infixr \\<open>##\\<close> 65)\nfor\n map: smap\n rel: stream_all2",
"abbreviation UNIV :: \"'a set\"\n where \"UNIV \\<equiv> top\""
] |
###lemma
?s \<in> UNIV \<Longrightarrow> Prover.fair ?rs \<Longrightarrow> enabled (shd (trim ?rs ?s)) ?s
|
###output
\<lbrakk>x_1 \<in> ?H1; ?H2 x_2\<rbrakk> \<Longrightarrow> ?H3 (?H4 (?H5 x_2 x_1)) x_1
###end
|
Robinson_Arithmetic/Robinson_Arithmetic
|
Robinson_Arithmetic.neg_E
|
lemma neg_E [intro!]: "H \<turnstile> A \<Longrightarrow> insert (neg A) H \<turnstile> fls"
|
?H \<turnstile> ?A \<Longrightarrow> insert (neg ?A) ?H \<turnstile> fls
|
?H1 x_1 x_2 \<Longrightarrow> ?H1 (?H2 (?H3 x_2) x_1) ?H4
|
[
"Robinson_Arithmetic.fls",
"Robinson_Arithmetic.neg",
"Set.insert",
"Robinson_Arithmetic.nprv"
] |
[
"definition fls where \"fls \\<equiv> neg (zer EQ zer)\"",
"definition insert :: \"'a \\<Rightarrow> 'a set \\<Rightarrow> 'a set\"\n where insert_compr: \"insert a B = {x. x = a \\<or> x \\<in> B}\"",
"inductive nprv :: \"fmla set \\<Rightarrow> fmla \\<Rightarrow> bool\" (infixl \"\\<turnstile>\" 55)\n where\n Hyp: \"A \\<in> H \\<Longrightarrow> H \\<turnstile> A\"\n | Q: \"A \\<in> Q_axioms \\<Longrightarrow> H \\<turnstile> A\"\n | Bool: \"A \\<in> boolean_axioms \\<Longrightarrow> H \\<turnstile> A\"\n | eql: \"A \\<in> equality_axioms \\<Longrightarrow> H \\<turnstile> A\"\n | Spec: \"A \\<in> special_axioms \\<Longrightarrow> H \\<turnstile> A\"\n | MP: \"H \\<turnstile> A IMP B \\<Longrightarrow> H' \\<turnstile> A \\<Longrightarrow> H \\<union> H' \\<turnstile> B\"\n | exiists: \"H \\<turnstile> A IMP B \\<Longrightarrow> atom i \\<sharp> B \\<Longrightarrow> \\<forall>C \\<in> H. atom i \\<sharp> C \\<Longrightarrow> H \\<turnstile> (exi i A) IMP B\""
] |
###lemma
?H \<turnstile> ?A \<Longrightarrow> insert (neg ?A) ?H \<turnstile> fls
|
###output
?H1 x_1 x_2 \<Longrightarrow> ?H1 (?H2 (?H3 x_2) x_1) ?H4
###end
|
Safe_OCL/OCL_Types
|
OCL_Types.type_less_eq_x_Optional_intro(2)
|
lemma type_less_eq_x_Optional_intro [intro]:
"\<tau> = \<rho>[1] \<Longrightarrow> \<rho> \<le> \<sigma> \<Longrightarrow> \<tau> \<le> \<sigma>[?]"
"\<tau> = \<rho>[?] \<Longrightarrow> \<rho> \<le> \<sigma> \<Longrightarrow> \<tau> \<le> \<sigma>[?]"
|
?\<tau> = ?\<rho>[?] \<Longrightarrow> ?\<rho> \<le> ?\<sigma> \<Longrightarrow> ?\<tau> \<le> ?\<sigma>[?]
|
\<lbrakk>x_1 = ?H1 x_2; x_2 \<le> x_3\<rbrakk> \<Longrightarrow> x_1 \<le> ?H1 x_3
|
[
"OCL_Types.type.Optional"
] |
[] |
###lemma
?\<tau> = ?\<rho>[?] \<Longrightarrow> ?\<rho> \<le> ?\<sigma> \<Longrightarrow> ?\<tau> \<le> ?\<sigma>[?]
|
###output
\<lbrakk>x_1 = ?H1 x_2; x_2 \<le> x_3\<rbrakk> \<Longrightarrow> x_1 \<le> ?H1 x_3
###end
|
Consensus_Refined/Refinement
|
Refinement.beh_obs_upd
|
lemma beh_obs_upd [simp]: "beh (S(| obs := x |)) = beh S"
|
beh (?S\<lparr>obs := ?x\<rparr>) = beh ?S
|
?H1 (?H2 (\<lambda>y_0. x_1) x_2) = ?H1 x_2
|
[
"Refinement.spec.obs_update",
"Refinement.beh"
] |
[
"record ('s, 'o) spec = \"'s TS\" +\n obs :: \"'s \\<Rightarrow> 'o\"",
"inductive_set \n beh :: \"('s, 'a) TS_scheme \\<Rightarrow> ('s list) set\"\n for T :: \"('s, 'a) TS_scheme\" \nwhere\n b_empty [iff]: \"[] \\<in> beh T\"\n| b_init [intro]: \"s \\<in> init T \\<Longrightarrow> [s] \\<in> beh T\"\n| b_trans [intro]: \"\\<lbrakk> s # b \\<in> beh T; (s, t) \\<in> trans T \\<rbrakk> \\<Longrightarrow> t # s # b \\<in> beh T\""
] |
###lemma
beh (?S\<lparr>obs := ?x\<rparr>) = beh ?S
|
###output
?H1 (?H2 (\<lambda>y_0. x_1) x_2) = ?H1 x_2
###end
|
BTree/BPlusTree
|
BPlusTree.set_nodes_nodes
|
lemma set_nodes_nodes: "set (inorder t) = set_nodes t"
|
set (inorder ?t) = set_nodes ?t
|
?H1 (?H2 x_1) = ?H3 x_1
|
[
"BPlusTree.set_nodes",
"BPlusTree.inorder",
"List.list.set"
] |
[
"fun set_nodes :: \"'a bplustree \\<Rightarrow> 'a set\" where\n \"set_nodes (Leaf ks) = {}\" |\n \"set_nodes (Node ts t) = \\<Union>(set (map set_nodes (subtrees ts))) \\<union> (set (separators ts)) \\<union> set_nodes t\"",
"fun inorder :: \"'a bplustree \\<Rightarrow> 'a list\" where\n \"inorder (Leaf ks) = []\" |\n \"inorder (Node ts t) = concat (map (\\<lambda> (sub, sep). inorder sub @ [sep]) ts) @ inorder t\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
set (inorder ?t) = set_nodes ?t
|
###output
?H1 (?H2 x_1) = ?H3 x_1
###end
|
Abstract-Rewriting/Abstract_Rewriting
|
Abstract_Rewriting.diamond_imp_CR'
|
lemma diamond_imp_CR':
assumes "\<diamond> s" and "r \<subseteq> s" and "s \<subseteq> r\<^sup>*" shows "CR r"
|
\<diamond> ?s \<Longrightarrow> ?r \<subseteq> ?s \<Longrightarrow> ?s \<subseteq> ?r\<^sup>* \<Longrightarrow> CR ?r
|
\<lbrakk>?H1 x_1; ?H2 x_2 x_1; ?H2 x_1 (?H3 x_2)\<rbrakk> \<Longrightarrow> ?H4 x_2
|
[
"Abstract_Rewriting.CR",
"Transitive_Closure.rtrancl",
"Set.subset_eq",
"Abstract_Rewriting.diamond"
] |
[
"abbreviation CR :: \"'a rel \\<Rightarrow> bool\" where\n \"CR r \\<equiv> CR_on r UNIV\"",
"inductive_set rtrancl :: \"('a \\<times> 'a) set \\<Rightarrow> ('a \\<times> 'a) set\" (\"(_\\<^sup>*)\" [1000] 999)\n for r :: \"('a \\<times> 'a) set\"\n where\n rtrancl_refl [intro!, Pure.intro!, simp]: \"(a, a) \\<in> r\\<^sup>*\"\n | rtrancl_into_rtrancl [Pure.intro]: \"(a, b) \\<in> r\\<^sup>* \\<Longrightarrow> (b, c) \\<in> r \\<Longrightarrow> (a, c) \\<in> r\\<^sup>*\"",
"abbreviation subset_eq :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> bool\"\n where \"subset_eq \\<equiv> less_eq\"",
"definition diamond :: \"'a rel \\<Rightarrow> bool\" (\"\\<diamond>\") where\n \"\\<diamond> r \\<longleftrightarrow> (r\\<inverse> O r) \\<subseteq> (r O r\\<inverse>)\""
] |
###lemma
\<diamond> ?s \<Longrightarrow> ?r \<subseteq> ?s \<Longrightarrow> ?s \<subseteq> ?r\<^sup>* \<Longrightarrow> CR ?r
|
###output
\<lbrakk>?H1 x_1; ?H2 x_2 x_1; ?H2 x_1 (?H3 x_2)\<rbrakk> \<Longrightarrow> ?H4 x_2
###end
|
Locally-Nameless-Sigma/preliminary/Environments
|
Environments.get_env_bigger2
|
lemma get_env_bigger2:
fixes
e :: "'a environment" and a :: string and X :: 'a and
b :: string and Y :: 'a and x :: string
assumes "x \<in> (env_dom (e\<lparr>a:X\<rparr>\<lparr>b:Y\<rparr>))" and "x \<noteq> a" and "x \<noteq> b"
shows "e!x = e\<lparr>a:X\<rparr>\<lparr>b:Y\<rparr>!x"
|
?x \<in> env_dom (?e\<lparr>?a:?X\<rparr>\<lparr>?b:?Y\<rparr>) \<Longrightarrow> ?x \<noteq> ?a \<Longrightarrow> ?x \<noteq> ?b \<Longrightarrow> ?e!?x = ?e\<lparr>?a:?X\<rparr>\<lparr>?b:?Y\<rparr>!?x
|
\<lbrakk>x_1 \<in> ?H1 (?H2 (?H2 x_2 x_3 x_4) x_5 x_6); x_1 \<noteq> x_3; x_1 \<noteq> x_5\<rbrakk> \<Longrightarrow> ?H3 x_2 x_1 = ?H3 (?H2 (?H2 x_2 x_3 x_4) x_5 x_6) x_1
|
[
"Environments.env_get",
"Environments.add",
"Environments.env_dom"
] |
[] |
###lemma
?x \<in> env_dom (?e\<lparr>?a:?X\<rparr>\<lparr>?b:?Y\<rparr>) \<Longrightarrow> ?x \<noteq> ?a \<Longrightarrow> ?x \<noteq> ?b \<Longrightarrow> ?e!?x = ?e\<lparr>?a:?X\<rparr>\<lparr>?b:?Y\<rparr>!?x
|
###output
\<lbrakk>x_1 \<in> ?H1 (?H2 (?H2 x_2 x_3 x_4) x_5 x_6); x_1 \<noteq> x_3; x_1 \<noteq> x_5\<rbrakk> \<Longrightarrow> ?H3 x_2 x_1 = ?H3 (?H2 (?H2 x_2 x_3 x_4) x_5 x_6) x_1
###end
|
Attack_Trees/AT
|
AT.base_subset
|
lemma base_subset:
assumes "xa \<subseteq> xc"
shows "\<turnstile>\<N>\<^bsub>(x, xa)\<^esub> \<Longrightarrow> \<turnstile>\<N>\<^bsub>(x, xc)\<^esub>"
|
?xa \<subseteq> ?xc \<Longrightarrow> \<turnstile>\<N>\<^bsub>(?x, ?xa)\<^esub> \<Longrightarrow> \<turnstile>\<N>\<^bsub>(?x, ?xc)\<^esub>
|
\<lbrakk>?H1 x_1 x_2; ?H2 (?H3 (x_3, x_1))\<rbrakk> \<Longrightarrow> ?H2 (?H3 (x_3, x_2))
|
[
"AT.attree.BaseAttack",
"AT.is_attack_tree",
"Set.subset_eq"
] |
[
"datatype ('s :: state) attree = BaseAttack \"('s set) * ('s set)\" (\"\\<N>\\<^bsub>(_)\\<^esub>\") |\n AndAttack \"('s attree) list\" \"('s set) * ('s set)\" (\"_ \\<oplus>\\<^sub>\\<and>\\<^bsup>(_)\\<^esup>\" 60) | \n OrAttack \"('s attree) list\" \"('s set) * ('s set)\" (\"_ \\<oplus>\\<^sub>\\<or>\\<^bsup>(_)\\<^esup>\" 61)",
"fun is_attack_tree :: \"[('s :: state) attree] \\<Rightarrow> bool\" (\"\\<turnstile>_\" [40] 40) \nwhere \natt_base: \"(\\<turnstile> \\<N>\\<^bsub>s\\<^esub>) = ( (\\<forall> x \\<in> (fst s). (\\<exists> y \\<in> (snd s). x \\<rightarrow>\\<^sub>i y )))\" |\natt_and: \"(\\<turnstile>(As \\<oplus>\\<^sub>\\<and>\\<^bsup>s\\<^esup>)) = \n (case As of\n [] \\<Rightarrow> (fst s \\<subseteq> snd s)\n | [a] \\<Rightarrow> ( \\<turnstile> a \\<and> attack a = s) \n | (a # l) \\<Rightarrow> (( \\<turnstile> a) \\<and> (fst(attack a) = fst s) \\<and> \n (\\<turnstile>(l \\<oplus>\\<^sub>\\<and>\\<^bsup>(snd(attack a),snd(s))\\<^esup>))))\" |\natt_or: \"(\\<turnstile>(As \\<oplus>\\<^sub>\\<or>\\<^bsup>s\\<^esup>)) = \n (case As of \n [] \\<Rightarrow> (fst s \\<subseteq> snd s) \n | [a] \\<Rightarrow> ( \\<turnstile> a \\<and> (fst(attack a) \\<supseteq> fst s) \\<and> (snd(attack a) \\<subseteq> snd s)) \n | (a # l) \\<Rightarrow> (( \\<turnstile> a) \\<and> fst(attack a) \\<subseteq> fst s \\<and> \n snd(attack a) \\<subseteq> snd s \\<and>\n ( \\<turnstile>(l \\<oplus>\\<^sub>\\<or>\\<^bsup>(fst s - fst(attack a), snd s)\\<^esup>))))\"",
"abbreviation subset_eq :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> bool\"\n where \"subset_eq \\<equiv> less_eq\""
] |
###lemma
?xa \<subseteq> ?xc \<Longrightarrow> \<turnstile>\<N>\<^bsub>(?x, ?xa)\<^esub> \<Longrightarrow> \<turnstile>\<N>\<^bsub>(?x, ?xc)\<^esub>
|
###output
\<lbrakk>?H1 x_1 x_2; ?H2 (?H3 (x_3, x_1))\<rbrakk> \<Longrightarrow> ?H2 (?H3 (x_3, x_2))
###end
|
Native_Word/Uint16
|
Uint16.uint16_test_bit_code
|
lemma uint16_test_bit_code [code]:
"uint16_test_bit w n =
(if n < 0 \<or> 15 < n then undefined (bit :: uint16 \<Rightarrow> _) w n else bit (Rep_uint16 w) (nat_of_integer n))"
|
uint16_test_bit ?w ?n = (if ?n < 0 \<or> 15 < ?n then undefined bit ?w ?n else bit (Rep_uint16 ?w) (nat_of_integer ?n))
|
?H1 x_1 x_2 = (if x_2 < ?H2 \<or> ?H3 (?H4 (?H4 (?H4 ?H5))) < x_2 then undefined ?H6 x_1 x_2 else ?H7 (?H8 x_1) (?H9 x_2))
|
[
"Code_Numeral.nat_of_integer",
"Uint16.uint16.Rep_uint16",
"Bit_Operations.semiring_bits_class.bit",
"Num.num.One",
"Num.num.Bit1",
"Num.numeral_class.numeral",
"Groups.zero_class.zero",
"Uint16.uint16_test_bit"
] |
[
"typedef uint16 = \\<open>UNIV :: 16 word set\\<close>",
"class semiring_bits = semiring_parity + semiring_modulo_trivial +\n assumes bit_induct [case_names stable rec]:\n \\<open>(\\<And>a. a div 2 = a \\<Longrightarrow> P a)\n \\<Longrightarrow> (\\<And>a b. P a \\<Longrightarrow> (of_bool b + 2 * a) div 2 = a \\<Longrightarrow> P (of_bool b + 2 * a))\n \\<Longrightarrow> P a\\<close>\n assumes bits_mod_div_trivial [simp]: \\<open>a mod b div b = 0\\<close>\n and half_div_exp_eq: \\<open>a div 2 div 2 ^ n = a div 2 ^ Suc n\\<close>\n and even_double_div_exp_iff: \\<open>2 ^ Suc n \\<noteq> 0 \\<Longrightarrow> even (2 * a div 2 ^ Suc n) \\<longleftrightarrow> even (a div 2 ^ n)\\<close>\n fixes bit :: \\<open>'a \\<Rightarrow> nat \\<Rightarrow> bool\\<close>\n assumes bit_iff_odd: \\<open>bit a n \\<longleftrightarrow> odd (a div 2 ^ n)\\<close>\nbegin",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\"",
"class zero =\n fixes zero :: 'a (\"0\")",
"definition uint16_test_bit :: \"uint16 \\<Rightarrow> integer \\<Rightarrow> bool\"\nwhere [code del]:\n \"uint16_test_bit x n =\n (if n < 0 \\<or> 15 < n then undefined (bit :: uint16 \\<Rightarrow> _) x n\n else bit x (nat_of_integer n))\""
] |
###lemma
uint16_test_bit ?w ?n = (if ?n < 0 \<or> 15 < ?n then undefined bit ?w ?n else bit (Rep_uint16 ?w) (nat_of_integer ?n))
|
###output
?H1 x_1 x_2 = (if x_2 < ?H2 \<or> ?H3 (?H4 (?H4 (?H4 ?H5))) < x_2 then undefined ?H6 x_1 x_2 else ?H7 (?H8 x_1) (?H9 x_2))
###end
|
Affine_Arithmetic/Affine_Approximation
|
Affine_Approximation.pdevs_val_trunc_err_pdevs
|
lemma pdevs_val_trunc_err_pdevs:
fixes x y::"'a::euclidean_space"
shows "pdevs_val e (trunc_err_pdevs p X) = pdevs_val e (trunc_pdevs p X) - pdevs_val e X"
|
pdevs_val ?e (trunc_err_pdevs ?p ?X) = pdevs_val ?e (trunc_pdevs ?p ?X) - pdevs_val ?e ?X
|
?H1 x_1 (?H2 x_2 x_3) = ?H3 (?H1 x_1 (?H4 x_2 x_3)) (?H1 x_1 x_3)
|
[
"Affine_Approximation.trunc_pdevs",
"Groups.minus_class.minus",
"Affine_Approximation.trunc_err_pdevs",
"Affine_Form.pdevs_val"
] |
[
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)",
"definition pdevs_val :: \"(nat \\<Rightarrow> real) \\<Rightarrow> 'a::real_normed_vector pdevs \\<Rightarrow> 'a\"\n where \"pdevs_val e x = (\\<Sum>i. e i *\\<^sub>R pdevs_apply x i)\""
] |
###lemma
pdevs_val ?e (trunc_err_pdevs ?p ?X) = pdevs_val ?e (trunc_pdevs ?p ?X) - pdevs_val ?e ?X
|
###output
?H1 x_1 (?H2 x_2 x_3) = ?H3 (?H1 x_1 (?H4 x_2 x_3)) (?H1 x_1 x_3)
###end
|
HereditarilyFinite/Ordinal
|
Ordinal.Ord_cases
|
lemma Ord_cases [cases type: hf, case_names 0 succ]:
assumes Ok: "Ord(k)"
obtains "k = 0" | l where "Ord l" "succ l = k"
|
Ord ?k \<Longrightarrow> (?k = 0 \<Longrightarrow> ?thesis) \<Longrightarrow> (\<And>l. Ord l \<Longrightarrow> succ l = ?k \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
\<lbrakk>?H1 x_1; x_1 = ?H2 \<Longrightarrow> x_2; \<And>y_0. \<lbrakk>?H1 y_0; ?H3 y_0 = x_1\<rbrakk> \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
|
[
"Ordinal.succ",
"Groups.zero_class.zero",
"Ordinal.Ord"
] |
[
"definition\n succ :: \"hf \\<Rightarrow> hf\" where\n \"succ(x) \\<equiv> hinsert x x\"",
"class zero =\n fixes zero :: 'a (\"0\")",
"definition\n Ord :: \"hf \\<Rightarrow> bool\" where\n \"Ord(k) \\<equiv> Transset(k) \\<and> (\\<forall>x \\<^bold>\\<in> k. Transset(x))\""
] |
###lemma
Ord ?k \<Longrightarrow> (?k = 0 \<Longrightarrow> ?thesis) \<Longrightarrow> (\<And>l. Ord l \<Longrightarrow> succ l = ?k \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
###output
\<lbrakk>?H1 x_1; x_1 = ?H2 \<Longrightarrow> x_2; \<And>y_0. \<lbrakk>?H1 y_0; ?H3 y_0 = x_1\<rbrakk> \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
###end
|
Sturm_Sequences/Sturm_Method
|
Sturm_Method.sturm_id_PR_prio1(9)
|
lemma sturm_id_PR_prio1:
"{x::real. x < a \<and> P x} = {x::real. x < a \<and> (PR_TAG P) x}"
"{x::real. x \<le> a \<and> P x} = {x::real. x \<le> a \<and> (PR_TAG P) x}"
"{x::real. x \<ge> b \<and> P x} = {x::real. x \<ge> b \<and> (PR_TAG P) x}"
"{x::real. x > b \<and> P x} = {x::real. x > b \<and> (PR_TAG P) x}"
"(\<forall>x::real < a. f x < g x) = (\<forall>x::real < a. PR_TAG (\<lambda>x. f x < g x) x)"
"(\<forall>x::real \<le> a. f x < g x) = (\<forall>x::real \<le> a. PR_TAG (\<lambda>x. f x < g x) x)"
"(\<forall>x::real > a. f x < g x) = (\<forall>x::real > a. PR_TAG (\<lambda>x. f x < g x) x)"
"(\<forall>x::real \<ge> a. f x < g x) = (\<forall>x::real \<ge> a. PR_TAG (\<lambda>x. f x < g x) x)"
"(\<forall>x::real < a. P x) = (\<forall>x::real < a. \<not>(PR_TAG (\<lambda>x. \<not>P x)) x)"
"(\<forall>x::real > a. P x) = (\<forall>x::real > a. \<not>(PR_TAG (\<lambda>x. \<not>P x)) x)"
"(\<forall>x::real \<le> a. P x) = (\<forall>x::real \<le> a. \<not>(PR_TAG (\<lambda>x. \<not>P x)) x)"
"(\<forall>x::real \<ge> a. P x) = (\<forall>x::real \<ge> a. \<not>(PR_TAG (\<lambda>x. \<not>P x)) x)"
|
(\<forall>x<?a. ?P x) = (\<forall>x<?a. \<not> PR_TAG (\<lambda>x. \<not> ?P x) x)
|
(\<forall>y_0<x_1. x_2 y_0) = (\<forall>y_1<x_1. \<not> ?H1 (\<lambda>y_2. \<not> x_2 y_2) y_1)
|
[
"Sturm_Method.PR_TAG"
] |
[
"definition \"PR_TAG x \\<equiv> x\""
] |
###lemma
(\<forall>x<?a. ?P x) = (\<forall>x<?a. \<not> PR_TAG (\<lambda>x. \<not> ?P x) x)
|
###output
(\<forall>y_0<x_1. x_2 y_0) = (\<forall>y_1<x_1. \<not> ?H1 (\<lambda>y_2. \<not> x_2 y_2) y_1)
###end
|
Auth/KerberosIV_Gets
|
KerberosIV_Gets.new_keys_not_used
|
lemma new_keys_not_used [simp]:
"\<lbrakk>Key K \<notin> used evs; K \<in> symKeys; evs \<in> kerbIV_gets\<rbrakk>
\<Longrightarrow> K \<notin> keysFor (parts (spies evs))"
|
Key ?K \<notin> used ?evs \<Longrightarrow> ?K \<in> symKeys \<Longrightarrow> ?evs \<in> kerbIV_gets \<Longrightarrow> ?K \<notin> keysFor (parts (knows Spy ?evs))
|
\<lbrakk>?H1 (?H2 x_1) (?H3 x_2); x_1 \<in> ?H4; x_2 \<in> ?H5\<rbrakk> \<Longrightarrow> ?H6 x_1 (?H7 (?H8 (?H9 ?H10 x_2)))
|
[
"Message.agent.Spy",
"Event.knows",
"Message.parts",
"Message.keysFor",
"KerberosIV_Gets.kerbIV_gets",
"Message.symKeys",
"Event.used",
"Message.msg.Key",
"Set.not_member"
] |
[
"primrec knows :: \"agent \\<Rightarrow> event list \\<Rightarrow> msg set\"\nwhere\n knows_Nil: \"knows A [] = initState A\"\n| knows_Cons:\n \"knows A (ev # evs) =\n (if A = Spy then \n (case ev of\n Says A' B X \\<Rightarrow> insert X (knows Spy evs)\n | Gets A' X \\<Rightarrow> knows Spy evs\n | Notes A' X \\<Rightarrow> \n if A' \\<in> bad then insert X (knows Spy evs) else knows Spy evs)\n else\n (case ev of\n Says A' B X \\<Rightarrow> \n if A'=A then insert X (knows A evs) else knows A evs\n | Gets A' X \\<Rightarrow> \n if A'=A then insert X (knows A evs) else knows A evs\n | Notes A' X \\<Rightarrow> \n if A'=A then insert X (knows A evs) else knows A evs))\"",
"inductive_set\n parts :: \"msg set \\<Rightarrow> msg set\"\n for H :: \"msg set\"\n where\n Inj [intro]: \"X \\<in> H \\<Longrightarrow> X \\<in> parts H\"\n | Fst: \"\\<lbrace>X,Y\\<rbrace> \\<in> parts H \\<Longrightarrow> X \\<in> parts H\"\n | Snd: \"\\<lbrace>X,Y\\<rbrace> \\<in> parts H \\<Longrightarrow> Y \\<in> parts H\"\n | Body: \"Crypt K X \\<in> parts H \\<Longrightarrow> X \\<in> parts H\"",
"definition keysFor :: \"msg set \\<Rightarrow> key set\" where\n \\<comment> \\<open>Keys useful to decrypt elements of a message set\\<close>\n \"keysFor H == invKey ` {K. \\<exists>X. Crypt K X \\<in> H}\"",
"inductive_set \"kerbIV_gets\" :: \"event list set\"\n where\n\n Nil: \"[] \\<in> kerbIV_gets\"\n\n | Fake: \"\\<lbrakk> evsf \\<in> kerbIV_gets; X \\<in> synth (analz (spies evsf)) \\<rbrakk>\n \\<Longrightarrow> Says Spy B X # evsf \\<in> kerbIV_gets\"\n\n | Reception: \"\\<lbrakk> evsr \\<in> kerbIV_gets; Says A B X \\<in> set evsr \\<rbrakk>\n \\<Longrightarrow> Gets B X # evsr \\<in> kerbIV_gets\"\n\n(* FROM the initiator *)\n | K1: \"\\<lbrakk> evs1 \\<in> kerbIV_gets \\<rbrakk>\n \\<Longrightarrow> Says A Kas \\<lbrace>Agent A, Agent Tgs, Number (CT evs1)\\<rbrace> # evs1\n \\<in> kerbIV_gets\"\n\n(* Adding the timestamp serves to A in K3 to check that\n she doesn't get a reply too late. This kind of timeouts are ordinary.\n If a server's reply is late, then it is likely to be fake. *)\n\n(*---------------------------------------------------------------------*)\n\n(*FROM Kas *)\n | K2: \"\\<lbrakk> evs2 \\<in> kerbIV_gets; Key authK \\<notin> used evs2; authK \\<in> symKeys;\n Gets Kas \\<lbrace>Agent A, Agent Tgs, Number T1\\<rbrace> \\<in> set evs2 \\<rbrakk>\n \\<Longrightarrow> Says Kas A\n (Crypt (shrK A) \\<lbrace>Key authK, Agent Tgs, Number (CT evs2),\n (Crypt (shrK Tgs) \\<lbrace>Agent A, Agent Tgs, Key authK,\n Number (CT evs2)\\<rbrace>)\\<rbrace>) # evs2 \\<in> kerbIV_gets\"\n(*\n The internal encryption builds the authTicket.\n The timestamp doesn't change inside the two encryptions: the external copy\n will be used by the initiator in K3; the one inside the\n authTicket by Tgs in K4.\n*)\n\n(*---------------------------------------------------------------------*)\n\n(* FROM the initiator *)\n | K3: \"\\<lbrakk> evs3 \\<in> kerbIV_gets;\n Says A Kas \\<lbrace>Agent A, Agent Tgs, Number T1\\<rbrace> \\<in> set evs3;\n Gets A (Crypt (shrK A) \\<lbrace>Key authK, Agent Tgs, Number Ta,\n authTicket\\<rbrace>) \\<in> set evs3;\n valid Ta wrt T1\n \\<rbrakk>\n \\<Longrightarrow> Says A Tgs \\<lbrace>authTicket,\n (Crypt authK \\<lbrace>Agent A, Number (CT evs3)\\<rbrace>),\n Agent B\\<rbrace> # evs3 \\<in> kerbIV_gets\"\n(*The two events amongst the premises allow A to accept only those authKeys\n that are not issued late. *)\n\n(*---------------------------------------------------------------------*)\n\n(* FROM Tgs *)\n(* Note that the last temporal check is not mentioned in the original MIT\n specification. Adding it makes many goals \"available\" to the peers. \n Theorems that exploit it have the suffix `_u', which stands for updated \n protocol.\n*)\n | K4: \"\\<lbrakk> evs4 \\<in> kerbIV_gets; Key servK \\<notin> used evs4; servK \\<in> symKeys;\n B \\<noteq> Tgs; authK \\<in> symKeys;\n Gets Tgs \\<lbrace>\n (Crypt (shrK Tgs) \\<lbrace>Agent A, Agent Tgs, Key authK,\n Number Ta\\<rbrace>),\n (Crypt authK \\<lbrace>Agent A, Number T2\\<rbrace>), Agent B\\<rbrace>\n \\<in> set evs4;\n \\<not> expiredAK Ta evs4;\n \\<not> expiredA T2 evs4;\n servKlife + (CT evs4) \\<le> authKlife + Ta\n \\<rbrakk>\n \\<Longrightarrow> Says Tgs A\n (Crypt authK \\<lbrace>Key servK, Agent B, Number (CT evs4),\n Crypt (shrK B) \\<lbrace>Agent A, Agent B, Key servK,\n Number (CT evs4)\\<rbrace> \\<rbrace>)\n # evs4 \\<in> kerbIV_gets\"\n(* Tgs creates a new session key per each request for a service, without\n checking if there is still a fresh one for that service.\n The cipher under Tgs' key is the authTicket, the cipher under B's key\n is the servTicket, which is built now.\n NOTE that the last temporal check is not present in the MIT specification.\n\n*)\n\n(*---------------------------------------------------------------------*)\n\n(* FROM the initiator *)\n | K5: \"\\<lbrakk> evs5 \\<in> kerbIV_gets; authK \\<in> symKeys; servK \\<in> symKeys;\n Says A Tgs\n \\<lbrace>authTicket, Crypt authK \\<lbrace>Agent A, Number T2\\<rbrace>,\n Agent B\\<rbrace>\n \\<in> set evs5;\n Gets A\n (Crypt authK \\<lbrace>Key servK, Agent B, Number Ts, servTicket\\<rbrace>)\n \\<in> set evs5;\n valid Ts wrt T2 \\<rbrakk>\n \\<Longrightarrow> Says A B \\<lbrace>servTicket,\n Crypt servK \\<lbrace>Agent A, Number (CT evs5)\\<rbrace> \\<rbrace>\n # evs5 \\<in> kerbIV_gets\"\n(* Checks similar to those in K3. *)\n\n(*---------------------------------------------------------------------*)\n\n(* FROM the responder*)\n | K6: \"\\<lbrakk> evs6 \\<in> kerbIV_gets;\n Gets B \\<lbrace>\n (Crypt (shrK B) \\<lbrace>Agent A, Agent B, Key servK, Number Ts\\<rbrace>),\n (Crypt servK \\<lbrace>Agent A, Number T3\\<rbrace>)\\<rbrace>\n \\<in> set evs6;\n \\<not> expiredSK Ts evs6;\n \\<not> expiredA T3 evs6\n \\<rbrakk>\n \\<Longrightarrow> Says B A (Crypt servK (Number T3))\n # evs6 \\<in> kerbIV_gets\"\n(* Checks similar to those in K4. *)\n\n(*---------------------------------------------------------------------*)\n\n(* Leaking an authK... *)\n | Oops1: \"\\<lbrakk> evsO1 \\<in> kerbIV_gets; A \\<noteq> Spy;\n Says Kas A\n (Crypt (shrK A) \\<lbrace>Key authK, Agent Tgs, Number Ta,\n authTicket\\<rbrace>) \\<in> set evsO1;\n expiredAK Ta evsO1 \\<rbrakk>\n \\<Longrightarrow> Says A Spy \\<lbrace>Agent A, Agent Tgs, Number Ta, Key authK\\<rbrace>\n # evsO1 \\<in> kerbIV_gets\"\n\n(*---------------------------------------------------------------------*)\n\n(*Leaking a servK... *)\n | Oops2: \"\\<lbrakk> evsO2 \\<in> kerbIV_gets; A \\<noteq> Spy;\n Says Tgs A\n (Crypt authK \\<lbrace>Key servK, Agent B, Number Ts, servTicket\\<rbrace>)\n \\<in> set evsO2;\n expiredSK Ts evsO2 \\<rbrakk>\n \\<Longrightarrow> Says A Spy \\<lbrace>Agent A, Agent B, Number Ts, Key servK\\<rbrace>\n # evsO2 \\<in> kerbIV_gets\"",
"definition symKeys :: \"key set\" where\n \"symKeys == {K. invKey K = K}\"",
"primrec used :: \"event list \\<Rightarrow> msg set\"\nwhere\n used_Nil: \"used [] = (UN B. parts (initState B))\"\n| used_Cons: \"used (ev # evs) =\n (case ev of\n Says A B X \\<Rightarrow> parts {X} \\<union> used evs\n | Gets A X \\<Rightarrow> used evs\n | Notes A X \\<Rightarrow> parts {X} \\<union> used evs)\"\n \\<comment> \\<open>The case for \\<^term>\\<open>Gets\\<close> seems anomalous, but \\<^term>\\<open>Gets\\<close> always\n follows \\<^term>\\<open>Says\\<close> in real protocols. Seems difficult to change.\n See \\<open>Gets_correct\\<close> in theory \\<open>Guard/Extensions.thy\\<close>.\\<close>",
"datatype\n msg = Agent agent \\<comment> \\<open>Agent names\\<close>\n | Number nat \\<comment> \\<open>Ordinary integers, timestamps, ...\\<close>\n | Nonce nat \\<comment> \\<open>Unguessable nonces\\<close>\n | Key key \\<comment> \\<open>Crypto keys\\<close>\n | Hash msg \\<comment> \\<open>Hashing\\<close>\n | MPair msg msg \\<comment> \\<open>Compound messages\\<close>\n | Crypt key msg \\<comment> \\<open>Encryption, public- or shared-key\\<close>",
"abbreviation not_member\n where \"not_member x A \\<equiv> \\<not> (x \\<in> A)\" \\<comment> \\<open>non-membership\\<close>"
] |
###lemma
Key ?K \<notin> used ?evs \<Longrightarrow> ?K \<in> symKeys \<Longrightarrow> ?evs \<in> kerbIV_gets \<Longrightarrow> ?K \<notin> keysFor (parts (knows Spy ?evs))
|
###output
\<lbrakk>?H1 (?H2 x_1) (?H3 x_2); x_1 \<in> ?H4; x_2 \<in> ?H5\<rbrakk> \<Longrightarrow> ?H6 x_1 (?H7 (?H8 (?H9 ?H10 x_2)))
###end
|
Nat-Interval-Logic/IL_IntervalOperators
|
IL_IntervalOperators.i_set0_cut_greater_closed
| null |
?I \<in> i_set0 \<Longrightarrow> ?I \<down>> ?t \<in> i_set0
|
x_1 \<in> ?H1 \<Longrightarrow> ?H2 x_1 x_2 \<in> ?H1
|
[
"SetIntervalCut.cut_greater",
"IL_IntervalOperators.i_set0"
] |
[
"definition i_set0 :: \"(nat set) set\"\n where \"i_set0 \\<equiv> insert {} i_set\""
] |
###lemma
?I \<in> i_set0 \<Longrightarrow> ?I \<down>> ?t \<in> i_set0
|
###output
x_1 \<in> ?H1 \<Longrightarrow> ?H2 x_1 x_2 \<in> ?H1
###end
|
Multirelations_Heterogeneous/Multirelations
|
Multirelations_Basics.x_c_nc_split
| null |
?R \<inter> NC * NC \<union> (?R * {} \<union>\<union> NC) = ?R * 1\<^sub>\<union>\<^sub>\<union> \<union>\<union> NC
|
?H1 (?H2 (?H3 x_1 ?H4) ?H5) (?H6 (?H2 x_1 ?H7) ?H8) = ?H6 (?H2 x_1 ?H9) ?H8
|
[
"Multirelations.iu_unit",
"Set.empty",
"Multirelations.inner_union",
"Multirelations_Basics.NC",
"Set.inter",
"Multirelations_Basics.s_prod",
"Set.union"
] |
[
"abbreviation \"iu_unit\" (\"1\\<^sub>\\<union>\\<^sub>\\<union>\")\n where \"1\\<^sub>\\<union>\\<^sub>\\<union> \\<equiv> p_id\"",
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"abbreviation \"inner_union\" (infixl \"\\<union>\\<union>\" 65)\n where \"inner_union \\<equiv> p_prod\"",
"abbreviation \"NC \\<equiv> U - 1\\<^sub>\\<pi>\"",
"abbreviation inter :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> 'a set\" (infixl \"\\<inter>\" 70)\n where \"(\\<inter>) \\<equiv> inf\"",
"definition s_prod :: \"('a,'b) mrel \\<Rightarrow> ('b,'c) mrel \\<Rightarrow> ('a,'c) mrel\" (infixl \"\\<cdot>\" 75) where\n \"R \\<cdot> S = {(a,A). (\\<exists>B. (a,B) \\<in> R \\<and> (\\<exists>f. (\\<forall>b \\<in> B. (b,f b) \\<in> S) \\<and> A = \\<Union>(f ` B)))}\"",
"abbreviation union :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> 'a set\" (infixl \"\\<union>\" 65)\n where \"union \\<equiv> sup\""
] |
###lemma
?R \<inter> NC * NC \<union> (?R * {} \<union>\<union> NC) = ?R * 1\<^sub>\<union>\<^sub>\<union> \<union>\<union> NC
|
###output
?H1 (?H2 (?H3 x_1 ?H4) ?H5) (?H6 (?H2 x_1 ?H7) ?H8) = ?H6 (?H2 x_1 ?H9) ?H8
###end
|
CRYSTALS-Kyber/Mod_Ring_Numeral
|
Mod_Ring_Numeral.numeral_eq_one_mod_ring_iff
|
lemma numeral_eq_one_mod_ring_iff [simp]:
"numeral a = (1 :: 'a :: nontriv mod_ring) \<longleftrightarrow> (numeral a mod CARD('a)) = (1 mod CARD('a))"
|
(numeral ?a = 1) = (numeral ?a mod CARD(?'a) = 1 mod CARD(?'a))
|
(?H1 x_1 = ?H2) = (?H3 (?H4 x_1) (?H5 ?H6) = ?H3 ?H7 (?H5 ?H6))
|
[
"Set.UNIV",
"Finite_Set.card",
"Rings.modulo_class.modulo",
"Groups.one_class.one",
"Num.numeral_class.numeral"
] |
[
"abbreviation UNIV :: \"'a set\"\n where \"UNIV \\<equiv> top\"",
"class modulo = dvd + divide +\n fixes modulo :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"mod\" 70)",
"class one =\n fixes one :: 'a (\"1\")",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\""
] |
###lemma
(numeral ?a = 1) = (numeral ?a mod CARD(?'a) = 1 mod CARD(?'a))
|
###output
(?H1 x_1 = ?H2) = (?H3 (?H4 x_1) (?H5 ?H6) = ?H3 ?H7 (?H5 ?H6))
###end
|
Probability/Convolution
|
Convolution.convolution_emeasure_3
|
lemma convolution_emeasure_3:
assumes [simp, measurable]: "A \<in> sets borel"
assumes [simp]: "finite_measure M" "finite_measure N" "finite_measure L"
assumes [simp]: "sets N = sets borel" "sets M = sets borel" "sets L = sets borel"
shows "emeasure (L \<star> (M \<star> N )) A = \<integral>\<^sup>+x. \<integral>\<^sup>+y. \<integral>\<^sup>+z. indicator A (x + y + z) \<partial>N \<partial>M \<partial>L"
|
?A \<in> sets borel \<Longrightarrow> finite_measure ?M \<Longrightarrow> finite_measure ?N \<Longrightarrow> finite_measure ?L \<Longrightarrow> sets ?N = sets borel \<Longrightarrow> sets ?M = sets borel \<Longrightarrow> sets ?L = sets borel \<Longrightarrow> emeasure (?L \<star> (?M \<star> ?N)) ?A = \<integral>\<^sup>+ x. \<integral>\<^sup>+ y. \<integral>\<^sup>+ z. indicator ?A (x + y + z) \<partial>?N \<partial>?M \<partial>?L
|
\<lbrakk>x_1 \<in> ?H1 ?H2; ?H3 x_2; ?H3 x_3; ?H3 x_4; ?H1 x_3 = ?H1 ?H2; ?H1 x_2 = ?H1 ?H2; ?H1 x_4 = ?H1 ?H2\<rbrakk> \<Longrightarrow> ?H4 (?H5 x_4 (?H5 x_2 x_3)) x_1 = ?H6 x_4 (\<lambda>y_0. ?H6 x_2 (\<lambda>y_1. ?H6 x_3 (\<lambda>y_2. ?H7 x_1 (?H8 (?H8 y_0 y_1) y_2))))
|
[
"Groups.plus_class.plus",
"Indicator_Function.indicator",
"Nonnegative_Lebesgue_Integration.nn_integral",
"Convolution.convolution",
"Sigma_Algebra.emeasure",
"Measure_Space.finite_measure",
"Borel_Space.topological_space_class.borel",
"Sigma_Algebra.sets"
] |
[
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)",
"definition \"indicator S x = of_bool (x \\<in> S)\"",
"definition convolution :: \"('a :: ordered_euclidean_space) measure \\<Rightarrow> 'a measure \\<Rightarrow> 'a measure\" (infix \"\\<star>\" 50) where\n \"convolution M N = distr (M \\<Otimes>\\<^sub>M N) borel (\\<lambda>(x, y). x + y)\""
] |
###lemma
?A \<in> sets borel \<Longrightarrow> finite_measure ?M \<Longrightarrow> finite_measure ?N \<Longrightarrow> finite_measure ?L \<Longrightarrow> sets ?N = sets borel \<Longrightarrow> sets ?M = sets borel \<Longrightarrow> sets ?L = sets borel \<Longrightarrow> emeasure (?L \<star> (?M \<star> ?N)) ?A = \<integral>\<^sup>+ x. \<integral>\<^sup>+ y. \<integral>\<^sup>+ z. indicator ?A (x + y + z) \<partial>?N \<partial>?M \<partial>?L
|
###output
\<lbrakk>x_1 \<in> ?H1 ?H2; ?H3 x_2; ?H3 x_3; ?H3 x_4; ?H1 x_3 = ?H1 ?H2; ?H1 x_2 = ?H1 ?H2; ?H1 x_4 = ?H1 ?H2\<rbrakk> \<Longrightarrow> ?H4 (?H5 x_4 (?H5 x_2 x_3)) x_1 = ?H6 x_4 (\<lambda>y_0. ?H6 x_2 (\<lambda>y_1. ?H6 x_3 (\<lambda>y_2. ?H7 x_1 (?H8 (?H8 y_0 y_1) y_2))))
###end
|
Stateful_Protocol_Composition_and_Typing/More_Unification
|
More_Unification.subst_eq_if_eq_vars
|
lemma subst_eq_if_eq_vars: "(\<And>v. (Var v) \<cdot> \<theta> = (Var v) \<cdot> \<sigma>) \<Longrightarrow> \<theta> = \<sigma>"
|
(\<And>v. Var v \<cdot> ?\<theta> = Var v \<cdot> ?\<sigma>) \<Longrightarrow> ?\<theta> = ?\<sigma>
|
(\<And>y_0. ?H1 (?H2 y_0) x_1 = ?H1 (?H2 y_0) x_2) \<Longrightarrow> x_1 = x_2
|
[
"Term.term.Var",
"Term.subst_apply_term"
] |
[
"type_synonym \"term\" = \"(expr+stmt,var,expr list) sum3\"",
"abbreviation subst_apply_term :: \"('f, 'v) term \\<Rightarrow> ('f, 'v, 'w) gsubst \\<Rightarrow> ('f, 'w) term\" (infixl \"\\<cdot>\" 67)\n where \"subst_apply_term \\<equiv> eval_term Fun\""
] |
###lemma
(\<And>v. Var v \<cdot> ?\<theta> = Var v \<cdot> ?\<sigma>) \<Longrightarrow> ?\<theta> = ?\<sigma>
|
###output
(\<And>y_0. ?H1 (?H2 y_0) x_1 = ?H1 (?H2 y_0) x_2) \<Longrightarrow> x_1 = x_2
###end
|
LLL_Basis_Reduction/More_IArray
|
More_IArray.iarray_update_length
|
lemma iarray_update_length[simp]: "IArray.length (iarray_update a i x) = IArray.length a"
|
IArray.length (iarray_update ?a ?i ?x) = IArray.length ?a
|
?H1 (?H2 x_1 x_2 x_3) = ?H1 x_1
|
[
"More_IArray.iarray_update",
"IArray.length"
] |
[
"definition iarray_update :: \"'a iarray \\<Rightarrow> nat \\<Rightarrow> 'a \\<Rightarrow> 'a iarray\" where\n \"iarray_update a i x = IArray.of_fun (\\<lambda> j. if j = i then x else a !! j) (IArray.length a)\"",
"definition length :: \"'a iarray \\<Rightarrow> nat\" where\n[simp]: \"length as = List.length (IArray.list_of as)\""
] |
###lemma
IArray.length (iarray_update ?a ?i ?x) = IArray.length ?a
|
###output
?H1 (?H2 x_1 x_2 x_3) = ?H1 x_1
###end
|
Kruskal/Kruskal
|
Kruskal_Misc.card2_get2
| null |
card ?x = 2 \<Longrightarrow> (\<And>a b. ?x = {a, b} \<Longrightarrow> a \<noteq> b \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
\<lbrakk>?H1 x_1 = ?H2 (?H3 ?H4); \<And>y_0 y_1. \<lbrakk>x_1 = ?H5 y_0 (?H5 y_1 ?H6); y_0 \<noteq> y_1\<rbrakk> \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
|
[
"Set.empty",
"Set.insert",
"Num.num.One",
"Num.num.Bit0",
"Num.numeral_class.numeral",
"Finite_Set.card"
] |
[
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"definition insert :: \"'a \\<Rightarrow> 'a set \\<Rightarrow> 'a set\"\n where insert_compr: \"insert a B = {x. x = a \\<or> x \\<in> B}\"",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\""
] |
###lemma
card ?x = 2 \<Longrightarrow> (\<And>a b. ?x = {a, b} \<Longrightarrow> a \<noteq> b \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
###output
\<lbrakk>?H1 x_1 = ?H2 (?H3 ?H4); \<And>y_0 y_1. \<lbrakk>x_1 = ?H5 y_0 (?H5 y_1 ?H6); y_0 \<noteq> y_1\<rbrakk> \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
###end
|
Universal_Turing_Machine/Abacus
|
Abacus.dec_on_right_moving_Oc_move
|
lemma dec_on_right_moving_Oc_move[simp]: "dec_on_right_moving (as, am) (s, l, Oc # r) ires
\<Longrightarrow> dec_on_right_moving (as, am) (s', Oc # l, r) ires"
|
dec_on_right_moving (?as, ?am) (?s, ?l, Oc # ?r) ?ires \<Longrightarrow> dec_on_right_moving (?as, ?am) (?s', Oc # ?l, ?r) ?ires
|
?H1 (x_1, x_2) (x_3, x_4, ?H2 ?H3 x_5) x_6 \<Longrightarrow> ?H1 (x_1, x_2) (x_7, ?H2 ?H3 x_4, x_5) x_6
|
[
"Turing.cell.Oc",
"List.list.Cons",
"Abacus.dec_on_right_moving"
] |
[
"datatype cell = Bk | Oc",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"fun dec_on_right_moving :: \"dec_inv_t\"\n where\n \"dec_on_right_moving (as, lm) (s, l, r) ires = \n (\\<exists> lm1 lm2 m ml mr rn. lm = lm1 @ [m] @ lm2 \\<and> \n ml + mr = Suc (Suc m) \\<and>\n (if lm1 = [] then l = Oc\\<up>ml@ Bk # Bk # ires\n else l = Oc\\<up>ml @ [Bk] @ <rev lm1> @ Bk # Bk # ires) \\<and> \n ((r = Oc\\<up>mr @ [Bk] @ <lm2> @ Bk\\<up>rn) \\<or> (r = Oc\\<up>mr \\<and> lm2 = [])))\""
] |
###lemma
dec_on_right_moving (?as, ?am) (?s, ?l, Oc # ?r) ?ires \<Longrightarrow> dec_on_right_moving (?as, ?am) (?s', Oc # ?l, ?r) ?ires
|
###output
?H1 (x_1, x_2) (x_3, x_4, ?H2 ?H3 x_5) x_6 \<Longrightarrow> ?H1 (x_1, x_2) (x_7, ?H2 ?H3 x_4, x_5) x_6
###end
|
Library/Liminf_Limsup
|
Liminf_Limsup.Liminf_le_Limsup
|
lemma Liminf_le_Limsup:
assumes ntriv: "\<not> trivial_limit F"
shows "Liminf F f \<le> Limsup F f"
|
?F \<noteq> bot \<Longrightarrow> Liminf ?F ?f \<le> Limsup ?F ?f
|
x_1 \<noteq> ?H1 \<Longrightarrow> ?H2 x_1 x_2 \<le> ?H3 x_1 x_2
|
[
"Liminf_Limsup.Limsup",
"Liminf_Limsup.Liminf",
"Orderings.bot_class.bot"
] |
[
"definition Limsup :: \"'a filter \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> 'b :: complete_lattice\" where\n \"Limsup F f = (INF P\\<in>{P. eventually P F}. SUP x\\<in>{x. P x}. f x)\"",
"definition Liminf :: \"'a filter \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> 'b :: complete_lattice\" where\n \"Liminf F f = (SUP P\\<in>{P. eventually P F}. INF x\\<in>{x. P x}. f x)\"",
"class bot =\n fixes bot :: 'a (\"\\<bottom>\")"
] |
###lemma
?F \<noteq> bot \<Longrightarrow> Liminf ?F ?f \<le> Limsup ?F ?f
|
###output
x_1 \<noteq> ?H1 \<Longrightarrow> ?H2 x_1 x_2 \<le> ?H3 x_1 x_2
###end
|
BTree/BTree_Height
|
BTree_Height.lower_bound_sharp
|
lemma lower_bound_sharp:
"k > 0 \<Longrightarrow> t = slim_tree k a h \<Longrightarrow> height t = h \<and> root_order k t \<and> bal t \<and> nodes t * k = 2*((k+1)^(height t - 1) - 1) + (of_bool (t \<noteq> Leaf))*k"
|
0 < ?k \<Longrightarrow> ?t = slim_tree ?k ?a ?h \<Longrightarrow> height ?t = ?h \<and> root_order ?k ?t \<and> bal ?t \<and> nodes ?t * ?k = 2 * bound ?k (height ?t - 1) + of_bool (?t \<noteq> Leaf) * ?k
|
\<lbrakk>?H1 < x_1; x_2 = ?H2 x_1 x_3 x_4\<rbrakk> \<Longrightarrow> ?H3 x_2 = x_4 \<and> ?H4 x_1 x_2 \<and> ?H5 x_2 \<and> ?H6 (?H7 x_2) x_1 = ?H8 (?H6 (?H9 (?H10 ?H11)) (?H12 x_1 (?H13 (?H3 x_2) ?H14))) (?H6 (?H15 (x_2 \<noteq> ?H16)) x_1)
|
[
"BTree.btree.Leaf",
"Rings.zero_neq_one_class.of_bool",
"Groups.one_class.one",
"Groups.minus_class.minus",
"BTree_Height.bound",
"Num.num.One",
"Num.num.Bit0",
"Num.numeral_class.numeral",
"Groups.plus_class.plus",
"BTree_Height.nodes",
"Groups.times_class.times",
"BTree.bal",
"BTree.root_order",
"BTree.height_class.height",
"BTree_Height.slim_tree",
"Groups.zero_class.zero"
] |
[
"datatype 'a btree = Leaf | Node \"('a btree * 'a) list\" \"'a btree\"",
"class zero_neq_one = zero + one +\n assumes zero_neq_one [simp]: \"0 \\<noteq> 1\"\nbegin",
"class one =\n fixes one :: 'a (\"1\")",
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)",
"abbreviation \"bound k h \\<equiv> ((k+1)^h - 1)\"",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\"",
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)",
"fun nodes::\"'a btree \\<Rightarrow> nat\" where\n \"nodes Leaf = 0\" |\n \"nodes (Node ts t) = 1 + (\\<Sum>t\\<leftarrow>subtrees ts. nodes t) + (nodes t)\"",
"class times =\n fixes times :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"*\" 70)",
"fun bal:: \"'a btree \\<Rightarrow> bool\" where\n \"bal Leaf = True\" |\n \"bal (Node ts t) = (\n (\\<forall>sub \\<in> set (subtrees ts). height sub = height t) \\<and>\n (\\<forall>sub \\<in> set (subtrees ts). bal sub) \\<and> bal t\n )\"",
"fun root_order:: \"nat \\<Rightarrow> 'a btree \\<Rightarrow> bool\" where\n \"root_order k Leaf = True\" |\n \"root_order k (Node ts t) = (\n (length ts > 0) \\<and>\n (length ts \\<le> 2*k) \\<and>\n (\\<forall>s \\<in> set (subtrees ts). order k s) \\<and> order k t\n)\"",
"class height =\n fixes height :: \"'a \\<Rightarrow> nat\"",
"fun slim_tree where\n \"slim_tree k c 0 = Leaf\" |\n \"slim_tree k c (Suc h) = Node [(slim_node k c h, c)] (slim_node k c h)\"",
"class zero =\n fixes zero :: 'a (\"0\")"
] |
###lemma
0 < ?k \<Longrightarrow> ?t = slim_tree ?k ?a ?h \<Longrightarrow> height ?t = ?h \<and> root_order ?k ?t \<and> bal ?t \<and> nodes ?t * ?k = 2 * bound ?k (height ?t - 1) + of_bool (?t \<noteq> Leaf) * ?k
|
###output
\<lbrakk>?H1 < x_1; x_2 = ?H2 x_1 x_3 x_4\<rbrakk> \<Longrightarrow> ?H3 x_2 = x_4 \<and> ?H4 x_1 x_2 \<and> ?H5 x_2 \<and> ?H6 (?H7 x_2) x_1 = ?H8 (?H6 (?H9 (?H10 ?H11)) (?H12 x_1 (?H13 (?H3 x_2) ?H14))) (?H6 (?H15 (x_2 \<noteq> ?H16)) x_1)
###end
|
CryptHOL/GPV_Expectation
|
GPV_Expectation.mcont_times_ennreal2
|
lemma mcont_times_ennreal2: "mcont Sup (\<le>) Sup (\<le>) (\<lambda>y. y * x :: ennreal)"
|
mcont Sup (\<le>) Sup (\<le>) (\<lambda>y. y * ?x)
|
?H1 ?H2 (\<le>) ?H2 (\<le>) (\<lambda>y_0. ?H3 y_0 x_1)
|
[
"Groups.times_class.times",
"Complete_Lattices.Sup_class.Sup",
"Complete_Partial_Order2.mcont"
] |
[
"class times =\n fixes times :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"*\" 70)",
"class Sup =\n fixes Sup :: \"'a set \\<Rightarrow> 'a\" (\"\\<Squnion> _\" [900] 900)",
"definition mcont :: \"('a set \\<Rightarrow> 'a) \\<Rightarrow> ('a \\<Rightarrow> 'a \\<Rightarrow> bool) \\<Rightarrow> ('b set \\<Rightarrow> 'b) \\<Rightarrow> ('b \\<Rightarrow> 'b \\<Rightarrow> bool) \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> bool\"\nwhere\n \"mcont luba orda lubb ordb f \\<longleftrightarrow>\n monotone orda ordb f \\<and> cont luba orda lubb ordb f\""
] |
###lemma
mcont Sup (\<le>) Sup (\<le>) (\<lambda>y. y * ?x)
|
###output
?H1 ?H2 (\<le>) ?H2 (\<le>) (\<lambda>y_0. ?H3 y_0 x_1)
###end
|
Archimedean_Field
|
Archimedean_Field.frac_ge_0
|
lemma frac_ge_0 [simp]: "frac x \<ge> 0"
|
(0::?'a) \<le> frac ?x
|
?H1 \<le> ?H2 x_1
|
[
"Archimedean_Field.frac",
"Groups.zero_class.zero"
] |
[
"definition frac :: \"'a \\<Rightarrow> 'a::floor_ceiling\"\n where \"frac x \\<equiv> x - of_int \\<lfloor>x\\<rfloor>\"",
"class zero =\n fixes zero :: 'a (\"0\")"
] |
###lemma
(0::?'a) \<le> frac ?x
|
###output
?H1 \<le> ?H2 x_1
###end
|
CryptHOL/Negligible
|
Negligible.negligibleD_real
|
lemma negligibleD_real:
assumes "negligible f"
shows "f \<in> o(\<lambda>x. inverse (x powr c))"
|
negligible ?f \<Longrightarrow> ?f \<in> o(\<lambda>x. inverse (real x powr ?c))
|
?H1 x_1 \<Longrightarrow> x_1 \<in> ?H2 (\<lambda>y_0. ?H3 (?H4 (?H5 y_0) x_2))
|
[
"Real.real",
"Transcendental.powr",
"Fields.inverse_class.inverse",
"Landau_Symbols.smallo_at_top",
"Negligible.negligible"
] |
[
"abbreviation real :: \"nat \\<Rightarrow> real\"\n where \"real \\<equiv> of_nat\"",
"definition powr :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a::ln\" (infixr \"powr\" 80)\n \\<comment> \\<open>exponentation via ln and exp\\<close>\n where \"x powr a \\<equiv> if x = 0 then 0 else exp (a * ln x)\"",
"class inverse = divide +\n fixes inverse :: \"'a \\<Rightarrow> 'a\"\nbegin",
"abbreviation smallo_at_top (\\<open>(2o'(_'))\\<close>) where\n \"o(g) \\<equiv> smallo at_top g\"",
"definition negligible :: \"(nat \\<Rightarrow> real) \\<Rightarrow> bool\" (* TODO: generalise types? *)\nwhere \"negligible f \\<longleftrightarrow> (\\<forall>c>0. f \\<in> o(\\<lambda>x. inverse (x powr c)))\""
] |
###lemma
negligible ?f \<Longrightarrow> ?f \<in> o(\<lambda>x. inverse (real x powr ?c))
|
###output
?H1 x_1 \<Longrightarrow> x_1 \<in> ?H2 (\<lambda>y_0. ?H3 (?H4 (?H5 y_0) x_2))
###end
|
Separation_Logic_Imperative_HOL/Assertions
|
Assertions.entt_disjI2'
|
lemma entt_disjI2': "A\<Longrightarrow>\<^sub>tC \<Longrightarrow> A\<Longrightarrow>\<^sub>tB\<or>\<^sub>AC"
|
?A \<Longrightarrow>\<^sub>t ?C \<Longrightarrow> ?A \<Longrightarrow>\<^sub>t ?B \<or>\<^sub>A ?C
|
?H1 x_1 x_2 \<Longrightarrow> ?H1 x_1 (?H2 x_3 x_2)
|
[
"Assertions.sup_assn",
"Assertions.entailst"
] |
[
"abbreviation sup_assn::\"assn\\<Rightarrow>assn\\<Rightarrow>assn\" (infixr \"\\<or>\\<^sub>A\" 61) \n where \"sup_assn \\<equiv> sup\"",
"definition entailst :: \"assn \\<Rightarrow> assn \\<Rightarrow> bool\" (infix \"\\<Longrightarrow>\\<^sub>t\" 10)\n where \"entailst A B \\<equiv> A \\<Longrightarrow>\\<^sub>A B * True\""
] |
###lemma
?A \<Longrightarrow>\<^sub>t ?C \<Longrightarrow> ?A \<Longrightarrow>\<^sub>t ?B \<or>\<^sub>A ?C
|
###output
?H1 x_1 x_2 \<Longrightarrow> ?H1 x_1 (?H2 x_3 x_2)
###end
|
Transcendental
|
Transcendental.tanh_real_lt_1
|
lemma tanh_real_lt_1: "tanh (x :: real) < 1"
|
tanh ?x < 1
|
?H1 x_1 < ?H2
|
[
"Groups.one_class.one",
"Transcendental.tanh"
] |
[
"class one =\n fixes one :: 'a (\"1\")",
"definition tanh :: \"'a :: {banach, real_normed_field} \\<Rightarrow> 'a\" where\n \"tanh x = sinh x / cosh x\""
] |
###lemma
tanh ?x < 1
|
###output
?H1 x_1 < ?H2
###end
|
Clean/src/Symbex_MonadSE
|
Symbex_MonadSE.mbindFSave_vs_mbindFStop
|
lemma mbindFSave_vs_mbindFStop :
"(\<sigma> \<Turnstile> (os \<leftarrow> (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>a\<^sub>v\<^sub>e \<iota>s ioprog); result(length \<iota>s = length os \<and> P \<iota>s os))) =
(\<sigma> \<Turnstile> (os \<leftarrow> (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>t\<^sub>o\<^sub>p \<iota>s ioprog); result(P \<iota>s os)))"
|
(?\<sigma> \<Turnstile> _bind_SE os (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>a\<^sub>v\<^sub>e ?\<iota>s ?ioprog) (unit\<^sub>S\<^sub>E (length ?\<iota>s = length os \<and> ?P ?\<iota>s os))) = (?\<sigma> \<Turnstile> _bind_SE os (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>t\<^sub>o\<^sub>p ?\<iota>s ?ioprog) (unit\<^sub>S\<^sub>E (?P ?\<iota>s os)))
|
?H1 x_1 (?H2 (?H3 x_2 x_3) (\<lambda>y_0. ?H4 (?H5 x_2 = ?H6 y_0 \<and> x_4 x_2 y_0))) = ?H1 x_1 (?H2 (?H7 x_2 x_3) (\<lambda>y_1. ?H4 (x_4 x_2 y_1)))
|
[
"Seq_MonadSE.mbind'",
"List.length",
"MonadSE.unit_SE",
"Seq_MonadSE.mbind",
"MonadSE.bind_SE",
"Symbex_MonadSE.valid_SE"
] |
[
"abbreviation length :: \"'a list \\<Rightarrow> nat\" where\n\"length \\<equiv> size\""
] |
###lemma
(?\<sigma> \<Turnstile> _bind_SE os (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>a\<^sub>v\<^sub>e ?\<iota>s ?ioprog) (unit\<^sub>S\<^sub>E (length ?\<iota>s = length os \<and> ?P ?\<iota>s os))) = (?\<sigma> \<Turnstile> _bind_SE os (mbind\<^sub>F\<^sub>a\<^sub>i\<^sub>l\<^sub>S\<^sub>t\<^sub>o\<^sub>p ?\<iota>s ?ioprog) (unit\<^sub>S\<^sub>E (?P ?\<iota>s os)))
|
###output
?H1 x_1 (?H2 (?H3 x_2 x_3) (\<lambda>y_0. ?H4 (?H5 x_2 = ?H6 y_0 \<and> x_4 x_2 y_0))) = ?H1 x_1 (?H2 (?H7 x_2 x_3) (\<lambda>y_1. ?H4 (x_4 x_2 y_1)))
###end
|
Group-Ring-Module/Algebra3
|
Algebra3.gbij_comp_bij
|
lemma gbij_comp_bij:"\<lbrakk>Group F; Group G; Group H; gbij\<^bsub>F,G\<^esub> f; gbij\<^bsub>G,H\<^esub> g\<rbrakk>
\<Longrightarrow> gbij\<^bsub>F,H\<^esub> (g \<circ>\<^bsub>F\<^esub> f)"
|
Group ?F \<Longrightarrow> Group ?G \<Longrightarrow> Group ?H \<Longrightarrow> gbij\<^bsub>?F,?G\<^esub> ?f \<Longrightarrow> gbij\<^bsub>?G,?H\<^esub> ?g \<Longrightarrow> gbij\<^bsub>?F,?H\<^esub> (?g \<circ>\<^bsub>?F\<^esub> ?f)
|
\<lbrakk>?H1 x_1; ?H2 x_2; ?H3 x_3; ?H4 x_1 x_2 x_4; ?H5 x_2 x_3 x_5\<rbrakk> \<Longrightarrow> ?H6 x_1 x_3 (?H7 x_5 x_1 x_4)
|
[
"Algebra2.GCOMP",
"Algebra2.gbijec",
"Algebra2.Group"
] |
[
"abbreviation\n GCOMP :: \"['b \\<Rightarrow> 'c, ('a, 'm) Group_scheme, 'a \\<Rightarrow> 'b] \\<Rightarrow> 'a \\<Rightarrow> 'c\"\n (\"(3_ \\<circ>\\<^bsub>_\\<^esub> _)\" [88, 88, 89]88) where\n \"g \\<circ>\\<^bsub>F\\<^esub> f == cmpghom F g f\"",
"definition\n gbijec :: \"[('a, 'm) Group_scheme, ('b, 'm1) Group_scheme, 'a \\<Rightarrow> 'b]\n \\<Rightarrow> bool\" (\"(3gbij\\<^bsub>_,_\\<^esub> _)\" [88,88,89]88) where\n \"gbij\\<^bsub>F,G\\<^esub> f \\<longleftrightarrow> gsurj\\<^bsub>F,G\\<^esub> f \\<and> ginj\\<^bsub>F,G\\<^esub> f\""
] |
###lemma
Group ?F \<Longrightarrow> Group ?G \<Longrightarrow> Group ?H \<Longrightarrow> gbij\<^bsub>?F,?G\<^esub> ?f \<Longrightarrow> gbij\<^bsub>?G,?H\<^esub> ?g \<Longrightarrow> gbij\<^bsub>?F,?H\<^esub> (?g \<circ>\<^bsub>?F\<^esub> ?f)
|
###output
\<lbrakk>?H1 x_1; ?H2 x_2; ?H3 x_3; ?H4 x_1 x_2 x_4; ?H5 x_2 x_3 x_5\<rbrakk> \<Longrightarrow> ?H6 x_1 x_3 (?H7 x_5 x_1 x_4)
###end
|
SuperCalc/multisets_continued
|
multisets_continued.equal_image_mset
|
lemma equal_image_mset:
assumes "\<forall>x \<in> E. (f x) = (g x)"
shows "{# (f x). x \<in># (mset_set E) #} = {# (g x). x \<in># (mset_set E) #}"
|
\<forall>x\<in>?E. ?f x = ?g x \<Longrightarrow> image_mset ?f (mset_set ?E) = image_mset ?g (mset_set ?E)
|
\<forall>y_0\<in>x_1. x_2 y_0 = x_3 y_0 \<Longrightarrow> ?H1 x_2 (?H2 x_1) = ?H1 x_3 (?H2 x_1)
|
[
"Multiset.mset_set",
"Multiset.image_mset"
] |
[
"definition image_mset :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a multiset \\<Rightarrow> 'b multiset\" where\n \"image_mset f = fold_mset (add_mset \\<circ> f) {#}\""
] |
###lemma
\<forall>x\<in>?E. ?f x = ?g x \<Longrightarrow> image_mset ?f (mset_set ?E) = image_mset ?g (mset_set ?E)
|
###output
\<forall>y_0\<in>x_1. x_2 y_0 = x_3 y_0 \<Longrightarrow> ?H1 x_2 (?H2 x_1) = ?H1 x_3 (?H2 x_1)
###end
|
Cook_Levin/Elementary
|
Elementary.config_update_fwd_0
|
lemma config_update_fwd_0: "config_update_fwd cfg j 0 = cfg"
|
config_update_fwd ?cfg ?j 0 = ?cfg
|
?H1 x_1 x_2 ?H2 = x_1
|
[
"Groups.zero_class.zero",
"Elementary.config_update_fwd"
] |
[
"class zero =\n fixes zero :: 'a (\"0\")",
"definition config_update_fwd :: \"config \\<Rightarrow> nat \\<Rightarrow> nat \\<Rightarrow> config\" where\n \"config_update_fwd cfg j d \\<equiv> (fst cfg, (snd cfg)[j:=(cfg <:> j, cfg <#> j + d)])\""
] |
###lemma
config_update_fwd ?cfg ?j 0 = ?cfg
|
###output
?H1 x_1 x_2 ?H2 = x_1
###end
|
Analysis/Infinite_Products
|
Infinite_Products.has_prod_mult
|
lemma has_prod_mult:
assumes f: "f has_prod a" and g: "g has_prod b"
shows "(\<lambda>n. f n * g n) has_prod (a * b)"
|
?f has_prod ?a \<Longrightarrow> ?g has_prod ?b \<Longrightarrow> (\<lambda>n. ?f n * ?g n) has_prod (?a * ?b)
|
\<lbrakk>?H1 x_1 x_2; ?H1 x_3 x_4\<rbrakk> \<Longrightarrow> ?H1 (\<lambda>y_0. ?H2 (x_1 y_0) (x_3 y_0)) (?H2 x_2 x_4)
|
[
"Groups.times_class.times",
"Infinite_Products.has_prod"
] |
[
"class times =\n fixes times :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"*\" 70)"
] |
###lemma
?f has_prod ?a \<Longrightarrow> ?g has_prod ?b \<Longrightarrow> (\<lambda>n. ?f n * ?g n) has_prod (?a * ?b)
|
###output
\<lbrakk>?H1 x_1 x_2; ?H1 x_3 x_4\<rbrakk> \<Longrightarrow> ?H1 (\<lambda>y_0. ?H2 (x_1 y_0) (x_3 y_0)) (?H2 x_2 x_4)
###end
|
Matrix_LP/Matrix
|
Matrix.ncols_le
|
lemma ncols_le: "(ncols A <= n) = (\<forall>j i. n <= i \<longrightarrow> (Rep_matrix A j i) = 0)" (is "_ = ?st")
|
(ncols ?A \<le> ?n) = (\<forall>j i. ?n \<le> i \<longrightarrow> Rep_matrix ?A j i = (0::?'a))
|
(?H1 x_1 \<le> x_2) = (\<forall>y_0 y_1. x_2 \<le> y_1 \<longrightarrow> ?H2 x_1 y_0 y_1 = ?H3)
|
[
"Groups.zero_class.zero",
"Matrix.matrix.Rep_matrix",
"Matrix.ncols"
] |
[
"class zero =\n fixes zero :: 'a (\"0\")",
"definition \"matrix = {(f::(nat \\<Rightarrow> nat \\<Rightarrow> 'a::zero)). finite (nonzero_positions f)}\"",
"definition ncols :: \"('a::zero) matrix \\<Rightarrow> nat\" where\n \"ncols A == if nonzero_positions(Rep_matrix A) = {} then 0 else Suc(Max ((image snd) (nonzero_positions (Rep_matrix A))))\""
] |
###lemma
(ncols ?A \<le> ?n) = (\<forall>j i. ?n \<le> i \<longrightarrow> Rep_matrix ?A j i = (0::?'a))
|
###output
(?H1 x_1 \<le> x_2) = (\<forall>y_0 y_1. x_2 \<le> y_1 \<longrightarrow> ?H2 x_1 y_0 y_1 = ?H3)
###end
|
Transcendental
|
Transcendental.sin_cos_eq_iff
|
lemma sin_cos_eq_iff: "sin y = sin x \<and> cos y = cos x \<longleftrightarrow> (\<exists>n::int. y = x + 2 * pi * n)" (is "?L=?R")
|
(sin ?y = sin ?x \<and> cos ?y = cos ?x) = (\<exists>x. ?y = ?x + 2 * pi * real_of_int x)
|
(?H1 x_1 = ?H1 x_2 \<and> ?H2 x_1 = ?H2 x_2) = (\<exists>y_0. x_1 = ?H3 x_2 (?H4 (?H4 (?H5 (?H6 ?H7)) ?H8) (?H9 y_0)))
|
[
"Real.real_of_int",
"Transcendental.pi",
"Num.num.One",
"Num.num.Bit0",
"Num.numeral_class.numeral",
"Groups.times_class.times",
"Groups.plus_class.plus",
"Transcendental.cos",
"Transcendental.sin"
] |
[
"abbreviation real_of_int :: \"int \\<Rightarrow> real\"\n where \"real_of_int \\<equiv> of_int\"",
"definition pi :: real\n where \"pi = 2 * (THE x. 0 \\<le> x \\<and> x \\<le> 2 \\<and> cos x = 0)\"",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\"",
"class times =\n fixes times :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"*\" 70)",
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)",
"definition cos :: \"'a \\<Rightarrow> 'a::{real_normed_algebra_1,banach}\"\n where \"cos = (\\<lambda>x. \\<Sum>n. cos_coeff n *\\<^sub>R x^n)\"",
"definition sin :: \"'a \\<Rightarrow> 'a::{real_normed_algebra_1,banach}\"\n where \"sin = (\\<lambda>x. \\<Sum>n. sin_coeff n *\\<^sub>R x^n)\""
] |
###lemma
(sin ?y = sin ?x \<and> cos ?y = cos ?x) = (\<exists>x. ?y = ?x + 2 * pi * real_of_int x)
|
###output
(?H1 x_1 = ?H1 x_2 \<and> ?H2 x_1 = ?H2 x_2) = (\<exists>y_0. x_1 = ?H3 x_2 (?H4 (?H4 (?H5 (?H6 ?H7)) ?H8) (?H9 y_0)))
###end
|
JinjaDCI/Compiler/TypeComp
|
TypeComp.wt_J2JVM
|
theorem wt_J2JVM:
"wf_J_prog P \<Longrightarrow> wf_jvm_prog (J2JVM P)"
|
wf_J_prog ?P \<Longrightarrow> wf_jvm_prog (J2JVM ?P)
|
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_1)
|
[
"Compiler.J2JVM",
"BVSpec.wf_jvm_prog",
"JWellForm.wf_J_prog"
] |
[
"definition J2JVM :: \"J_prog \\<Rightarrow> jvm_prog\"\nwhere \n \"J2JVM \\<equiv> compP\\<^sub>2 \\<circ> compP\\<^sub>1\""
] |
###lemma
wf_J_prog ?P \<Longrightarrow> wf_jvm_prog (J2JVM ?P)
|
###output
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_1)
###end
|
Simpl/HoareTotalProps
|
HoareTotalProps.MarkGuardsI_sound
|
lemma MarkGuardsI_sound:
assumes valid: "\<Gamma>,\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> P c Q,A"
shows "\<Gamma>,\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> P mark_guards f c Q,A"
|
?\<Gamma>,?\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> ?P ?c ?Q,?A \<Longrightarrow> ?\<Gamma>,?\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> ?P mark_guards ?f ?c ?Q,?A
|
?H1 x_1 x_2 ?H2 x_3 x_4 x_5 x_6 \<Longrightarrow> ?H1 x_1 x_2 ?H2 x_3 (?H3 x_7 x_4) x_5 x_6
|
[
"Language.mark_guards",
"Set.empty",
"HoareTotalDef.cvalidt"
] |
[
"primrec mark_guards:: \"'f \\<Rightarrow> ('s,'p,'g) com \\<Rightarrow> ('s,'p,'f) com\"\nwhere\n\"mark_guards f Skip = Skip\" |\n\"mark_guards f (Basic g) = Basic g\" |\n\"mark_guards f (Spec r) = Spec r\" |\n\"mark_guards f (Seq c\\<^sub>1 c\\<^sub>2) = (Seq (mark_guards f c\\<^sub>1) (mark_guards f c\\<^sub>2))\" |\n\"mark_guards f (Cond b c\\<^sub>1 c\\<^sub>2) = Cond b (mark_guards f c\\<^sub>1) (mark_guards f c\\<^sub>2)\" |\n\"mark_guards f (While b c) = While b (mark_guards f c)\" |\n\"mark_guards f (Call p) = Call p\" |\n\"mark_guards f (DynCom c) = DynCom (\\<lambda>s. (mark_guards f (c s)))\" |\n\"mark_guards f (Guard f' g c) = Guard f g (mark_guards f c)\" |\n\"mark_guards f Throw = Throw\" |\n\"mark_guards f (Catch c\\<^sub>1 c\\<^sub>2) = Catch (mark_guards f c\\<^sub>1) (mark_guards f c\\<^sub>2)\"",
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"definition\n cvalidt::\n \"[('s,'p,'f) body,('s,'p) quadruple set,'f set,\n 's assn,('s,'p,'f) com,'s assn,'s assn] \\<Rightarrow> bool\"\n (\"_,_\\<Turnstile>\\<^sub>t\\<^bsub>'/_\\<^esub>/ _ _ _,_\" [61,60, 60,1000, 20, 1000,1000] 60)\nwhere\n \"\\<Gamma>,\\<Theta>\\<Turnstile>\\<^sub>t\\<^bsub>/F\\<^esub> P c Q,A \\<equiv> (\\<forall>(P,p,Q,A)\\<in>\\<Theta>. \\<Gamma>\\<Turnstile>\\<^sub>t\\<^bsub>/F\\<^esub> P (Call p) Q,A) \\<longrightarrow> \\<Gamma> \\<Turnstile>\\<^sub>t\\<^bsub>/F\\<^esub> P c Q,A\""
] |
###lemma
?\<Gamma>,?\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> ?P ?c ?Q,?A \<Longrightarrow> ?\<Gamma>,?\<Theta>\<Turnstile>\<^sub>t\<^bsub>/{}\<^esub> ?P mark_guards ?f ?c ?Q,?A
|
###output
?H1 x_1 x_2 ?H2 x_3 x_4 x_5 x_6 \<Longrightarrow> ?H1 x_1 x_2 ?H2 x_3 (?H3 x_7 x_4) x_5 x_6
###end
|
FO_Theory_Rewriting/Util/Utils
|
Utils.swap_trancl
|
lemma swap_trancl:
"(prod.swap ` R)\<^sup>+ = prod.swap ` (R\<^sup>+)"
|
(prod.swap ` ?R)\<^sup>+ = prod.swap ` ?R\<^sup>+
|
?H1 (?H2 ?H3 x_1) = ?H2 ?H3 (?H1 x_1)
|
[
"Product_Type.prod.swap",
"Set.image",
"Transitive_Closure.trancl"
] |
[
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"definition image :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a set \\<Rightarrow> 'b set\" (infixr \"`\" 90)\n where \"f ` A = {y. \\<exists>x\\<in>A. y = f x}\"",
"inductive_set trancl :: \"('a \\<times> 'a) set \\<Rightarrow> ('a \\<times> 'a) set\" (\"(_\\<^sup>+)\" [1000] 999)\n for r :: \"('a \\<times> 'a) set\"\n where\n r_into_trancl [intro, Pure.intro]: \"(a, b) \\<in> r \\<Longrightarrow> (a, b) \\<in> r\\<^sup>+\"\n | trancl_into_trancl [Pure.intro]: \"(a, b) \\<in> r\\<^sup>+ \\<Longrightarrow> (b, c) \\<in> r \\<Longrightarrow> (a, c) \\<in> r\\<^sup>+\""
] |
###lemma
(prod.swap ` ?R)\<^sup>+ = prod.swap ` ?R\<^sup>+
|
###output
?H1 (?H2 ?H3 x_1) = ?H2 ?H3 (?H1 x_1)
###end
|
Safe_OCL/OCL_Types
|
OCL_Types.type_less_x_OclSuper_intro
|
lemma type_less_x_OclSuper_intro [intro]:
"\<tau> \<noteq> OclSuper \<Longrightarrow> \<tau> < OclSuper"
|
?\<tau> \<noteq> OclSuper \<Longrightarrow> ?\<tau> < OclSuper
|
x_1 \<noteq> ?H1 \<Longrightarrow> x_1 < ?H1
|
[
"OCL_Types.type.OclSuper"
] |
[] |
###lemma
?\<tau> \<noteq> OclSuper \<Longrightarrow> ?\<tau> < OclSuper
|
###output
x_1 \<noteq> ?H1 \<Longrightarrow> x_1 < ?H1
###end
|
Predicate_Compile_Examples/Specialisation_Examples
|
Specialisation_Examples.mapBP_FioB_i_oI
| null |
mapBP ?x1.0 ?xa ?xb \<Longrightarrow> (\<lambda>xa. pred.eval (?x xa)) = ?x1.0 \<Longrightarrow> pred.eval (mapBP_FioB_i_o ?x ?xa) ?xb
|
\<lbrakk>?H1 x_1 x_2 x_3; (\<lambda>y_0. ?H2 (x_4 y_0)) = x_1\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_4 x_2) x_3
|
[
"Specialisation_Examples.mapBP_FioB_i_o",
"Predicate.pred.eval",
"Specialisation_Examples.mapBP"
] |
[
"datatype (plugins only: extraction) (dead 'a) pred = Pred (eval: \"'a \\<Rightarrow> bool\")"
] |
###lemma
mapBP ?x1.0 ?xa ?xb \<Longrightarrow> (\<lambda>xa. pred.eval (?x xa)) = ?x1.0 \<Longrightarrow> pred.eval (mapBP_FioB_i_o ?x ?xa) ?xb
|
###output
\<lbrakk>?H1 x_1 x_2 x_3; (\<lambda>y_0. ?H2 (x_4 y_0)) = x_1\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_4 x_2) x_3
###end
|
Library/Old_Datatype
|
Old_Datatype.Scons_inject
|
lemma Scons_inject:
"[| Scons M N = Scons M' N'; [| M=M'; N=N' |] ==> P |] ==> P"
|
Scons ?M ?N = Scons ?M' ?N' \<Longrightarrow> (?M = ?M' \<Longrightarrow> ?N = ?N' \<Longrightarrow> ?P) \<Longrightarrow> ?P
|
\<lbrakk>?H1 x_1 x_2 = ?H1 x_3 x_4; \<lbrakk>x_1 = x_3; x_2 = x_4\<rbrakk> \<Longrightarrow> x_5\<rbrakk> \<Longrightarrow> x_5
|
[
"Old_Datatype.Scons"
] |
[
"definition Scons :: \"[('a, 'b) dtree, ('a, 'b) dtree] => ('a, 'b) dtree\"\n where \"Scons M N == (Push_Node (Inr 1) ` M) Un (Push_Node (Inr (Suc 1)) ` N)\""
] |
###lemma
Scons ?M ?N = Scons ?M' ?N' \<Longrightarrow> (?M = ?M' \<Longrightarrow> ?N = ?N' \<Longrightarrow> ?P) \<Longrightarrow> ?P
|
###output
\<lbrakk>?H1 x_1 x_2 = ?H1 x_3 x_4; \<lbrakk>x_1 = x_3; x_2 = x_4\<rbrakk> \<Longrightarrow> x_5\<rbrakk> \<Longrightarrow> x_5
###end
|
S_Finite_Measure_Monad/Monad_QuasiBorel
|
Monad_QuasiBorel.qbs_spmf_qbs
|
lemma qbs_spmf_qbs[qbs]:
fixes q :: "(_ :: countable) spmf"
shows "qbs_spmf q \<in> qbs_space (monadM_qbs (count_space\<^sub>Q UNIV))"
|
qbs_spmf ?q \<in> qbs_space (monadM_qbs (count_space\<^sub>Q UNIV))
|
?H1 x_1 \<in> ?H2 (?H3 (?H4 ?H5))
|
[
"Set.UNIV",
"Measure_QuasiBorel_Adjunction.qbs_count_space",
"Monad_QuasiBorel.monadM_qbs",
"QuasiBorel.qbs_space",
"Monad_QuasiBorel.qbs_spmf"
] |
[
"abbreviation UNIV :: \"'a set\"\n where \"UNIV \\<equiv> top\"",
"abbreviation qbs_count_space (\"count'_space\\<^sub>Q\") where \"qbs_count_space I \\<equiv> measure_to_qbs (count_space I)\"",
"definition monadM_qbs :: \"'a quasi_borel \\<Rightarrow> 'a qbs_measure quasi_borel\" where\n\"monadM_qbs X \\<equiv> Abs_quasi_borel ({s. qbs_space_of s = X}, {\\<lambda>r. \\<lbrakk>X, \\<alpha>, k r\\<rbrakk>\\<^sub>s\\<^sub>f\\<^sub>i\\<^sub>n |\\<alpha> k. \\<alpha> \\<in> qbs_Mx X \\<and> s_finite_kernel borel borel k})\"",
"definition qbs_space :: \"'a quasi_borel \\<Rightarrow> 'a set\" where\n \"qbs_space X \\<equiv> fst (Rep_quasi_borel X)\"",
"definition \"qbs_spmf \\<equiv> (\\<lambda>p. qbs_l_inverse (measure_spmf p))\""
] |
###lemma
qbs_spmf ?q \<in> qbs_space (monadM_qbs (count_space\<^sub>Q UNIV))
|
###output
?H1 x_1 \<in> ?H2 (?H3 (?H4 ?H5))
###end
|
Slicing/Dynamic/BitVector
|
BitVector.atLeastAtMost_singleton'
| null |
?a = ?b \<Longrightarrow> BitVector.atLeastAtMost ?a ?b = {?a}
|
x_1 = x_2 \<Longrightarrow> ?H1 x_1 x_2 = ?H2 x_1 ?H3
|
[
"Set.empty",
"Set.insert",
"BitVector.atLeastAtMost"
] |
[
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"definition insert :: \"'a \\<Rightarrow> 'a set \\<Rightarrow> 'a set\"\n where insert_compr: \"insert a B = {x. x = a \\<or> x \\<in> B}\""
] |
###lemma
?a = ?b \<Longrightarrow> BitVector.atLeastAtMost ?a ?b = {?a}
|
###output
x_1 = x_2 \<Longrightarrow> ?H1 x_1 x_2 = ?H2 x_1 ?H3
###end
|
Metalogic_ProofChecker/EtaNorm
|
EtaNorm.lift_subst_bv2_dummy
|
theorem lift_subst_bv2_dummy: "\<not> loose_bvar s i \<Longrightarrow> lift (decr i s) i = s"
|
\<not> loose_bvar ?s ?i \<Longrightarrow> lift (decr ?i ?s) ?i = ?s
|
\<not> ?H1 x_1 x_2 \<Longrightarrow> ?H2 (?H3 x_2 x_1) x_2 = x_1
|
[
"Term.decr",
"Core.lift",
"Term.loose_bvar"
] |
[
"fun decr :: \"nat \\<Rightarrow> term \\<Rightarrow> term\" where\n \"decr lev (Bv i) = (if i \\<ge> lev then Bv (i - 1) else Bv i)\"\n| \"decr lev (Abs T t) = Abs T (decr (lev + 1) t)\"\n| \"decr lev (t $ u) = (decr lev t $ decr lev u)\"\n| \"decr _ t = t\"",
"fun lift :: \"term \\<Rightarrow> nat \\<Rightarrow> term\" where\n \"lift (Bv i) n = (if i \\<ge> n then Bv (i+1) else Bv i)\"\n| \"lift (Abs T body) n = Abs T (lift body (n+1))\"\n| \"lift (App f t) n = App (lift f n) (lift t n)\"\n| \"lift u n = u\"",
"fun loose_bvar :: \"term \\<Rightarrow> nat \\<Rightarrow> bool\" where\n \"loose_bvar (Bv i) k \\<longleftrightarrow> i \\<ge> k\"\n| \"loose_bvar (t $ u) k \\<longleftrightarrow> loose_bvar t k \\<or> loose_bvar u k\"\n| \"loose_bvar (Abs _ t) k = loose_bvar t (k+1)\"\n| \"loose_bvar _ _ = False\""
] |
###lemma
\<not> loose_bvar ?s ?i \<Longrightarrow> lift (decr ?i ?s) ?i = ?s
|
###output
\<not> ?H1 x_1 x_2 \<Longrightarrow> ?H2 (?H3 x_2 x_1) x_2 = x_1
###end
|
Analysis/Topology_Euclidean_Space
|
Topology_Euclidean_Space.bounded_inner_imp_bdd_below
|
lemma bounded_inner_imp_bdd_below:
assumes "bounded s"
shows "bdd_below ((\<lambda>x. x \<bullet> a) ` s)"
|
bounded ?s \<Longrightarrow> bdd_below ((\<lambda>x. x \<bullet> ?a) ` ?s)
|
?H1 x_1 \<Longrightarrow> ?H2 (?H3 (\<lambda>y_0. ?H4 y_0 x_2) x_1)
|
[
"Inner_Product.real_inner_class.inner",
"Set.image",
"Conditionally_Complete_Lattices.preorder_class.bdd_below",
"Elementary_Metric_Spaces.metric_space_class.bounded"
] |
[
"class real_inner = real_vector + sgn_div_norm + dist_norm + uniformity_dist + open_uniformity +\n fixes inner :: \"'a \\<Rightarrow> 'a \\<Rightarrow> real\"\n assumes inner_commute: \"inner x y = inner y x\"\n and inner_add_left: \"inner (x + y) z = inner x z + inner y z\"\n and inner_scaleR_left [simp]: \"inner (scaleR r x) y = r * (inner x y)\"\n and inner_ge_zero [simp]: \"0 \\<le> inner x x\"\n and inner_eq_zero_iff [simp]: \"inner x x = 0 \\<longleftrightarrow> x = 0\"\n and norm_eq_sqrt_inner: \"norm x = sqrt (inner x x)\"\nbegin",
"definition image :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a set \\<Rightarrow> 'b set\" (infixr \"`\" 90)\n where \"f ` A = {y. \\<exists>x\\<in>A. y = f x}\""
] |
###lemma
bounded ?s \<Longrightarrow> bdd_below ((\<lambda>x. x \<bullet> ?a) ` ?s)
|
###output
?H1 x_1 \<Longrightarrow> ?H2 (?H3 (\<lambda>y_0. ?H4 y_0 x_2) x_1)
###end
|
Universal_Turing_Machine/StrongCopyTM
|
StrongCopyTM.tm_erase_right_then_dblBk_left_erp_total_correctness_helper_CL_neq_Nil_n_gt_1
|
lemma tm_erase_right_then_dblBk_left_erp_total_correctness_helper_CL_neq_Nil_n_gt_1:
assumes "(nl::nat list) \<noteq> []"
and "1<n"
and "n \<le> length nl"
shows "\<exists>CL CR.
[Oc] @ CL = rev(<take n nl>) \<and> noDblBk CL \<and> CL \<noteq> [] \<and> last CL = Oc \<and>
CR = (<drop n nl>) \<and> noDblBk CR"
|
?nl \<noteq> [] \<Longrightarrow> 1 < ?n \<Longrightarrow> ?n \<le> length ?nl \<Longrightarrow> \<exists>CL CR. [Oc] @ CL = rev (<take ?n ?nl>) \<and> noDblBk CL \<and> CL \<noteq> [] \<and> last CL = Oc \<and> CR = <drop ?n ?nl> \<and> noDblBk CR
|
\<lbrakk>x_1 \<noteq> ?H1; ?H2 < x_2; x_2 \<le> ?H3 x_1\<rbrakk> \<Longrightarrow> \<exists>y_0 y_1. ?H4 (?H5 ?H6 ?H7) y_0 = ?H8 (?H9 (?H10 x_2 x_1)) \<and> ?H11 y_0 \<and> y_0 \<noteq> ?H7 \<and> ?H12 y_0 = ?H6 \<and> y_1 = ?H9 (?H13 x_2 x_1) \<and> ?H11 y_1
|
[
"List.drop",
"List.last",
"Numerals.noDblBk",
"List.take",
"Numerals.tape_class.tape_of",
"List.rev",
"Turing.cell.Oc",
"List.list.Cons",
"List.append",
"List.length",
"Groups.one_class.one",
"List.list.Nil"
] |
[
"primrec drop:: \"nat \\<Rightarrow> 'a list \\<Rightarrow> 'a list\" where\ndrop_Nil: \"drop n [] = []\" |\ndrop_Cons: \"drop n (x # xs) = (case n of 0 \\<Rightarrow> x # xs | Suc m \\<Rightarrow> drop m xs)\"\n \\<comment> \\<open>Warning: simpset does not contain this definition, but separate\n theorems for \\<open>n = 0\\<close> and \\<open>n = Suc k\\<close>\\<close>",
"primrec (nonexhaustive) last :: \"'a list \\<Rightarrow> 'a\" where\n\"last (x # xs) = (if xs = [] then x else last xs)\"",
"definition noDblBk:: \"cell list \\<Rightarrow> bool\"\n where \"noDblBk cs \\<equiv> \\<forall>i. Suc i < length cs \\<and> cs!i = Bk \\<longrightarrow> cs!(Suc i) = Oc\"",
"primrec take:: \"nat \\<Rightarrow> 'a list \\<Rightarrow> 'a list\" where\ntake_Nil:\"take n [] = []\" |\ntake_Cons: \"take n (x # xs) = (case n of 0 \\<Rightarrow> [] | Suc m \\<Rightarrow> x # take m xs)\"\n \\<comment> \\<open>Warning: simpset does not contain this definition, but separate\n theorems for \\<open>n = 0\\<close> and \\<open>n = Suc k\\<close>\\<close>",
"class tape =\n fixes tape_of :: \"'a \\<Rightarrow> cell list\" (\"<_>\" 100)",
"primrec rev :: \"'a list \\<Rightarrow> 'a list\" where\n\"rev [] = []\" |\n\"rev (x # xs) = rev xs @ [x]\"",
"datatype cell = Bk | Oc",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"primrec append :: \"'a list \\<Rightarrow> 'a list \\<Rightarrow> 'a list\" (infixr \"@\" 65) where\nappend_Nil: \"[] @ ys = ys\" |\nappend_Cons: \"(x#xs) @ ys = x # xs @ ys\"",
"abbreviation length :: \"'a list \\<Rightarrow> nat\" where\n\"length \\<equiv> size\"",
"class one =\n fixes one :: 'a (\"1\")",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
?nl \<noteq> [] \<Longrightarrow> 1 < ?n \<Longrightarrow> ?n \<le> length ?nl \<Longrightarrow> \<exists>CL CR. [Oc] @ CL = rev (<take ?n ?nl>) \<and> noDblBk CL \<and> CL \<noteq> [] \<and> last CL = Oc \<and> CR = <drop ?n ?nl> \<and> noDblBk CR
|
###output
\<lbrakk>x_1 \<noteq> ?H1; ?H2 < x_2; x_2 \<le> ?H3 x_1\<rbrakk> \<Longrightarrow> \<exists>y_0 y_1. ?H4 (?H5 ?H6 ?H7) y_0 = ?H8 (?H9 (?H10 x_2 x_1)) \<and> ?H11 y_0 \<and> y_0 \<noteq> ?H7 \<and> ?H12 y_0 = ?H6 \<and> y_1 = ?H9 (?H13 x_2 x_1) \<and> ?H11 y_1
###end
|
ABY3_Protocols/Additive_Sharing
|
Additive_Sharing.make_sharing_collapse
|
lemma make_sharing_collapse[simp]:
"make_sharing (get_party Party1 s) (get_party Party2 s) (get_party Party3 s) = s"
|
make_sharing (get_party Party1 ?s) (get_party Party2 ?s) (get_party Party3 ?s) = ?s
|
?H1 (?H2 ?H3 x_1) (?H2 ?H4 x_1) (?H2 ?H5 x_1) = x_1
|
[
"Additive_Sharing.Role.Party3",
"Additive_Sharing.Role.Party2",
"Additive_Sharing.Role.Party1",
"Additive_Sharing.get_party",
"Additive_Sharing.make_sharing"
] |
[
"datatype Role = Party1 | Party2 | Party3",
"datatype Role = Party1 | Party2 | Party3",
"datatype Role = Party1 | Party2 | Party3",
"definition get_party :: \"Role \\<Rightarrow> 'a sharing \\<Rightarrow> 'a\" where\n \"get_party r x = x r\"",
"abbreviation \"make_sharing \\<equiv> make_sharing' Party1 Party2 Party3\""
] |
###lemma
make_sharing (get_party Party1 ?s) (get_party Party2 ?s) (get_party Party3 ?s) = ?s
|
###output
?H1 (?H2 ?H3 x_1) (?H2 ?H4 x_1) (?H2 ?H5 x_1) = x_1
###end
|
Simpl/SmallStep
|
SmallStep.steps_redexes_Seq
|
lemma steps_redexes_Seq:
assumes steps: "\<Gamma>\<turnstile> (r, s) \<rightarrow>\<^sup>* (r', s')"
shows "\<And>c. Seq r c\<^sub>2 \<in> redexes c \<Longrightarrow>
\<exists>c'. \<Gamma>\<turnstile>(c,s) \<rightarrow>\<^sup>* (c',s') \<and> Seq r' c\<^sub>2 \<in> redexes c'"
|
?\<Gamma>\<turnstile> (?r, ?s) \<rightarrow>\<^sup>* (?r', ?s') \<Longrightarrow> Seq ?r ?c\<^sub>2 \<in> redexes ?c \<Longrightarrow> \<exists>c'. ?\<Gamma>\<turnstile> (?c, ?s) \<rightarrow>\<^sup>* (c', ?s') \<and> Seq ?r' ?c\<^sub>2 \<in> redexes c'
|
\<lbrakk>?H1 x_1 (x_2, x_3) (x_4, x_5); ?H2 x_2 x_6 \<in> ?H3 x_7\<rbrakk> \<Longrightarrow> \<exists>y_0. ?H1 x_1 (x_7, x_3) (y_0, x_5) \<and> ?H2 x_4 x_6 \<in> ?H3 y_0
|
[
"SmallStep.redexes",
"Language.com.Seq",
"SmallStep.step_rtrancl"
] |
[
"primrec redexes:: \"('s,'p,'f)com \\<Rightarrow> ('s,'p,'f)com set\"\nwhere\n\"redexes Skip = {Skip}\" |\n\"redexes (Basic f) = {Basic f}\" |\n\"redexes (Spec r) = {Spec r}\" |\n\"redexes (Seq c\\<^sub>1 c\\<^sub>2) = {Seq c\\<^sub>1 c\\<^sub>2} \\<union> redexes c\\<^sub>1\" |\n\"redexes (Cond b c\\<^sub>1 c\\<^sub>2) = {Cond b c\\<^sub>1 c\\<^sub>2}\" |\n\"redexes (While b c) = {While b c}\" |\n\"redexes (Call p) = {Call p}\" |\n\"redexes (DynCom d) = {DynCom d}\" |\n\"redexes (Guard f b c) = {Guard f b c}\" |\n\"redexes (Throw) = {Throw}\" |\n\"redexes (Catch c\\<^sub>1 c\\<^sub>2) = {Catch c\\<^sub>1 c\\<^sub>2} \\<union> redexes c\\<^sub>1\"",
"datatype (dead 's, 'p, 'f) com =\n Skip\n | Basic \"'s \\<Rightarrow> 's\"\n | Spec \"('s \\<times> 's) set\"\n | Seq \"('s ,'p, 'f) com\" \"('s,'p, 'f) com\"\n | Cond \"'s bexp\" \"('s,'p,'f) com\" \"('s,'p,'f) com\"\n | While \"'s bexp\" \"('s,'p,'f) com\"\n | Call \"'p\"\n | DynCom \"'s \\<Rightarrow> ('s,'p,'f) com\"\n | Guard \"'f\" \"'s bexp\" \"('s,'p,'f) com\"\n | Throw\n | Catch \"('s,'p,'f) com\" \"('s,'p,'f) com\"",
"abbreviation\n \"step_rtrancl\" :: \"[('s,'p,'f) body,('s,'p,'f) config,('s,'p,'f) config] \\<Rightarrow> bool\"\n (\"_\\<turnstile> (_ \\<rightarrow>\\<^sup>*/ _)\" [81,81,81] 100)\n where\n \"\\<Gamma>\\<turnstile>cf0 \\<rightarrow>\\<^sup>* cf1 \\<equiv> (CONST step \\<Gamma>)\\<^sup>*\\<^sup>* cf0 cf1\""
] |
###lemma
?\<Gamma>\<turnstile> (?r, ?s) \<rightarrow>\<^sup>* (?r', ?s') \<Longrightarrow> Seq ?r ?c\<^sub>2 \<in> redexes ?c \<Longrightarrow> \<exists>c'. ?\<Gamma>\<turnstile> (?c, ?s) \<rightarrow>\<^sup>* (c', ?s') \<and> Seq ?r' ?c\<^sub>2 \<in> redexes c'
|
###output
\<lbrakk>?H1 x_1 (x_2, x_3) (x_4, x_5); ?H2 x_2 x_6 \<in> ?H3 x_7\<rbrakk> \<Longrightarrow> \<exists>y_0. ?H1 x_1 (x_7, x_3) (y_0, x_5) \<and> ?H2 x_4 x_6 \<in> ?H3 y_0
###end
|
Predicate_Compile_Examples/Predicate_Compile_Tests
|
Predicate_Compile_Tests.mapP_FooB_o_iI
| null |
mapP ?x1.0 ?xa ?xb \<Longrightarrow> (\<lambda>xa xb. pred.eval ?x (xa, xb)) = ?x1.0 \<Longrightarrow> pred.eval (mapP_FooB_o_i ?x ?xb) ?xa
|
\<lbrakk>?H1 x_1 x_2 x_3; (\<lambda>y_0 y_1. ?H2 x_4 (y_0, y_1)) = x_1\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_4 x_3) x_2
|
[
"Predicate_Compile_Tests.mapP_FooB_o_i",
"Predicate.pred.eval",
"Predicate_Compile_Tests.mapP"
] |
[
"datatype (plugins only: extraction) (dead 'a) pred = Pred (eval: \"'a \\<Rightarrow> bool\")"
] |
###lemma
mapP ?x1.0 ?xa ?xb \<Longrightarrow> (\<lambda>xa xb. pred.eval ?x (xa, xb)) = ?x1.0 \<Longrightarrow> pred.eval (mapP_FooB_o_i ?x ?xb) ?xa
|
###output
\<lbrakk>?H1 x_1 x_2 x_3; (\<lambda>y_0 y_1. ?H2 x_4 (y_0, y_1)) = x_1\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_4 x_3) x_2
###end
|
Simple_Firewall/Service_Matrix
|
Service_Matrix.build_ip_partition_no_empty_elems
|
lemma build_ip_partition_no_empty_elems: "wi \<in> set (build_ip_partition c rs) \<Longrightarrow> \<not> wordinterval_empty wi"
|
?wi \<in> set (build_ip_partition ?c ?rs) \<Longrightarrow> \<not> wordinterval_empty ?wi
|
x_1 \<in> ?H1 (?H2 x_2 x_3) \<Longrightarrow> \<not> ?H3 x_1
|
[
"WordInterval.wordinterval_empty",
"Service_Matrix.build_ip_partition",
"List.list.set"
] |
[
"fun wordinterval_empty :: \"'a::len wordinterval \\<Rightarrow> bool\" where\n \"wordinterval_empty (WordInterval s e) \\<longleftrightarrow> e < s\" |\n \"wordinterval_empty (RangeUnion r1 r2) \\<longleftrightarrow> wordinterval_empty r1 \\<and> wordinterval_empty r2\"",
"definition build_ip_partition :: \"parts_connection \\<Rightarrow> 'i::len simple_rule list \\<Rightarrow> 'i wordinterval list\" where\n \"build_ip_partition c rs = map\n (\\<lambda>xs. wordinterval_sort (wordinterval_compress (foldr wordinterval_union xs Empty_WordInterval)))\n (groupWIs3 c rs)\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
?wi \<in> set (build_ip_partition ?c ?rs) \<Longrightarrow> \<not> wordinterval_empty ?wi
|
###output
x_1 \<in> ?H1 (?H2 x_2 x_3) \<Longrightarrow> \<not> ?H3 x_1
###end
|
Probability/Probability
|
Probability_Mass_Function.pmf_eqI
| null |
(\<And>i. pmf ?M i = pmf ?N i) \<Longrightarrow> ?M = ?N
|
(\<And>y_0. ?H1 x_1 y_0 = ?H1 x_2 y_0) \<Longrightarrow> x_1 = x_2
|
[
"Probability_Mass_Function.pmf"
] |
[] |
###lemma
(\<And>i. pmf ?M i = pmf ?N i) \<Longrightarrow> ?M = ?N
|
###output
(\<And>y_0. ?H1 x_1 y_0 = ?H1 x_2 y_0) \<Longrightarrow> x_1 = x_2
###end
|
CommCSL/Lang
|
Lang.red_properties(2)
|
lemma red_properties:
"red C \<sigma> C' \<sigma>' \<Longrightarrow> fvC C' \<subseteq> fvC C \<and> wrC C' \<subseteq> wrC C \<and> agrees (- wrC C) (fst \<sigma>') (fst \<sigma>)"
"red_rtrans C \<sigma> C' \<sigma>' \<Longrightarrow> fvC C' \<subseteq> fvC C \<and> wrC C' \<subseteq> wrC C \<and> agrees (- wrC C) (fst \<sigma>') (fst \<sigma>)"
|
red_rtrans ?C ?\<sigma> ?C' ?\<sigma>' \<Longrightarrow> fvC ?C' \<subseteq> fvC ?C \<and> wrC ?C' \<subseteq> wrC ?C \<and> agrees (- wrC ?C) (fst ?\<sigma>') (fst ?\<sigma>)
|
?H1 x_1 x_2 x_3 x_4 \<Longrightarrow> ?H2 (?H3 x_3) (?H3 x_1) \<and> ?H2 (?H4 x_3) (?H4 x_1) \<and> ?H5 (?H6 (?H4 x_1)) (?H7 x_4) (?H7 x_2)
|
[
"Product_Type.prod.fst",
"Groups.uminus_class.uminus",
"Lang.agrees",
"Lang.wrC",
"Lang.fvC",
"Set.subset_eq",
"Lang.red_rtrans"
] |
[
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"class uminus =\n fixes uminus :: \"'a \\<Rightarrow> 'a\" (\"- _\" [81] 80)",
"definition \n agrees :: \"'a set \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> bool\" \nwhere\n \"agrees X s s' \\<equiv> \\<forall>x \\<in> X. s x = s' x\"",
"primrec\n wrC :: \"cmd \\<Rightarrow> var set\"\nwhere\n \"wrC (Cskip) = {}\"\n| \"wrC (Cassign v E) = {v}\"\n| \"wrC (Cread v E) = {v}\"\n| \"wrC (Cwrite E1 E2) = {}\"\n| \"wrC (Calloc v E) = {v}\"\n| \"wrC (Cdispose E) = {}\"\n| \"wrC (Cseq C1 C2) = (wrC C1 \\<union> wrC C2)\"\n| \"wrC (Cpar C1 C2) = (wrC C1 \\<union> wrC C2)\"\n| \"wrC (Cif B C1 C2) = (wrC C1 \\<union> wrC C2)\"\n| \"wrC (Cwhile B C) = (wrC C)\"\n| \"wrC (Catomic C) = (wrC C)\"",
"primrec\n fvC :: \"cmd \\<Rightarrow> var set\"\nwhere\n \"fvC (Cskip) = {}\"\n| \"fvC (Cassign v E) = ({v} \\<union> fvE E)\"\n| \"fvC (Cread v E) = ({v} \\<union> fvE E)\"\n| \"fvC (Cwrite E1 E2) = (fvE E1 \\<union> fvE E2)\"\n| \"fvC (Calloc v E) = ({v} \\<union> fvE E)\"\n| \"fvC (Cdispose E) = (fvE E)\"\n| \"fvC (Cseq C1 C2) = (fvC C1 \\<union> fvC C2)\"\n| \"fvC (Cpar C1 C2) = (fvC C1 \\<union> fvC C2)\"\n| \"fvC (Cif B C1 C2) = (fvB B \\<union> fvC C1 \\<union> fvC C2)\"\n| \"fvC (Cwhile B C) = (fvB B \\<union> fvC C)\"\n| \"fvC (Catomic C) = (fvC C)\"",
"abbreviation subset_eq :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> bool\"\n where \"subset_eq \\<equiv> less_eq\""
] |
###lemma
red_rtrans ?C ?\<sigma> ?C' ?\<sigma>' \<Longrightarrow> fvC ?C' \<subseteq> fvC ?C \<and> wrC ?C' \<subseteq> wrC ?C \<and> agrees (- wrC ?C) (fst ?\<sigma>') (fst ?\<sigma>)
|
###output
?H1 x_1 x_2 x_3 x_4 \<Longrightarrow> ?H2 (?H3 x_3) (?H3 x_1) \<and> ?H2 (?H4 x_3) (?H4 x_1) \<and> ?H5 (?H6 (?H4 x_1)) (?H7 x_4) (?H7 x_2)
###end
|
Combinatorics_Words/CoWBasic
|
CoWBasic.prim_conjugE
|
lemma prim_conjugE[elim, consumes 3]: assumes "(u \<cdot> v) \<cdot> z = z \<cdot> (v \<cdot> u)" and "primitive (u \<cdot> v)" and "v \<noteq> \<epsilon>"
obtains k where "(u \<cdot> v)\<^sup>@k \<cdot> u = z"
|
(?u \<cdot> ?v) \<cdot> ?z = ?z \<cdot> ?v \<cdot> ?u \<Longrightarrow> primitive (?u \<cdot> ?v) \<Longrightarrow> ?v \<noteq> \<epsilon> \<Longrightarrow> (\<And>k. (?u \<cdot> ?v) \<^sup>@ k \<cdot> ?u = ?z \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
\<lbrakk>?H1 (?H1 x_1 x_2) x_3 = ?H1 x_3 (?H1 x_2 x_1); ?H2 (?H1 x_1 x_2); x_2 \<noteq> ?H3; \<And>y_0. ?H1 (?H4 (?H1 x_1 x_2) y_0) x_1 = x_3 \<Longrightarrow> x_4\<rbrakk> \<Longrightarrow> x_4
|
[
"CoWBasic.list_power",
"List.list.Nil",
"CoWBasic.primitive",
"List.append"
] |
[
"primrec list_power :: \"'a list \\<Rightarrow> nat \\<Rightarrow> 'a list\" (infixr \"\\<^sup>@\" 80)\n where\n pow_0: \"u \\<^sup>@ 0 = \\<epsilon>\"\n | pow_Suc: \"u \\<^sup>@ Suc n = u \\<cdot> u \\<^sup>@ n\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"definition primitive :: \"'a list \\<Rightarrow> bool\"\n where \"primitive u = (\\<forall> r k. r\\<^sup>@k = u \\<longrightarrow> k = 1)\"",
"primrec append :: \"'a list \\<Rightarrow> 'a list \\<Rightarrow> 'a list\" (infixr \"@\" 65) where\nappend_Nil: \"[] @ ys = ys\" |\nappend_Cons: \"(x#xs) @ ys = x # xs @ ys\""
] |
###lemma
(?u \<cdot> ?v) \<cdot> ?z = ?z \<cdot> ?v \<cdot> ?u \<Longrightarrow> primitive (?u \<cdot> ?v) \<Longrightarrow> ?v \<noteq> \<epsilon> \<Longrightarrow> (\<And>k. (?u \<cdot> ?v) \<^sup>@ k \<cdot> ?u = ?z \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
###output
\<lbrakk>?H1 (?H1 x_1 x_2) x_3 = ?H1 x_3 (?H1 x_2 x_1); ?H2 (?H1 x_1 x_2); x_2 \<noteq> ?H3; \<And>y_0. ?H1 (?H4 (?H1 x_1 x_2) y_0) x_1 = x_3 \<Longrightarrow> x_4\<rbrakk> \<Longrightarrow> x_4
###end
|
Functional-Automata/RegExp2NAe
|
RegExp2NAe.lemma2b'
|
lemma lemma2b':
"(p,q) : (eps R)\<^sup>* \<Longrightarrow> (False#p, False#q) : (eps(conc L R))\<^sup>*"
|
(?p, ?q) \<in> (eps ?R)\<^sup>* \<Longrightarrow> (False # ?p, False # ?q) \<in> (eps (RegExp2NAe.conc ?L ?R))\<^sup>*
|
(x_1, x_2) \<in> ?H1 (?H2 x_3) \<Longrightarrow> (?H3 False x_1, ?H3 False x_2) \<in> ?H1 (?H2 (?H4 x_4 x_3))
|
[
"RegExp2NAe.conc",
"List.list.Cons",
"NAe.eps",
"Transitive_Closure.rtrancl"
] |
[
"definition\n conc :: \"'a bitsNAe \\<Rightarrow> 'a bitsNAe \\<Rightarrow> 'a bitsNAe\" where\n\"conc = (\\<lambda>(ql,dl,fl)(qr,dr,fr).\n (True#ql,\n \\<lambda>a s. case s of\n [] \\<Rightarrow> {}\n | left#s \\<Rightarrow> if left then (True ## dl a s) \\<union>\n (if fl s \\<and> a=None then {False#qr} else {})\n else False ## dr a s,\n \\<lambda>s. case s of [] \\<Rightarrow> False | left#s \\<Rightarrow> \\<not>left \\<and> fr s))\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"abbreviation\n eps :: \"('a,'s)nae \\<Rightarrow> ('s * 's)set\" where\n \"eps A \\<equiv> step A None\"",
"inductive_set rtrancl :: \"('a \\<times> 'a) set \\<Rightarrow> ('a \\<times> 'a) set\" (\"(_\\<^sup>*)\" [1000] 999)\n for r :: \"('a \\<times> 'a) set\"\n where\n rtrancl_refl [intro!, Pure.intro!, simp]: \"(a, a) \\<in> r\\<^sup>*\"\n | rtrancl_into_rtrancl [Pure.intro]: \"(a, b) \\<in> r\\<^sup>* \\<Longrightarrow> (b, c) \\<in> r \\<Longrightarrow> (a, c) \\<in> r\\<^sup>*\""
] |
###lemma
(?p, ?q) \<in> (eps ?R)\<^sup>* \<Longrightarrow> (False # ?p, False # ?q) \<in> (eps (RegExp2NAe.conc ?L ?R))\<^sup>*
|
###output
(x_1, x_2) \<in> ?H1 (?H2 x_3) \<Longrightarrow> (?H3 False x_1, ?H3 False x_2) \<in> ?H1 (?H2 (?H4 x_4 x_3))
###end
|
Simple_Firewall/Common/GroupF
|
GroupF.groupF_concat_set
|
lemma groupF_concat_set: "set (concat (groupF f xs)) = set xs"
|
set (concat (groupF ?f ?xs)) = set ?xs
|
?H1 (?H2 (?H3 x_1 x_2)) = ?H1 x_2
|
[
"GroupF.groupF",
"List.concat",
"List.list.set"
] |
[
"primrec concat:: \"'a list list \\<Rightarrow> 'a list\" where\n\"concat [] = []\" |\n\"concat (x # xs) = x @ concat xs\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
set (concat (groupF ?f ?xs)) = set ?xs
|
###output
?H1 (?H2 (?H3 x_1 x_2)) = ?H1 x_2
###end
|
Word_Lib/Aligned
|
Aligned.is_aligned_no_overflow_mask
|
lemma is_aligned_no_overflow_mask:
"is_aligned x n \<Longrightarrow> x \<le> x + mask n"
|
is_aligned ?x ?n \<Longrightarrow> ?x \<le> ?x + mask ?n
|
?H1 x_1 x_2 \<Longrightarrow> x_1 \<le> ?H2 x_1 (?H3 x_2)
|
[
"Bit_Operations.semiring_bit_operations_class.mask",
"Groups.plus_class.plus",
"Aligned.is_aligned"
] |
[
"class semiring_bit_operations = semiring_bits +\n fixes \"and\" :: \\<open>'a \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close> (infixr \\<open>AND\\<close> 64)\n and or :: \\<open>'a \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close> (infixr \\<open>OR\\<close> 59)\n and xor :: \\<open>'a \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close> (infixr \\<open>XOR\\<close> 59)\n and mask :: \\<open>nat \\<Rightarrow> 'a\\<close>\n and set_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n and unset_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n and flip_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n and push_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n and drop_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n and take_bit :: \\<open>nat \\<Rightarrow> 'a \\<Rightarrow> 'a\\<close>\n assumes and_rec: \\<open>a AND b = of_bool (odd a \\<and> odd b) + 2 * ((a div 2) AND (b div 2))\\<close>\n and or_rec: \\<open>a OR b = of_bool (odd a \\<or> odd b) + 2 * ((a div 2) OR (b div 2))\\<close>\n and xor_rec: \\<open>a XOR b = of_bool (odd a \\<noteq> odd b) + 2 * ((a div 2) XOR (b div 2))\\<close>\n and mask_eq_exp_minus_1: \\<open>mask n = 2 ^ n - 1\\<close>\n and set_bit_eq_or: \\<open>set_bit n a = a OR push_bit n 1\\<close>\n and unset_bit_eq_or_xor: \\<open>unset_bit n a = (a OR push_bit n 1) XOR push_bit n 1\\<close>\n and flip_bit_eq_xor: \\<open>flip_bit n a = a XOR push_bit n 1\\<close>\n and push_bit_eq_mult: \\<open>push_bit n a = a * 2 ^ n\\<close>\n and drop_bit_eq_div: \\<open>drop_bit n a = a div 2 ^ n\\<close>\n and take_bit_eq_mod: \\<open>take_bit n a = a mod 2 ^ n\\<close>\nbegin",
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)"
] |
###lemma
is_aligned ?x ?n \<Longrightarrow> ?x \<le> ?x + mask ?n
|
###output
?H1 x_1 x_2 \<Longrightarrow> x_1 \<le> ?H2 x_1 (?H3 x_2)
###end
|
WebAssembly/Wasm_Properties
|
Wasm_Properties_Aux.const_typeof
| null |
?\<S>\<bullet>?\<C> \<turnstile> [$C ?v] : [] _> [?t] \<Longrightarrow> typeof ?v = ?t
|
?H1 x_1 x_2 (?H2 (?H3 (?H4 x_3)) ?H5) (?H6 ?H7 (?H8 x_4 ?H7)) \<Longrightarrow> ?H9 x_3 = x_4
|
[
"Wasm_Base_Defs.typeof",
"Wasm_Ast.tf.Tf",
"List.list.Nil",
"Wasm_Ast.b_e.EConst",
"Wasm_Ast.e.Basic",
"List.list.Cons",
"Wasm.e_typing"
] |
[
"definition typeof :: \" v \\<Rightarrow> t\" where\n \"typeof v = (case v of\n ConstInt32 _ \\<Rightarrow> T_i32\n | ConstInt64 _ \\<Rightarrow> T_i64\n | ConstFloat32 _ \\<Rightarrow> T_f32\n | ConstFloat64 _ \\<Rightarrow> T_f64)\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"datatype e = \\<comment> \\<open>administrative instruction\\<close>\n Basic b_e (\"$_\" 60)\n | Trap\n | Callcl cl\n | Label nat \"e list\" \"e list\"\n | Local nat i \"v list\" \"e list\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"inductive e_typing :: \"[s_context, t_context, e list, tf] \\<Rightarrow> bool\" (\"_\\<bullet>_ \\<turnstile> _ : _\" 60)\nand s_typing :: \"[s_context, (t list) option, nat, v list, e list, t list] \\<Rightarrow> bool\" (\"_\\<bullet>_ \\<tturnstile>'_ _ _;_ : _\" 60) where\n(* section: e_typing *)\n (* lifting *)\n \"\\<C> \\<turnstile> b_es : tf \\<Longrightarrow> \\<S>\\<bullet>\\<C> \\<turnstile> $*b_es : tf\"\n (* composition *)\n| \"\\<lbrakk>\\<S>\\<bullet>\\<C> \\<turnstile> es : (t1s _> t2s); \\<S>\\<bullet>\\<C> \\<turnstile> [e] : (t2s _> t3s)\\<rbrakk> \\<Longrightarrow> \\<S>\\<bullet>\\<C> \\<turnstile> es @ [e] : (t1s _> t3s)\"\n (* weakening *)\n| \"\\<S>\\<bullet>\\<C> \\<turnstile> es : (t1s _> t2s) \\<Longrightarrow>\\<S>\\<bullet>\\<C> \\<turnstile> es : (ts @ t1s _> ts @ t2s)\"\n (* trap *)\n| \"\\<S>\\<bullet>\\<C> \\<turnstile> [Trap] : tf\"\n (* local *)\n| \"\\<lbrakk>\\<S>\\<bullet>Some ts \\<tturnstile>_i vs;es : ts; length ts = n\\<rbrakk> \\<Longrightarrow> \\<S>\\<bullet>\\<C> \\<turnstile> [Local n i vs es] : ([] _> ts)\"\n (* callcl *)\n| \"\\<lbrakk>cl_typing \\<S> cl tf\\<rbrakk> \\<Longrightarrow> \\<S>\\<bullet>\\<C> \\<turnstile> [Callcl cl] : tf\"\n (* label *)\n| \"\\<lbrakk>\\<S>\\<bullet>\\<C> \\<turnstile> e0s : (ts _> t2s); \\<S>\\<bullet>\\<C>\\<lparr>label := ([ts] @ (label \\<C>))\\<rparr> \\<turnstile> es : ([] _> t2s); length ts = n\\<rbrakk> \\<Longrightarrow> \\<S>\\<bullet>\\<C> \\<turnstile> [Label n e0s es] : ([] _> t2s)\"\n(* section: s_typing *)\n| \"\\<lbrakk>i < (length (s_inst \\<S>)); tvs = map typeof vs; \\<C> =((s_inst \\<S>)!i)\\<lparr>local := (local ((s_inst \\<S>)!i) @ tvs), return := rs\\<rparr>; \\<S>\\<bullet>\\<C> \\<turnstile> es : ([] _> ts); (rs = Some ts) \\<or> rs = None\\<rbrakk> \\<Longrightarrow> \\<S>\\<bullet>rs \\<tturnstile>_i vs;es : ts\""
] |
###lemma
?\<S>\<bullet>?\<C> \<turnstile> [$C ?v] : [] _> [?t] \<Longrightarrow> typeof ?v = ?t
|
###output
?H1 x_1 x_2 (?H2 (?H3 (?H4 x_3)) ?H5) (?H6 ?H7 (?H8 x_4 ?H7)) \<Longrightarrow> ?H9 x_3 = x_4
###end
|
UNITY/WFair
|
WFair.leadsTo_induct_pre
|
lemma leadsTo_induct_pre:
"[| F \<in> za leadsTo zb;
P zb;
!!A B. [| F \<in> A ensures B; F \<in> B leadsTo zb; P B |] ==> P A;
!!S. \<forall>A \<in> S. F \<in> A leadsTo zb & P A ==> P (\<Union>S)
|] ==> P za"
|
?F \<in> ?za \<longmapsto> ?zb \<Longrightarrow> ?P ?zb \<Longrightarrow> (\<And>A B. ?F \<in> A ensures B \<Longrightarrow> ?F \<in> B \<longmapsto> ?zb \<Longrightarrow> ?P B \<Longrightarrow> ?P A) \<Longrightarrow> (\<And>S. \<forall>A\<in>S. ?F \<in> A \<longmapsto> ?zb \<and> ?P A \<Longrightarrow> ?P (\<Union> S)) \<Longrightarrow> ?P ?za
|
\<lbrakk>x_1 \<in> ?H1 x_2 x_3; x_4 x_3; \<And>y_0 y_1. \<lbrakk>x_1 \<in> ?H2 y_0 y_1; x_1 \<in> ?H1 y_1 x_3; x_4 y_1\<rbrakk> \<Longrightarrow> x_4 y_0; \<And>y_2. \<forall>y_3\<in>y_2. x_1 \<in> ?H1 y_3 x_3 \<and> x_4 y_3 \<Longrightarrow> x_4 (?H3 y_2)\<rbrakk> \<Longrightarrow> x_4 x_2
|
[
"Complete_Lattices.Union",
"WFair.ensures",
"WFair.leadsTo"
] |
[
"abbreviation Union :: \"'a set set \\<Rightarrow> 'a set\" (\"\\<Union>\")\n where \"\\<Union>S \\<equiv> \\<Squnion>S\"",
"definition\n ensures :: \"['a set, 'a set] => 'a program set\" (infixl \"ensures\" 60) where\n \"A ensures B == (A-B co A \\<union> B) \\<inter> transient (A-B)\"",
"definition leadsTo :: \"['a set, 'a set] => 'a program set\" (infixl \"leadsTo\" 60) where\n \\<comment> \\<open>visible version of the LEADS-TO relation\\<close>\n \"A leadsTo B == {F. (A,B) \\<in> leads F}\""
] |
###lemma
?F \<in> ?za \<longmapsto> ?zb \<Longrightarrow> ?P ?zb \<Longrightarrow> (\<And>A B. ?F \<in> A ensures B \<Longrightarrow> ?F \<in> B \<longmapsto> ?zb \<Longrightarrow> ?P B \<Longrightarrow> ?P A) \<Longrightarrow> (\<And>S. \<forall>A\<in>S. ?F \<in> A \<longmapsto> ?zb \<and> ?P A \<Longrightarrow> ?P (\<Union> S)) \<Longrightarrow> ?P ?za
|
###output
\<lbrakk>x_1 \<in> ?H1 x_2 x_3; x_4 x_3; \<And>y_0 y_1. \<lbrakk>x_1 \<in> ?H2 y_0 y_1; x_1 \<in> ?H1 y_1 x_3; x_4 y_1\<rbrakk> \<Longrightarrow> x_4 y_0; \<And>y_2. \<forall>y_3\<in>y_2. x_1 \<in> ?H1 y_3 x_3 \<and> x_4 y_3 \<Longrightarrow> x_4 (?H3 y_2)\<rbrakk> \<Longrightarrow> x_4 x_2
###end
|
List_Update/OPT2
|
OPT2.OPT2_A'
|
lemma OPT2_A': assumes "x \<noteq> y" "qs \<in> lang (seq [Plus (Atom x) One, Atom y, Atom y])"
shows "real (T\<^sub>p [x,y] qs (OPT2 qs [x,y])) = 1"
|
?x \<noteq> ?y \<Longrightarrow> ?qs \<in> lang (seq [question (Atom ?x), Atom ?y, Atom ?y]) \<Longrightarrow> real (T\<^sub>p [?x, ?y] ?qs (OPT2 ?qs [?x, ?y])) = 1
|
\<lbrakk>x_1 \<noteq> x_2; x_3 \<in> ?H1 (?H2 (?H3 (?H4 (?H5 x_1)) (?H3 (?H5 x_2) (?H3 (?H5 x_2) ?H6))))\<rbrakk> \<Longrightarrow> ?H7 (?H8 (?H9 x_1 (?H9 x_2 ?H10)) x_3 (?H11 x_3 (?H9 x_1 (?H9 x_2 ?H10)))) = ?H12
|
[
"Groups.one_class.one",
"OPT2.OPT2",
"Partial_Cost_Model.T\\<^sub>p",
"Real.real",
"List.list.Nil",
"Regular_Exp.rexp.Atom",
"RExp_Var.question",
"List.list.Cons",
"RExp_Var.seq",
"Regular_Exp.lang"
] |
[
"class one =\n fixes one :: 'a (\"1\")",
"fun OPT2 :: \"'a list \\<Rightarrow> 'a list \\<Rightarrow> (nat * nat list) list\" where\n \"OPT2 [] [x,y] = []\"\n| \"OPT2 [a] [x,y] = [(0,[])]\"\n| \"OPT2 (a#b#\\<sigma>') [x,y] = (if a=x then (0,[]) # (OPT2 (b#\\<sigma>') [x,y])\n else (if b=x then (0,[])# (OPT2 (b#\\<sigma>') [x,y])\n else (1,[])# (OPT2 (b#\\<sigma>') [y,x])))\"",
"abbreviation \"T\\<^sub>p == T\"",
"abbreviation real :: \"nat \\<Rightarrow> real\"\n where \"real \\<equiv> of_nat\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"datatype (atoms: 'a) rexp =\n is_Zero: Zero |\n is_One: One |\n Atom 'a |\n Plus \"('a rexp)\" \"('a rexp)\" |\n Times \"('a rexp)\" \"('a rexp)\" |\n Star \"('a rexp)\"",
"abbreviation question where \"question x == Plus x One\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"fun seq :: \"'a rexp list \\<Rightarrow> 'a rexp\" where\n\"seq [] = One\" |\n\"seq [r] = r\" |\n\"seq (r#rs) = Times r (seq rs)\"",
"primrec lang :: \"'a rexp => 'a lang\" where\n\"lang Zero = {}\" |\n\"lang One = {[]}\" |\n\"lang (Atom a) = {[a]}\" |\n\"lang (Plus r s) = (lang r) Un (lang s)\" |\n\"lang (Times r s) = conc (lang r) (lang s)\" |\n\"lang (Star r) = star(lang r)\""
] |
###lemma
?x \<noteq> ?y \<Longrightarrow> ?qs \<in> lang (seq [question (Atom ?x), Atom ?y, Atom ?y]) \<Longrightarrow> real (T\<^sub>p [?x, ?y] ?qs (OPT2 ?qs [?x, ?y])) = 1
|
###output
\<lbrakk>x_1 \<noteq> x_2; x_3 \<in> ?H1 (?H2 (?H3 (?H4 (?H5 x_1)) (?H3 (?H5 x_2) (?H3 (?H5 x_2) ?H6))))\<rbrakk> \<Longrightarrow> ?H7 (?H8 (?H9 x_1 (?H9 x_2 ?H10)) x_3 (?H11 x_3 (?H9 x_1 (?H9 x_2 ?H10)))) = ?H12
###end
|
Collections/ICF/CollectionsV1
|
CollectionsV1.ahs_correct(10)
| null |
ahs.invar ?s \<Longrightarrow> ahs.\<alpha> (ahs.delete ?x ?s) = ahs.\<alpha> ?s - {?x}
|
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_2 x_1) = ?H4 (?H2 x_1) (?H5 x_2 ?H6)
|
[
"Set.empty",
"Set.insert",
"Groups.minus_class.minus",
"ArrayHashSet.ahs.delete",
"ArrayHashSet.ahs.\\<alpha>",
"ArrayHashSet.ahs.invar"
] |
[
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"definition insert :: \"'a \\<Rightarrow> 'a set \\<Rightarrow> 'a set\"\n where insert_compr: \"insert a B = {x. x = a \\<or> x \\<in> B}\"",
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)"
] |
###lemma
ahs.invar ?s \<Longrightarrow> ahs.\<alpha> (ahs.delete ?x ?s) = ahs.\<alpha> ?s - {?x}
|
###output
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_2 x_1) = ?H4 (?H2 x_1) (?H5 x_2 ?H6)
###end
|
UTP/utp/utp_subst
|
utp_subst.usubst_upd_pr_var_id
|
lemma usubst_upd_pr_var_id [usubst]:
"vwb_lens x \<Longrightarrow> [x \<mapsto>\<^sub>s var (pr_var x)] = id"
|
vwb_lens ?x \<Longrightarrow> [?x \<mapsto>\<^sub>s &?x] = id
|
?H1 x_1 \<Longrightarrow> ?H2 ?H3 x_1 (?H4 (?H5 x_1)) = ?H3
|
[
"utp_var.pr_var",
"utp_expr.var",
"Fun.id",
"utp_subst.subst_upd_uvar",
"Lens_Laws.vwb_lens"
] |
[
"definition id :: \"'a \\<Rightarrow> 'a\"\n where \"id = (\\<lambda>x. x)\""
] |
###lemma
vwb_lens ?x \<Longrightarrow> [?x \<mapsto>\<^sub>s &?x] = id
|
###output
?H1 x_1 \<Longrightarrow> ?H2 ?H3 x_1 (?H4 (?H5 x_1)) = ?H3
###end
|
Affine_Arithmetic/Intersection
|
Intersection.list_cases4
|
lemma list_cases4:
"\<And>x P. (x = [] \<Longrightarrow> P) \<Longrightarrow> (\<And>y. x = [y] \<Longrightarrow> P) \<Longrightarrow>
(\<And>y z. x = [y, z] \<Longrightarrow> P) \<Longrightarrow>
(\<And>w y z zs. x = w # y # z # zs \<Longrightarrow> P) \<Longrightarrow> P"
|
(?x = [] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>y. ?x = [y] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>y z. ?x = [y, z] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>w y z zs. ?x = w # y # z # zs \<Longrightarrow> ?P) \<Longrightarrow> ?P
|
\<lbrakk>x_1 = ?H1 \<Longrightarrow> x_2; \<And>y_0. x_1 = ?H2 y_0 ?H1 \<Longrightarrow> x_2; \<And>y_1 y_2. x_1 = ?H2 y_1 (?H2 y_2 ?H1) \<Longrightarrow> x_2; \<And>y_3 y_4 y_5 y_6. x_1 = ?H2 y_3 (?H2 y_4 (?H2 y_5 y_6)) \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
|
[
"List.list.Cons",
"List.list.Nil"
] |
[
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\""
] |
###lemma
(?x = [] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>y. ?x = [y] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>y z. ?x = [y, z] \<Longrightarrow> ?P) \<Longrightarrow> (\<And>w y z zs. ?x = w # y # z # zs \<Longrightarrow> ?P) \<Longrightarrow> ?P
|
###output
\<lbrakk>x_1 = ?H1 \<Longrightarrow> x_2; \<And>y_0. x_1 = ?H2 y_0 ?H1 \<Longrightarrow> x_2; \<And>y_1 y_2. x_1 = ?H2 y_1 (?H2 y_2 ?H1) \<Longrightarrow> x_2; \<And>y_3 y_4 y_5 y_6. x_1 = ?H2 y_3 (?H2 y_4 (?H2 y_5 y_6)) \<Longrightarrow> x_2\<rbrakk> \<Longrightarrow> x_2
###end
|
AOT/AOT_PLM
|
AOT_PLM.thm-neg=E
| null |
\<^bold>\<turnstile>\<^sub>\<box> x \<noteq>\<^sub>E y \<equiv> \<not>x =\<^sub>E y
|
H1 x_1 (H2 (H3 (H4 H5) (H6 x_2, H6 x_3)) (H7 (H3 H5 (H6 x_2, H6 x_3))))
|
[
"AOT_syntax.AOT_not",
"AOT_model.AOT_var.AOT_term_of_var",
"AOT_PLM.eq_E",
"AOT_PLM.relation_negation",
"AOT_syntax.AOT_exe",
"AOT_syntax.AOT_equiv",
"AOT_model.AOT_model_valid_in"
] |
[
"definition AOT_model_valid_in :: \\<open>w\\<Rightarrow>\\<o>\\<Rightarrow>bool\\<close> where\n \\<open>AOT_model_valid_in w \\<phi> \\<equiv> AOT_model_d\\<o> \\<phi> w\\<close>"
] |
###lemma
\<^bold>\<turnstile>\<^sub>\<box> x \<noteq>\<^sub>E y \<equiv> \<not>x =\<^sub>E y
|
###output
H1 x_1 (H2 (H3 (H4 H5) (H6 x_2, H6 x_3)) (H7 (H3 H5 (H6 x_2, H6 x_3))))
###end
|
Density_Compiler/PDF_Values
|
PDF_Values.map_int_pair_measurable
|
lemma map_int_pair_measurable[measurable]:
assumes f: "case_prod f \<in> measurable (count_space UNIV \<Otimes>\<^sub>M count_space UNIV) M"
shows "map_int_pair f g \<in> measurable (PRODUCT INTEG INTEG) M"
|
(\<lambda>(x, y). ?f x y) \<in> count_space UNIV \<Otimes>\<^sub>M count_space UNIV \<rightarrow>\<^sub>M ?M \<Longrightarrow> map_int_pair ?f ?g \<in> stock_measure (PRODUCT INTEG INTEG) \<rightarrow>\<^sub>M ?M
|
?H1 x_1 \<in> ?H2 (?H3 (?H4 ?H5) (?H4 ?H5)) x_2 \<Longrightarrow> ?H6 x_1 x_3 \<in> ?H7 (?H8 (?H9 ?H10 ?H10)) x_2
|
[
"PDF_Values.pdf_type.INTEG",
"PDF_Values.pdf_type.PRODUCT",
"PDF_Values.stock_measure",
"PDF_Values.map_int_pair",
"Set.UNIV",
"Sigma_Algebra.count_space",
"Binary_Product_Measure.pair_measure",
"Sigma_Algebra.measurable",
"Product_Type.prod.case_prod"
] |
[
"datatype pdf_type = UNIT | BOOL | INTEG | REAL | PRODUCT pdf_type pdf_type",
"datatype pdf_type = UNIT | BOOL | INTEG | REAL | PRODUCT pdf_type pdf_type",
"primrec stock_measure :: \"pdf_type \\<Rightarrow> val measure\" where\n \"stock_measure UNIT = count_space {UnitVal}\"\n| \"stock_measure INTEG = count_space (range IntVal)\"\n| \"stock_measure BOOL = count_space (range BoolVal)\"\n| \"stock_measure REAL = embed_measure lborel RealVal\"\n| \"stock_measure (PRODUCT t1 t2) =\n embed_measure (stock_measure t1 \\<Otimes>\\<^sub>M stock_measure t2) (\\<lambda>(a, b). <|a, b|>)\"",
"definition map_int_pair where\n \"map_int_pair f g x = (case x of <| IntVal a, IntVal b |> \\<Rightarrow> f a b | _ \\<Rightarrow> g x)\"",
"abbreviation UNIV :: \"'a set\"\n where \"UNIV \\<equiv> top\"",
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\""
] |
###lemma
(\<lambda>(x, y). ?f x y) \<in> count_space UNIV \<Otimes>\<^sub>M count_space UNIV \<rightarrow>\<^sub>M ?M \<Longrightarrow> map_int_pair ?f ?g \<in> stock_measure (PRODUCT INTEG INTEG) \<rightarrow>\<^sub>M ?M
|
###output
?H1 x_1 \<in> ?H2 (?H3 (?H4 ?H5) (?H4 ?H5)) x_2 \<Longrightarrow> ?H6 x_1 x_3 \<in> ?H7 (?H8 (?H9 ?H10 ?H10)) x_2
###end
|
CakeML_Codegen/Rewriting/Rewriting_Sterm
|
Rewriting_Sterm.srelated_subst'
|
lemma srelated_subst':
assumes "srelated'.P_env penv senv" "wellformed t"
shows "pterm_to_sterm (subst t penv) = subst (pterm_to_sterm t) senv"
|
srelated'.P_env ?penv ?senv \<Longrightarrow> pre_strong_term_class.wellformed ?t \<Longrightarrow> pterm_to_sterm (subst ?t ?penv) = subst (pterm_to_sterm ?t) ?senv
|
\<lbrakk>?H1 x_1 x_2; ?H2 x_3\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_3 x_1) = ?H5 (?H3 x_3) x_2
|
[
"Term_Class.pre_term_class.subst",
"Rewriting_Sterm.pterm_to_sterm",
"Strong_Term.pre_strong_term_class.wellformed",
"Rewriting_Sterm.srelated'.P_env"
] |
[
"class pre_term = size +\n fixes\n frees :: \"'a \\<Rightarrow> name fset\" and\n subst :: \"'a \\<Rightarrow> (name, 'a) fmap \\<Rightarrow> 'a\" and\n \"consts\" :: \"'a \\<Rightarrow> name fset\"\n fixes\n app :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" and unapp :: \"'a \\<Rightarrow> ('a \\<times> 'a) option\"\n fixes\n const :: \"name \\<Rightarrow> 'a\" and unconst :: \"'a \\<Rightarrow> name option\"\n fixes\n free :: \"name \\<Rightarrow> 'a\" and unfree :: \"'a \\<Rightarrow> name option\"\n assumes unapp_app[simp]: \"unapp (app u\\<^sub>1 u\\<^sub>2) = Some (u\\<^sub>1, u\\<^sub>2)\"\n assumes app_unapp[dest]: \"unapp u = Some (u\\<^sub>1, u\\<^sub>2) \\<Longrightarrow> u = app u\\<^sub>1 u\\<^sub>2\"\n assumes app_size[simp]: \"size (app u\\<^sub>1 u\\<^sub>2) = size u\\<^sub>1 + size u\\<^sub>2 + 1\"\n assumes unconst_const[simp]: \"unconst (const name) = Some name\"\n assumes const_unconst[dest]: \"unconst u = Some name \\<Longrightarrow> u = const name\"\n assumes unfree_free[simp]: \"unfree (free name) = Some name\"\n assumes free_unfree[dest]: \"unfree u = Some name \\<Longrightarrow> u = free name\"\n assumes app_const_distinct: \"app u\\<^sub>1 u\\<^sub>2 \\<noteq> const name\"\n assumes app_free_distinct: \"app u\\<^sub>1 u\\<^sub>2 \\<noteq> free name\"\n assumes free_const_distinct: \"free name\\<^sub>1 \\<noteq> const name\\<^sub>2\"\n assumes frees_const[simp]: \"frees (const name) = fempty\"\n assumes frees_free[simp]: \"frees (free name) = {| name |}\"\n assumes frees_app[simp]: \"frees (app u\\<^sub>1 u\\<^sub>2) = frees u\\<^sub>1 |\\<union>| frees u\\<^sub>2\"\n assumes consts_free[simp]: \"consts (free name) = fempty\"\n assumes consts_const[simp]: \"consts (const name) = {| name |}\"\n assumes consts_app[simp]: \"consts (app u\\<^sub>1 u\\<^sub>2) = consts u\\<^sub>1 |\\<union>| consts u\\<^sub>2\"\n assumes subst_app[simp]: \"subst (app u\\<^sub>1 u\\<^sub>2) env = app (subst u\\<^sub>1 env) (subst u\\<^sub>2 env)\"\n assumes subst_const[simp]: \"subst (const name) env = const name\"\n assumes subst_free[simp]: \"subst (free name) env = (case fmlookup env name of Some t \\<Rightarrow> t | _ \\<Rightarrow> free name)\"\n assumes free_inject: \"free name\\<^sub>1 = free name\\<^sub>2 \\<Longrightarrow> name\\<^sub>1 = name\\<^sub>2\"\n assumes const_inject: \"const name\\<^sub>1 = const name\\<^sub>2 \\<Longrightarrow> name\\<^sub>1 = name\\<^sub>2\"\n assumes app_inject: \"app u\\<^sub>1 u\\<^sub>2 = app u\\<^sub>3 u\\<^sub>4 \\<Longrightarrow> u\\<^sub>1 = u\\<^sub>3 \\<and> u\\<^sub>2 = u\\<^sub>4\""
] |
###lemma
srelated'.P_env ?penv ?senv \<Longrightarrow> pre_strong_term_class.wellformed ?t \<Longrightarrow> pterm_to_sterm (subst ?t ?penv) = subst (pterm_to_sterm ?t) ?senv
|
###output
\<lbrakk>?H1 x_1 x_2; ?H2 x_3\<rbrakk> \<Longrightarrow> ?H3 (?H4 x_3 x_1) = ?H5 (?H3 x_3) x_2
###end
|
IP_Addresses/WordInterval
|
WordInterval.l2wi_append
|
lemma l2wi_append: "wordinterval_to_set (l2wi (l1@l2)) =
wordinterval_to_set (l2wi l1) \<union> wordinterval_to_set (l2wi l2)"
|
wordinterval_to_set (l2wi (?l1.0 @ ?l2.0)) = wordinterval_to_set (l2wi ?l1.0) \<union> wordinterval_to_set (l2wi ?l2.0)
|
?H1 (?H2 (?H3 x_1 x_2)) = ?H4 (?H1 (?H2 x_1)) (?H1 (?H2 x_2))
|
[
"Set.union",
"List.append",
"WordInterval.l2wi",
"WordInterval.wordinterval_to_set"
] |
[
"abbreviation union :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> 'a set\" (infixl \"\\<union>\" 65)\n where \"union \\<equiv> sup\"",
"primrec append :: \"'a list \\<Rightarrow> 'a list \\<Rightarrow> 'a list\" (infixr \"@\" 65) where\nappend_Nil: \"[] @ ys = ys\" |\nappend_Cons: \"(x#xs) @ ys = x # xs @ ys\"",
"fun l2wi :: \"('a::len word \\<times> 'a word) list \\<Rightarrow> 'a wordinterval\" where\n \"l2wi [] = Empty_WordInterval\" |\n \"l2wi [(s,e)] = (WordInterval s e)\" |\n \"l2wi ((s,e)#rs) = (RangeUnion (WordInterval s e) (l2wi rs))\"",
"fun wordinterval_to_set :: \"'a::len wordinterval \\<Rightarrow> ('a::len word) set\"\n where\n \"wordinterval_to_set (WordInterval start end) =\n {start .. end}\" |\n \"wordinterval_to_set (RangeUnion r1 r2) =\n wordinterval_to_set r1 \\<union> wordinterval_to_set r2\""
] |
###lemma
wordinterval_to_set (l2wi (?l1.0 @ ?l2.0)) = wordinterval_to_set (l2wi ?l1.0) \<union> wordinterval_to_set (l2wi ?l2.0)
|
###output
?H1 (?H2 (?H3 x_1 x_2)) = ?H4 (?H1 (?H2 x_1)) (?H1 (?H2 x_2))
###end
|
Khovanskii_Theorem/Khovanskii
|
Khovanskii.length_plus_list
|
lemma length_plus_list [simp]:
fixes xs :: "'a::plus list"
shows "length (xs+ys) = min (length xs) (length ys)"
|
length (?xs + ?ys) = min (length ?xs) (length ?ys)
|
?H1 (?H2 x_1 x_2) = ?H3 (?H1 x_1) (?H1 x_2)
|
[
"Orderings.ord_class.min",
"Groups.plus_class.plus",
"List.length"
] |
[
"class ord =\n fixes less_eq :: \"'a \\<Rightarrow> 'a \\<Rightarrow> bool\"\n and less :: \"'a \\<Rightarrow> 'a \\<Rightarrow> bool\"\nbegin",
"class plus =\n fixes plus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"+\" 65)",
"abbreviation length :: \"'a list \\<Rightarrow> nat\" where\n\"length \\<equiv> size\""
] |
###lemma
length (?xs + ?ys) = min (length ?xs) (length ?ys)
|
###output
?H1 (?H2 x_1 x_2) = ?H3 (?H1 x_1) (?H1 x_2)
###end
|
Induct/Com
|
Complete_Lattices.Union_disjoint
| null |
(\<Union> ?C \<inter> ?A = {}) = (\<forall>B\<in>?C. B \<inter> ?A = {})
|
(?H1 (?H2 x_1) x_2 = ?H3) = (\<forall>y_0\<in>x_1. ?H1 y_0 x_2 = ?H3)
|
[
"Set.empty",
"Complete_Lattices.Union",
"Set.inter"
] |
[
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"abbreviation Union :: \"'a set set \\<Rightarrow> 'a set\" (\"\\<Union>\")\n where \"\\<Union>S \\<equiv> \\<Squnion>S\"",
"abbreviation inter :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> 'a set\" (infixl \"\\<inter>\" 70)\n where \"(\\<inter>) \\<equiv> inf\""
] |
###lemma
(\<Union> ?C \<inter> ?A = {}) = (\<forall>B\<in>?C. B \<inter> ?A = {})
|
###output
(?H1 (?H2 x_1) x_2 = ?H3) = (\<forall>y_0\<in>x_1. ?H1 y_0 x_2 = ?H3)
###end
|
Fourier/Square_Integrable
|
Square_Integrable.lspace_approximate_bounded
|
lemma lspace_approximate_bounded:
assumes f: "f \<in> lspace (lebesgue_on S) p" and S: "S \<in> lmeasurable" and "p > 0" "e > 0"
obtains g where "g \<in> lspace (lebesgue_on S) p" "bounded (g ` S)"
"lnorm (lebesgue_on S) p (f - g) < e"
|
?f \<in> lspace (lebesgue_on ?S) (ennreal ?p) \<Longrightarrow> ?S \<in> lmeasurable \<Longrightarrow> 0 < ?p \<Longrightarrow> 0 < ?e \<Longrightarrow> (\<And>g. g \<in> lspace (lebesgue_on ?S) (ennreal ?p) \<Longrightarrow> bounded (g ` ?S) \<Longrightarrow> lnorm (lebesgue_on ?S) ?p (?f - g) < ?e \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
\<lbrakk>x_1 \<in> ?H1 (?H2 x_2) (?H3 x_3); x_2 \<in> ?H4; ?H5 < x_3; ?H5 < x_4; \<And>y_0. \<lbrakk>y_0 \<in> ?H1 (?H2 x_2) (?H3 x_3); ?H6 (?H7 y_0 x_2); ?H8 (?H2 x_2) x_3 (?H9 x_1 y_0) < x_4\<rbrakk> \<Longrightarrow> x_5\<rbrakk> \<Longrightarrow> x_5
|
[
"Groups.minus_class.minus",
"Square_Integrable.lnorm",
"Set.image",
"Elementary_Metric_Spaces.metric_space_class.bounded",
"Groups.zero_class.zero",
"Lebesgue_Measure.lmeasurable",
"Extended_Nonnegative_Real.ennreal",
"Lebesgue_Measure.lebesgue_on",
"Lspace.lspace"
] |
[
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)",
"definition lnorm :: \"['a measure, real, 'a \\<Rightarrow> real] \\<Rightarrow> real\"\n where \"lnorm M p f \\<equiv> (\\<integral>x. \\<bar>f x\\<bar> powr p \\<partial>M) powr (1/p)\"",
"definition image :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a set \\<Rightarrow> 'b set\" (infixr \"`\" 90)\n where \"f ` A = {y. \\<exists>x\\<in>A. y = f x}\"",
"class zero =\n fixes zero :: 'a (\"0\")",
"typedef ennreal = \"{x :: ereal. 0 \\<le> x}\"\n morphisms enn2ereal e2ennreal'",
"abbreviation lspace :: \"'a measure \\<Rightarrow> ennreal \\<Rightarrow> ('a \\<Rightarrow> real) set\"\n where \"lspace M p \\<equiv> space\\<^sub>N (\\<LL> p M)\""
] |
###lemma
?f \<in> lspace (lebesgue_on ?S) (ennreal ?p) \<Longrightarrow> ?S \<in> lmeasurable \<Longrightarrow> 0 < ?p \<Longrightarrow> 0 < ?e \<Longrightarrow> (\<And>g. g \<in> lspace (lebesgue_on ?S) (ennreal ?p) \<Longrightarrow> bounded (g ` ?S) \<Longrightarrow> lnorm (lebesgue_on ?S) ?p (?f - g) < ?e \<Longrightarrow> ?thesis) \<Longrightarrow> ?thesis
|
###output
\<lbrakk>x_1 \<in> ?H1 (?H2 x_2) (?H3 x_3); x_2 \<in> ?H4; ?H5 < x_3; ?H5 < x_4; \<And>y_0. \<lbrakk>y_0 \<in> ?H1 (?H2 x_2) (?H3 x_3); ?H6 (?H7 y_0 x_2); ?H8 (?H2 x_2) x_3 (?H9 x_1 y_0) < x_4\<rbrakk> \<Longrightarrow> x_5\<rbrakk> \<Longrightarrow> x_5
###end
|
Transition_Systems_and_Automata/Basic/Refine
|
Refine_While.WHILEI_tailrec_conv
| null |
WHILE\<^bsup>?I\<^esup> ?c ?f = REC (tailrec_body (\<lambda>s. ASSERT (?I s) \<bind> (\<lambda>_. ASSUME (?c s) \<bind> (\<lambda>_. ?f s))) (\<lambda>s. ASSERT (?I s) \<bind> (\<lambda>_. ASSUME (\<not> ?c s) \<bind> (\<lambda>_. RETURN s))))
|
?H1 x_1 x_2 x_3 = ?H2 (?H3 (\<lambda>y_0. ?H4 (?H5 (x_1 y_0)) (\<lambda>y_1. ?H4 (?H6 (x_2 y_0)) (\<lambda>y_2. x_3 y_0))) (\<lambda>y_3. ?H4 (?H5 (x_1 y_3)) (\<lambda>y_4. ?H4 (?H6 (\<not> x_2 y_3)) (\<lambda>y_5. ?H7 y_3))))
|
[
"Refine_Basic.RETURN",
"Refine_Basic.ASSUME",
"Refine_Basic.ASSERT",
"Refine_Basic.bind",
"Refine_While.tailrec_body",
"RefineG_Recursion.REC",
"Refine_While.WHILEI"
] |
[
"definition \"RETURN x \\<equiv> RES {x}\"",
"definition ASSUME where \"ASSUME \\<equiv> iASSUME RETURN\"",
"definition ASSERT where \"ASSERT \\<equiv> iASSERT RETURN\"",
"definition bind where \"bind M f \\<equiv> case M of \n FAILi \\<Rightarrow> FAIL |\n RES X \\<Rightarrow> Sup (f`X)\"",
"definition \"tailrec_body a b \\<equiv> (\\<lambda>D s. sup (bind (a s) D) (b s))\"",
"definition WHILEI (\"WHILE\\<^bsup>_\\<^esup>\") where \"WHILEI \\<equiv> iWHILEI bind RETURN\""
] |
###lemma
WHILE\<^bsup>?I\<^esup> ?c ?f = REC (tailrec_body (\<lambda>s. ASSERT (?I s) \<bind> (\<lambda>_. ASSUME (?c s) \<bind> (\<lambda>_. ?f s))) (\<lambda>s. ASSERT (?I s) \<bind> (\<lambda>_. ASSUME (\<not> ?c s) \<bind> (\<lambda>_. RETURN s))))
|
###output
?H1 x_1 x_2 x_3 = ?H2 (?H3 (\<lambda>y_0. ?H4 (?H5 (x_1 y_0)) (\<lambda>y_1. ?H4 (?H6 (x_2 y_0)) (\<lambda>y_2. x_3 y_0))) (\<lambda>y_3. ?H4 (?H5 (x_1 y_3)) (\<lambda>y_4. ?H4 (?H6 (\<not> x_2 y_3)) (\<lambda>y_5. ?H7 y_3))))
###end
|
Stateful_Protocol_Composition_and_Typing/Labeled_Strands
|
Labeled_Strands.proj_unl_cons(2)
|
lemma proj_unl_cons[simp]:
"proj_unl l ((ln l, a)#A) = a#proj_unl l A"
"l \<noteq> l' \<Longrightarrow> proj_unl l' ((ln l, a)#A) = proj_unl l' A"
"proj_unl l ((\<star>, a)#A) = a#proj_unl l A"
|
?l \<noteq> ?l' \<Longrightarrow> proj_unl ?l' ((ln ?l, ?a) # ?A) = proj_unl ?l' ?A
|
x_1 \<noteq> x_2 \<Longrightarrow> ?H1 x_2 (?H2 (?H3 x_1, x_3) x_4) = ?H1 x_2 x_4
|
[
"Labeled_Strands.strand_label.LabelN",
"List.list.Cons",
"Labeled_Strands.proj_unl"
] |
[
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"abbreviation proj_unl where \"proj_unl n S \\<equiv> unlabel (proj n S)\""
] |
###lemma
?l \<noteq> ?l' \<Longrightarrow> proj_unl ?l' ((ln ?l, ?a) # ?A) = proj_unl ?l' ?A
|
###output
x_1 \<noteq> x_2 \<Longrightarrow> ?H1 x_2 (?H2 (?H3 x_1, x_3) x_4) = ?H1 x_2 x_4
###end
|
Topological_Semantics/conditions_relativized
|
conditions_relativized.CNTR_fp
|
lemma CNTR_fp: "CNTR \<phi> = nCNTR \<phi>\<^sup>f\<^sup>p"
|
CNTR (?\<phi>::(?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) = nCNTR ?\<phi>\<^sup>f\<^sup>p
|
(?H1::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> bool) (x_1::(?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) = (?H2::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> bool) ((?H3::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) x_1)
|
[
"boolean_algebra_operators.op_fixpoint",
"conditions_negative.nCNTR",
"conditions_positive.CNTR"
] |
[
"definition op_fixpoint::\"('w \\<sigma> \\<Rightarrow> 'w \\<sigma>) \\<Rightarrow> ('w \\<sigma> \\<Rightarrow> 'w \\<sigma>)\" (\"(_\\<^sup>f\\<^sup>p)\")\n where \"\\<phi>\\<^sup>f\\<^sup>p \\<equiv> \\<lambda>X. (\\<phi> X) \\<^bold>\\<leftrightarrow> X\"",
"definition nCNTR::\"('w \\<sigma> \\<Rightarrow> 'w \\<sigma>) \\<Rightarrow> bool\" (\"nCNTR\")\n where \"nCNTR \\<phi> \\<equiv> \\<forall>A. \\<^bold>\\<midarrow>A \\<^bold>\\<le> \\<phi> A\"",
"definition CNTR::\"('w \\<sigma> \\<Rightarrow> 'w \\<sigma>) \\<Rightarrow> bool\" (\"CNTR\")\n where \"CNTR \\<phi> \\<equiv> \\<forall>A. \\<phi> A \\<^bold>\\<le> A\""
] |
###lemma
CNTR (?\<phi>::(?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) = nCNTR ?\<phi>\<^sup>f\<^sup>p
|
###output
(?H1::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> bool) (x_1::(?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) = (?H2::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> bool) ((?H3::((?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) \<Rightarrow> (?'a \<Rightarrow> bool) \<Rightarrow> ?'a \<Rightarrow> bool) x_1)
###end
|
CakeML_Codegen/Utils/Compiler_Utils
|
Compiler_Utils.fmax_decr
|
lemma fmax_decr:
fixes X :: "nat fset"
assumes "fBex X (\<lambda>x. x \<ge> k)"
shows "fMax ((\<lambda>x. x - k) |`| X) = fMax X - k"
|
\<exists>x|\<in>|?X. ?k \<le> x \<Longrightarrow> fMax ((\<lambda>x. x - ?k) |`| ?X) = fMax ?X - ?k
|
?H1 x_1 ((\<le>) x_2) \<Longrightarrow> ?H2 (?H3 (\<lambda>y_1. ?H4 y_1 x_2) x_1) = ?H4 (?H2 x_1) x_2
|
[
"Groups.minus_class.minus",
"FSet.fimage",
"FSet.linorder_class.fMax",
"FSet.Bex"
] |
[
"class minus =\n fixes minus :: \"'a \\<Rightarrow> 'a \\<Rightarrow> 'a\" (infixl \"-\" 65)",
"abbreviation Bex :: \"'a fset \\<Rightarrow> ('a \\<Rightarrow> bool) \\<Rightarrow> bool\" where\n \"Bex X \\<equiv> Set.Bex (fset X)\""
] |
###lemma
\<exists>x|\<in>|?X. ?k \<le> x \<Longrightarrow> fMax ((\<lambda>x. x - ?k) |`| ?X) = fMax ?X - ?k
|
###output
?H1 x_1 ((\<le>) x_2) \<Longrightarrow> ?H2 (?H3 (\<lambda>y_1. ?H4 y_1 x_2) x_1) = ?H4 (?H2 x_1) x_2
###end
|
Martingales/Conditional_Expectation_Banach
|
Conditional_Expectation_Banach.has_cond_exp_sets_cong
|
lemma has_cond_exp_sets_cong:
assumes "sets F = sets G"
shows "has_cond_exp M F = has_cond_exp M G"
|
sets ?F = sets ?G \<Longrightarrow> has_cond_exp ?M ?F = has_cond_exp ?M ?G
|
?H1 x_1 = ?H1 x_2 \<Longrightarrow> ?H2 x_3 x_1 = ?H2 x_3 x_2
|
[
"Conditional_Expectation_Banach.has_cond_exp",
"Sigma_Algebra.sets"
] |
[
"definition has_cond_exp :: \"'a measure \\<Rightarrow> 'a measure \\<Rightarrow> ('a \\<Rightarrow> 'b) \\<Rightarrow> ('a \\<Rightarrow> 'b::{real_normed_vector, second_countable_topology}) \\<Rightarrow> bool\" where \n \"has_cond_exp M F f g = ((\\<forall>A \\<in> sets F. (\\<integral> x \\<in> A. f x \\<partial>M) = (\\<integral> x \\<in> A. g x \\<partial>M))\n \\<and> integrable M f \n \\<and> integrable M g \n \\<and> g \\<in> borel_measurable F)\""
] |
###lemma
sets ?F = sets ?G \<Longrightarrow> has_cond_exp ?M ?F = has_cond_exp ?M ?G
|
###output
?H1 x_1 = ?H1 x_2 \<Longrightarrow> ?H2 x_3 x_1 = ?H2 x_3 x_2
###end
|
Optics/Prisms
|
Prisms.prism_lens_inverse
|
lemma prism_lens_inverse:
"wb_prism X \<Longrightarrow> lens_prism (prism_lens X) = X"
|
wb_prism ?X \<Longrightarrow> lens_prism (prism_lens ?X) = ?X
|
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_1) = x_1
|
[
"Prisms.prism_lens",
"Prisms.lens_prism",
"Prisms.wb_prism"
] |
[
"definition prism_lens :: \"('a, 's) prism \\<Rightarrow> ('a \\<Longrightarrow> 's)\" where\n\"prism_lens X = \\<lparr> lens_get = (\\<lambda> s. the (match\\<^bsub>X\\<^esub> s)), lens_put = (\\<lambda> s v. build\\<^bsub>X\\<^esub> v) \\<rparr>\"",
"definition lens_prism :: \"('a \\<Longrightarrow> 's) \\<Rightarrow> ('a, 's) prism\" where\n\"lens_prism X = \\<lparr> prism_match = (\\<lambda> s. if (s \\<in> \\<S>\\<^bsub>X\\<^esub>) then Some (get\\<^bsub>X\\<^esub> s) else None)\n , prism_build = create\\<^bsub>X\\<^esub> \\<rparr>\""
] |
###lemma
wb_prism ?X \<Longrightarrow> lens_prism (prism_lens ?X) = ?X
|
###output
?H1 x_1 \<Longrightarrow> ?H2 (?H3 x_1) = x_1
###end
|
VerifyThis2019/Challenge2A
|
Challenge2A.pop_cons
|
lemma pop_cons: "pop (j#js) v = (if xs!j \<ge> v then pop js v else j#js)"
|
pop ?xs (?j # ?js) ?v = (if ?v \<le> ?xs ! ?j then pop ?xs ?js ?v else ?j # ?js)
|
?H1 x_1 (?H2 x_2 x_3) x_4 = (if x_4 \<le> ?H3 x_1 x_2 then ?H1 x_1 x_3 x_4 else ?H2 x_2 x_3)
|
[
"List.nth",
"List.list.Cons",
"Challenge2A.pop"
] |
[
"primrec (nonexhaustive) nth :: \"'a list => nat => 'a\" (infixl \"!\" 100) where\nnth_Cons: \"(x # xs) ! n = (case n of 0 \\<Rightarrow> x | Suc k \\<Rightarrow> xs ! k)\"\n \\<comment> \\<open>Warning: simpset does not contain this definition, but separate\n theorems for \\<open>n = 0\\<close> and \\<open>n = Suc k\\<close>\\<close>",
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"definition \"pop stk v \\<equiv> dropWhile (\\<lambda>j. xs!j\\<ge>v) stk\""
] |
###lemma
pop ?xs (?j # ?js) ?v = (if ?v \<le> ?xs ! ?j then pop ?xs ?js ?v else ?j # ?js)
|
###output
?H1 x_1 (?H2 x_2 x_3) x_4 = (if x_4 \<le> ?H3 x_1 x_2 then ?H1 x_1 x_3 x_4 else ?H2 x_2 x_3)
###end
|
AOT/AOT_NaturalNumbers
|
AOT_NaturalNumbers.eq-part-act:1
| null |
\<^bold>\<turnstile> [\<lambda>z \<^bold>\<A>[F]z] \<equiv>\<^sub>E F
|
H1 H2 (H3 (H4 (\<lambda>y_0. H5 (H6 (H7 x_1) y_0))) (H7 x_1))
|
[
"AOT_model.AOT_var.AOT_term_of_var",
"AOT_syntax.AOT_exe",
"AOT_syntax.AOT_act",
"AOT_syntax.AOT_lambda",
"AOT_ExtendedRelationComprehension.eqE",
"AOT_model.w\\<^sub>0",
"AOT_model.AOT_model_valid_in"
] |
[
"consts w\\<^sub>0 :: w \\<comment>\\<open>The designated actual world.\\<close>",
"definition AOT_model_valid_in :: \\<open>w\\<Rightarrow>\\<o>\\<Rightarrow>bool\\<close> where\n \\<open>AOT_model_valid_in w \\<phi> \\<equiv> AOT_model_d\\<o> \\<phi> w\\<close>"
] |
###lemma
\<^bold>\<turnstile> [\<lambda>z \<^bold>\<A>[F]z] \<equiv>\<^sub>E F
|
###output
H1 H2 (H3 (H4 (\<lambda>y_0. H5 (H6 (H7 x_1) y_0))) (H7 x_1))
###end
|
AODV/variants/b_fwdrreps/B_Global_Invariants
|
B_Global_Invariants.odests_vD_inc_sqn
| null |
opaodv ?i \<Turnstile> (?S, other ?ANY {?i} \<rightarrow>) onl \<Gamma>\<^sub>A\<^sub>O\<^sub>D\<^sub>V (seql ?i (\<lambda>(\<xi>, l). (l \<in> {PAodv-:15, PPkt-:7, PRreq-:9, PRreq-:21, PRrep-:9} \<longrightarrow> (\<forall>ip\<in>dom (dests \<xi>). ip \<in> vD (rt \<xi>) \<and> the (dests \<xi> ip) = inc (sqn (rt \<xi>) ip))) \<and> (l = PRerr-:1 \<longrightarrow> (\<forall>ip\<in>dom (dests \<xi>). ip \<in> vD (rt \<xi>) \<and> sqn (rt \<xi>) ip < the (dests \<xi> ip)))))
|
?H1 (?H2 x_1) x_2 (?H3 x_3 (?H4 x_1 ?H5)) (?H6 ?H7 (?H8 x_1 (?H9 (\<lambda>y_0 y_1. (y_1 \<in> ?H10 (?H11 ?H12 (?H13 (?H14 (?H14 (?H14 ?H15))))) (?H10 (?H11 ?H16 (?H13 (?H14 (?H14 ?H15)))) (?H10 (?H11 ?H17 (?H13 (?H14 (?H18 (?H18 ?H15))))) (?H10 (?H11 ?H17 (?H13 (?H14 (?H18 (?H14 (?H18 ?H15)))))) (?H10 (?H11 ?H19 (?H13 (?H14 (?H18 (?H18 ?H15))))) ?H20)))) \<longrightarrow> (\<forall>y_2\<in>?H21 (?H22 y_0). y_2 \<in> ?H23 (?H24 y_0) \<and> ?H25 (?H22 y_0 y_2) = ?H26 (?H27 (?H24 y_0) y_2))) \<and> (y_1 = ?H11 ?H28 ?H29 \<longrightarrow> (\<forall>y_3\<in>?H21 (?H22 y_0). y_3 \<in> ?H23 (?H24 y_0) \<and> ?H27 (?H24 y_0) y_3 < ?H25 (?H22 y_0 y_3)))))))
|
[
"Groups.one_class.one",
"B_Aodv.pseqp.PRerr",
"B_Aodv_Data.sqn",
"B_Aodv_Data.inc",
"Option.option.the",
"B_Aodv.state.rt",
"B_Aodv_Data.vD",
"B_Aodv.state.dests",
"Map.dom",
"B_Aodv.pseqp.PRrep",
"Num.num.Bit0",
"B_Aodv.pseqp.PRreq",
"B_Aodv.pseqp.PPkt",
"Num.num.One",
"Num.num.Bit1",
"Num.numeral_class.numeral",
"B_Aodv.pseqp.PAodv",
"AWN_Labels.label.LABEL",
"Product_Type.prod.case_prod",
"OAWN_Convert.seql",
"B_Aodv.\\<Gamma>\\<^sub>A\\<^sub>O\\<^sub>D\\<^sub>V",
"AWN_Invariants.onl",
"Set.empty",
"Set.insert",
"OInvariants.other",
"B_OAodv.opaodv",
"OInvariants.oinvariant"
] |
[
"class one =\n fixes one :: 'a (\"1\")",
"datatype 'a option =\n None\n | Some (the: 'a)",
"definition\n dom :: \"('a \\<rightharpoonup> 'b) \\<Rightarrow> 'a set\" where\n \"dom m = {a. m a \\<noteq> None}\"",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"datatype num = One | Bit0 num | Bit1 num",
"primrec numeral :: \"num \\<Rightarrow> 'a\"\n where\n numeral_One: \"numeral One = 1\"\n | numeral_Bit0: \"numeral (Bit0 n) = numeral n + numeral n\"\n | numeral_Bit1: \"numeral (Bit1 n) = numeral n + numeral n + 1\"",
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"definition\n seql :: \"'i \\<Rightarrow> (('s \\<times> 'l) \\<Rightarrow> bool) \\<Rightarrow> (('i \\<Rightarrow> 's) \\<times> 'l) \\<Rightarrow> bool\"\nwhere\n \"seql i P \\<equiv> (\\<lambda>(\\<sigma>, p). P (\\<sigma> i, p))\"",
"definition\n onl :: \"('s, 'm, 'p, 'l) seqp_env\n \\<Rightarrow> ('z \\<times> 'l \\<Rightarrow> bool)\n \\<Rightarrow> 'z \\<times> ('s, 'm, 'p, 'l) seqp\n \\<Rightarrow> bool\"\nwhere\n \"onl \\<Gamma> P \\<equiv> (\\<lambda>(\\<xi>, p). \\<forall>l\\<in>labels \\<Gamma> p. P (\\<xi>, l))\"",
"abbreviation empty :: \"'a set\" (\"{}\")\n where \"{} \\<equiv> bot\"",
"definition insert :: \"'a \\<Rightarrow> 'a set \\<Rightarrow> 'a set\"\n where insert_compr: \"insert a B = {x. x = a \\<or> x \\<in> B}\"",
"definition other :: \"('s \\<Rightarrow> 's \\<Rightarrow> bool) \\<Rightarrow> 'i set \\<Rightarrow> ('i \\<Rightarrow> 's) \\<Rightarrow> ('i \\<Rightarrow> 's) \\<Rightarrow> bool\"\nwhere \"other P I \\<sigma> \\<sigma>' \\<equiv> \\<forall>i. if i\\<in>I then \\<sigma>' i = \\<sigma> i else P (\\<sigma> i) (\\<sigma>' i)\"",
"definition oinvariant\n :: \"('g \\<times> 'l, 'a) automaton\n \\<Rightarrow> ('g \\<Rightarrow> 'g \\<Rightarrow> 'a \\<Rightarrow> bool) \\<Rightarrow> ('g \\<Rightarrow> 'g \\<Rightarrow> bool)\n \\<Rightarrow> (('g \\<times> 'l) \\<Rightarrow> bool) \\<Rightarrow> bool\"\n (\"_ \\<Turnstile> (1'((1_),/ (1_) \\<rightarrow>')/ _)\" [100, 0, 0, 9] 8)\nwhere\n \"(A \\<Turnstile> (S, U \\<rightarrow>) P) = (\\<forall>s\\<in>oreachable A S U. P s)\""
] |
###lemma
opaodv ?i \<Turnstile> (?S, other ?ANY {?i} \<rightarrow>) onl \<Gamma>\<^sub>A\<^sub>O\<^sub>D\<^sub>V (seql ?i (\<lambda>(\<xi>, l). (l \<in> {PAodv-:15, PPkt-:7, PRreq-:9, PRreq-:21, PRrep-:9} \<longrightarrow> (\<forall>ip\<in>dom (dests \<xi>). ip \<in> vD (rt \<xi>) \<and> the (dests \<xi> ip) = inc (sqn (rt \<xi>) ip))) \<and> (l = PRerr-:1 \<longrightarrow> (\<forall>ip\<in>dom (dests \<xi>). ip \<in> vD (rt \<xi>) \<and> sqn (rt \<xi>) ip < the (dests \<xi> ip)))))
|
###output
?H1 (?H2 x_1) x_2 (?H3 x_3 (?H4 x_1 ?H5)) (?H6 ?H7 (?H8 x_1 (?H9 (\<lambda>y_0 y_1. (y_1 \<in> ?H10 (?H11 ?H12 (?H13 (?H14 (?H14 (?H14 ?H15))))) (?H10 (?H11 ?H16 (?H13 (?H14 (?H14 ?H15)))) (?H10 (?H11 ?H17 (?H13 (?H14 (?H18 (?H18 ?H15))))) (?H10 (?H11 ?H17 (?H13 (?H14 (?H18 (?H14 (?H18 ?H15)))))) (?H10 (?H11 ?H19 (?H13 (?H14 (?H18 (?H18 ?H15))))) ?H20)))) \<longrightarrow> (\<forall>y_2\<in>?H21 (?H22 y_0). y_2 \<in> ?H23 (?H24 y_0) \<and> ?H25 (?H22 y_0 y_2) = ?H26 (?H27 (?H24 y_0) y_2))) \<and> (y_1 = ?H11 ?H28 ?H29 \<longrightarrow> (\<forall>y_3\<in>?H21 (?H22 y_0). y_3 \<in> ?H23 (?H24 y_0) \<and> ?H27 (?H24 y_0) y_3 < ?H25 (?H22 y_0 y_3)))))))
###end
|
Pi_Calculus/Rel
|
Relation.converseI
| null |
(?a, ?b) \<in> ?r \<Longrightarrow> (?b, ?a) \<in> ?r\<inverse>
|
(x_1, x_2) \<in> x_3 \<Longrightarrow> (x_2, x_1) \<in> ?H1 x_3
|
[
"Relation.converse"
] |
[
"inductive_set converse :: \"('a \\<times> 'b) set \\<Rightarrow> ('b \\<times> 'a) set\" (\"(_\\<inverse>)\" [1000] 999)\n for r :: \"('a \\<times> 'b) set\"\n where \"(a, b) \\<in> r \\<Longrightarrow> (b, a) \\<in> r\\<inverse>\""
] |
###lemma
(?a, ?b) \<in> ?r \<Longrightarrow> (?b, ?a) \<in> ?r\<inverse>
|
###output
(x_1, x_2) \<in> x_3 \<Longrightarrow> (x_2, x_1) \<in> ?H1 x_3
###end
|
Polynomials/Power_Products
|
Power_Products.drlex_pm_lin
|
lemma drlex_pm_lin: "drlex_pm s t \<or> drlex_pm t s"
|
drlex_pm ?s ?t \<or> drlex_pm ?t ?s
|
?H1 x_1 x_2 \<or> ?H1 x_2 x_1
|
[
"Power_Products.drlex_pm"
] |
[
"definition drlex_pm::\"('a::linorder \\<Rightarrow>\\<^sub>0 'b::{ordered_comm_monoid_add,linorder}) \\<Rightarrow> ('a \\<Rightarrow>\\<^sub>0 'b) \\<Rightarrow> bool\"\n where \"drlex_pm \\<equiv> dord_pm (\\<lambda>s t. lex_pm t s)\""
] |
###lemma
drlex_pm ?s ?t \<or> drlex_pm ?t ?s
|
###output
?H1 x_1 x_2 \<or> ?H1 x_2 x_1
###end
|
UNITY/Comp
|
Complete_Lattices.vimage_INT
| null |
?f -` \<Inter> (?B ` ?A) = (\<Inter>x\<in>?A. ?f -` ?B x)
|
?H1 x_1 (?H2 (?H3 x_2 x_3)) = ?H4 (?H5 (\<lambda>y_1. ?H1 x_1 (x_2 y_1)) x_3)
|
[
"Set.image",
"Complete_Lattices.Inter",
"Set.vimage"
] |
[
"definition image :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a set \\<Rightarrow> 'b set\" (infixr \"`\" 90)\n where \"f ` A = {y. \\<exists>x\\<in>A. y = f x}\"",
"abbreviation Inter :: \"'a set set \\<Rightarrow> 'a set\" (\"\\<Inter>\")\n where \"\\<Inter>S \\<equiv> \\<Sqinter>S\"",
"definition vimage :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'b set \\<Rightarrow> 'a set\" (infixr \"-`\" 90)\n where \"f -` B \\<equiv> {x. f x \\<in> B}\""
] |
###lemma
?f -` \<Inter> (?B ` ?A) = (\<Inter>x\<in>?A. ?f -` ?B x)
|
###output
?H1 x_1 (?H2 (?H3 x_2 x_3)) = ?H4 (?H5 (\<lambda>y_1. ?H1 x_1 (x_2 y_1)) x_3)
###end
|
Prime_Number_Theorem/Prime_Number_Theorem_Library
|
Prime_Number_Theorem_Library.natfun_bigo_iff_Bseq
|
lemma natfun_bigo_iff_Bseq: "f \<in> O(\<lambda>_. 1) \<longleftrightarrow> Bseq f"
|
(?f \<in> O(\<lambda>_. 1::?'a)) = Bseq ?f
|
(x_1 \<in> ?H1 (\<lambda>y_0. ?H2)) = ?H3 x_1
|
[
"Limits.Bseq",
"Groups.one_class.one",
"Landau_Symbols.bigo_at_top"
] |
[
"abbreviation Bseq :: \"(nat \\<Rightarrow> 'a::metric_space) \\<Rightarrow> bool\"\n where \"Bseq X \\<equiv> Bfun X sequentially\"",
"class one =\n fixes one :: 'a (\"1\")",
"abbreviation bigo_at_top (\\<open>(2O'(_'))\\<close>) where\n \"O(g) \\<equiv> bigo at_top g\""
] |
###lemma
(?f \<in> O(\<lambda>_. 1::?'a)) = Bseq ?f
|
###output
(x_1 \<in> ?H1 (\<lambda>y_0. ?H2)) = ?H3 x_1
###end
|
Real_Time_Deque/States_Proof
|
States_Proof.step_push_size_new_small
|
lemma step_push_size_new_small [simp]: "\<lbrakk>
invar (States dir big small);
step (States dir big (Small.push x small)) = States dir' big' small'
\<rbrakk> \<Longrightarrow> size_new small' = Suc (size_new small)"
|
invar (States ?dir ?big ?small) \<Longrightarrow> step (States ?dir ?big (Small.push ?x ?small)) = States ?dir' ?big' ?small' \<Longrightarrow> size_new ?small' = Suc (size_new ?small)
|
\<lbrakk>?H1 (?H2 x_1 x_2 x_3); ?H3 (?H2 x_1 x_2 (?H4 x_4 x_3)) = ?H2 x_5 x_6 x_7\<rbrakk> \<Longrightarrow> ?H5 x_7 = ?H6 (?H5 x_3)
|
[
"Nat.Suc",
"Type_Classes.size_new_class.size_new",
"Small.push",
"Type_Classes.step_class.step",
"States.states.States",
"Type_Classes.invar_class.invar"
] |
[
"definition Suc :: \"nat \\<Rightarrow> nat\"\n where \"Suc n = Abs_Nat (Suc_Rep (Rep_Nat n))\"",
"class size_new =\n fixes size_new :: \"'a \\<Rightarrow> nat\"",
"fun push :: \"'a \\<Rightarrow> 'a small_state \\<Rightarrow> 'a small_state\" where\n \"push x (Small3 state) = Small3 (Common.push x state)\"\n| \"push x (Small1 current small auxS) = Small1 (Current.push x current) small auxS\"\n| \"push x (Small2 current auxS big newS count) = \n Small2 (Current.push x current) auxS big newS count\"",
"class step =\n fixes step :: \"'a \\<Rightarrow> 'a\"",
"datatype 'a states = States direction \"'a big_state\" \"'a small_state\"",
"class invar =\n fixes invar :: \"'a \\<Rightarrow> bool\""
] |
###lemma
invar (States ?dir ?big ?small) \<Longrightarrow> step (States ?dir ?big (Small.push ?x ?small)) = States ?dir' ?big' ?small' \<Longrightarrow> size_new ?small' = Suc (size_new ?small)
|
###output
\<lbrakk>?H1 (?H2 x_1 x_2 x_3); ?H3 (?H2 x_1 x_2 (?H4 x_4 x_3)) = ?H2 x_5 x_6 x_7\<rbrakk> \<Longrightarrow> ?H5 x_7 = ?H6 (?H5 x_3)
###end
|
HOLCF/Cfun
|
Cfun.cont2cont_Let'
|
lemma cont2cont_Let' [simp, cont2cont]:
assumes f: "cont (\<lambda>x. f x)"
assumes g: "cont (\<lambda>p. g (fst p) (snd p))"
shows "cont (\<lambda>x. let y = f x in g x y)"
|
cont ?f \<Longrightarrow> cont (\<lambda>p. ?g (fst p) (snd p)) \<Longrightarrow> cont (\<lambda>x. Let (?f x) (?g x))
|
\<lbrakk>?H1 x_1; ?H2 (\<lambda>y_1. x_2 (?H3 y_1) (?H4 y_1))\<rbrakk> \<Longrightarrow> ?H5 (\<lambda>y_2. Let (x_1 y_2) (x_2 y_2))
|
[
"Product_Type.prod.snd",
"Product_Type.prod.fst",
"Cont.cont"
] |
[
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"definition \"prod = {f. \\<exists>a b. f = Pair_Rep (a::'a) (b::'b)}\"",
"definition cont :: \"('a::cpo \\<Rightarrow> 'b::cpo) \\<Rightarrow> bool\"\n where \"cont f = (\\<forall>Y. chain Y \\<longrightarrow> range (\\<lambda>i. f (Y i)) <<| f (\\<Squnion>i. Y i))\""
] |
###lemma
cont ?f \<Longrightarrow> cont (\<lambda>p. ?g (fst p) (snd p)) \<Longrightarrow> cont (\<lambda>x. Let (?f x) (?g x))
|
###output
\<lbrakk>?H1 x_1; ?H2 (\<lambda>y_1. x_2 (?H3 y_1) (?H4 y_1))\<rbrakk> \<Longrightarrow> ?H5 (\<lambda>y_2. Let (x_1 y_2) (x_2 y_2))
###end
|
Kruskal/UGraph_Impl
|
UGraph_Impl.uGraph_from_list_\<alpha>_inj_on
| null |
uGraph_from_list_invar ?E \<Longrightarrow> inj_on \<alpha> (set ?E)
|
?H1 x_1 \<Longrightarrow> ?H2 ?H3 (?H4 x_1)
|
[
"List.list.set",
"UGraph_Impl.\\<alpha>",
"Fun.inj_on",
"UGraph_Impl.uGraph_from_list_invar"
] |
[
"datatype (set: 'a) list =\n Nil (\"[]\")\n | Cons (hd: 'a) (tl: \"'a list\") (infixr \"#\" 65)\nfor\n map: map\n rel: list_all2\n pred: list_all\nwhere\n \"tl [] = []\"",
"definition \"\\<alpha> = (\\<lambda>(u,w,v). Upair u v)\"",
"definition inj_on :: \"('a \\<Rightarrow> 'b) \\<Rightarrow> 'a set \\<Rightarrow> bool\" \\<comment> \\<open>injective\\<close>\n where \"inj_on f A \\<longleftrightarrow> (\\<forall>x\\<in>A. \\<forall>y\\<in>A. f x = f y \\<longrightarrow> x = y)\"",
"definition uGraph_from_list_invar :: \"(nat\\<times>int\\<times>nat) list \\<Rightarrow> bool\" where\n \"uGraph_from_list_invar L = (distinct (map \\<alpha> L) \\<and> (\\<forall>p\\<in>set L. case p of (u,w,v) \\<Rightarrow>u\\<noteq>v))\""
] |
###lemma
uGraph_from_list_invar ?E \<Longrightarrow> inj_on \<alpha> (set ?E)
|
###output
?H1 x_1 \<Longrightarrow> ?H2 ?H3 (?H4 x_1)
###end
|
MLSS_Decision_Proc/MLSS_Semantics
|
MLSS_Semantics.finite_subfms
|
lemma finite_subfms: "finite (subfms \<phi>)"
|
finite (subfms ?\<phi>)
|
?H1 (?H2 x_1)
|
[
"MLSS_Semantics.subfms",
"Finite_Set.finite"
] |
[
"fun subfms :: \"'a fm \\<Rightarrow> 'a fm set\" where\n \"subfms (Atom a) = {Atom a}\"\n| \"subfms (And p q) = {And p q} \\<union> subfms p \\<union> subfms q\"\n| \"subfms (Or p q) = {Or p q} \\<union> subfms p \\<union> subfms q\"\n| \"subfms (Neg q) = {Neg q} \\<union> subfms q\"",
"class finite =\n assumes finite_UNIV: \"finite (UNIV :: 'a set)\"\nbegin"
] |
###lemma
finite (subfms ?\<phi>)
|
###output
?H1 (?H2 x_1)
###end
|
Inductive_Confidentiality/GeneralAttacker/MessageGA
|
MessageGA.Crypt_imp_invKey_keysFor
|
lemma Crypt_imp_invKey_keysFor: "Crypt K X \<in> H \<Longrightarrow> invKey K \<in> keysFor H"
|
Crypt ?K ?X \<in> ?H \<Longrightarrow> invKey ?K \<in> keysFor ?H
|
?H1 x_1 x_2 \<in> x_3 \<Longrightarrow> ?H2 x_1 \<in> ?H3 x_3
|
[
"MessageGA.keysFor",
"MessageGA.invKey",
"MessageGA.msg.Crypt"
] |
[] |
###lemma
Crypt ?K ?X \<in> ?H \<Longrightarrow> invKey ?K \<in> keysFor ?H
|
###output
?H1 x_1 x_2 \<in> x_3 \<Longrightarrow> ?H2 x_1 \<in> ?H3 x_3
###end
|
UNITY/Constrains
|
Constrains.Constrains_weaken_R
|
lemma Constrains_weaken_R:
"[| F \<in> A Co A'; A'<=B' |] ==> F \<in> A Co B'"
|
?F \<in> ?A Co ?A' \<Longrightarrow> ?A' \<subseteq> ?B' \<Longrightarrow> ?F \<in> ?A Co ?B'
|
\<lbrakk>x_1 \<in> ?H1 x_2 x_3; ?H2 x_3 x_4\<rbrakk> \<Longrightarrow> x_1 \<in> ?H1 x_2 x_4
|
[
"Set.subset_eq",
"Constrains.Constrains"
] |
[
"abbreviation subset_eq :: \"'a set \\<Rightarrow> 'a set \\<Rightarrow> bool\"\n where \"subset_eq \\<equiv> less_eq\"",
"definition Constrains :: \"['a set, 'a set] => 'a program set\" (infixl \"Co\" 60) where\n \"A Co B == {F. F \\<in> (reachable F \\<inter> A) co B}\""
] |
###lemma
?F \<in> ?A Co ?A' \<Longrightarrow> ?A' \<subseteq> ?B' \<Longrightarrow> ?F \<in> ?A Co ?B'
|
###output
\<lbrakk>x_1 \<in> ?H1 x_2 x_3; ?H2 x_3 x_4\<rbrakk> \<Longrightarrow> x_1 \<in> ?H1 x_2 x_4
###end
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 2