update data

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+proofs.json filter=lfs diff=lfs merge=lfs -text

proofs.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:642901a9b4f0c2b8fc3c87567d2374808f981c6ecc7172ae953d9be7a4f17611
+size 11951475

src_data/babel-formal/proofs/hol-light/circle_average.ml

@@ -0,0 +1,329 @@
+let is_add_monoid = new_definition
+  `is_add_monoid (zero:A) (add:A->A->A) <=>
+      (!x. add x zero = x) /\
+      (!x y. add x y = add y x) /\
+      (!x y z. add (add x y) z = add x (add y z))`;;
+
+let is_integral = new_definition
+  `is_integral (integral:(A->A)->A) (add:A->A->A) (zero:A) <=>
+      (!g h. (!t. g t = h t) ==> integral g = integral h) /\
+      (!c. integral (\t. c) = c) /\
+      (!f g. integral (\t. add (f t) (g t)) =
+             add (integral f) (integral g)) /\
+      (!f c. integral (\t. f (add t c)) = integral f)`;;
+
+let circleMap = new_definition
+  `circleMap (add:A->A->A) c t = add t c`;;
+
+let circleAverage = new_definition
+  `circleAverage (integral:(A->A)->A) (add:A->A->A) (f:A->A) c =
+      integral (\t. f (circleMap add c t))`;;
+
+let dest_add_monoid th = CONJUNCTS (REWRITE_RULE[is_add_monoid] th);;
+let dest_integral th = CONJUNCTS (REWRITE_RULE[is_integral] th);;
+
+let circleMap_zero = prove
+ (`!(zero:A) (add:A->A->A).
+      is_add_monoid zero add ==> !t:A. circleMap add zero t = t`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun mono ->
+    let add_zero = hd (dest_add_monoid mono) in
+    ASSUME_TAC add_zero) THEN
+  GEN_TAC THEN REWRITE_TAC[circleMap] THEN ASM_REWRITE_TAC[]);;
+
+let circleAverage_zero = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !f:A->A. circleAverage integral add f zero = integral f`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let int_th = CONJUNCT2 th in
+    let shift = List.nth (dest_integral int_th) 3 in
+    ASSUME_TAC shift) THEN
+  GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN ASM_REWRITE_TAC[]);;
+
+let circleAverage_add = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (g:A->A) (c:A).
+        circleAverage integral add (\z. add (f z) (g z)) c =
+        add (circleAverage integral add f c) (circleAverage integral add g c)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_th ->
+    let add_th = List.nth (dest_integral int_th) 2 in
+    ASSUME_TAC add_th) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun add_th ->
+    ASM_REWRITE_TAC[
+      SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) t (c:A))`;
+         `\t:A. (g:A->A) ((add:A->A->A) t (c:A))`]
+        add_th]) THEN
+  REFL_TAC);;
+
+let circleAverage_fun_add = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (c:A).
+        circleAverage integral add (\z. f (add z c)) zero =
+        circleAverage integral add f c`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_zero = hd (dest_add_monoid mono_th) in
+    let int_ext = hd (dest_integral int_th) in
+    ASSUME_TAC add_zero THEN ASSUME_TAC int_ext) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_ext ->
+    MATCH_MP_TAC
+      (SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) ((add:A->A->A) t (zero:A)) (c:A))`;
+         `\t:A. (f:A->A) ((add:A->A->A) t (c:A))`]
+        int_ext)) THEN
+  GEN_TAC THEN
+  FIRST_ASSUM (fun add_zero -> ASM_REWRITE_TAC[SPEC `t:A` add_zero]) THEN
+  REFL_TAC);;
+
+let circleMap_add = prove
+ (`!(zero:A) (add:A->A->A).
+      is_add_monoid zero add ==>
+      !(c:A) (d:A) (t:A).
+        circleMap add (add c d) t = circleMap add c (circleMap add d t)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun mono ->
+    let add_comm = List.nth (dest_add_monoid mono) 1 in
+    let add_assoc = List.nth (dest_add_monoid mono) 2 in
+    ASSUME_TAC add_comm THEN ASSUME_TAC add_assoc) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleMap] THEN
+  FIRST_ASSUM (fun add_comm -> ASM_REWRITE_TAC[SPECL [`c:A`; `d:A`] add_comm]) THEN
+  FIRST_ASSUM (fun add_assoc -> ASM_REWRITE_TAC[SPECL [`t:A`; `d:A`; `c:A`] add_assoc]) THEN
+  REFL_TAC);;
+
+let circleAverage_shift = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (c:A) (d:A).
+        circleAverage integral add f (add c d) =
+        circleAverage integral add (\z. f (add z d)) c`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_assoc = List.nth (dest_add_monoid mono_th) 2 in
+    let int_ext = hd (dest_integral int_th) in
+    ASSUME_TAC add_assoc THEN ASSUME_TAC int_ext) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_ext ->
+    MATCH_MP_TAC
+      (SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) t ((add:A->A->A) (c:A) (d:A)))`;
+         `\t:A. (f:A->A) ((add:A->A->A) ((add:A->A->A) t (c:A)) (d:A))`]
+        int_ext)) THEN
+  GEN_TAC THEN
+  FIRST_ASSUM (fun add_assoc ->
+    REWRITE_TAC[GSYM (SPECL [`t:A`; `c:A`; `d:A`] add_assoc)]) THEN
+  REFL_TAC);;
+
+let circleAverage_const = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(k:A) (c:A). circleAverage integral add (\z. k) c = k`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_th ->
+    let int_const = List.nth (dest_integral int_th) 1 in
+    ASSUME_TAC int_const) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_const -> ASM_REWRITE_TAC[SPEC `k:A` int_const]) THEN
+  REFL_TAC);;
+
+let circleAverage_add_const = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (k:A) (c:A).
+        circleAverage integral add (\z. add (f z) k) c =
+        add (circleAverage integral add f c) k`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_th ->
+    let int_const = List.nth (dest_integral int_th) 1 in
+    let int_add = List.nth (dest_integral int_th) 2 in
+    ASSUME_TAC int_const THEN ASSUME_TAC int_add) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_add ->
+    ASM_REWRITE_TAC[
+      SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) t (c:A))`;
+         `\t:A. (k:A)`]
+        int_add]) THEN
+  FIRST_ASSUM (fun int_const -> ASM_REWRITE_TAC[SPEC `k:A` int_const]) THEN
+  REFL_TAC);;
+
+let circleAverage_comm_add = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (g:A->A) (c:A).
+        circleAverage integral add (\z. add (f z) (g z)) c =
+        circleAverage integral add (\z. add (g z) (f z)) c`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_comm = List.nth (dest_add_monoid mono_th) 1 in
+    let int_ext = hd (dest_integral int_th) in
+    REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+    MATCH_MP_TAC
+      (SPECL
+        [`\t:A. (add:A->A->A)
+                 ((f:A->A) ((add:A->A->A) t (c:A)))
+                 ((g:A->A) ((add:A->A->A) t (c:A)))`;
+         `\t:A. (add:A->A->A)
+                 ((g:A->A) ((add:A->A->A) t (c:A)))
+                 ((f:A->A) ((add:A->A->A) t (c:A)))`]
+        int_ext) THEN
+    GEN_TAC THEN BETA_TAC THEN
+    ACCEPT_TAC
+      (SPECL
+        [`(f:A->A) ((add:A->A->A) (t:A) (c:A))`;
+         `(g:A->A) ((add:A->A->A) (t:A) (c:A))`]
+        add_comm)));;
+
+let circleAverage_add_assoc = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (g:A->A) (h:A->A) (c:A).
+        circleAverage integral add (\z. add (add (f z) (g z)) (h z)) c =
+        add (circleAverage integral add f c)
+            (add (circleAverage integral add g c)
+                 (circleAverage integral add h c))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_assoc = List.nth (dest_add_monoid mono_th) 2 in
+    let int_add = List.nth (dest_integral int_th) 2 in
+    ASSUME_TAC add_assoc THEN ASSUME_TAC int_add) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_add ->
+    ASM_REWRITE_TAC[
+      SPECL
+        [`\t:A. (add:A->A->A)
+                 ((f:A->A) ((add:A->A->A) t (c:A)))
+                 ((g:A->A) ((add:A->A->A) t (c:A)))`;
+         `\t:A. (h:A->A) ((add:A->A->A) t (c:A))`]
+        int_add]) THEN
+  FIRST_ASSUM (fun int_add ->
+    ASM_REWRITE_TAC[
+      SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) t (c:A))`;
+         `\t:A. (g:A->A) ((add:A->A->A) t (c:A))`]
+        int_add]) THEN
+  FIRST_ASSUM (fun add_assoc ->
+    ASM_REWRITE_TAC[SPECL
+      [`integral (\t. f (add t c)):A`;
+       `integral (\t. g (add t c)):A`;
+       `integral (\t. h (add t c)):A`] add_assoc]) THEN
+  REFL_TAC);;
+
+let circleAverage_center_comm = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (c:A) (d:A).
+        circleAverage integral add f (add c d) =
+        circleAverage integral add f (add d c)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_comm = List.nth (dest_add_monoid mono_th) 1 in
+    let int_ext = hd (dest_integral int_th) in
+    ASSUME_TAC add_comm THEN ASSUME_TAC int_ext) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_ext ->
+    MATCH_MP_TAC
+      (SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) t ((add:A->A->A) (c:A) (d:A)))`;
+         `\t:A. (f:A->A) ((add:A->A->A) t ((add:A->A->A) (d:A) (c:A)))`]
+        int_ext)) THEN
+  GEN_TAC THEN
+  FIRST_ASSUM (fun add_comm -> ASM_REWRITE_TAC[SPECL [`c:A`; `d:A`] add_comm]) THEN
+  REFL_TAC);;
+
+let circleAverage_center_independent = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (c:A). circleAverage integral add f c = integral f`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_th ->
+    let shift = List.nth (dest_integral int_th) 3 in
+    ASSUME_TAC shift) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN ASM_REWRITE_TAC[]);;
+
+let circleAverage_center_eq = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (c:A) (d:A).
+        circleAverage integral add f c = circleAverage integral add f d`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_assum ->
+    let ind0 =
+      MATCH_MP
+        (SPECL [`zero:A`; `add:A->A->A`; `integral:(A->A)->A`]
+          circleAverage_center_independent)
+        int_assum in
+    REPEAT GEN_TAC THEN
+    ASM_REWRITE_TAC[
+      SPECL [`f:A->A`; `c:A`] ind0;
+      SPECL [`f:A->A`; `d:A`] ind0] THEN
+    REFL_TAC));;
+
+let circleAverage_idempotent = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (c:A).
+        circleAverage integral add (\z. circleAverage integral add f z) c =
+        circleAverage integral add f c`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_th ->
+    let int_const = List.nth (dest_integral int_th) 1 in
+    let shift = List.nth (dest_integral int_th) 3 in
+    ASSUME_TAC int_const THEN ASSUME_TAC shift) THEN
+  REPEAT GEN_TAC THEN
+  REWRITE_TAC[circleAverage; circleMap] THEN
+
+  FIRST_ASSUM (fun shift ->
+    ASM_REWRITE_TAC[SPECL [`f:A->A`; `add t c:A`] shift]) THEN
+  FIRST_ASSUM (fun int_const -> ASM_REWRITE_TAC[SPEC `integral (f:A->A):A` int_const]) THEN
+  REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun shift -> ASM_REWRITE_TAC[SPECL [`f:A->A`; `c:A`] shift]) THEN
+  REFL_TAC);;
+
+let circleAverage_of_zero_integral = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (c:A).
+        integral f = zero ==> circleAverage integral add f c = zero`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun int_assum ->
+    let ind0 =
+      MATCH_MP
+        (SPECL [`zero:A`; `add:A->A->A`; `integral:(A->A)->A`]
+          circleAverage_center_independent)
+        int_assum in
+    REPEAT GEN_TAC THEN DISCH_TAC THEN
+    ASM_REWRITE_TAC[SPECL [`f:A->A`; `c:A`] ind0]));;
+
+let circleAverage_linear = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_integral integral add zero ==>
+      !(f:A->A) (g:A->A) (c:A).
+        circleAverage integral add (\z. add (f z) (g z)) c =
+        add (circleAverage integral add f c) (circleAverage integral add g c)`,
+  ACCEPT_TAC circleAverage_add);;
+
+let circleAverage_shift_commute = prove
+ (`!(zero:A) (add:A->A->A) (integral:(A->A)->A).
+      is_add_monoid zero add /\ is_integral integral add zero ==>
+      !(f:A->A) (c:A) (d:A).
+        circleAverage integral add (\z. f (circleMap add d z)) c =
+        circleAverage integral add f (add c d)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun th ->
+    let mono_th = CONJUNCT1 th in
+    let int_th = CONJUNCT2 th in
+    let add_assoc = List.nth (dest_add_monoid mono_th) 2 in
+    let int_ext = hd (dest_integral int_th) in
+    ASSUME_TAC add_assoc THEN ASSUME_TAC int_ext) THEN
+  REPEAT GEN_TAC THEN REWRITE_TAC[circleAverage; circleMap] THEN
+  FIRST_ASSUM (fun int_ext ->
+    MATCH_MP_TAC
+      (SPECL
+        [`\t:A. (f:A->A) ((add:A->A->A) ((add:A->A->A) t (c:A)) (d:A))`;
+         `\t:A. (f:A->A) ((add:A->A->A) t ((add:A->A->A) (c:A) (d:A)))`]
+        int_ext)) THEN
+  GEN_TAC THEN
+  FIRST_ASSUM (fun add_assoc -> ASM_REWRITE_TAC[SPECL [`t:A`; `c:A`; `d:A`] add_assoc]) THEN
+  REFL_TAC);;

src_data/babel-formal/proofs/hol-light/comp_commute.ml

@@ -0,0 +1,53 @@
+let myComp = new_definition
+  `myComp (g:B->C) (f:A->B) = (\x:A. g (f x))`;;
+
+let myId = new_definition
+  `myId = (\x:A. x)`;;
+
+let comp_assoc = prove
+  (`!h g f. myComp h (myComp g f) = myComp (myComp h g) f`,
+   REWRITE_TAC[myComp]);;
+
+let comp_id_l = prove
+  (`!f:A->B. myComp myId f = f`,
+   REWRITE_TAC[myComp; myId; FUN_EQ_THM] THEN BETA_TAC THEN REWRITE_TAC[]);;
+
+let comp_id_r = prove
+  (`!f:A->B. myComp f myId = f`,
+   REWRITE_TAC[myComp; myId; FUN_EQ_THM] THEN BETA_TAC THEN REWRITE_TAC[]);;
+
+let commute = new_definition
+  `commute (f:A->A) (g:A->A) <=> myComp f g = myComp g f`;;
+
+let commute_symm = prove
+  (`!f g. commute f g ==> commute g f`,
+   REWRITE_TAC[commute] THEN MESON_TAC[]);;
+
+let commute_with_id_l = prove
+  (`!f:A->A. commute f myId`,
+   REWRITE_TAC[commute] THEN
+   REWRITE_TAC[comp_id_l; comp_id_r]);;
+
+let commute_with_id_r = prove
+  (`!f:A->A. commute myId f`,
+   REWRITE_TAC[commute] THEN
+   REWRITE_TAC[comp_id_l; comp_id_r]);;
+
+let commute_refl = prove
+  (`!f:A->A. commute f f`,
+   REWRITE_TAC[commute]);;
+
+let commute_congr = prove
+  (`!f1 f2 g1 g2:A->A.
+      f1 = f2 ==> g1 = g2 ==> commute f1 g1 ==> commute f2 g2`,
+   REWRITE_TAC[commute] THEN MESON_TAC[]);;
+
+let commute_transport_left_id = prove
+  (`!f g:A->A. commute f g ==> commute (myComp myId f) g`,
+   REWRITE_TAC[commute] THEN
+   REWRITE_TAC[comp_id_l]);;
+
+let commute_transport_right_id = prove
+  (`!f g:A->A. commute f g ==> commute f (myComp myId g)`,
+   REWRITE_TAC[commute] THEN
+   REWRITE_TAC[comp_id_l]);;

src_data/babel-formal/proofs/hol-light/galois.ml

@@ -0,0 +1,324 @@
+let field_like = new_definition
+  `field_like (zero_F:'a) (one_F:'a) (add_F:'a->'a->'a) (mul_F:'a->'a->'a)
+              (opp_F:'a->'a) (inv_F:'a->'a) <=>
+     (!x:'a y:'a. add_F x y = add_F y x) /\
+     (!x:'a y:'a z:'a. add_F (add_F x y) z = add_F x (add_F y z)) /\
+     (!x:'a. add_F x zero_F = x) /\
+     (!x:'a. add_F (opp_F x) x = zero_F) /\
+     (!x:'a y:'a. mul_F x y = mul_F y x) /\
+     (!x:'a y:'a z:'a. mul_F (mul_F x y) z = mul_F x (mul_F y z)) /\
+     (!x:'a. mul_F one_F x = x) /\
+     (!x:'a. ~(x = zero_F) ==> mul_F (inv_F x) x = one_F) /\
+     (!x:'a y:'a z:'a. mul_F x (add_F y z) = add_F (mul_F x y) (mul_F x z)) /\
+     ~(zero_F = one_F) /\
+     (!x:'a. ~(x = zero_F) ==> ~(inv_F x = zero_F))`;;
+
+let tower = new_definition
+  `tower (solv:'a->bool) (mp:'a->'a) (splt:'a->bool) <=>
+     (!p:'a q:'a. solv p ==> solv (mp q) ==> solv q) /\
+     (!p:'a. solv p ==> solv (mp p)) /\
+     (!p:'a. splt p ==> solv p)`;;
+
+let zero_add = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==> !x:'f. add_F zero_F x = x`,
+   REWRITE_TAC[field_like] THEN MESON_TAC[]);;
+
+let mul_one_r = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==> !x. mul_F x one_F = x`,
+   REWRITE_TAC[field_like] THEN MESON_TAC[]);;
+
+let mul_inv_r = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x. ~(x = zero_F) ==> mul_F x (inv_F x) = one_F`,
+   REPEAT GEN_TAC THEN REWRITE_TAC[field_like] THEN
+   DISCH_THEN(fun hfield ->
+     let [_; _; _; _;
+          hmul_comm; _; _; hmul_inv_l;
+          _; _; _] = CONJUNCTS hfield in
+     GEN_TAC THEN DISCH_TAC THEN
+     MATCH_MP_TAC EQ_TRANS THEN
+     EXISTS_TAC
+      `(mul_F:'f->'f->'f) ((inv_F:'f->'f) (x:'f)) (x:'f)` THEN
+     CONJ_TAC THENL
+      [MATCH_ACCEPT_TAC
+        (SPECL [`x:'f`; `(inv_F:'f->'f) (x:'f)`] hmul_comm);
+       MATCH_MP_TAC (SPEC `x:'f` hmul_inv_l) THEN
+       ASM_REWRITE_TAC[]]));;
+
+let add_cancel_l = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x y z. add_F x y = add_F x z ==> y = z`,
+   REPEAT GEN_TAC THEN REWRITE_TAC[field_like] THEN
+   DISCH_THEN(fun hfield ->
+     let [add_comm; add_assoc; add_zero; add_inv_l; _; _; _; _; _; _; _] =
+       CONJUNCTS hfield in
+     REPEAT GEN_TAC THEN DISCH_THEN(fun heq ->
+       let assoc_y =
+         SYM
+          (SPECL
+            [`(opp_F:'f->'f) (x:'f)`; `x:'f`; `y:'f`]
+            add_assoc) in
+       let inv_y =
+         BETA_RULE
+           (AP_TERM `\t:'f. (add_F:'f->'f->'f) t (y:'f)`
+             (SPEC `x:'f` add_inv_l)) in
+       let zero_y =
+         TRANS (SPECL [`(zero_F:'f)`; `y:'f`] add_comm)
+               (SPEC `y:'f` add_zero) in
+       let cancel_y = TRANS assoc_y (TRANS inv_y zero_y) in
+       let assoc_z =
+         SYM
+          (SPECL
+            [`(opp_F:'f->'f) (x:'f)`; `x:'f`; `z:'f`]
+            add_assoc) in
+       let inv_z =
+         BETA_RULE
+           (AP_TERM `\t:'f. (add_F:'f->'f->'f) t (z:'f)`
+             (SPEC `x:'f` add_inv_l)) in
+       let zero_z =
+         TRANS (SPECL [`(zero_F:'f)`; `z:'f`] add_comm)
+               (SPEC `z:'f` add_zero) in
+       let cancel_z = TRANS assoc_z (TRANS inv_z zero_z) in
+       let cong =
+         BETA_RULE
+           (AP_TERM
+             `\t:'f.
+                (add_F:'f->'f->'f)
+                  ((opp_F:'f->'f) (x:'f)) t`
+             heq) in
+       MATCH_ACCEPT_TAC (TRANS (TRANS (SYM cancel_y) cong) cancel_z))));;
+
+let add_cancel_r = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x y z. add_F y x = add_F z x ==> y = z`,
+   REPEAT GEN_TAC THEN DISCH_THEN(fun hfield ->
+     let [add_comm; _; _; _; _; _; _; _; _; _; _] =
+       CONJUNCTS (REWRITE_RULE[field_like] hfield) in
+     REPEAT GEN_TAC THEN DISCH_THEN(fun heq ->
+       let heq' =
+         TRANS (SPECL [`x:'f`; `y:'f`] add_comm)
+               (TRANS heq (SPECL [`z:'f`; `x:'f`] add_comm)) in
+       let cancel_l =
+         MATCH_MP
+           (SPECL
+             [`(zero_F:'f)`;
+              `(one_F:'f)`;
+              `(add_F:'f->'f->'f)`;
+              `(mul_F:'f->'f->'f)`;
+              `(opp_F:'f->'f)`;
+              `(inv_F:'f->'f)`]
+             add_cancel_l)
+           hfield in
+       MATCH_ACCEPT_TAC
+         (MATCH_MP (SPECL [`x:'f`; `y:'f`; `z:'f`] cancel_l) heq'))));;
+
+let mul_cancel_l = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x y z. ~(x = zero_F) ==> mul_F x y = mul_F x z ==> y = z`,
+   REPEAT GEN_TAC THEN DISCH_THEN(fun hfield ->
+     let [_; _; _; _; _; mul_assoc; mul_one_l; mul_inv_l; _; _; _] =
+       CONJUNCTS (REWRITE_RULE[field_like] hfield) in
+     REPEAT GEN_TAC THEN DISCH_THEN(fun hx ->
+	       DISCH_THEN(fun heq ->
+	         let eq_inv = MATCH_MP (SPEC `x:'f` mul_inv_l) hx in
+	         let th1 = SYM (SPEC `y:'f` mul_one_l) in
+	         let th2 =
+	           BETA_RULE
+	             (AP_TERM `\t:'f. (mul_F:'f->'f->'f) t (y:'f)` (SYM eq_inv)) in
+         let th3 =
+           SPECL
+             [`(inv_F:'f->'f) (x:'f)`; `x:'f`; `y:'f`]
+             mul_assoc in
+	         let th4 =
+	           BETA_RULE
+	             (AP_TERM
+	               `\t:'f. (mul_F:'f->'f->'f) ((inv_F:'f->'f) (x:'f)) t`
+	               heq) in
+         let th5 =
+           SYM
+            (SPECL
+              [`(inv_F:'f->'f) (x:'f)`; `x:'f`; `z:'f`]
+              mul_assoc) in
+	         let th6 =
+	           BETA_RULE
+	             (AP_TERM `\t:'f. (mul_F:'f->'f->'f) t (z:'f)` eq_inv) in
+         let th7 = SPEC `z:'f` mul_one_l in
+         MATCH_ACCEPT_TAC
+          (TRANS th1
+            (TRANS th2
+              (TRANS th3
+                (TRANS th4 (TRANS th5 (TRANS th6 th7))))))))));;
+
+let mul_cancel_r = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x y z. ~(x = zero_F) ==> mul_F y x = mul_F z x ==> y = z`,
+   REPEAT GEN_TAC THEN DISCH_THEN(fun hfield ->
+     let [_; _; _; _; mul_comm; _; _; _; _; _; _] =
+       CONJUNCTS (REWRITE_RULE[field_like] hfield) in
+     REPEAT GEN_TAC THEN DISCH_THEN(fun hx ->
+       DISCH_THEN(fun heq ->
+         let heq' =
+           TRANS (SPECL [`x:'f`; `y:'f`] mul_comm)
+                 (TRANS heq (SPECL [`z:'f`; `x:'f`] mul_comm)) in
+         let cancel_l =
+           MATCH_MP
+             (SPECL
+               [`(zero_F:'f)`;
+                `(one_F:'f)`;
+                `(add_F:'f->'f->'f)`;
+                `(mul_F:'f->'f->'f)`;
+                `(opp_F:'f->'f)`;
+                `(inv_F:'f->'f)`]
+               mul_cancel_l)
+             hfield in
+         MATCH_ACCEPT_TAC
+           (MATCH_MP
+             (MATCH_MP (SPECL [`x:'f`; `y:'f`; `z:'f`] cancel_l) hx)
+             heq')))));;
+
+let inv_unique = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x y. ~(x = zero_F) ==> mul_F x y = one_F ==> y = inv_F x`,
+   REPEAT GEN_TAC THEN DISCH_THEN(fun hfield ->
+     let [_; _; _; _; _; mul_assoc; mul_one_l; mul_inv_l; _; _; _] =
+       CONJUNCTS (REWRITE_RULE[field_like] hfield) in
+     let mul_one_r_th =
+       MATCH_MP
+         (SPECL
+           [`(zero_F:'f)`;
+            `(one_F:'f)`;
+            `(add_F:'f->'f->'f)`;
+            `(mul_F:'f->'f->'f)`;
+            `(opp_F:'f->'f)`;
+            `(inv_F:'f->'f)`]
+           mul_one_r)
+         hfield in
+     REPEAT GEN_TAC THEN DISCH_THEN(fun hx ->
+	       DISCH_THEN(fun heq ->
+	         let eq_inv = MATCH_MP (SPEC `x:'f` mul_inv_l) hx in
+	         let th1 = SYM (SPEC `y:'f` mul_one_l) in
+	         let th2 =
+	           BETA_RULE
+	             (AP_TERM `\t:'f. (mul_F:'f->'f->'f) t (y:'f)` (SYM eq_inv)) in
+         let th3 =
+           SPECL
+             [`(inv_F:'f->'f) (x:'f)`; `x:'f`; `y:'f`]
+             mul_assoc in
+	         let th4 =
+	           BETA_RULE
+	             (AP_TERM
+	               `\t:'f. (mul_F:'f->'f->'f) ((inv_F:'f->'f) (x:'f)) t`
+	               heq) in
+         let th5 = SPEC `(inv_F:'f->'f) (x:'f)` mul_one_r_th in
+         MATCH_ACCEPT_TAC (TRANS th1 (TRANS th2 (TRANS th3 (TRANS th4 th5))))))));;
+
+let inv_involutive = prove
+  (`!zero_F:'f one_F:'f (add_F:'f->'f->'f) (mul_F:'f->'f->'f)
+      (opp_F:'f->'f) (inv_F:'f->'f).
+      field_like zero_F one_F add_F mul_F opp_F inv_F ==>
+      !x. ~(x = zero_F) ==> inv_F (inv_F x) = x`,
+   REPEAT GEN_TAC THEN DISCH_THEN(fun hfield ->
+     let [_; _; _; _; _; _; _; mul_inv_l; _; _; inv_nonzero] =
+       CONJUNCTS (REWRITE_RULE[field_like] hfield) in
+     let inv_unique_th =
+       MATCH_MP
+         (SPECL
+           [`(zero_F:'f)`;
+            `(one_F:'f)`;
+            `(add_F:'f->'f->'f)`;
+            `(mul_F:'f->'f->'f)`;
+            `(opp_F:'f->'f)`;
+            `(inv_F:'f->'f)`]
+           inv_unique)
+         hfield in
+     GEN_TAC THEN DISCH_THEN(fun hx ->
+       let hx_inv = MATCH_MP (SPEC `x:'f` inv_nonzero) hx in
+       let eq_inv = MATCH_MP (SPEC `x:'f` mul_inv_l) hx in
+       let eq =
+         MATCH_MP
+           (MATCH_MP
+             (SPECL [`(inv_F:'f->'f) (x:'f)`; `x:'f`] inv_unique_th)
+             hx_inv)
+           eq_inv in
+       MATCH_ACCEPT_TAC (SYM eq))));;
+
+let gal_isSolvable_tower = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a q:'a.
+      tower solv mp splt ==> solv p ==> solv (mp q) ==> solv q`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_double_tower = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a q:'a r:'a.
+      tower solv mp splt ==> solv p ==> solv (mp q) ==> solv (mp r) ==> solv r`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_triple_tower = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a q:'a r:'a s:'a.
+      tower solv mp splt ==> solv p ==> solv (mp q) ==> solv (mp r) ==> solv (mp s) ==> solv s`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_quadruple_tower = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a q:'a r:'a s:'a t:'a.
+      tower solv mp splt ==> solv p ==> solv (mp q) ==> solv (mp r) ==> solv (mp s) ==> solv (mp t) ==> solv t`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_map_poly = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> solv p ==> solv (mp p)`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_of_split = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> splt p ==> solv p`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_split_tower = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool q:'a.
+      tower solv mp splt ==> splt q ==> solv q`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_two_step_map = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> solv p ==> solv (mp (mp p))`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_three_step_map = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> solv p ==> solv (mp (mp (mp p)))`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_map_poly_comp = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> solv p ==> solv (mp (mp p))`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_mutual_split = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a q:'a.
+      tower solv mp splt ==> splt p ==> splt q ==> solv p /\ solv q`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_map_after_split = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool p:'a.
+      tower solv mp splt ==> splt p ==> solv (mp p)`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;
+
+let gal_isSolvable_tower_split = prove
+  (`!solv:'a->bool mp:'a->'a splt:'a->bool q:'a r:'a.
+      tower solv mp splt ==> splt q ==> solv (mp r) ==> solv r`,
+   REWRITE_TAC[tower] THEN MESON_TAC[]);;

src_data/babel-formal/proofs/hol-light/graph_paths.ml

@@ -0,0 +1,91 @@
+let path_RULES,path_INDUCT,path_CASES = new_inductive_definition
+  `(!E:A->A->bool v. path E v v) /\
+   (!E:A->A->bool u v w. path E u v /\ E v w ==> path E u w)`;;
+
+let undirected = new_definition
+  `undirected (E:A->A->bool) <=> !x y. E x y ==> E y x`;;
+
+let erev = new_definition
+  `erev (E:A->A->bool) x y <=> E y x`;;
+
+let path_refl = prove
+  (`!E:A->A->bool v. path E v v`,
+   MESON_TAC[path_RULES]);;
+
+let path_append_right = prove
+  (`!E:A->A->bool v w. path E v w ==> !u. path E u v ==> path E u w`,
+   MATCH_MP_TAC path_INDUCT THEN MESON_TAC[path_RULES]);;
+
+let path_trans = prove
+  (`!E:A->A->bool u v w. path E u v ==> path E v w ==> path E u w`,
+   MESON_TAC[path_append_right]);;
+
+let trans = path_trans;;
+
+let edge_path = prove
+  (`!E:A->A->bool u v. E u v ==> path E u v`,
+   MESON_TAC[path_RULES]);;
+
+let concat_edge_right = prove
+  (`!E:A->A->bool u v w. path E u v ==> E v w ==> path E u w`,
+   MESON_TAC[path_RULES]);;
+
+let concat = path_trans;;
+
+let concat_edge_left = prove
+  (`!E:A->A->bool u v w. E u v ==> path E v w ==> path E u w`,
+   MESON_TAC[edge_path; path_trans]);;
+
+let concat3 = prove
+  (`!E:A->A->bool u v w t.
+      path E u v ==> path E v w ==> path E w t ==> path E u t`,
+   MESON_TAC[path_trans]);;
+
+let reverse_edge_Erev = prove
+  (`!E:A->A->bool v w. E v w ==> path (erev E) w v`,
+   REPEAT GEN_TAC THEN DISCH_TAC THEN
+   MATCH_MP_TAC edge_path THEN ASM_REWRITE_TAC[erev]);;
+
+let reverse_step_Erev = prove
+  (`!E:A->A->bool u v w.
+      path (erev E) v u ==> E v w ==> path (erev E) w u`,
+   REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+   MP_TAC (SPECL
+     [`erev (E:A->A->bool)`; `w:A`; `v:A`; `u:A`] path_trans) THEN
+   ASM_REWRITE_TAC[] THEN DISCH_THEN MATCH_MP_TAC THEN
+   MATCH_MP_TAC reverse_edge_Erev THEN ASM_REWRITE_TAC[]);;
+
+let reverse_in_Erev = prove
+  (`!E:A->A->bool u v. path E u v ==> path (erev E) v u`,
+   MATCH_MP_TAC path_INDUCT THEN CONJ_TAC THENL
+    [MESON_TAC[path_RULES];
+     MESON_TAC[reverse_step_Erev]]);;
+
+let path_mono = prove
+  (`!(E:A->A->bool) (G:A->A->bool) u v.
+      (!x y. E x y ==> G x y) ==> path E u v ==> path G u v`,
+   REPEAT GEN_TAC THEN DISCH_TAC THEN
+   MP_TAC (SPEC
+     `\(H:A->A->bool) (x:A) (y:A).
+        H = (E:A->A->bool) ==> path (G:A->A->bool) x y`
+     path_INDUCT) THEN
+   ANTS_TAC THENL
+    [CONJ_TAC THENL
+      [MESON_TAC[path_RULES];
+       ASM_MESON_TAC[path_RULES]];
+     DISCH_THEN (MP_TAC o SPECL [`E:A->A->bool`; `u:A`; `v:A`]) THEN
+     ASM_REWRITE_TAC[]]);;
+
+let reverse_path = prove
+  (`!E:A->A->bool u v. undirected E ==> path E u v ==> path E v u`,
+   REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+   MP_TAC (SPECL [`E:A->A->bool`; `u:A`; `v:A`] reverse_in_Erev) THEN
+   ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+   MP_TAC (SPECL [`erev (E:A->A->bool)`; `E:A->A->bool`; `v:A`; `u:A`] path_mono) THEN
+   ASM_REWRITE_TAC[] THEN
+   DISCH_THEN MATCH_MP_TAC THEN
+   ASM_MESON_TAC[undirected; erev]);;
+
+let cycle_refl = prove
+  (`!E:A->A->bool v w. path E v w ==> path E w v ==> path E v v`,
+   MESON_TAC[path_trans]);;

src_data/babel-formal/proofs/hol-light/group.ml

@@ -0,0 +1,322 @@
+let is_group = new_definition
+  `is_group (mul:A->A->A) (e:A) (ginv:A->A) <=>
+     (!a b c. mul a (mul b c) = mul (mul a b) c) /\
+     (!a. mul a e = a) /\
+     (!a. mul e a = a) /\
+     (!a. mul (ginv a) a = e) /\
+     (!a. mul a (ginv a) = e)`;;
+
+
+let INTRO_GROUP_HYPS =
+  REWRITE_TAC[is_group] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC
+   (CONJUNCTS_THEN2 ASSUME_TAC
+   (CONJUNCTS_THEN2 ASSUME_TAC
+   (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC))));;
+
+
+
+let FUN_CONG = prove
+  (`!f:A->B x y. x = y ==> f x = f y`,
+   REPEAT GEN_TAC THEN DISCH_THEN SUBST1_TAC THEN REFL_TAC);;
+
+let GROUP_ASSOC = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a b c:A. mul a (mul b c) = mul (mul a b) c`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_ASSOC_SYM = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a b c:A. mul (mul a b) c = mul a (mul b c)`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_MUL_ONE = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a:A. mul a e = a`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_ONE_MUL = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a:A. mul e a = a`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_MUL_INV_L = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a:A. mul (ginv a) a = e`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_MUL_INV_R = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a:A. mul a (ginv a) = e`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_LEFT_CANCEL_NORMALIZE = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a b:A. mul (ginv a) (mul a b) = b`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let GROUP_RIGHT_CANCEL_NORMALIZE = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv ==> !a b:A. mul (mul b a) (ginv a) = b`,
+   REWRITE_TAC[is_group] THEN MESON_TAC[]);;
+
+let MUL_LEFT_CANCEL = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A). is_group mul e ginv ==>
+    !a b c:A. mul a b = mul a c ==> b = c`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN DISCH_TAC THEN
+  MP_TAC(ISPECL [`mul:A->A->A`; `e:A`; `ginv:A->A`]
+    GROUP_LEFT_CANCEL_NORMALIZE) THEN
+  ASM_REWRITE_TAC[] THEN
+  DISCH_THEN(fun nth ->
+    MP_TAC(SPECL [`a:A`; `b:A`] nth) THEN
+    MP_TAC(SPECL [`a:A`; `c:A`] nth)) THEN
+  ASM_MESON_TAC[]);;
+
+let MUL_RIGHT_CANCEL = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A). is_group mul e ginv ==>
+    !a b c:A. mul b a = mul c a ==> b = c`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN DISCH_TAC THEN
+  MP_TAC(ISPECL [`mul:A->A->A`; `e:A`; `ginv:A->A`]
+    GROUP_RIGHT_CANCEL_NORMALIZE) THEN
+  ASM_REWRITE_TAC[] THEN
+  DISCH_THEN(fun nth ->
+    MP_TAC(SPECL [`a:A`; `b:A`] nth) THEN
+    MP_TAC(SPECL [`a:A`; `c:A`] nth)) THEN
+  ASM_MESON_TAC[]);;
+
+let INV_INV = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A). is_group mul e ginv ==> !a:A. ginv (ginv a) = a`,
+  MESON_TAC[MUL_RIGHT_CANCEL; GROUP_MUL_INV_L; GROUP_MUL_INV_R]);;
+
+let GROUP_INV_MUL_PRODUCT = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A).
+        is_group mul e ginv
+        ==> !a b:A. mul (mul (ginv b) (ginv a)) (mul a b) = e`,
+   MESON_TAC[GROUP_ASSOC_SYM; GROUP_LEFT_CANCEL_NORMALIZE; GROUP_MUL_INV_L]);;
+
+let INV_MUL = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A). is_group mul e ginv ==>
+    !a b:A. ginv (mul a b) = mul (ginv b) (ginv a)`,
+  MESON_TAC[MUL_RIGHT_CANCEL; GROUP_MUL_INV_L; GROUP_INV_MUL_PRODUCT]);;
+
+let INV_EQ_OF_MUL_EQ_ONE = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A). is_group mul e ginv ==>
+    !a b:A. mul a b = e ==> b = ginv a`,
+  MESON_TAC[GROUP_ASSOC; GROUP_MUL_INV_L; GROUP_MUL_ONE; GROUP_ONE_MUL]);;
+
+
+
+
+let is_group_comm = new_definition
+  `is_group_comm (mul:A->A->A) (e:A) (ginv:A->A) <=>
+     is_group mul e ginv /\ (!a b. mul a b = mul b a)`;;
+
+let MUL_ROTATE' = prove
+  (`!mul (e:A) ginv. is_group_comm mul e ginv ==>
+    !a b c. mul a (mul b c) = mul b (mul c a)`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_group_comm; is_group] THEN
+  MESON_TAC[]);;
+
+
+
+
+let is_group_action = new_definition
+  `is_group_action (mul:A->A->A) (e:A) (ginv:A->A) (act:A->B->B) <=>
+     is_group mul e ginv /\
+     (!x. act e x = x) /\
+     (!(g:A) (h:A) (x:B). act (mul g h) x = act g (act h x))`;;
+
+let INTRO_ACTION_HYPS =
+  REWRITE_TAC[is_group_action] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC
+   (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC));;
+
+let GROUP_ACTION_REFL_TAC () =
+  ASM_REWRITE_TAC[is_group_action] THEN REFL_TAC;;
+
+let ACT_INV = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !g x. act (ginv g) (act g x) = x`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_group_action; is_group] THEN
+  MESON_TAC[]);;
+
+let ACT_INV_SPEC = prove
+  (`!mul (e:A) ginv (act:A->B->B) g x. is_group_action mul e ginv act ==>
+    act (ginv g) (act g x) = x`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  ASM_MESON_TAC[ACT_INV]);;
+
+let ACT_INV_R = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !g x. act g (act (ginv g) x) = x`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_group_action; is_group] THEN
+  MESON_TAC[]);;
+
+let ACT_INV_R_SPEC = prove
+  (`!mul (e:A) ginv (act:A->B->B) g x. is_group_action mul e ginv act ==>
+    act g (act (ginv g) x) = x`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  ASM_MESON_TAC[ACT_INV_R]);;
+
+let ACT_INV_R_SYM = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !g x. x = act g (act (ginv g) x)`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN
+  CONV_TAC SYM_CONV THEN
+  MATCH_MP_TAC(ISPECL
+   [`mul:A->A->A`; `e:A`; `ginv:A->A`; `act:A->B->B`; `g:A`; `x:B`]
+   ACT_INV_R_SPEC) THEN
+  ASM_REWRITE_TAC[]);;
+
+
+
+let is_orbit = new_definition
+  `is_orbit (act:A->B->B) x y <=> ?g. act g x = y`;;
+
+let is_stabilizer = new_definition
+  `is_stabilizer (act:A->B->B) x g <=> act g x = x`;;
+
+let ORBIT_REFL = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x. is_orbit act x x`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_group_action; is_orbit] THEN
+  MESON_TAC[]);;
+
+let ORBIT_SYM = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y. is_orbit act x y ==> is_orbit act y x`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN
+  REWRITE_TAC[is_orbit] THEN
+  ASM_MESON_TAC[ACT_INV]);;
+
+let ORBIT_TRANS = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y z. is_orbit act x y ==> is_orbit act y z ==> is_orbit act x z`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_orbit; is_group_action] THEN
+  MESON_TAC[]);;
+
+let ORBIT_PARTITION = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y z. is_orbit act x y ==>
+            (is_orbit act x z <=> is_orbit act y z)`,
+  MESON_TAC[ORBIT_SYM; ORBIT_TRANS]);;
+
+let STABILIZER_MUL = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x g h. is_stabilizer act x g ==> is_stabilizer act x h ==>
+            is_stabilizer act x (mul g h)`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_group_action; is_stabilizer] THEN
+  MESON_TAC[]);;
+
+let STABILIZER_INV = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x g. is_stabilizer act x g ==> is_stabilizer act x (ginv g)`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN
+  REWRITE_TAC[is_stabilizer] THEN DISCH_TAC THEN
+  MATCH_MP_TAC EQ_TRANS THEN
+  EXISTS_TAC `act (ginv g:A) (act g (x:B))` THEN
+  CONJ_TAC THENL
+   [AP_TERM_TAC THEN ASM_REWRITE_TAC[];
+    MATCH_MP_TAC(ISPECL
+     [`mul:A->A->A`; `e:A`; `ginv:A->A`; `act:A->B->B`; `g:A`; `x:B`]
+     ACT_INV_SPEC) THEN
+    ASM_REWRITE_TAC[]]);;
+
+let STABILIZER_ONE = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x. is_stabilizer act x e`,
+  REPEAT GEN_TAC THEN REWRITE_TAC[is_stabilizer; is_group_action] THEN
+  MESON_TAC[]);;
+
+let STABILIZER_CONJUGATE = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x g h. is_stabilizer act x h ==>
+            is_stabilizer act (act g x) (mul (mul g h) (ginv g))`,
+  REPEAT GEN_TAC THEN DISCH_THEN(fun hact ->
+    ASSUME_TAC hact THEN
+    REPEAT GEN_TAC THEN REWRITE_TAC[is_stabilizer] THEN DISCH_TAC THEN
+    STRIP_ASSUME_TAC(REWRITE_RULE[is_group_action] hact) THEN
+    ASM_REWRITE_TAC[] THEN
+    SUBGOAL_THEN `act (ginv g:A) (act g (x:B)) = x` SUBST1_TAC THENL
+     [MATCH_MP_TAC(ISPECL
+       [`mul:A->A->A`; `e:A`; `ginv:A->A`; `act:A->B->B`; `g:A`; `x:B`]
+       ACT_INV_SPEC) THEN
+      ASM_REWRITE_TAC[];
+      ASM_REWRITE_TAC[]]));;
+
+let CONJUGATE_MUL_CANCEL_LEFT = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A) g h.
+        is_group mul e ginv
+        ==> mul g (mul (mul (ginv g) h) g) = mul h g`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(STRIP_ASSUME_TAC o REWRITE_RULE[is_group]) THEN
+  MATCH_MP_TAC EQ_TRANS THEN
+  EXISTS_TAC `mul (mul (mul g (ginv g:A)) h) g` THEN
+  ASM_REWRITE_TAC[]);;
+
+let CONJUGATE_MUL_CANCEL = prove
+  (`!mul:A->A->A (e:A) (ginv:A->A) g h.
+        is_group mul e ginv
+        ==> mul (mul g (mul (mul (ginv g) h) g)) (ginv g) = h`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  MP_TAC(ISPECL
+   [`mul:A->A->A`; `e:A`; `ginv:A->A`; `g:A`; `h:A`]
+   CONJUGATE_MUL_CANCEL_LEFT) THEN
+  ASM_REWRITE_TAC[] THEN
+  DISCH_THEN SUBST1_TAC THEN
+  FIRST_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE[is_group]) THEN
+  MATCH_MP_TAC EQ_TRANS THEN
+  EXISTS_TAC `(mul (h:A) (mul (g:A) (ginv g))):A` THEN
+  CONJ_TAC THENL
+   [CONV_TAC SYM_CONV THEN ASM_MESON_TAC[];
+    ASM_MESON_TAC[]]);;
+
+let STABILIZER_CONJUGATE_ORBIT_FWD = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y g h. act g x = y ==>
+            is_stabilizer act y h ==>
+            is_stabilizer act x (mul (mul (ginv g) h) g)`,
+  REPEAT GEN_TAC THEN DISCH_THEN(fun hact ->
+    ASSUME_TAC hact THEN REPEAT GEN_TAC THEN
+    DISCH_THEN(fun hxy ->
+      ASSUME_TAC hxy THEN
+      REWRITE_TAC[is_stabilizer] THEN
+      DISCH_THEN(fun hstab ->
+        ASSUME_TAC hstab THEN
+        STRIP_ASSUME_TAC(REWRITE_RULE[is_group_action] hact) THEN
+        ASM_REWRITE_TAC[] THEN
+        SUBST1_TAC hxy THEN
+        ASM_REWRITE_TAC[] THEN
+        SUBST1_TAC(SYM hxy) THEN
+        MATCH_MP_TAC(ISPECL
+         [`mul:A->A->A`; `e:A`; `ginv:A->A`; `act:A->B->B`; `g:A`; `x:B`]
+         ACT_INV_SPEC) THEN
+        ASM_REWRITE_TAC[]))));;
+
+let STABILIZER_CONJUGATE_ORBIT_REV = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y g h. act g x = y ==>
+            is_stabilizer act x (mul (mul (ginv g) h) g) ==>
+            is_stabilizer act y h`,
+  REPEAT GEN_TAC THEN DISCH_THEN(fun hact ->
+    REPEAT GEN_TAC THEN DISCH_THEN(fun hxy ->
+      DISCH_THEN(fun hstab ->
+        let hgroup = CONJUNCT1 (REWRITE_RULE[is_group_action] hact) in
+        let eq_conj =
+          MATCH_MP
+            (ISPECL
+              [`mul:A->A->A`; `e:A`; `ginv:A->A`; `g:A`; `h:A`]
+              CONJUGATE_MUL_CANCEL)
+            hgroup in
+        let stab_conj = MATCH_MP (SPECL [`mul:A->A->A`; `e:A`; `ginv:A->A`; `act:A->B->B`] STABILIZER_CONJUGATE) hact in
+        let stab_step =
+          MATCH_MP
+            (ISPECL [`x:B`; `g:A`; `mul (mul (ginv g) h) g:A`] stab_conj)
+            hstab in
+        MATCH_ACCEPT_TAC (REWRITE_RULE[hxy; eq_conj] stab_step)))));;
+let STABILIZER_CONJUGATE_ORBIT = prove
+  (`!mul (e:A) ginv (act:A->B->B). is_group_action mul e ginv act ==>
+    !x y g h. act g x = y ==>
+            (is_stabilizer act y h <=>
+             is_stabilizer act x (mul (mul (ginv g) h) g))`,
+  MESON_TAC[STABILIZER_CONJUGATE_ORBIT_FWD; STABILIZER_CONJUGATE_ORBIT_REV]);;

src_data/babel-formal/proofs/hol-light/ideals.ml

@@ -0,0 +1,107 @@
+let cring = new_definition
+  `cring (zero:'r) (oneR:'r) (add:'r->'r->'r) (mul:'r->'r->'r) (opp:'r->'r) <=>
+     (!x y. add x y = add y x) /\
+     (!x y z. add (add x y) z = add x (add y z)) /\
+     (!x. add x zero = x) /\
+     (!x. add x (opp x) = zero) /\
+     (!x y. mul x y = mul y x) /\
+     (!x y z. mul (mul x y) z = mul x (mul y z)) /\
+     (!x. mul x oneR = x) /\
+     (!a x y. mul a (add x y) = add (mul a x) (mul a y)) /\
+     (!x y. opp (add x y) = add (opp x) (opp y))`;;
+
+let IsIdeal = new_definition
+  `IsIdeal (zero:'r) (add:'r->'r->'r) (mul:'r->'r->'r) (opp:'r->'r)
+           (ideal:'r->bool) <=>
+     ideal zero /\
+     (!x y. ideal x /\ ideal y ==> ideal (add x y)) /\
+     (!x. ideal x ==> ideal (opp x)) /\
+     (!a x. ideal x ==> ideal (mul a x))`;;
+
+let inter = new_definition
+  `inter (fam:'i->'r->bool) = (\x:'r. !i. fam i x)`;;
+
+let add_rearrange = prove
+  (`!zeroR:'r oneR:'r (add:'r->'r->'r) (mul:'r->'r->'r) (opp:'r->'r).
+      cring zeroR oneR add mul opp ==>
+      !a:'r b c d. add (add a b) (add c d) = add (add a c) (add b d)`,
+   REWRITE_TAC[cring] THEN MESON_TAC[]);;
+
+let ideal_sum = new_definition
+  `ideal_sum (add:'r->'r->'r) (ideal1:'r->bool) (ideal2:'r->bool) =
+     (\x:'r. ?a b. ideal1 a /\ ideal2 b /\ x = add a b)`;;
+
+let inter_isIdeal = prove
+  (`!zeroR oneR add mul opp (fam:'i->'r->bool).
+      cring zeroR oneR add mul opp ==>
+      (!i. IsIdeal zeroR add mul opp (fam i)) ==>
+      IsIdeal zeroR add mul opp (inter fam)`,
+   REWRITE_TAC[cring; IsIdeal; inter] THEN REPEAT STRIP_TAC THEN
+   ASM_MESON_TAC[]);;
+
+let sum_isIdeal = prove
+  (`!zeroR oneR add mul opp (ideal1:'r->bool) (ideal2:'r->bool).
+      cring zeroR oneR add mul opp ==>
+      IsIdeal zeroR add mul opp ideal1 ==>
+      IsIdeal zeroR add mul opp ideal2 ==>
+      IsIdeal zeroR add mul opp (ideal_sum add ideal1 ideal2)`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(fun hring ->
+    DISCH_THEN(fun hideal1 ->
+      DISCH_THEN(fun hideal2 ->
+        ASSUME_TAC hring THEN ASSUME_TAC hideal1 THEN ASSUME_TAC hideal2 THEN
+        STRIP_ASSUME_TAC(REWRITE_RULE[cring] hring) THEN
+        STRIP_ASSUME_TAC(REWRITE_RULE[IsIdeal] hideal1) THEN
+        STRIP_ASSUME_TAC(REWRITE_RULE[IsIdeal] hideal2) THEN
+        REWRITE_TAC[IsIdeal; ideal_sum] THEN
+        REPEAT CONJ_TAC THENL
+         [EXISTS_TAC `zeroR:'r` THEN EXISTS_TAC `zeroR:'r` THEN
+          ASM_REWRITE_TAC[];
+          REPEAT GEN_TAC THEN
+          DISCH_THEN(CONJUNCTS_THEN2
+            (X_CHOOSE_THEN `a1:'r`
+              (X_CHOOSE_THEN `b1:'r`
+                (CONJUNCTS_THEN2 ASSUME_TAC
+                  (CONJUNCTS_THEN2 ASSUME_TAC SUBST_ALL_TAC))))
+            (X_CHOOSE_THEN `a2:'r`
+              (X_CHOOSE_THEN `b2:'r`
+                (CONJUNCTS_THEN2 ASSUME_TAC
+                  (CONJUNCTS_THEN2 ASSUME_TAC SUBST_ALL_TAC))))) THEN
+          EXISTS_TAC `(add:'r->'r->'r) (a1:'r) (a2:'r)` THEN
+          EXISTS_TAC `(add:'r->'r->'r) (b1:'r) (b2:'r)` THEN
+          REPEAT CONJ_TAC THENL
+           [ASM_MESON_TAC[];
+            ASM_MESON_TAC[];
+            MATCH_ACCEPT_TAC
+              (SPECL [`a1:'r`; `b1:'r`; `a2:'r`; `b2:'r`]
+                (MATCH_MP
+                  (SPECL
+                    [`zeroR:'r`;
+                     `oneR:'r`;
+                     `add:'r->'r->'r`;
+                     `mul:'r->'r->'r`;
+                     `opp:'r->'r`]
+                    add_rearrange)
+                  hring))];
+          GEN_TAC THEN
+          DISCH_THEN(X_CHOOSE_THEN `a1:'r`
+            (X_CHOOSE_THEN `b1:'r`
+              (CONJUNCTS_THEN2 ASSUME_TAC
+                (CONJUNCTS_THEN2 ASSUME_TAC SUBST_ALL_TAC)))) THEN
+          EXISTS_TAC `(opp:'r->'r) (a1:'r)` THEN
+          EXISTS_TAC `(opp:'r->'r) (b1:'r)` THEN
+          REPEAT CONJ_TAC THENL
+           [ASM_MESON_TAC[];
+            ASM_MESON_TAC[];
+            ASM_REWRITE_TAC[]];
+          REPEAT GEN_TAC THEN
+          DISCH_THEN(X_CHOOSE_THEN `a1:'r`
+            (X_CHOOSE_THEN `b1:'r`
+              (CONJUNCTS_THEN2 ASSUME_TAC
+                (CONJUNCTS_THEN2 ASSUME_TAC SUBST_ALL_TAC)))) THEN
+          EXISTS_TAC `(mul:'r->'r->'r) (a:'r) (a1:'r)` THEN
+          EXISTS_TAC `(mul:'r->'r->'r) (a:'r) (b1:'r)` THEN
+          REPEAT CONJ_TAC THENL
+           [ASM_MESON_TAC[];
+            ASM_MESON_TAC[];
+            ASM_REWRITE_TAC[]]]))));;

src_data/babel-formal/proofs/hol-light/inner_product.ml

@@ -0,0 +1,111 @@
+let is_inner_context = new_definition
+  `is_inner_context (zeroR:R) (oneR:R)
+                    (add:R->R->R) (mul:R->R->R) (opp:R->R)
+                    (addV:V->V->V) (oppV:V->V) (smul:R->V->V)
+                    (ip:V->V->R) <=>
+     (!x y. add x y = add y x) /\
+     (!x y z. add (add x y) z = add x (add y z)) /\
+     (!x. add x zeroR = x) /\
+     (!x. add zeroR x = x) /\
+     (!x. opp (opp x) = x) /\
+     (!x. mul (opp oneR) x = opp x) /\
+     (!u. oppV u = smul (opp oneR) u) /\
+     (!u v w. ip (addV u v) w = add (ip u w) (ip v w)) /\
+     (!a u v. ip (smul a u) v = mul a (ip u v)) /\
+     (!u v w. ip u (addV v w) = add (ip u v) (ip u w)) /\
+     (!a u v. ip u (smul a v) = mul a (ip u v)) /\
+     (!u v. ip u v = ip v u)`;;
+
+let subV = new_definition
+  `subV (addV:V->V->V) (oppV:V->V) u v = addV u (oppV v)`;;
+
+let INTRO_INNER_HYPS =
+  REWRITE_TAC[is_inner_context] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (fun th -> ASSUME_TAC th THEN MAP_EVERY ASSUME_TAC (CONJUNCTS th));;
+
+let ip_neg_left = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip (oppV u) v = opp (ip u v)`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let ip_neg_right = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip u (oppV v) = opp (ip u v)`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let ip_add_add = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip (addV u v) (addV u v) =
+         add (add (ip u u) (ip v u)) (add (ip u v) (ip v v))`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let opp_opp_ctx = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip x.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> opp (opp x) = x`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let add_zero_right_ctx = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip x.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> add x zeroR = x`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let add_zero_left_ctx = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip x.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> add zeroR x = x`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let ip_symm_ctx = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip u v = ip v u`,
+  INTRO_INNER_HYPS THEN ASM_REWRITE_TAC[]);;
+
+let ip_sub_sub = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip (subV addV oppV u v) (subV addV oppV u v) =
+         add (add (ip u u) (opp (ip v u))) (add (opp (ip u v)) (ip v v))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  REWRITE_TAC[subV] THEN
+  FIRST_ASSUM (fun ctx ->
+    let addadd = MATCH_MP ip_add_add ctx in
+    let negL = MATCH_MP ip_neg_left ctx in
+    let negR = MATCH_MP ip_neg_right ctx in
+    let oppopp = MATCH_MP opp_opp_ctx ctx in
+    REWRITE_TAC[addadd; negL; negR; oppopp]) THEN
+  REFL_TAC);;
+
+let pythagoras = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> ip u v = zeroR
+     ==> ip (addV u v) (addV u v) = add (ip u u) (ip v v)`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN (fun ctx ->
+    DISCH_THEN (fun orth ->
+      ASSUME_TAC orth THEN
+      let addadd = MATCH_MP ip_add_add ctx in
+      let symm = MATCH_MP ip_symm_ctx ctx in
+      let addzr = MATCH_MP add_zero_right_ctx ctx in
+      let addzl = MATCH_MP add_zero_left_ctx ctx in
+      REWRITE_TAC[addadd] THEN ASM_REWRITE_TAC[symm; addzr; addzl])));;
+
+let parallelogram = prove
+ (`!zeroR oneR add mul opp (addV:V->V->V) oppV smul ip u v.
+     is_inner_context zeroR oneR add mul opp addV oppV smul ip
+     ==> add (ip (addV u v) (addV u v))
+              (ip (subV addV oppV u v) (subV addV oppV u v)) =
+         add (add (add (ip u u) (ip v u)) (add (ip u v) (ip v v)))
+             (add (add (ip u u) (opp (ip v u))) (add (opp (ip u v)) (ip v v)))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_ASSUM (fun ctx ->
+    let addadd = MATCH_MP ip_add_add ctx in
+    let subsub = MATCH_MP ip_sub_sub ctx in
+    REWRITE_TAC[addadd; subsub]) THEN
+  REFL_TAC);;

src_data/babel-formal/proofs/hol-light/integral_comp_neg_Iic.ml

@@ -0,0 +1,259 @@
+new_type ("R",0);;
+
+let is_integral_context = new_definition
+  `is_integral_context (zero:R) (oneR:R)
+                       (add:R->R->R) (opp:R->R) (mul:R->R->R)
+                       (le:R->R->bool) (lt:R->R->bool) (absR:R->R)
+                       (sigma:(R->bool)->(R->R)->R) <=>
+     (!x:R y:R. add x y = add y x) /\
+     (!x:R y:R z:R. add (add x y) z = add x (add y z)) /\
+     (!x:R. add x zero = x) /\
+     (!x:R. add (opp x) x = zero) /\
+     (!x:R y:R z:R. add x z = add y z ==> x = y) /\
+     (!x:R y:R. mul x y = mul y x) /\
+     (!x:R y:R z:R. mul (mul x y) z = mul x (mul y z)) /\
+     (!x:R. mul x oneR = x) /\
+     (!x:R y:R z:R. mul x (add y z) = add (mul x y) (mul x z)) /\
+     (!x:R. opp (opp x) = x) /\
+     (!x:R y:R z:R. le x y ==> le (add x z) (add y z)) /\
+     (!x:R y:R z:R. le zero z ==> le x y ==> le (mul x z) (mul y z)) /\
+     le zero oneR /\
+     (!x:R y:R. le x y \/ le y x) /\
+     (!x:R y:R. le x y \/ ~(le x y)) /\
+     (!x:R y:R. le x y ==> le (opp y) (opp x)) /\
+     (!x:R y:R. le x y ==> le y x ==> x = y) /\
+     (!x:R y:R. lt x y ==> lt (opp y) (opp x)) /\
+     (!x:R. le x x) /\
+     (!x:R y:R z:R. le x y ==> le y z ==> le x z) /\
+     (!x:R y:R. lt x y <=> (le x y /\ ~(x = y))) /\
+     (!x:R. le zero x ==> absR x = x) /\
+     (!x:R. le x zero ==> absR x = opp x) /\
+     (!x:R. le zero (absR x)) /\
+     (!x:R. absR (opp x) = absR x) /\
+     (!x:R y:R. le (absR (add x y)) (add (absR x) (absR y))) /\
+     (!D:R->bool f:R->R c:R. sigma D (\x. mul c (f x)) = mul c (sigma D f)) /\
+     (!D:R->bool f:R->R g:R->R. (!x:R. D x ==> f x = g x) ==> sigma D f = sigma D g) /\
+     (!D:R->bool. sigma D (\x:R. zero) = zero) /\
+     (!D:R->bool f:R->R g:R->R. sigma D (\x. add (f x) (g x)) = add (sigma D f) (sigma D g)) /\
+     (!D:R->bool E:R->bool f:R->R. (!x:R. D x ==> E x ==> F) ==> sigma (\x. D x \/ E x) f = add (sigma D f) (sigma E f)) /\
+     (!D:R->bool f:R->R g:R->R. (!x:R. D x ==> le (f x) (g x)) ==> le (sigma D f) (sigma D g)) /\
+     (!D:R->bool E:R->bool f:R->R. (!x:R. D x <=> E x) ==> sigma D f = sigma E f) /\
+     (!D:R->bool f:R->R. le (absR (sigma D f)) (sigma D (\x:R. absR (f x))))`;;
+
+let iic = new_definition `iic (le:R->R->bool) c x <=> le x c`;;
+let ioi = new_definition `ioi (lt:R->R->bool) c x <=> lt c x`;;
+let iio = new_definition `iio (lt:R->R->bool) c x <=> lt x c`;;
+
+let unionD = new_definition `unionD (D:R->bool) (E:R->bool) x <=> D x \/ E x`;;
+let interD = new_definition `interD (D:R->bool) (E:R->bool) x <=> D x /\ E x`;;
+
+let preimage = new_definition `preimage (g:R->R) (D:R->bool) x <=> D (g x)`;;
+
+let INTRO_INT_HYPS =
+  REWRITE_TAC[is_integral_context] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (fun th -> ASSUME_TAC th THEN MAP_EVERY ASSUME_TAC (CONJUNCTS th));;
+
+let ASSUM_MATCH_TAC pat ttac =
+  ASSUM_LIST
+    (fun asms ->
+      let th =
+        find
+          (fun th ->
+            try
+              let (_,tinst,_) = term_match [] pat (concl th) in
+              forall (fun (v,t) -> t = v) tinst
+            with Failure _ -> false)
+          asms in
+      ttac th);;
+
+let INT_CONTEXT_CONJ n ctx =
+  List.nth (CONJUNCTS (REWRITE_RULE[is_integral_context] ctx)) n;;
+
+let lt_irrefl = prove
+ (`!zero oneR add opp mul le lt absR sigma x.
+     is_integral_context zero oneR add opp mul le lt absR sigma ==> ~(lt x x)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    MP_TAC (SPECL [`x:R`; `x:R`] (INT_CONTEXT_CONJ 20 ctx)) THEN
+    MESON_TAC[]));;
+
+let lt_trans_strict = prove
+ (`!zero oneR add opp mul le lt absR sigma x y z.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> lt x y ==> lt y z ==> lt x z`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    let le_antisymm = INT_CONTEXT_CONJ 16 ctx in
+    let le_trans = INT_CONTEXT_CONJ 19 ctx in
+    let lt_def = INT_CONTEXT_CONJ 20 ctx in
+    MESON_TAC[le_antisymm; le_trans; lt_def]));;
+
+let preimage_union = prove
+ (`!D E (g:R->R) x.
+     preimage g (unionD D E) x <=> preimage g D x \/ preimage g E x`,
+  REWRITE_TAC[preimage; unionD]);;
+
+let preimage_inter = prove
+ (`!D E (g:R->R) x.
+     preimage g (interD D E) x <=> preimage g D x /\ preimage g E x`,
+  REWRITE_TAC[preimage; interD]);;
+
+let preimage_neg_Ioi = prove
+ (`!zero oneR add opp mul le lt absR sigma c x.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> (preimage opp (ioi lt c) x <=> lt x (opp c))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    REWRITE_TAC[preimage; ioi] THEN
+    MESON_TAC[INT_CONTEXT_CONJ 9 ctx; INT_CONTEXT_CONJ 17 ctx]));;
+
+let preimage_neg_Iic = prove
+ (`!zero oneR add opp mul le lt absR sigma c x.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> (preimage opp (iic le c) x <=> iic le x (opp c))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    REWRITE_TAC[preimage; iic] THEN
+    MESON_TAC[INT_CONTEXT_CONJ 9 ctx; INT_CONTEXT_CONJ 15 ctx]));;
+
+let preimage_comp = prove
+ (`!D (g:R->R) (h:R->R) x.
+     preimage g (preimage h D) x <=> preimage (\x. h (g x)) D x`,
+  REWRITE_TAC[preimage]);;
+
+let integral_neg = prove
+ (`!(zero:R) (oneR:R) (add:R->R->R) (opp:R->R) (mul:R->R->R)
+      (le:R->R->bool) (lt:R->R->bool) (absR:R->R)
+      (sigma:(R->bool)->(R->R)->R) (D:R->bool) (phi:R->R).
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> sigma D (\x. opp (phi x)) = opp (sigma D phi)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    let add_opp = INT_CONTEXT_CONJ 3 ctx in
+    let add_right_cancel = INT_CONTEXT_CONJ 4 ctx in
+    let sigma_zero = INT_CONTEXT_CONJ 28 ctx in
+    let sigma_add = INT_CONTEXT_CONJ 29 ctx in
+    SUBGOAL_THEN
+      `(add:R->R->R)
+         ((sigma:(R->bool)->(R->R)->R) D
+           (\x:R. (opp:R->R) ((phi:R->R) x)))
+         (sigma D phi) =
+       add (opp (sigma D phi)) (sigma D phi)`
+      MP_TAC THENL
+     [SUBGOAL_THEN
+       `(add:R->R->R)
+          ((sigma:(R->bool)->(R->R)->R) D
+            (\x:R. (opp:R->R) ((phi:R->R) x)))
+          (sigma D phi) = zero`
+       SUBST1_TAC THENL
+     [ONCE_REWRITE_TAC[GSYM sigma_add] THEN
+      REWRITE_TAC[add_opp; sigma_zero];
+     REWRITE_TAC[add_opp]];
+     DISCH_TAC THEN
+     SUBGOAL_THEN
+       `!x:R y:R.
+          (add:R->R->R) x ((sigma:(R->bool)->(R->R)->R) D (phi:R->R)) =
+          add y (sigma D phi) ==> x = y`
+       (fun cancel ->
+          MATCH_MP_TAC
+            (ISPECL
+              [`(sigma:(R->bool)->(R->R)->R) D
+                  (\x:R. (opp:R->R) ((phi:R->R) x))`;
+               `(opp:R->R) ((sigma:(R->bool)->(R->R)->R) D (phi:R->R))`]
+              cancel))
+       THENL [MP_TAC add_right_cancel THEN MESON_TAC[]; ASM_REWRITE_TAC[]]]));;
+
+let integral_sub = prove
+ (`!zero oneR add opp mul le lt absR sigma D f g.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> sigma D (\x. add (f x) (opp (g x))) = add (sigma D f) (opp (sigma D g))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    let neg_g =
+      MATCH_MP
+        (ISPECL
+          [`zero:R`; `oneR:R`; `add:R->R->R`; `opp:R->R`;
+           `mul:R->R->R`; `le:R->R->bool`; `lt:R->R->bool`;
+           `absR:R->R`; `sigma:(R->bool)->(R->R)->R`;
+           `D:R->bool`; `g:R->R`]
+          integral_neg)
+        ctx in
+    REWRITE_TAC[INT_CONTEXT_CONJ 29 ctx; neg_g]));;
+
+let sigma_empty = prove
+ (`!zero oneR add opp mul le lt absR sigma f.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> sigma (\x. F) f = zero`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    MESON_TAC[INT_CONTEXT_CONJ 27 ctx; INT_CONTEXT_CONJ 28 ctx]));;
+
+let sigma_bilinear = prove
+ (`!zero oneR add opp mul le lt absR sigma D f g c d.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> sigma D (\x. add (mul c (f x)) (mul d (g x))) =
+         add (mul c (sigma D f)) (mul d (sigma D g))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    REWRITE_TAC[INT_CONTEXT_CONJ 26 ctx; INT_CONTEXT_CONJ 29 ctx]));;
+
+let sigma_le_monotone = prove
+ (`!zero oneR add opp mul le lt absR sigma D f g.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> (!x. D x ==> le (f x) (g x)) ==> le (sigma D f) (sigma D g)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    MESON_TAC[INT_CONTEXT_CONJ 31 ctx]));;
+
+let sigma_nonneg = prove
+ (`!zero oneR add opp mul le lt absR sigma D f.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> (!x. D x ==> le zero (f x)) ==> le zero (sigma D f)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    MESON_TAC[INT_CONTEXT_CONJ 28 ctx; INT_CONTEXT_CONJ 31 ctx]));;
+
+let sigma_split = prove
+ (`!zero oneR add opp mul le lt absR sigma D P f.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> (!x. D x ==> P x \/ ~(P x))
+     ==> sigma D f =
+         add (sigma (\x. D x /\ P x) f) (sigma (\x. D x /\ ~(P x)) f)`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    let sigma_union_disjoint = INT_CONTEXT_CONJ 30 ctx in
+    let sigma_dom_congr = INT_CONTEXT_CONJ 32 ctx in
+    DISCH_THEN (fun dec ->
+      ASSUME_TAC dec THEN
+      SUBGOAL_THEN
+        `(sigma:(R->bool)->(R->R)->R) (D:R->bool) (f:R->R) =
+         sigma (\x:R. D x /\ (P:R->bool) x \/ D x /\ ~(P x)) f`
+        SUBST1_TAC THENL
+       [MATCH_MP_TAC
+          (BETA_RULE (ISPECL
+            [`D:R->bool`;
+             `\x:R. (D:R->bool) x /\ (P:R->bool) x \/ D x /\ ~(P x)`;
+             `f:R->R`]
+            sigma_dom_congr)) THEN
+        ASM_MESON_TAC[];
+        MATCH_MP_TAC
+          (BETA_RULE (ISPECL
+            [`\x:R. (D:R->bool) x /\ (P:R->bool) x`;
+             `\x:R. (D:R->bool) x /\ ~((P:R->bool) x)`;
+             `f:R->R`]
+            sigma_union_disjoint)) THEN
+        MESON_TAC[]])));;
+
+let sigma_preimage_neg_Ioi = prove
+ (`!zero oneR add opp mul le lt absR sigma f c.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> sigma (preimage opp (ioi lt c)) f = sigma (iio lt (opp c)) f`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    let opp_involutive = INT_CONTEXT_CONJ 9 ctx in
+    let lt_opp = INT_CONTEXT_CONJ 17 ctx in
+    let sigma_dom_congr = INT_CONTEXT_CONJ 32 ctx in
+    MATCH_MP_TAC
+      (ISPECL
+        [`preimage (opp:R->R) (ioi (lt:R->R->bool) (c:R))`;
+         `iio (lt:R->R->bool) ((opp:R->R) (c:R))`;
+         `f:R->R`]
+        sigma_dom_congr) THEN
+    X_GEN_TAC `x:R` THEN
+    REWRITE_TAC[preimage; ioi; iio] THEN
+    MESON_TAC[opp_involutive; lt_opp]));;
+
+let sigma_abs_bound = prove
+ (`!zero oneR add opp mul le lt absR sigma D f.
+     is_integral_context zero oneR add opp mul le lt absR sigma
+     ==> le (absR (sigma D f)) (sigma D (\x. absR (f x)))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (fun ctx ->
+    MATCH_ACCEPT_TAC (ISPECL [`D:R->bool`; `f:R->R`] (INT_CONTEXT_CONJ 33 ctx))));;

src_data/babel-formal/proofs/hol-light/lattice_like.ml

@@ -0,0 +1,148 @@
+let is_lattice_like = new_definition
+  `is_lattice_like (le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A) <=>
+     (!x. le_rel x x) /\
+     (!x y z. le_rel x y /\ le_rel y z ==> le_rel x z) /\
+     (!x y. le_rel x y /\ le_rel y x ==> x = y) /\
+     (!a b. le_rel (inf_op a b) a) /\
+     (!a b. le_rel (inf_op a b) b) /\
+     (!c a b. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)) /\
+     (!a b. le_rel a (sup_op a b)) /\
+     (!a b. le_rel b (sup_op a b)) /\
+     (!a b c. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c)`;;
+
+let INTRO_LATTICE_HYPS =
+  REWRITE_TAC[is_lattice_like] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (fun th -> MAP_EVERY ASSUME_TAC (CONJUNCTS th));;
+
+let inf_comm = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==> !a b:A. inf_op a b = inf_op b a`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`inf_op (a:A) (b:A) : A`; `inf_op (b:A) (a:A) : A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [
+     MATCH_MP_TAC
+       (SPECL [`inf_op (a:A) (b:A) : A`; `b:A`; `a:A`]
+              (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`)) THEN
+     ASM_MESON_TAC[]
+   ;
+     MATCH_MP_TAC
+       (SPECL [`inf_op (b:A) (a:A) : A`; `a:A`; `b:A`]
+              (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`)) THEN
+     ASM_MESON_TAC[] ]);;
+
+let sup_comm = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==> !a b:A. sup_op a b = sup_op b a`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`sup_op (a:A) (b:A) : A`; `sup_op (b:A) (a:A) : A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [
+     MATCH_MP_TAC
+       (SPECL [`a:A`; `b:A`; `sup_op (b:A) (a:A) : A`]
+              (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`)) THEN
+     ASM_MESON_TAC[]
+   ;
+     MATCH_MP_TAC
+       (SPECL [`b:A`; `a:A`; `sup_op (a:A) (b:A) : A`]
+              (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`)) THEN
+     ASM_MESON_TAC[] ]);;
+
+let inf_assoc = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==>
+      !a b c:A. inf_op (inf_op a b) c = inf_op a (inf_op b c)`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`inf_op (inf_op (a:A) (b:A) : A) (c:A) : A`;
+             `inf_op (a:A) (inf_op (b:A) (c:A) : A) : A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [
+     MATCH_MP_TAC (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`) THEN
+     CONJ_TAC THENL
+     [
+       MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+       ASM_MESON_TAC[]
+     ;
+       MATCH_MP_TAC (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`) THEN
+       CONJ_TAC THENL
+       [
+         MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+         ASM_MESON_TAC[]
+       ; ASM_MESON_TAC[] ] ]
+   ;
+     MATCH_MP_TAC (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`) THEN
+     CONJ_TAC THENL
+     [
+       MATCH_MP_TAC (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`) THEN
+       CONJ_TAC THENL
+       [ ASM_MESON_TAC[]
+       ; MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+         ASM_MESON_TAC[] ]
+     ;
+       MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+       ASM_MESON_TAC[] ] ]);;
+
+let sup_assoc = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==>
+      !a b c:A. sup_op (sup_op a b) c = sup_op a (sup_op b c)`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`sup_op (sup_op (a:A) (b:A) : A) (c:A) : A`;
+             `sup_op (a:A) (sup_op (b:A) (c:A) : A) : A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [
+     MATCH_MP_TAC (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`) THEN
+     CONJ_TAC THENL
+     [
+       MATCH_MP_TAC (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`) THEN
+       CONJ_TAC THENL
+       [ ASM_MESON_TAC[]
+       ; MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+         ASM_MESON_TAC[] ]
+     ;
+       MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+       ASM_MESON_TAC[] ]
+   ;
+     MATCH_MP_TAC (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`) THEN
+     CONJ_TAC THENL
+     [
+       MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+       ASM_MESON_TAC[]
+     ;
+       MATCH_MP_TAC (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`) THEN
+       CONJ_TAC THENL
+       [ MATCH_MP_TAC (ASSUME `!x:A y:A z:A. le_rel x y /\ le_rel y z ==> le_rel x z`) THEN
+         ASM_MESON_TAC[]
+       ; ASM_MESON_TAC[] ] ] ]);;
+
+let inf_absorption = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==> !a b:A. inf_op a (sup_op a b) = a`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`inf_op (a:A) (sup_op (a:A) (b:A) : A) : A`; `a:A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [ ASM_MESON_TAC[]
+   ; MATCH_MP_TAC (ASSUME `!c:A a:A b:A. le_rel c a /\ le_rel c b ==> le_rel c (inf_op a b)`) THEN
+     ASM_MESON_TAC[] ]);;
+
+let sup_absorption = prove
+  (`!(le_rel:A->A->bool) (inf_op:A->A->A) (sup_op:A->A->A).
+      is_lattice_like le_rel inf_op sup_op ==> !a b:A. sup_op a (inf_op a b) = a`,
+   INTRO_LATTICE_HYPS THEN REPEAT GEN_TAC THEN
+   MATCH_MP_TAC
+     (SPECL [`sup_op (a:A) (inf_op (a:A) (b:A) : A) : A`; `a:A`]
+            (ASSUME `!x:A y:A. le_rel x y /\ le_rel y x ==> x = y`)) THEN
+   CONJ_TAC THENL
+   [ MATCH_MP_TAC (ASSUME `!a:A b:A c:A. le_rel a c /\ le_rel b c ==> le_rel (sup_op a b) c`) THEN
+     ASM_MESON_TAC[]
+   ; ASM_MESON_TAC[] ]);;

src_data/babel-formal/proofs/hol-light/limits_uniqueness.ml

@@ -0,0 +1,31 @@
+let limit = new_definition
+  `limit zero lt absV le sub natLe u l <=>
+     !eps. lt zero eps ==>
+       ?N. !n. natLe N n ==> le (absV (sub (u n) l)) eps`;;
+
+let abs_sub_triangle = prove
+ (`!(absV:A->A) (le:A->A->bool) (add:A->A->A) (sub:A->A->A) (x:A) (y:A) (z:A).
+      (!u v w. sub u w = add (sub u v) (sub v w)) /\
+      (!u v. le (absV (add u v)) (add (absV u) (absV v))) /\
+      (!u v w. le u v ==> le v w ==> le u w) ==>
+      le (absV (sub x z)) (add (absV (sub x y)) (absV (sub y z)))`,
+  REPEAT GEN_TAC THEN DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC
+    (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN
+  SUBGOAL_THEN `(sub:A->A->A) x z = add (sub x y) (sub y z)` SUBST1_TAC THENL
+  [ASM_MESON_TAC[]; ASM_MESON_TAC[]]);;
+
+let limit_unique = prove
+ (`!zero add absV le lt sub natLe natMax u l m.
+      (!x y. natLe x (natMax x y)) /\
+      (!x y. natLe y (natMax x y)) /\
+      (!x y z. sub x z = add (sub x y) (sub y z)) /\
+      (!x y. absV (sub x y) = absV (sub y x)) /\
+      (!x y z. le x y ==> le y z ==> le x z) /\
+      (!a b c d. le a b ==> le c d ==> le (add a c) (add b d)) /\
+      (!x y. le (absV (add x y)) (add (absV x) (absV y))) /\
+      (!x y. sub x y = zero ==> x = y) /\
+      (!x. (!eps. lt zero eps ==> le (absV x) (add eps eps)) ==> x = zero) /\
+      limit zero lt absV le sub natLe u l ==>
+      limit zero lt absV le sub natLe u m ==>
+      l = m`,
+  REWRITE_TAC[limit] THEN MESON_TAC[]);;

src_data/babel-formal/proofs/hol-light/linear_map.ml

@@ -0,0 +1,45 @@
+let is_linear_map = new_definition
+  `is_linear_map (zeroV:'v) (addV:'v->'v->'v) (smul:'r->'v->'v)
+                 (zeroW:'w) (addW:'w->'w->'w) (smulW:'r->'w->'w)
+                 (toFun:'v->'w) <=>
+     (!u v. addV u v = addV v u) /\
+     (!u v w. addV (addV u v) w = addV u (addV v w)) /\
+     (!u. addV u zeroV = u) /\
+     (!a. smul a zeroV = zeroV) /\
+     (!u v. addW u v = addW v u) /\
+     (!u v w. addW (addW u v) w = addW u (addW v w)) /\
+     (!u. addW u zeroW = u) /\
+     (!a. smulW a zeroW = zeroW) /\
+     (!u v. toFun (addV u v) = addW (toFun u) (toFun v)) /\
+     (!a u. toFun (smul a u) = smulW a (toFun u))`;;
+
+let ker = new_definition
+  `ker (toFun:'v->'w) (zeroW:'w) x <=> toFun x = zeroW`;;
+
+let im = new_definition
+  `im (toFun:'v->'w) y <=> ?x. toFun x = y`;;
+
+let ker_add = prove
+  (`!zeroV addV smul zeroW addW smulW (toFun:'v->'w) x y.
+      is_linear_map zeroV addV smul zeroW addW smulW toFun ==>
+      ker toFun zeroW x ==> ker toFun zeroW y ==> ker toFun zeroW (addV x y)`,
+  REWRITE_TAC[is_linear_map; ker] THEN MESON_TAC[]);;
+
+let ker_smul = prove
+  (`!zeroV addV smul zeroW addW smulW (toFun:'v->'w) a x.
+      is_linear_map zeroV addV smul zeroW addW smulW toFun ==>
+      ker toFun zeroW x ==> ker toFun zeroW (smul a x)`,
+  REWRITE_TAC[is_linear_map; ker] THEN MESON_TAC[]);;
+
+let im_add = prove
+  (`!zeroV addV smul zeroW addW smulW (toFun:'v->'w) y z.
+      is_linear_map zeroV addV smul zeroW addW smulW toFun ==>
+      im toFun y ==> im toFun z ==> im toFun (addW y z)`,
+  REWRITE_TAC[is_linear_map; im] THEN MESON_TAC[]);;
+
+let im_smul = prove
+  (`!zeroV addV smul zeroW addW smulW (toFun:'v->'w) a y.
+      is_linear_map zeroV addV smul zeroW addW smulW toFun ==>
+      im toFun y ==> im toFun (smulW a y)`,
+  REWRITE_TAC[is_linear_map; im] THEN MESON_TAC[]);;
+

src_data/babel-formal/proofs/hol-light/polynomial.ml

@@ -0,0 +1,608 @@
+let mynat_INDUCT,mynat_RECURSION = define_type
+ "mynat = Nat_O | Nat_S mynat";;
+
+let mynat_add = new_recursive_definition mynat_RECURSION
+ `(mynat_add Nat_O m = m) /\
+  (mynat_add (Nat_S n) m = Nat_S (mynat_add n m))`;;
+
+let mynat_add_O_left = prove
+ (`!m. mynat_add Nat_O m = m`,
+  REWRITE_TAC[mynat_add]);;
+
+let mynat_add_S_left = prove
+ (`!n m. mynat_add (Nat_S n) m = Nat_S (mynat_add n m)`,
+  REWRITE_TAC[mynat_add]);;
+
+let mynat_le_RULES,mynat_le_INDUCT,mynat_le_CASES = new_inductive_definition
+ `(!n. mynat_le n n) /\
+  (!n m. mynat_le n m ==> mynat_le n (Nat_S m))`;;
+
+let mynat_zero_le = prove
+ (`!n. mynat_le Nat_O n`,
+  MATCH_MP_TAC (BETA_RULE (SPEC `\(n:mynat). mynat_le Nat_O n` mynat_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_le_RULES];
+    ASM_MESON_TAC[mynat_le_RULES]]);;
+
+let mynat_add_zero_r = prove
+ (`!n. mynat_add n Nat_O = n`,
+  MATCH_MP_TAC
+   (BETA_RULE (SPEC `\(n:mynat). mynat_add n Nat_O = n` mynat_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_add];
+    REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[mynat_add]]);;
+
+let mynat_succ_le_succ = prove
+ (`!n m. mynat_le n m ==> mynat_le (Nat_S n) (Nat_S m)`,
+  MATCH_MP_TAC
+   (BETA_RULE
+     (SPEC `\(n:mynat) (m:mynat). mynat_le (Nat_S n) (Nat_S m)`
+           mynat_le_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_le_RULES];
+    REPEAT STRIP_TAC THEN ASM_MESON_TAC[mynat_le_RULES]]);;
+
+let mynat_add_S_r = prove
+ (`!m n. mynat_add m (Nat_S n) = Nat_S (mynat_add m n)`,
+  MATCH_MP_TAC
+   (BETA_RULE
+     (SPEC `\(m:mynat). !n. mynat_add m (Nat_S n) = Nat_S (mynat_add m n)`
+           mynat_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_add];
+    REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[mynat_add]]);;
+
+let mynat_add_comm = prove
+ (`!n m. mynat_add n m = mynat_add m n`,
+  MATCH_MP_TAC
+   (BETA_RULE
+     (SPEC `\(n:mynat). !m. mynat_add n m = mynat_add m n`
+           mynat_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_add; mynat_add_zero_r];
+    REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[mynat_add; mynat_add_S_r]]);;
+
+let mynat_le_add_left = prove
+ (`!n m. mynat_le n (mynat_add m n)`,
+  GEN_TAC THEN
+  MATCH_MP_TAC
+   (BETA_RULE
+     (SPEC `\(m:mynat). mynat_le n (mynat_add m n)` mynat_INDUCT)) THEN
+  CONJ_TAC THENL
+   [REWRITE_TAC[mynat_add; mynat_le_RULES];
+    REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[mynat_add] THEN
+    ASM_MESON_TAC[mynat_le_RULES]]);;
+
+let mylist_INDUCT,mylist_RECURSION = define_type
+ "mylist = NilL | ConsL A mylist";;
+
+let InL_RULES,InL_INDUCT,InL_CASES = new_inductive_definition
+ `(!x xs. InL x (ConsL x xs)) /\
+  (!x y xs. InL x xs ==> InL x (ConsL y xs))`;;
+
+let NoDupL_RULES,NoDupL_INDUCT,NoDupL_CASES = new_inductive_definition
+ `NoDupL NilL /\
+  (!x xs. ~(InL x xs) /\ NoDupL xs ==> NoDupL (ConsL x xs))`;;
+
+let InL_cons_intro = prove
+ (`!x y (xs:A mylist). InL x xs ==> InL x (ConsL y xs)`,
+  MESON_TAC[InL_RULES]);;
+
+let NoDupL_cons_tail = prove
+ (`!x (xs:A mylist). NoDupL (ConsL x xs) ==> NoDupL xs`,
+  MESON_TAC[NoDupL_CASES; distinctness "mylist"; injectivity "mylist"]);;
+
+let NoDupL_cons_notin = prove
+ (`!x (xs:A mylist). NoDupL (ConsL x xs) ==> ~(InL x xs)`,
+  MESON_TAC[NoDupL_CASES; distinctness "mylist"; injectivity "mylist"]);;
+
+let lengthL = new_recursive_definition mylist_RECURSION
+ `(lengthL NilL = Nat_O) /\
+  (lengthL (ConsL x xs) = Nat_S (lengthL xs))`;;
+
+let X = new_definition
+ `X (monomial:mynat->R->P) (oneR:R) = monomial (Nat_S Nat_O) oneR`;;
+
+let C = new_definition
+ `C (monomial:mynat->R->P) (c:R) = monomial Nat_O c`;;
+
+let x_minus_def = new_definition
+ `X_minus (monomial:mynat->R->P) (addP:P->P->P) (oppR:R->R)
+          (oneR:R) (a:R) =
+    addP (X monomial oneR) (C monomial (oppR a))`;;
+
+let is_root = new_definition
+ `is_root (eval:P->R->R) (zeroR:R) (a:R) (p:P) <=> eval p a = zeroR`;;
+
+let poly_of_roots = new_recursive_definition mylist_RECURSION
+ `(poly_of_roots (monomial:mynat->R->P) (addP:P->P->P) (oppR:R->R)
+                 (oneR:R) (mulP:P->P->P) (oneP:P) NilL = oneP) /\
+  (poly_of_roots monomial addP oppR oneR mulP oneP (ConsL a xs) =
+     mulP (X_minus monomial addP oppR oneR a)
+          (poly_of_roots monomial addP oppR oneR mulP oneP xs))`;;
+
+let is_ring = new_definition
+ `is_ring (zr:A) (un:A) (add:A->A->A) (mul:A->A->A) (opp:A->A) <=>
+    ~(un = zr) /\
+    (!x y. add x y = add y x) /\
+    (!x y z. add (add x y) z = add x (add y z)) /\
+    (!x. add x zr = x) /\
+    (!x. add x (opp x) = zr) /\
+    (!x y. mul x y = mul y x) /\
+    (!x y z. mul (mul x y) z = mul x (mul y z)) /\
+    (!x. mul x un = x) /\
+    (!x y z. mul x (add y z) = add (mul x y) (mul x z)) /\
+    (!x. mul x zr = zr) /\
+    (!x y. mul x y = zr ==> x = zr \/ y = zr)`;;
+
+let is_poly_context = new_definition
+ `is_poly_context
+      (zeroR:R) (oneR:R) (addR:R->R->R) (mulR:R->R->R) (oppR:R->R)
+      (zeroP:P) (oneP:P) (addP:P->P->P) (mulP:P->P->P) (oppP:P->P)
+      (degree:P->mynat) (monomial:mynat->R->P) (eval:P->R->R) <=>
+    is_ring zeroR oneR addR mulR oppR /\
+    is_ring zeroP oneP addP mulP oppP /\
+    C monomial zeroR = zeroP /\
+    C monomial oneR = oneP /\
+    degree zeroP = Nat_O /\
+    (!p q x. eval (addP p q) x = addR (eval p x) (eval q x)) /\
+    (!p q x. eval (mulP p q) x = mulR (eval p x) (eval q x)) /\
+    (!c x. eval (C monomial c) x = c) /\
+    (!x. eval (X monomial oneR) x = x) /\
+    (!c. ~(c = zeroR) ==> degree (C monomial c) = Nat_O) /\
+    (!p. degree p = Nat_O <=> ?c. p = C monomial c) /\
+    (!a. degree (X_minus monomial addP oppR oneR a) = Nat_S Nat_O) /\
+    (!p q. ~(p = zeroP) /\ ~(q = zeroP)
+           ==> degree (mulP p q) = mynat_add (degree p) (degree q)) /\
+    (!p a. ?q r. p = addP (mulP q (X_minus monomial addP oppR oneR a)) r /\
+                  degree r = Nat_O)`;;
+
+let ring_add_comm = prove
+ (`!zr un add mul opp (x:A) y.
+     is_ring zr un add mul opp ==> add x y = add y x`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_add_assoc = prove
+ (`!zr un add mul opp (x:A) y z.
+     is_ring zr un add mul opp ==> add (add x y) z = add x (add y z)`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_add_zero = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> add x zr = x`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_add_opp = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> add x (opp x) = zr`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let poly_context_poly_ring = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> is_ring zeroP oneP addP mulP oppP`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_oneP_nonzero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ~(oneP = zeroP)`,
+  REWRITE_TAC[is_poly_context; is_ring] THEN MESON_TAC[]);;
+
+let poly_context_oneP_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> degree oneP = Nat_O`,
+  REWRITE_TAC[is_poly_context; is_ring; C] THEN MESON_TAC[]);;
+
+let poly_context_zeroP_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> degree zeroP = Nat_O`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_x_minus_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> degree (X_minus monomial addP oppR oneR a) = Nat_S Nat_O`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_mul_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ~(p = zeroP) /\ ~(q = zeroP)
+     ==> degree (mulP p q) = mynat_add (degree p) (degree q)`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let ring_mul_comm = prove
+ (`!zr un add mul opp (x:A) y.
+     is_ring zr un add mul opp ==> mul x y = mul y x`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_mul_assoc = prove
+ (`!zr un add mul opp (x:A) y z.
+     is_ring zr un add mul opp ==> mul (mul x y) z = mul x (mul y z)`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_mul_reassoc_comm = prove
+ (`!zr un add mul opp (x:A) y z.
+     is_ring zr un add mul opp ==> mul (mul x y) z = mul x (mul z y)`,
+  MESON_TAC[ring_mul_assoc; ring_mul_comm]);;
+
+let ring_mul_one = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> mul x un = x`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_mul_zero = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> mul x zr = zr`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_no_zero_div = prove
+ (`!zr un add mul opp (x:A) y.
+     is_ring zr un add mul opp ==> mul x y = zr ==> x = zr \/ y = zr`,
+  REWRITE_TAC[is_ring] THEN MESON_TAC[]);;
+
+let ring_mul_zero_left = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> mul zr x = zr`,
+  MESON_TAC[ring_mul_comm; ring_mul_zero]);;
+
+let sub_eq_zero_l = prove
+ (`!zeroR oneR addR mulR oppR (a:R) b.
+     is_ring zeroR oneR addR mulR oppR
+     ==> addR a (oppR b) = zeroR ==> a = b`,
+  MESON_TAC[ring_add_comm; ring_add_assoc; ring_add_zero; ring_add_opp]);;
+
+let eval_x_minus_self = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> eval (X_minus monomial addP oppR oneR a) a = zeroR`,
+  REWRITE_TAC[is_poly_context; X; C; x_minus_def] THEN
+  REPEAT STRIP_TAC THEN
+  ASM_REWRITE_TAC[] THEN
+  ASM_MESON_TAC[ring_add_opp]);;
+
+let eval_x_minus = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (a:R) b.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> eval (X_minus monomial addP oppR oneR a) b = addR b (oppR a)`,
+  REWRITE_TAC[is_poly_context; X; C; x_minus_def] THEN
+  REPEAT STRIP_TAC THEN
+  ASM_REWRITE_TAC[]);;
+
+let poly_context_division = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ?q r. p = addP (mulP q (X_minus monomial addP oppR oneR a)) r /\
+               degree r = Nat_O`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_C_zero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> C monomial zeroR = zeroP`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_eval_C = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (c:R) x.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> eval (C monomial c) x = c`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_degree_zero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> (degree p = Nat_O <=> ?c. p = C monomial c)`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_base_ring = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> is_ring zeroR oneR addR mulR oppR`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_eval_add = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q x.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> eval (addP p q) x = addR (eval p x) (eval q x)`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let poly_context_eval_mul = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q x.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> eval (mulP p q) x = mulR (eval p x) (eval q x)`,
+  REWRITE_TAC[is_poly_context] THEN MESON_TAC[]);;
+
+let ring_add_zero_left = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> add zr x = x`,
+  MESON_TAC[ring_add_comm; ring_add_zero]);;
+
+let ring_add_zero_left_eq = prove
+ (`!zr un add mul opp (x:A).
+     is_ring zr un add mul opp ==> add zr x = zr ==> x = zr`,
+  MESON_TAC[ring_add_zero_left]);;
+
+let poly_context_add_zero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (x:P).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> addP x zeroP = x`,
+  MESON_TAC[poly_context_poly_ring; ring_add_zero]);;
+
+let ring_add_mul_zero_cancel = prove
+ (`!zr un add mul opp (x:A) y.
+     is_ring zr un add mul opp ==> add (mul x zr) y = zr ==> y = zr`,
+  MESON_TAC[ring_mul_zero; ring_add_zero_left_eq]);;
+
+let constant_root_zero_lemma = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> degree p = Nat_O ==> is_root eval zeroR a p ==> p = zeroP`,
+  MESON_TAC[poly_context_degree_zero; poly_context_eval_C;
+            poly_context_C_zero; is_root]);;
+
+let root_factor_remainder_root = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q r (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+	     ==> p = addP (mulP q (X_minus monomial addP oppR oneR a)) r
+	     ==> is_root eval zeroR a p
+	     ==> is_root eval zeroR a r`,
+  REWRITE_TAC[is_root] THEN
+  MESON_TAC[poly_context_eval_add; poly_context_eval_mul; eval_x_minus_self;
+            poly_context_base_ring; ring_add_mul_zero_cancel]);;
+
+let root_factor_remainder_zero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q r (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> p = addP (mulP q (X_minus monomial addP oppR oneR a)) r
+     ==> degree r = Nat_O
+     ==> is_root eval zeroR a p
+     ==> r = zeroP`,
+  MESON_TAC[root_factor_remainder_root; constant_root_zero_lemma]);;
+
+let root_factor = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> is_root eval zeroR a p
+     ==> ?q. p = mulP q (X_minus monomial addP oppR oneR a)`,
+  MESON_TAC[poly_context_division; root_factor_remainder_zero;
+            poly_context_add_zero]);;
+
+let root_transfer = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q (a:R) b.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> p = mulP q (X_minus monomial addP oppR oneR a)
+     ==> ~(b = a)
+     ==> is_root eval zeroR b p
+     ==> is_root eval zeroR b q`,
+  REWRITE_TAC[is_root] THEN
+  MESON_TAC[poly_context_eval_mul; eval_x_minus; poly_context_base_ring;
+            ring_no_zero_div; sub_eq_zero_l]);;
+
+let x_minus_nonzero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ~(X_minus monomial addP oppR oneR a = zeroP)`,
+  MESON_TAC[poly_context_x_minus_degree; poly_context_zeroP_degree;
+            distinctness "mynat"]);;
+
+let constant_root_zero = constant_root_zero_lemma;;
+
+let root_of_product = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) q (a:R).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> is_root eval zeroR a (mulP p q)
+     ==> is_root eval zeroR a p \/ is_root eval zeroR a q`,
+  REWRITE_TAC[is_poly_context; is_ring; is_root] THEN MESON_TAC[]);;
+
+let root_scale_constant = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (c:R) a.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ~(c = zeroR)
+     ==> (is_root eval zeroR a p <=>
+          is_root eval zeroR a (mulP (C monomial c) p))`,
+  REWRITE_TAC[is_poly_context; is_ring; is_root; C] THEN MESON_TAC[]);;
+
+let poly_of_roots_nonzero = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (xs:R mylist).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> ~(poly_of_roots monomial addP oppR oneR mulP oneP xs = zeroP)`,
+  REPEAT GEN_TAC THEN
+  DISCH_TAC THEN
+  SPEC_TAC(`xs:R mylist`,`xs:R mylist`) THEN
+  MATCH_MP_TAC
+   (BETA_RULE
+     (ISPEC `\(xs:R mylist).
+               ~(poly_of_roots monomial addP oppR oneR mulP oneP xs = zeroP)`
+           mylist_INDUCT)) THEN
+  ASM_REWRITE_TAC[poly_of_roots] THEN
+  CONJ_TAC THENL
+   [ASM_MESON_TAC[poly_context_oneP_nonzero];
+    ASM_MESON_TAC[poly_context_poly_ring; ring_no_zero_div;
+                  x_minus_nonzero]]);;
+
+let poly_context_x_roots_mul_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (a:R) (xs:R mylist).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+         degree monomial eval
+     ==> degree (mulP (X_minus monomial addP oppR oneR a)
+                   (poly_of_roots monomial addP oppR oneR mulP oneP xs)) =
+         mynat_add (degree (X_minus monomial addP oppR oneR a))
+                   (degree (poly_of_roots monomial addP oppR oneR mulP oneP xs))`,
+  MESON_TAC[poly_context_mul_degree; x_minus_nonzero;
+            poly_of_roots_nonzero]);;
+
+let deg_poly_of_roots = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (xs:R mylist).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> degree (poly_of_roots monomial addP oppR oneR mulP oneP xs) =
+         lengthL xs`,
+  REPEAT GEN_TAC THEN
+  DISCH_TAC THEN
+  SPEC_TAC(`xs:R mylist`,`xs:R mylist`) THEN
+  MATCH_MP_TAC
+   (BETA_RULE
+     (ISPEC `\(xs:R mylist).
+               degree (poly_of_roots monomial addP oppR oneR mulP oneP xs) =
+               lengthL xs`
+           mylist_INDUCT)) THEN
+  CONJ_TAC THENL
+   [ASM_REWRITE_TAC[poly_of_roots; lengthL] THEN
+    ASM_MESON_TAC[poly_context_oneP_degree];
+    X_GEN_TAC `a:R` THEN
+    X_GEN_TAC `xs:R mylist` THEN
+    DISCH_TAC THEN
+    ASM_REWRITE_TAC[poly_of_roots; lengthL] THEN
+    ASM_MESON_TAC[poly_context_x_roots_mul_degree;
+                  poly_context_x_minus_degree;
+                  mynat_add_S_left; mynat_add_O_left] ]);;
+
+let root_factor_list = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (xs:R mylist).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> NoDupL xs
+     ==> (!a. InL a xs ==> is_root eval zeroR a p)
+     ==> ?q. p = mulP q (poly_of_roots monomial addP oppR oneR mulP oneP xs)`,
+  REPEAT GEN_TAC THEN
+  DISCH_TAC THEN
+  SPEC_TAC(`p:P`,`p:P`) THEN
+  SPEC_TAC(`xs:R mylist`,`xs:R mylist`) THEN
+  MATCH_MP_TAC
+   (BETA_RULE
+     (ISPEC `\(xs:R mylist).
+               !p:P.
+                 NoDupL xs
+                 ==> (!a. InL a xs ==> is_root eval zeroR a p)
+                 ==> ?q. p = mulP q
+                            (poly_of_roots monomial addP oppR oneR mulP oneP xs)`
+           mylist_INDUCT)) THEN
+  ASM_REWRITE_TAC[poly_of_roots] THEN
+  CONJ_TAC THENL
+   [REPEAT STRIP_TAC THEN EXISTS_TAC `p:P` THEN
+    ASM_MESON_TAC[poly_context_poly_ring; ring_mul_one];
+    X_GEN_TAC `a:R` THEN
+    X_GEN_TAC `xs:R mylist` THEN
+    DISCH_THEN(LABEL_TAC "IH") THEN
+    X_GEN_TAC `p:P` THEN
+    DISCH_THEN(LABEL_TAC "ND") THEN
+    DISCH_THEN(LABEL_TAC "ROOTS") THEN
+    MP_TAC
+     (ISPECL
+       [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+        `oppR:R->R`; `zeroP:P`; `oneP:P`; `addP:P->P->P`;
+        `mulP:P->P->P`; `oppP:P->P`; `degree:P->mynat`;
+        `monomial:mynat->R->P`; `eval:P->R->R`; `p:P`; `a:R`]
+       root_factor) THEN
+    ASM_REWRITE_TAC[] THEN
+    ANTS_TAC THENL
+     [USE_THEN "ROOTS" MATCH_MP_TAC THEN REWRITE_TAC[InL_RULES];
+      ALL_TAC] THEN
+    DISCH_THEN(X_CHOOSE_TAC `q0:P`) THEN
+    USE_THEN "IH" (MP_TAC o SPEC `q0:P`) THEN
+    ANTS_TAC THENL
+     [USE_THEN "ND" MP_TAC THEN MESON_TAC[NoDupL_cons_tail];
+      ALL_TAC] THEN
+    ANTS_TAC THENL
+     [X_GEN_TAC `b:R` THEN DISCH_TAC THEN
+      ASM_MESON_TAC[NoDupL_cons_notin; InL_cons_intro; root_transfer];
+      DISCH_THEN(X_CHOOSE_TAC `q:P`) THEN
+      EXISTS_TAC `q:P` THEN
+      ASM_MESON_TAC[poly_context_poly_ring; ring_mul_reassoc_comm]]]);;
+
+let degree_factorisation = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (xs:R mylist) q.
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> p = mulP q (poly_of_roots monomial addP oppR oneR mulP oneP xs)
+     ==> ~(q = zeroP)
+     ==> degree p = mynat_add (degree q) (lengthL xs)`,
+  MESON_TAC[poly_context_mul_degree; poly_of_roots_nonzero;
+            deg_poly_of_roots]);;
+
+let roots_le_degree = prove
+ (`!zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+     degree monomial eval (p:P) (xs:R mylist).
+     is_poly_context zeroR oneR addR mulR oppR zeroP oneP addP mulP oppP
+                     degree monomial eval
+     ==> NoDupL xs
+     ==> (!a. InL a xs ==> is_root eval zeroR a p)
+     ==> ~(p = zeroP)
+     ==> mynat_le (lengthL xs) (degree p)`,
+  REPEAT STRIP_TAC THEN
+  MP_TAC
+   (SPECL [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+           `oppR:R->R`; `zeroP:P`; `oneP:P`; `addP:P->P->P`;
+           `mulP:P->P->P`; `oppP:P->P`; `degree:P->mynat`;
+           `monomial:mynat->R->P`; `eval:P->R->R`; `p:P`;
+           `xs:R mylist`] root_factor_list) THEN
+  ASM_REWRITE_TAC[] THEN
+  DISCH_THEN(X_CHOOSE_TAC `q:P`) THEN
+  SUBGOAL_THEN `~(q:P = zeroP)` ASSUME_TAC THENL
+   [ASM_MESON_TAC[poly_context_poly_ring; ring_mul_zero_left];
+    MP_TAC
+     (SPECL [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+             `oppR:R->R`; `zeroP:P`; `oneP:P`; `addP:P->P->P`;
+             `mulP:P->P->P`; `oppP:P->P`; `degree:P->mynat`;
+             `monomial:mynat->R->P`; `eval:P->R->R`; `p:P`;
+             `xs:R mylist`; `q:P`] degree_factorisation) THEN
+    ASM_REWRITE_TAC[] THEN
+    DISCH_THEN SUBST1_TAC THEN
+    REWRITE_TAC[mynat_le_add_left]]);;

src_data/babel-formal/proofs/hol-light/probability.ml

@@ -0,0 +1,643 @@
+new_type ("R",0);;
+new_type ("W",0);;
+
+let subR = new_definition
+  `subR (addR:R->R->R) (oppR:R->R) (x:R) (y:R) = addR x (oppR y)`;;
+
+let ev_false = new_definition
+  `ev_false:W->bool = (\w. F)`;;
+
+let ev_true = new_definition
+  `ev_true:W->bool = (\w. T)`;;
+
+let ev_inter = new_definition
+  `ev_inter (A:W->bool) (B:W->bool) = (\w. A w /\ B w)`;;
+
+let ev_union = new_definition
+  `ev_union (A:W->bool) (B:W->bool) = (\w. A w \/ B w)`;;
+
+let ev_compl = new_definition
+  `ev_compl (A:W->bool) = (\w. ~(A w))`;;
+
+let ev_diff = new_definition
+  `ev_diff (A:W->bool) (B:W->bool) = (\w. A w /\ ~(B w))`;;
+
+let disjoint = new_definition
+  `disjoint (A:W->bool) (B:W->bool) <=> !w. ~(ev_inter A B w)`;;
+
+let pairwise_disjoint = new_recursive_definition list_RECURSION
+  `pairwise_disjoint ([]:(W->bool)list) = T /\
+   pairwise_disjoint (CONS (A:W->bool) xs) =
+     ((!B. MEM B xs ==> disjoint A B) /\ pairwise_disjoint xs)`;;
+
+let bigUnion = new_recursive_definition list_RECURSION
+  `bigUnion ([]:(W->bool)list) = ev_false /\
+   bigUnion (CONS (A:W->bool) xs) = ev_union A (bigUnion xs)`;;
+
+let fold_add = new_recursive_definition list_RECURSION
+  `fold_add (addR:R->R->R) (zeroR:R) ([]:R list) = zeroR /\
+   fold_add addR zeroR (CONS x xs) = addR x (fold_add addR zeroR xs)`;;
+
+let NilL = new_definition
+  `NilL:A list = []`;;
+
+let ConsL = new_definition
+  `ConsL (x:A) (xs:A list) = CONS x xs`;;
+
+let InL = new_definition
+  `InL (x:A) (xs:A list) <=> MEM x xs`;;
+
+let mapL = new_definition
+  `mapL (f:A->B) (xs:A list) = MAP f xs`;;
+
+let fold_addL = new_definition
+  `fold_addL (addR:R->R->R) (zeroR:R) (xs:R list) =
+   fold_add addR zeroR xs`;;
+
+let indep = new_definition
+  `indep (prob:(W->bool)->R) (mulR:R->R->R) (A:W->bool) (B:W->bool) <=>
+     prob (ev_inter A B) = mulR (prob A) (prob B)`;;
+
+let is_prob_context = new_definition
+  `!zeroR oneR addR mulR oppR prob cprob.
+     is_prob_context zeroR oneR addR mulR oppR prob cprob <=>
+     ~(oneR = zeroR) /\
+	     (!x y. addR x y = addR y x) /\
+	     (!x y z. addR (addR x y) z = addR x (addR y z)) /\
+	     (!x y z. addR x z = addR y z ==> x = y) /\
+	     (!x. addR x zeroR = x) /\
+	     (!x. addR zeroR x = x) /\
+	     (!x. addR x (oppR x) = zeroR) /\
+	     (!x. addR (oppR x) x = zeroR) /\
+     (!x y. mulR x y = mulR y x) /\
+     (!x y z. mulR (mulR x y) z = mulR x (mulR y z)) /\
+     (!x. mulR x oneR = x) /\
+     (!x. mulR oneR x = x) /\
+     (!x y z. mulR x (addR y z) = addR (mulR x y) (mulR x z)) /\
+     (!x. mulR x zeroR = zeroR) /\
+     (!x. mulR zeroR x = zeroR) /\
+     (!x y. mulR x y = zeroR ==> x = zeroR \/ y = zeroR) /\
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B) /\
+     (prob ev_false = zeroR) /\
+     (prob ev_true  = oneR) /\
+     (!A B. prob (ev_union A B) =
+            addR (prob A) (addR (prob B) (oppR (prob (ev_inter A B))))) /\
+     (!A. prob (ev_compl A) = addR oneR (oppR (prob A))) /\
+     (!A B. prob (ev_inter A B) = mulR (cprob A B) (prob B)) /\
+     (oppR zeroR = zeroR) /\
+     (!x. oppR (oppR x) = x) /\
+     (!x y. mulR x (oppR y) = oppR (mulR x y)) /\
+	     (!x y. mulR (oppR x) y = oppR (mulR x y)) /\
+	     (!A B. disjoint A B ==> prob (ev_union A B) = addR (prob A) (prob B)) /\
+	     (!A xs. pairwise_disjoint (CONS A xs) ==> disjoint A (bigUnion xs)) /\
+	     (!A B. indep prob mulR A B ==> indep prob mulR (ev_compl A) (ev_compl B)) /\
+	     (!A B C.
+	        prob (ev_union (ev_union A B) C) =
+	        addR (prob A)
+	          (addR (prob B)
+	            (addR (prob C)
+	              (oppR (addR (prob (ev_inter A B))
+	                (addR (prob (ev_inter A C))
+	                  (addR (prob (ev_inter B C))
+	                    (oppR (prob (ev_inter (ev_inter A B) C))))))))))`;;
+
+let INTRO_PROB_HYPS =
+  REWRITE_TAC[is_prob_context] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN STRIP_ASSUME_TAC;;
+
+let ASSUM_MATCH_TAC pat ttac =
+  ASSUM_LIST
+    (fun asms ->
+      let th =
+        find
+          (fun th ->
+            try
+              let (_,tinst,_) = term_match [] pat (concl th) in
+              forall (fun (v,t) -> t = v) tinst
+            with Failure _ -> false)
+          asms in
+      ttac th);;
+
+let FUN_CONG = prove
+ (`!f:A->B x y. x = y ==> f x = f y`,
+  REPEAT GEN_TAC THEN DISCH_THEN SUBST1_TAC THEN REFL_TAC);;
+
+let add_right_cancel = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (x:R) (y:R) (z:R).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> addR x z = addR y z ==> x = y`,
+  INTRO_PROB_HYPS THEN ASM_MESON_TAC[]);;
+
+let add_move_right_raw = prove
+ (`!zeroR addR oppR (x:R) (y:R) (z:R).
+     (!a b c. addR (addR a b) c = addR a (addR b c))
+     ==> (!a b c. addR a c = addR b c ==> a = b)
+     ==> (!a. addR a zeroR = a)
+     ==> (!a. addR (oppR a) a = zeroR)
+     ==> addR x y = z
+     ==> x = addR z (oppR y)`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN (fun add_assoc ->
+  DISCH_THEN (fun add_cancel ->
+  DISCH_THEN (fun add_rzero ->
+  DISCH_THEN (fun add_linv ->
+  DISCH_TAC THEN
+  MATCH_MP_TAC
+    (SPECL [`x:R`; `addR z (oppR y):R`; `y:R`] add_cancel) THEN
+  ASM_REWRITE_TAC[add_assoc; add_rzero; add_linv])))));;
+
+let add_move_right = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (x:R) (y:R) (z:R).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> addR x y = z ==> x = addR z (oppR y)`,
+  INTRO_PROB_HYPS THEN
+  MP_TAC
+    (ISPECL [`zeroR:R`; `addR:R->R->R`; `oppR:R->R`;
+             `x:R`; `y:R`; `z:R`] add_move_right_raw) THEN
+  ASM_REWRITE_TAC[]);;
+
+let ev_diff_union_inter = prove
+ (`!A B. !w. ev_union (ev_diff A B) (ev_inter A B) w <=> A w`,
+  REWRITE_TAC[ev_union; ev_diff; ev_inter] THEN MESON_TAC[]);;
+
+let ev_diff_inter_disjoint = prove
+ (`!A B. disjoint (ev_diff A B) (ev_inter A B)`,
+  REWRITE_TAC[disjoint; ev_diff; ev_inter] THEN MESON_TAC[]);;
+
+let ev_diff_inter_compl = prove
+ (`!A B. !w. ev_diff A B w <=> ev_inter A (ev_compl B) w`,
+  REWRITE_TAC[ev_diff; ev_inter; ev_compl] THEN MESON_TAC[]);;
+
+let ev_partition = prove
+ (`!A B. !w.
+     A w <=>
+     ev_union (ev_inter A B) (ev_inter A (ev_compl B)) w`,
+  REWRITE_TAC[ev_union; ev_inter; ev_compl] THEN MESON_TAC[]);;
+
+let ev_partition_disjoint = prove
+ (`!A B. disjoint (ev_inter A B) (ev_inter A (ev_compl B))`,
+  REWRITE_TAC[disjoint; ev_inter; ev_compl] THEN MESON_TAC[]);;
+
+let prob_ext_diff_compl_raw = prove
+ (`!prob (A:W->bool) B.
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B)
+     ==> prob (ev_diff A B) = prob (ev_inter A (ev_compl B))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_X_ASSUM MATCH_MP_TAC THEN
+  REWRITE_TAC[ev_diff_inter_compl]);;
+
+let prob_ext_partition_raw = prove
+ (`!prob (A:W->bool) B.
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B)
+     ==> prob A =
+         prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B)))`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN
+   (fun th ->
+     MP_TAC
+      (ISPECL
+        [`A:W->bool`;
+         `ev_union (ev_inter (A:W->bool) B) (ev_inter A (ev_compl B))`]
+        th)) THEN
+  ANTS_TAC THENL
+  [MATCH_ACCEPT_TAC (ISPECL [`A:W->bool`; `B:W->bool`] ev_partition);
+   DISCH_THEN ACCEPT_TAC]);;
+
+let prob_partition_union_raw = prove
+ (`!addR prob (A:W->bool) B.
+     (!A B. disjoint A B ==> prob (ev_union A B) = addR (prob A) (prob B))
+     ==> prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B))) =
+         addR (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B)))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_X_ASSUM MATCH_MP_TAC THEN
+  MATCH_ACCEPT_TAC (ISPECL [`A:W->bool`; `B:W->bool`] ev_partition_disjoint));;
+
+let prob_partition_sum_raw = prove
+ (`!(addR:R->R->R) (prob:(W->bool)->R) (A:W->bool) B.
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B)
+     ==> (!A B. disjoint A B ==> prob (ev_union A B) = addR (prob A) (prob B))
+     ==> prob A =
+         addR (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B)))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+  MATCH_MP_TAC EQ_TRANS THEN
+  EXISTS_TAC
+   `prob (ev_union (ev_inter (A:W->bool) B)
+                   (ev_inter A (ev_compl B))):R` THEN
+  CONJ_TAC THENL
+  [MP_TAC
+     (ISPECL [`prob:(W->bool)->R`; `A:W->bool`; `B:W->bool`]
+       prob_ext_partition_raw) THEN
+   ASM_REWRITE_TAC[];
+   MP_TAC
+     (ISPECL [`addR:R->R->R`; `prob:(W->bool)->R`;
+              `A:W->bool`; `B:W->bool`]
+       prob_partition_union_raw) THEN
+   ASM_REWRITE_TAC[]]);;
+
+let prob_inter_comm_raw = prove
+ (`!prob (A:W->bool) B.
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B)
+     ==> prob (ev_inter A B) = prob (ev_inter B A)`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_X_ASSUM MATCH_MP_TAC THEN
+  REWRITE_TAC[ev_inter] THEN MESON_TAC[]);;
+
+let add_swap_eq_raw = prove
+ (`!(addR:R->R->R) (a:R) (b:R) (c:R).
+     (!x y. addR x y = addR y x)
+     ==> a = addR b c
+     ==> addR c b = a`,
+  MESON_TAC[]);;
+
+let add_sub_right_from_sum_raw = prove
+ (`!zeroR addR oppR (x:R) (y:R) (z:R).
+     (!a b c. addR (addR a b) c = addR a (addR b c))
+     ==> (!a b c. addR a c = addR b c ==> a = b)
+     ==> (!a. addR a zeroR = a)
+     ==> (!a. addR (oppR a) a = zeroR)
+     ==> (!a b. addR a b = addR b a)
+     ==> z = addR y x
+     ==> x = addR z (oppR y)`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN (fun h_assoc ->
+  DISCH_THEN (fun h_cancel ->
+  DISCH_THEN (fun h_rzero ->
+  DISCH_THEN (fun h_linv ->
+  DISCH_THEN (fun h_comm ->
+  DISCH_TAC THEN
+  MP_TAC
+    (ISPECL [`zeroR:R`; `addR:R->R->R`; `oppR:R->R`;
+             `x:R`; `y:R`; `z:R`] add_move_right_raw) THEN
+  REWRITE_TAC[h_assoc; h_cancel; h_rzero; h_linv] THEN
+  ANTS_TAC THENL
+  [ASM_MESON_TAC[h_comm]; DISCH_THEN ACCEPT_TAC]))))));;
+
+let indep_compl_right_alg_raw = prove
+ (`!oneR addR mulR oppR (x:R) (y:R).
+     (!a b c. mulR a (addR b c) = addR (mulR a b) (mulR a c))
+     ==> (!a. mulR a oneR = a)
+     ==> (!a b. mulR a (oppR b) = oppR (mulR a b))
+     ==> addR x (oppR (mulR x y)) = mulR x (addR oneR (oppR y))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+  ASM_REWRITE_TAC[]);;
+
+let indep_compl_right_alg_sym_raw = prove
+ (`!oneR addR mulR oppR (x:R) (y:R).
+     (!a b c. mulR a (addR b c) = addR (mulR a b) (mulR a c))
+     ==> (!a. mulR a oneR = a)
+     ==> (!a b. mulR a (oppR b) = oppR (mulR a b))
+     ==> mulR x (addR oneR (oppR y)) = addR x (oppR (mulR x y))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+  ASM_REWRITE_TAC[]);;
+
+let indep_compl_right_raw = prove
+ (`!oneR addR mulR oppR prob (A:W->bool) B.
+     (!A B. (!w. A w <=> B w) ==> prob A = prob B)
+     ==> (!A. prob (ev_compl A) = addR oneR (oppR (prob A)))
+     ==> (!a b c. mulR a (addR b c) = addR (mulR a b) (mulR a c))
+     ==> (!a. mulR a oneR = a)
+     ==> (!a b. mulR a (oppR b) = oppR (mulR a b))
+     ==> prob (ev_diff A B) =
+         addR (prob A) (oppR (prob (ev_inter A B)))
+     ==> prob (ev_inter A B) = mulR (prob A) (prob B)
+     ==> prob (ev_inter A (ev_compl B)) =
+         mulR (prob A) (prob (ev_compl B))`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN (fun h_prob_ext ->
+  DISCH_THEN (fun h_prob_compl ->
+  DISCH_THEN (fun h_dist ->
+  DISCH_THEN (fun h_mul_one ->
+  DISCH_THEN (fun h_opp_mul ->
+  DISCH_THEN (fun h_diff ->
+  DISCH_THEN (fun h_indep ->
+  let h_ext =
+    MP
+      (ISPECL
+        [`ev_diff (A:W->bool) B`;
+         `ev_inter (A:W->bool) (ev_compl B)`] h_prob_ext)
+      (ISPECL [`A:W->bool`; `B:W->bool`] ev_diff_inter_compl) in
+  ASSUME_TAC (TRANS (SYM h_ext) h_diff) THEN
+  ASM_REWRITE_TAC[h_prob_compl; h_indep] THEN
+  ASM_REWRITE_TAC[h_dist; h_mul_one; h_opp_mul]))))))));;
+
+let fold_add_zero = prove
+ (`!addR zeroR (xs:R list).
+     (!x. addR x zeroR = x)
+     ==> (!x. MEM x xs ==> x = zeroR)
+     ==> fold_add addR zeroR xs = zeroR`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  SPEC_TAC(`xs:R list`,`xs:R list`) THEN
+  LIST_INDUCT_TAC THEN
+  ASM_REWRITE_TAC[fold_add; MEM] THEN
+  ASM_MESON_TAC[]);;
+
+let fold_add_map_zero = prove
+ (`!addR zeroR (f:A->R) (xs:A list).
+     (!x. addR x zeroR = x)
+     ==> (!a. MEM a xs ==> f a = zeroR)
+     ==> fold_add addR zeroR (MAP f xs) = zeroR`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  SPEC_TAC(`xs:A list`,`xs:A list`) THEN
+  LIST_INDUCT_TAC THEN
+  ASM_REWRITE_TAC[MAP; fold_add; MEM] THEN
+  ASM_MESON_TAC[]);;
+
+let fold_addL_map_zero_raw = prove
+ (`!addR zeroR prob (xs:(W->bool) list).
+     (!x. addR x zeroR = x)
+     ==> (!A. InL A xs ==> prob A = zeroR)
+     ==> fold_addL addR zeroR (mapL prob xs) = zeroR`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  REWRITE_TAC[InL; mapL; fold_addL] THEN
+  MATCH_MP_TAC fold_add_map_zero THEN
+  ASM_REWRITE_TAC[]);;
+
+let fold_addL_map_zero = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (xs:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> (!A. InL A xs ==> prob A = zeroR)
+     ==> fold_addL addR zeroR (mapL prob xs) = zeroR`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE[is_prob_context]) THEN
+  DISCH_TAC THEN
+  MP_TAC
+    (ISPECL [`addR:R->R->R`; `zeroR:R`; `prob:(W->bool)->R`;
+             `xs:(W->bool) list`] fold_addL_map_zero_raw) THEN
+  ASM_REWRITE_TAC[]);;
+
+let prob_bigUnion_disjoint_cons_raw = prove
+ (`!(addR:R->R->R) (prob:(W->bool)->R) (h:W->bool)
+     (t:(W->bool) list) (s:R).
+     (!A B. disjoint A B ==> prob (ev_union A B) = addR (prob A) (prob B))
+     ==> disjoint h (bigUnion t)
+     ==> prob (bigUnion t) = s
+     ==> prob (ev_union h (bigUnion t)) = addR (prob h) s`,
+  MESON_TAC[]);;
+
+let prob_bigUnion_disjoint_cons_ih_raw = prove
+ (`!(addR:R->R->R) (zeroR:R) (prob:(W->bool)->R)
+     (h:W->bool) (t:(W->bool) list).
+     (!A B. disjoint A B ==> prob (ev_union A B) = addR (prob A) (prob B))
+     ==> disjoint h (bigUnion t)
+     ==> (pairwise_disjoint t ==>
+          prob (bigUnion t) = fold_addL addR zeroR (mapL prob t))
+     ==> pairwise_disjoint t
+     ==> prob (ev_union h (bigUnion t)) =
+         addR (prob h) (fold_add addR zeroR (MAP prob t))`,
+  REWRITE_TAC[fold_addL; mapL] THEN
+  MESON_TAC[prob_bigUnion_disjoint_cons_raw]);;
+
+let prob_disjoint_union_context = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> disjoint A B
+     ==> prob (ev_union A B) = addR (prob A) (prob B)`,
+  INTRO_PROB_HYPS THEN ASM_MESON_TAC[]);;
+
+let pairwise_cons_bigUnion_disjoint_context = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (xs:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> pairwise_disjoint (CONS A xs)
+     ==> disjoint A (bigUnion xs)`,
+  INTRO_PROB_HYPS THEN ASM_MESON_TAC[]);;
+
+let prob_bigUnion_disjoint_cons_context = prove
+ (`!zeroR oneR addR mulR oppR prob cprob
+     (h:W->bool) (t:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> disjoint h (bigUnion t)
+     ==> (pairwise_disjoint t ==>
+          prob (bigUnion t) = fold_addL addR zeroR (mapL prob t))
+     ==> pairwise_disjoint t
+     ==> prob (ev_union h (bigUnion t)) =
+         addR (prob h) (fold_add addR zeroR (MAP prob t))`,
+  REWRITE_TAC[fold_addL; mapL] THEN
+  MESON_TAC[prob_disjoint_union_context]);;
+
+let prob_bigUnion_disjoint_cons_step_context = prove
+ (`!zeroR oneR addR mulR oppR prob cprob
+     (h:W->bool) (t:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> (!B. MEM B t ==> disjoint h B)
+     ==> pairwise_disjoint t
+     ==> (pairwise_disjoint t ==>
+          prob (bigUnion t) = fold_addL addR zeroR (mapL prob t))
+     ==> prob (ev_union h (bigUnion t)) =
+         addR (prob h) (fold_add addR zeroR (MAP prob t))`,
+  REWRITE_TAC[fold_addL; mapL] THEN
+  MESON_TAC[pairwise_cons_bigUnion_disjoint_context;
+            prob_disjoint_union_context; pairwise_disjoint]);;
+
+
+
+
+
+let prob_union_comm = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> prob (ev_union A B) = prob (ev_union B A)`,
+  INTRO_PROB_HYPS THEN
+  ASSUM_MATCH_TAC
+    `!A B. (!w. A w <=> B w) ==> prob A = prob B`
+    MATCH_MP_TAC THEN
+  REWRITE_TAC[ev_union] THEN MESON_TAC[]);;
+
+let prob_union_idem = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> prob (ev_union A A) = prob A`,
+  INTRO_PROB_HYPS THEN
+  ASSUM_MATCH_TAC
+    `!A B. (!w. A w <=> B w) ==> prob A = prob B`
+    MATCH_MP_TAC THEN
+  REWRITE_TAC[ev_union] THEN MESON_TAC[]);;
+
+let prob_diff = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> prob (ev_diff A B) =
+         subR addR oppR (prob A) (prob (ev_inter A B))`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[subR] THEN
+  FIRST_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE[is_prob_context]) THEN
+  MP_TAC
+    (ISPECL [`prob:(W->bool)->R`; `A:W->bool`; `B:W->bool`]
+      prob_ext_diff_compl_raw) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL [`addR:R->R->R`; `prob:(W->bool)->R`;
+             `A:W->bool`; `B:W->bool`]
+      prob_partition_sum_raw) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `addR:R->R->R`; `oppR:R->R`;
+       `prob (ev_inter (A:W->bool) (ev_compl B)):R`;
+       `prob (ev_inter A B):R`; `prob (A:W->bool):R`]
+      add_sub_right_from_sum_raw) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  ASM_REWRITE_TAC[]);;
+
+let bayes_symm = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> mulR (cprob A B) (prob B) = mulR (cprob B A) (prob A)`,
+  INTRO_PROB_HYPS THEN
+  MP_TAC
+    (ISPECL [`prob:(W->bool)->R`; `A:W->bool`; `B:W->bool`]
+      prob_inter_comm_raw) THEN
+  ASM_REWRITE_TAC[]);;
+
+let law_total_prob = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> prob A =
+         addR (mulR (cprob A B) (prob B))
+              (mulR (cprob A (ev_compl B)) (prob (ev_compl B)))`,
+  INTRO_PROB_HYPS THEN
+  MP_TAC
+    (ISPECL [`addR:R->R->R`; `prob:(W->bool)->R`;
+             `A:W->bool`; `B:W->bool`]
+      prob_partition_sum_raw) THEN
+  ASM_REWRITE_TAC[]);;
+
+let prob_union_indep = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> indep prob mulR A B
+     ==> prob (ev_union A B) =
+         addR (prob A) (addR (prob B) (oppR (mulR (prob A) (prob B))))`,
+  INTRO_PROB_HYPS THEN REWRITE_TAC[indep] THEN
+  DISCH_TAC THEN ASM_REWRITE_TAC[]);;
+
+let indep_compl_right = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> indep prob mulR A B
+     ==> indep prob mulR A (ev_compl B)`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE[is_prob_context]) THEN
+  REWRITE_TAC[indep] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `A:W->bool`; `B:W->bool`] prob_diff) THEN
+  ASM_REWRITE_TAC[subR] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL [`oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+             `oppR:R->R`; `prob:(W->bool)->R`; `A:W->bool`; `B:W->bool`]
+      indep_compl_right_raw) THEN
+  ASM_REWRITE_TAC[]);;
+
+let indep_symm = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> indep prob mulR A B ==> indep prob mulR B A`,
+  INTRO_PROB_HYPS THEN REWRITE_TAC[indep] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL [`prob:(W->bool)->R`; `B:W->bool`; `A:W->bool`]
+      prob_inter_comm_raw) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  ASM_REWRITE_TAC[]);;
+
+let indep_compl_left = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> indep prob mulR A B ==> indep prob mulR (ev_compl A) B`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `A:W->bool`; `B:W->bool`] indep_symm) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `B:W->bool`; `A:W->bool`] indep_compl_right) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `B:W->bool`; `ev_compl (A:W->bool)`] indep_symm) THEN
+  ASM_REWRITE_TAC[]);;
+
+let indep_compl_both = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (A:W->bool) (B:W->bool).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> indep prob mulR A B
+     ==> indep prob mulR (ev_compl A) (ev_compl B)`,
+  INTRO_PROB_HYPS THEN DISCH_TAC THEN
+  ASSUM_MATCH_TAC
+    `!A B. indep prob mulR A B ==> indep prob mulR (ev_compl A) (ev_compl B)`
+    (fun th -> MATCH_MP_TAC (ISPECL [`A:W->bool`; `B:W->bool`] th)) THEN
+  ASM_REWRITE_TAC[]);;
+
+let inclusion_exclusion_three = prove
+ (`!zeroR oneR addR mulR oppR prob cprob A B C.
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> prob (ev_union (ev_union A B) C) =
+         addR (prob A)
+           (addR (prob B)
+             (addR (prob C)
+               (oppR (addR (prob (ev_inter A B))
+                 (addR (prob (ev_inter A C))
+                   (addR (prob (ev_inter B C))
+                     (oppR (prob (ev_inter (ev_inter A B) C)))))))))`,
+  INTRO_PROB_HYPS THEN
+  ASSUM_MATCH_TAC
+    `!A B C.
+       prob (ev_union (ev_union A B) C) =
+       addR (prob A)
+         (addR (prob B)
+           (addR (prob C)
+             (oppR (addR (prob (ev_inter A B))
+               (addR (prob (ev_inter A C))
+                 (addR (prob (ev_inter B C))
+                   (oppR (prob (ev_inter (ev_inter A B) C)))))))))`
+    (fun th -> MATCH_ACCEPT_TAC
+       (ISPECL [`A:W->bool`; `B:W->bool`; `C:W->bool`] th)));;
+
+let prob_bigUnion_disjoint = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (xs:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> pairwise_disjoint xs
+     ==> prob (bigUnion xs) = fold_addL addR zeroR (mapL prob xs)`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN
+  FIRST_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE[is_prob_context]) THEN
+  SPEC_TAC(`xs:(W->bool) list`,`xs:(W->bool) list`) THEN
+  LIST_INDUCT_TAC THENL
+  [(REWRITE_TAC[bigUnion; mapL; fold_addL; fold_add; MAP; pairwise_disjoint] THEN
+    ASM_REWRITE_TAC[]);
+   (REWRITE_TAC[bigUnion; mapL; fold_addL; fold_add; MAP; pairwise_disjoint] THEN
+    STRIP_TAC THEN
+    MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `h:W->bool`; `t:(W->bool) list`]
+      prob_bigUnion_disjoint_cons_step_context) THEN
+    ASM_REWRITE_TAC[]) ]);;
+
+let prob_bigUnion_disjoint_zero = prove
+ (`!zeroR oneR addR mulR oppR prob cprob (xs:(W->bool) list).
+     is_prob_context zeroR oneR addR mulR oppR prob cprob
+     ==> pairwise_disjoint xs
+     ==> (!A. InL A xs ==> prob A = zeroR)
+     ==> prob (bigUnion xs) = zeroR`,
+  REPEAT GEN_TAC THEN DISCH_TAC THEN DISCH_TAC THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `xs:(W->bool) list`] prob_bigUnion_disjoint) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  MP_TAC
+    (ISPECL
+      [`zeroR:R`; `oneR:R`; `addR:R->R->R`; `mulR:R->R->R`;
+       `oppR:R->R`; `prob:(W->bool)->R`; `cprob:(W->bool)->(W->bool)->R`;
+       `xs:(W->bool) list`] fold_addL_map_zero) THEN
+  ASM_REWRITE_TAC[] THEN DISCH_TAC THEN
+  ASM_REWRITE_TAC[]);;

src_data/babel-formal/proofs/hol-light/set_algebra.ml

@@ -0,0 +1,25 @@
+let sUnion = new_definition
+  `sUnion (A:'a->bool) (B:'a->bool) = \x. A x \/ B x`;;
+
+let sInter = new_definition
+  `sInter (A:'a->bool) (B:'a->bool) = \x. A x /\ B x`;;
+
+let sCompl = new_definition
+  `sCompl (A:'a->bool) = \x. ~A x`;;
+
+let inter_distrib_left = prove
+  (`!A B C x. sInter A (sUnion B C) x <=> sUnion (sInter A B) (sInter A C) x`,
+  REWRITE_TAC[sUnion; sInter] THEN MESON_TAC[]);;
+
+let inter_distrib_right = prove
+  (`!A B C x. sInter (sUnion A B) C x <=> sUnion (sInter A C) (sInter B C) x`,
+  REWRITE_TAC[sUnion; sInter] THEN MESON_TAC[]);;
+
+let de_morgan_union = prove
+  (`!A B x. sCompl (sUnion A B) x <=> sInter (sCompl A) (sCompl B) x`,
+  REWRITE_TAC[sUnion; sInter; sCompl] THEN MESON_TAC[]);;
+
+let de_morgan_inter = prove
+  (`!A B x. sCompl (sInter A B) x <=> sUnion (sCompl A) (sCompl B) x`,
+  REWRITE_TAC[sUnion; sInter; sCompl] THEN MESON_TAC[]);;
+

src_data/babel-formal/proofs/hol-light/supinf.ml

@@ -0,0 +1,366 @@
+let is_supinf_context = new_definition
+  `is_supinf_context (zero_nat:N) (Succ:N->N)
+		                     (NatAltle:N->N->bool)
+		                     (zero:R) (oneR:R) (add:R->R->R) (mul:R->R->R)
+		                     (opp:R->R) (invR:R->R)
+		                     (Rle:R->R->bool) (Rlt:R->R->bool) (Rabs:R->R)
+		                     (ofNat:N->R) <=>
+	     (!n. NatAltle n n) /\
+	     (!n m. NatAltle n m ==> NatAltle n (Succ m)) /\
+	     (!n. NatAltle n (Succ n)) /\
+	     (!x y. add x y = add y x) /\
+	     (!x y z. add (add x y) z = add x (add y z)) /\
+	     (!x. add x zero = x) /\
+	     (!x. add (opp x) x = zero) /\
+	     (!x y. mul x y = mul y x) /\
+	     (!x y z. mul (mul x y) z = mul x (mul y z)) /\
+	     (!x. mul x oneR = x) /\
+     (!x y z. mul x (add y z) = add (mul x y) (mul x z)) /\
+     (!x. add x (opp zero) = x) /\
+     (!x. Rle x x) /\
+     (!x y z. Rle x y /\ Rle y z ==> Rle x z) /\
+     (!x y. Rle x y /\ Rle y x ==> x = y) /\
+     (!x y. Rlt x y <=> (Rle x y /\ ~(x = y))) /\
+     (!x. Rle (add x (opp zero)) (Rabs x)) /\
+     (!x. Rlt zero x ==> Rlt zero (invR x)) /\
+     (!x y z. Rle y z ==> Rle (add x y) (add x z)) /\
+     (!x. Rlt zero x ==> invR (invR x) = x) /\
+	     (!n. Rlt zero (ofNat (Succ n))) /\
+	     (!m n. NatAltle m n ==> Rle (ofNat m) (ofNat n)) /\
+	     (ofNat zero_nat = zero) /\
+	     (!n. ofNat (Succ n) = add (ofNat n) oneR) /\
+	     (!x y. Rlt x y \/ x = y \/ Rlt y x) /\
+	     (!a b. Rlt zero a /\ Rlt zero b /\ Rle a b ==> Rle (invR b) (invR a)) /\
+	     (!x y. Rlt x y ==> ?eps. Rlt zero eps /\ Rlt (add x eps) y) /\
+		     (!x. ?n. Rle x (ofNat n)) /\
+	     (!A. (?ub. !a. A a ==> Rle ub a) ==>
+	          ?sup. (!a. A a ==> Rle a sup) /\
+	                (!y. (!a. A a ==> Rle a y) ==> Rle sup y))`;;
+
+let sub = new_definition
+  `sub (add:R->R->R) (opp:R->R) x y = add x (opp y)`;;
+
+let up_bounds = new_definition
+  `up_bounds (Rle:R->R->bool) (A:R->bool) x <=>
+     !a. A a ==> Rle a x`;;
+
+let is_maximum = new_definition
+  `is_maximum (Rle:R->R->bool) (A:R->bool) x <=>
+     A x /\ up_bounds Rle A x`;;
+
+let low_bounds = new_definition
+  `low_bounds (Rle:R->R->bool) (A:R->bool) x <=>
+     !a. A a ==> Rle x a`;;
+
+let is_inf = new_definition
+  `is_inf (Rle:R->R->bool) (A:R->bool) x <=>
+     is_maximum Rle (low_bounds Rle A) x`;;
+
+let limit = new_definition
+  `limit (zero:R) (Rlt:R->R->bool) (Rabs:R->R) (Rle:R->R->bool)
+         (subf:R->R->R) (NatAltle:N->N->bool) u l <=>
+     !eps. Rlt zero eps ==> ?N. !n. NatAltle N n ==> Rle (Rabs (subf (u n) l)) eps`;;
+
+let INTRO_SUPINF_HYPS =
+  REWRITE_TAC[is_supinf_context] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN (fun th -> ASSUME_TAC th THEN MAP_EVERY ASSUME_TAC (CONJUNCTS th));;
+
+let ASSUM_MATCH_TAC pat ttac =
+  ASSUM_LIST
+    (fun asms ->
+      let th =
+        find
+          (fun th ->
+            try
+              let (_,tinst,_) = term_match [] pat (concl th) in
+              forall (fun (v,t) -> t = v) tinst
+            with Failure _ -> false)
+          asms in
+      ttac th);;
+
+let supinf_order_core = prove
+ (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat.
+     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+     ==> (!x. Rle x x) /\
+         (!x y z. Rle x y /\ Rle y z ==> Rle x z) /\
+         (!x y. Rle x y /\ Rle y x ==> x = y) /\
+         (!x y. Rlt x y <=> Rle x y /\ ~(x = y)) /\
+         (!x y. Rlt x y \/ x = y \/ Rlt y x) /\
+         (!x y. Rlt x y ==> ?eps. Rlt zero eps /\ Rlt (add x eps) y)`,
+  REWRITE_TAC[is_supinf_context] THEN MESON_TAC[]);;
+
+let inf_lt_core = prove
+ (`!Rle Rlt (A:R->bool) x y.
+     (!x. Rle x x) /\
+     (!x y. Rle x y /\ Rle y x ==> x = y) /\
+     (!x y. Rlt x y <=> Rle x y /\ ~(x = y)) /\
+     (!x y. Rlt x y \/ x = y \/ Rlt y x)
+     ==> is_inf Rle A x ==> Rlt x y ==> ?a. A a /\ Rlt a y`,
+  REWRITE_TAC[is_inf; is_maximum; up_bounds; low_bounds] THEN MESON_TAC[]);;
+
+let not_lt_of_le_core = prove
+ (`!Rle Rlt (x:A) y.
+     (!u v. Rle u v /\ Rle v u ==> u = v) /\
+     (!u v. Rlt u v <=> Rle u v /\ ~(u = v))
+     ==> Rlt x y ==> ~(Rle y x)`,
+  MESON_TAC[]);;
+
+let lt_of_not_le_core = prove
+ (`!Rle Rlt (x:A) y.
+     (!u. Rle u u) /\
+     (!u v. Rlt u v <=> Rle u v /\ ~(u = v)) /\
+     (!u v. Rlt u v \/ u = v \/ Rlt v u)
+     ==> ~(Rle y x) ==> Rlt x y`,
+  MESON_TAC[]);;
+
+let le_of_le_add_eps_core = prove
+ (`!zero (add:A->A->A) Rle Rlt x y.
+     (!u. Rle u u) /\
+     (!u v. Rle u v /\ Rle v u ==> u = v) /\
+     (!u v. Rlt u v <=> Rle u v /\ ~(u = v)) /\
+     (!u v. Rlt u v \/ u = v \/ Rlt v u) /\
+     (!u v. Rlt u v ==> ?eps. Rlt zero eps /\ Rlt (add u eps) v)
+     ==> (!eps. Rlt zero eps ==> Rle y (add x eps))
+     ==> Rle y x`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(CONJUNCTS_THEN ASSUME_TAC) THEN
+  DISCH_TAC THEN
+  ASM_CASES_TAC `(Rle:A->A->bool) y x` THEN ASM_REWRITE_TAC[] THEN
+  SUBGOAL_THEN `(Rlt:A->A->bool) x y` ASSUME_TAC THENL
+  [ASM_MESON_TAC[lt_of_not_le_core];
+   SUBGOAL_THEN `?eps:A. (Rlt:A->A->bool) zero eps /\ Rlt (add x eps) y` MP_TAC THENL
+   [ASM_MESON_TAC[];
+    DISCH_THEN(X_CHOOSE_THEN `eps:A` STRIP_ASSUME_TAC) THEN
+    SUBGOAL_THEN `(Rle:A->A->bool) y (add x eps)` ASSUME_TAC THENL
+    [ASM_MESON_TAC[];
+     ASM_MESON_TAC[not_lt_of_le_core]]]]);;
+
+let le_of_le_add_eps_r_core = prove
+ (`!(zero:R) (add:R->R->R) Rle Rlt x y.
+     (!u. Rle u u) /\
+     (!u v. Rle u v /\ Rle v u ==> u = v) /\
+     (!u v. Rlt u v <=> Rle u v /\ ~(u = v)) /\
+     (!u v. Rlt u v \/ u = v \/ Rlt v u) /\
+     (!u v. Rlt u v ==> ?eps. Rlt zero eps /\ Rlt (add u eps) v)
+     ==> (!eps. Rlt zero eps ==> Rle y (add x eps))
+     ==> Rle y x`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(CONJUNCTS_THEN ASSUME_TAC) THEN
+  DISCH_TAC THEN
+  ASM_CASES_TAC `(Rle:R->R->bool) y x` THEN ASM_REWRITE_TAC[] THEN
+  SUBGOAL_THEN `(Rlt:R->R->bool) x y` ASSUME_TAC THENL
+  [ASM_MESON_TAC[lt_of_not_le_core];
+   SUBGOAL_THEN `?eps:R. (Rlt:R->R->bool) zero eps /\ Rlt (add x eps) y` MP_TAC THENL
+   [ASM_MESON_TAC[];
+    DISCH_THEN(X_CHOOSE_THEN `eps:R` STRIP_ASSUME_TAC) THEN
+    SUBGOAL_THEN `(Rle:R->R->bool) y (add x eps)` ASSUME_TAC THENL
+    [ASM_MESON_TAC[];
+     ASM_MESON_TAC[not_lt_of_le_core]]]]);;
+
+let le_of_le_add_eps_r_core_imp = prove
+ (`!(zero:R) (add:R->R->R) Rle Rlt x y.
+     (!u. Rle u u)
+     ==> (!u v. Rle u v /\ Rle v u ==> u = v)
+     ==> (!u v. Rlt u v <=> Rle u v /\ ~(u = v))
+     ==> (!u v. Rlt u v \/ u = v \/ Rlt v u)
+     ==> (!u v. Rlt u v ==> ?eps. Rlt zero eps /\ Rlt (add u eps) v)
+     ==> (!eps. Rlt zero eps ==> Rle y (add x eps))
+     ==> Rle y x`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(fun h_refl ->
+  DISCH_THEN(fun h_antisym ->
+  DISCH_THEN(fun h_lt ->
+  DISCH_THEN(fun h_total ->
+  DISCH_THEN(fun h_dense ->
+  DISCH_THEN(fun h_bound ->
+    ACCEPT_TAC
+      (MATCH_MP
+        (MATCH_MP
+          (SPECL [`zero:R`; `add:R->R->R`; `Rle:R->R->bool`;
+                  `Rlt:R->R->bool`; `x:R`; `y:R`]
+             le_of_le_add_eps_r_core)
+          (CONJ h_refl (CONJ h_antisym (CONJ h_lt (CONJ h_total h_dense)))))
+        h_bound))))))));;
+
+let add_sub_cancel_r = prove
+ (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat a b.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> add a (sub add opp b a) = b`,
+  REWRITE_TAC[is_supinf_context; sub] THEN MESON_TAC[]);;
+
+let rabs_pos = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat t.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> Rle t (Rabs t)`,
+  REWRITE_TAC[is_supinf_context] THEN MESON_TAC[]);;
+
+let unique_max = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat (A:R->bool) x y.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> is_maximum Rle A x ==> is_maximum Rle A y ==> x = y`,
+  REWRITE_TAC[is_supinf_context; is_maximum; up_bounds] THEN MESON_TAC[]);;
+
+let inf_lt = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat (A:R->bool) x y.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> is_inf Rle A x ==> Rlt x y ==> ?a. A a /\ Rlt a y`,
+  REWRITE_TAC[is_supinf_context] THEN REPEAT GEN_TAC THEN STRIP_TAC THEN
+  MATCH_MP_TAC
+    (SPECL [`Rle:R->R->bool`; `Rlt:R->R->bool`; `A:R->bool`; `x:R`; `y:R`]
+       inf_lt_core) THEN
+  ASM_REWRITE_TAC[]);;
+
+let le_of_le_add_eps = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat x y.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> (!eps. Rlt zero eps ==> Rle y (add x eps))
+	     ==> Rle y x`,
+  REWRITE_TAC[is_supinf_context] THEN REPEAT GEN_TAC THEN STRIP_TAC THEN
+  MATCH_MP_TAC le_of_le_add_eps_core THEN
+  ASM_REWRITE_TAC[]);;
+
+let le_lim_eps_core = prove
+ (`!(zero:R) (add:R->R->R) Rle Rlt Rabs subf NatAltle (u:N->R) x y eps.
+     (!n. NatAltle n n) /\
+     (!a b c. Rle a b /\ Rle b c ==> Rle a c) /\
+     (!a b c. Rle b c ==> Rle (add a b) (add a c)) /\
+     (!t. Rle t (Rabs t)) /\
+     (!a b. add a (subf b a) = b) /\
+     (!eps. Rlt zero eps ==> ?N. !n. NatAltle N n ==> Rle (Rabs (subf (u n) x)) eps) /\
+     (!n. Rle y (u n)) /\
+     Rlt zero eps
+     ==> Rle y (add x eps)`,
+  MESON_TAC[]);;
+
+let le_lim_eps_core_imp = prove
+ (`!(zero:R) (add:R->R->R) Rle Rlt Rabs subf NatAltle (u:N->R) x y eps.
+     (!n. NatAltle n n)
+     ==> (!a b c. Rle a b /\ Rle b c ==> Rle a c)
+     ==> (!a b c. Rle b c ==> Rle (add a b) (add a c))
+     ==> (!t. Rle t (Rabs t))
+     ==> (!a b. add a (subf b a) = b)
+     ==> (!eps. Rlt zero eps ==> ?N. !n. NatAltle N n ==> Rle (Rabs (subf (u n) x)) eps)
+     ==> (!n. Rle y (u n))
+     ==> Rlt zero eps
+     ==> Rle y (add x eps)`,
+  MESON_TAC[le_lim_eps_core]);;
+
+let le_lim_core = prove
+ (`!(zero:R) (add:R->R->R) Rle Rlt Rabs subf NatAltle (u:N->R) x y.
+     (!n. NatAltle n n) /\
+     (!a. Rle a a) /\
+     (!a b c. Rle a b /\ Rle b c ==> Rle a c) /\
+     (!a b. Rle a b /\ Rle b a ==> a = b) /\
+     (!a b. Rlt a b <=> Rle a b /\ ~(a = b)) /\
+     (!a b. Rlt a b \/ a = b \/ Rlt b a) /\
+     (!a b c. Rle b c ==> Rle (add a b) (add a c)) /\
+     (!a b. Rlt a b ==> ?eps. Rlt zero eps /\ Rlt (add a eps) b) /\
+     (!t. Rle t (Rabs t)) /\
+     (!a b. add a (subf b a) = b)
+     ==> limit zero Rlt Rabs Rle subf NatAltle u x
+     ==> (!n. Rle y (u n))
+     ==> Rle y x`,
+  REWRITE_TAC[limit] THEN REPEAT GEN_TAC THEN
+  DISCH_THEN(fun hctx ->
+  DISCH_THEN(fun hlim ->
+  DISCH_THEN(fun hbound ->
+    let [h_nrefl; h_refl; h_trans; h_antisym; h_lt; h_total;
+         h_add_mono; h_dense; h_abs; h_sub] = CONJUNCTS hctx in
+    let h_eps =
+      GEN `eps:R`
+        (DISCH `(Rlt:R->R->bool) zero eps`
+          (MATCH_MP
+            (MATCH_MP
+              (MATCH_MP
+                (MATCH_MP
+                  (MATCH_MP
+                    (MATCH_MP
+                      (MATCH_MP
+                        (MATCH_MP
+                          (SPECL [`zero:R`; `add:R->R->R`; `Rle:R->R->bool`;
+                                  `Rlt:R->R->bool`; `Rabs:R->R`;
+                                  `subf:R->R->R`; `NatAltle:N->N->bool`;
+                                  `u:N->R`; `x:R`; `y:R`; `eps:R`]
+                             le_lim_eps_core_imp)
+                          h_nrefl)
+                        h_trans)
+                      h_add_mono)
+                    h_abs)
+                  h_sub)
+                hlim)
+              hbound)
+            (ASSUME `(Rlt:R->R->bool) zero eps`))) in
+    ACCEPT_TAC
+      (MATCH_MP
+        (MATCH_MP
+          (MATCH_MP
+            (MATCH_MP
+              (MATCH_MP
+                (MATCH_MP
+                  (SPECL [`zero:R`; `add:R->R->R`; `Rle:R->R->bool`;
+                          `Rlt:R->R->bool`; `x:R`; `y:R`]
+                     le_of_le_add_eps_r_core_imp)
+                  h_refl)
+                h_antisym)
+              h_lt)
+            h_total)
+          h_dense)
+        h_eps)))));;
+
+let le_lim = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat (u:N->R) x y.
+		     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+		     ==> limit zero Rlt Rabs Rle (sub add opp) NatAltle u x
+		     ==> (!n. Rle y (u n))
+		     ==> Rle y x`,
+  REPEAT GEN_TAC THEN
+  DISCH_THEN(fun hctx ->
+  DISCH_THEN(fun hlim ->
+  DISCH_THEN(fun hbound ->
+    let [h_nrefl; _; _; _; _; _; _; _; _; _; _; h_add_opp_zero;
+         h_refl; h_trans; h_antisym; h_lt; h_abs0; _; h_add_mono; _;
+         _; _; _; _; h_total; _; h_dense; _; _] =
+      CONJUNCTS (REWRITE_RULE[is_supinf_context] hctx) in
+    let h_abs =
+      GEN `t:R`
+        (REWRITE_RULE [SPEC `t:R` h_add_opp_zero] (SPEC `t:R` h_abs0)) in
+    let h_sub =
+      GEN `a:R`
+        (GEN `b:R`
+          (MATCH_MP
+            (SPEC_ALL add_sub_cancel_r)
+            hctx)) in
+    let h_core_ctx =
+      CONJ h_nrefl
+        (CONJ h_refl
+          (CONJ h_trans
+            (CONJ h_antisym
+              (CONJ h_lt
+                (CONJ h_total
+                  (CONJ h_add_mono
+                    (CONJ h_dense
+                      (CONJ h_abs h_sub)))))))) in
+    ACCEPT_TAC
+      (MATCH_MP
+        (MATCH_MP
+          (MATCH_MP
+            (SPECL [`zero:R`; `add:R->R->R`; `Rle:R->R->bool`;
+                    `Rlt:R->R->bool`; `Rabs:R->R`; `(sub add opp):R->R->R`;
+                    `NatAltle:N->N->bool`; `u:N->R`; `x:R`; `y:R`]
+               le_lim_core)
+            h_core_ctx)
+          hlim)
+        hbound)))));;
+
+let inv_succ_pos = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat n.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> Rlt zero (invR (ofNat (Succ n)))`,
+  REWRITE_TAC[is_supinf_context] THEN MESON_TAC[]);;
+
+let limit_inv_succ = prove
+	 (`!zero_nat Succ NatAltle (zero:R) oneR add mul opp invR Rle Rlt Rabs ofNat eps.
+	     is_supinf_context zero_nat Succ NatAltle zero oneR add mul opp invR Rle Rlt Rabs ofNat
+	     ==> Rlt zero eps
+	     ==> ?N. !n. NatAltle N n ==> Rle (invR (ofNat (Succ n))) eps`,
+  REWRITE_TAC[is_supinf_context] THEN MESON_TAC[]);;

src_data/babel-formal/proofs/hol-light/zero_le_one_elem.ml

@@ -0,0 +1,71 @@
+let one_matrix = new_definition
+  `one_matrix (decEq:M->M->bool) (oneA:A) (zeroA:A) =
+     (\i j. if decEq i j then oneA else zeroA)`;;
+
+let zero_matrix = new_definition
+  `zero_matrix (zeroA:A) = (\i j. zeroA)`;;
+
+let matrix_le = new_definition
+  `matrix_le (le:A->A->bool) (A0:M->M->A) (B0:M->M->A) <=>
+     !i j. le (A0 i j) (B0 i j)`;;
+
+let matrix_eq = new_definition
+  `matrix_eq (A0:M->M->A) (B0:M->M->A) <=> !i j. A0 i j = B0 i j`;;
+
+let zero_le_one_elem = prove
+  (`!decEq (zeroA:A) oneA (le:A->A->bool) i j.
+      le zeroA oneA ==> le zeroA zeroA ==> le zeroA (one_matrix decEq oneA zeroA i j)`,
+   REWRITE_TAC[one_matrix] THEN
+   REPEAT GEN_TAC THEN STRIP_TAC THEN
+   COND_CASES_TAC THEN ASM_REWRITE_TAC[]);;
+
+let zero_le_one_matrix = prove
+  (`!decEq (zeroA:A) oneA (le:A->A->bool).
+      le zeroA oneA ==> le zeroA zeroA ==>
+      matrix_le le (zero_matrix zeroA) (one_matrix decEq oneA zeroA)`,
+   REWRITE_TAC[matrix_le; zero_matrix] THEN
+   REPEAT GEN_TAC THEN STRIP_TAC THEN
+   REPEAT GEN_TAC THEN
+   ASM_MESON_TAC[zero_le_one_elem]);;
+
+let matrix_le_refl = prove
+  (`!le:A->A->bool. (!x. le x x) ==> !A0:M->M->A. matrix_le le A0 A0`,
+   REWRITE_TAC[matrix_le] THEN
+   REPEAT GEN_TAC THEN DISCH_TAC THEN
+   REPEAT GEN_TAC THEN ASM_REWRITE_TAC[]);;
+
+let matrix_le_trans = prove
+  (`!le:A->A->bool.
+      (!x y z. le x y ==> le y z ==> le x z) ==>
+      !A0 B0 C0:M->M->A.
+        matrix_le le A0 B0 ==> matrix_le le B0 C0 ==> matrix_le le A0 C0`,
+   REWRITE_TAC[matrix_le] THEN MESON_TAC[]);;
+
+let matrix_eq_refl = prove
+  (`!A0:M->M->A. matrix_eq A0 A0`,
+   REWRITE_TAC[matrix_eq] THEN REPEAT GEN_TAC THEN REFL_TAC);;
+
+let matrix_eq_sym = prove
+  (`!A0 B0:M->M->A. matrix_eq A0 B0 ==> matrix_eq B0 A0`,
+   REWRITE_TAC[matrix_eq] THEN MESON_TAC[]);;
+
+let matrix_eq_trans = prove
+  (`!A0 B0 C0:M->M->A. matrix_eq A0 B0 ==> matrix_eq B0 C0 ==> matrix_eq A0 C0`,
+   REWRITE_TAC[matrix_eq] THEN MESON_TAC[]);;
+
+let matrix_eq_le = prove
+  (`!le:A->A->bool.
+      (!x. le x x) ==>
+      !A0 B0:M->M->A. matrix_eq A0 B0 ==> matrix_le le A0 B0 /\ matrix_le le B0 A0`,
+   REWRITE_TAC[matrix_eq; matrix_le] THEN
+   REPEAT GEN_TAC THEN DISCH_TAC THEN
+   REPEAT GEN_TAC THEN DISCH_TAC THEN
+   CONJ_TAC THEN REPEAT GEN_TAC THEN
+   ASM_MESON_TAC[]);;
+
+let matrix_le_antisymm = prove
+  (`!le:A->A->bool.
+      (!x y. le x y ==> le y x ==> x = y) ==>
+      !A0 B0:M->M->A.
+        matrix_le le A0 B0 ==> matrix_le le B0 A0 ==> matrix_eq A0 B0`,
+   REWRITE_TAC[matrix_le; matrix_eq] THEN MESON_TAC[]);;

src_data/babel-formal/proofs/isabelle/ROOT

@@ -0,0 +1,19 @@
+session "Babel_Formal" = HOL +
+  theories
+    circle_average
+    comp_commute
+    galois
+    graph_paths
+    group
+    ideals
+    inner_product
+    integral_comp_neg_Iic
+    lattice_like
+    limits_uniqueness
+    linear_map
+    polynomial
+    probability
+    set_algebra
+    supinf
+    zero_le_one_elem
+

src_data/babel-formal/proofs/isabelle/circle_average.thy

@@ -0,0 +1,117 @@
+theory circle_average
+  imports Main
+begin
+
+locale circle_average_setup =
+  fixes zero     :: "'r"
+    and add      :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"     (infixl "+C" 65)
+    and integral :: "('r \<Rightarrow> 'r) \<Rightarrow> 'r"
+  assumes add_zero      : "\<And>x. x +C zero = x"
+    and   add_comm      : "\<And>x y. x +C y = y +C x"
+    and   add_assoc     : "\<And>x y z. (x +C y) +C z = x +C (y +C z)"
+    and   integral_ext  : "\<And>g h. (\<forall>\<theta>. g \<theta> = h \<theta>) \<Longrightarrow> integral g = integral h"
+    and   integral_const: "\<And>c. integral (\<lambda>_. c) = c"
+    and   integral_add  : "\<And>f g. integral (\<lambda>\<theta>. f \<theta> +C g \<theta>) = integral f +C integral g"
+    and   integral_shift: "\<And>f c. integral (\<lambda>\<theta>. f (\<theta> +C c)) = integral f"
+begin
+
+
+
+
+
+definition circleMap :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"
+  where "circleMap c \<theta> \<equiv> \<theta> +C c"
+
+definition circleAverage :: "('r \<Rightarrow> 'r) \<Rightarrow> 'r \<Rightarrow> 'r"
+  where "circleAverage f c \<equiv> integral (\<lambda>\<theta>. f (circleMap c \<theta>))"
+
+
+
+
+
+lemma circleMap_zero: "circleMap zero \<theta> = \<theta>"
+  unfolding circleMap_def by (rule add_zero)
+
+lemma circleAverage_zero: "circleAverage f zero = integral f"
+  unfolding circleAverage_def
+  by (rule integral_ext) (simp add: circleMap_def add_zero)
+
+lemma circleAverage_add:
+  "circleAverage (\<lambda>z. f z +C g z) c =
+   circleAverage f c +C circleAverage g c"
+  unfolding circleAverage_def
+  by (simp add: integral_add)
+
+lemma circleAverage_fun_add:
+  "circleAverage (\<lambda>z. f (z +C c)) zero = circleAverage f c"
+  unfolding circleAverage_def circleMap_def
+  by (rule integral_ext) (simp add: add_zero)
+
+lemma circleMap_add:
+  "circleMap (c +C d) \<theta> = circleMap c (circleMap d \<theta>)"
+  unfolding circleMap_def
+  by (simp only: add_comm[of c d] add_assoc[symmetric])
+
+lemma circleAverage_shift:
+  "circleAverage f (c +C d) = circleAverage (\<lambda>z. f (z +C d)) c"
+  unfolding circleAverage_def circleMap_def
+  by (rule integral_ext) (simp add: add_assoc)
+
+lemma circleAverage_const:
+  "circleAverage (\<lambda>_. k) c = k"
+  unfolding circleAverage_def
+  by (simp add: integral_const)
+
+lemma circleAverage_add_const:
+  "circleAverage (\<lambda>z. f z +C k) c = circleAverage f c +C k"
+  unfolding circleAverage_def
+  by (simp add: integral_add integral_const)
+
+lemma circleAverage_comm_add:
+  "circleAverage (\<lambda>z. f z +C g z) c =
+   circleAverage (\<lambda>z. g z +C f z) c"
+  unfolding circleAverage_def
+  by (rule integral_ext) (simp add: add_comm)
+
+lemma circleAverage_add_assoc:
+  "circleAverage (\<lambda>z. (f z +C g z) +C h z) c =
+   circleAverage f c +C (circleAverage g c +C circleAverage h c)"
+  unfolding circleAverage_def
+  by (simp add: integral_add add_assoc)
+
+lemma circleAverage_center_comm:
+  "circleAverage f (c +C d) = circleAverage f (d +C c)"
+  unfolding circleAverage_def circleMap_def
+  by (simp only: add_comm[of c d])
+
+lemma circleAverage_center_independent:
+  "circleAverage f c = integral f"
+  unfolding circleAverage_def circleMap_def
+  by (rule integral_shift)
+
+lemma circleAverage_center_eq:
+  "circleAverage f c = circleAverage f d"
+  by (simp add: circleAverage_center_independent)
+
+lemma circleAverage_idempotent:
+  "circleAverage (\<lambda>z. circleAverage f z) c = circleAverage f c"
+  by (simp add: circleAverage_center_independent integral_const)
+
+lemma circleAverage_of_zero_integral:
+  "integral f = zero \<Longrightarrow> circleAverage f c = zero"
+  by (simp add: circleAverage_center_independent)
+
+lemma circleAverage_linear:
+  "circleAverage (\<lambda>z. f z +C g z) c =
+   circleAverage f c +C circleAverage g c"
+  by (rule circleAverage_add)
+
+lemma circleAverage_shift_commute:
+  "circleAverage (\<lambda>z. f (circleMap d z)) c =
+   circleAverage f (c +C d)"
+  unfolding circleAverage_def circleMap_def
+  by (rule integral_ext) (simp add: add_assoc)
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/comp_commute.thy

@@ -0,0 +1,62 @@
+theory comp_commute
+  imports Main
+begin
+
+definition myComp :: "('b \<Rightarrow> 'c) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> ('a \<Rightarrow> 'c)"
+  where "myComp g f \<equiv> \<lambda>x. g (f x)"
+
+definition myId :: "'a \<Rightarrow> 'a"
+  where "myId \<equiv> \<lambda>x. x"
+
+
+
+lemma comp_assoc:
+  "myComp h (myComp g f) = myComp (myComp h g) f"
+  unfolding myComp_def by simp
+
+lemma comp_id_l:
+  "myComp myId f = f"
+  unfolding myComp_def myId_def by simp
+
+lemma comp_id_r:
+  "myComp f myId = f"
+  unfolding myComp_def myId_def by simp
+
+
+
+definition commute :: "('a \<Rightarrow> 'a) \<Rightarrow> ('a \<Rightarrow> 'a) \<Rightarrow> bool"
+  where "commute f g \<equiv> myComp f g = myComp g f"
+
+lemma commute_symm:
+  "commute f g \<Longrightarrow> commute g f"
+  unfolding commute_def by simp
+
+lemma commute_with_id_l:
+  "commute f myId"
+  unfolding commute_def
+  by (simp add: comp_id_r comp_id_l)
+
+lemma commute_with_id_r:
+  "commute myId f"
+  unfolding commute_def
+  by (simp add: comp_id_l comp_id_r)
+
+lemma commute_refl:
+  "commute f f"
+  unfolding commute_def by simp
+
+lemma commute_congr:
+  "f1 = f2 \<Longrightarrow> g1 = g2 \<Longrightarrow> commute f1 g1 \<Longrightarrow> commute f2 g2"
+  by simp
+
+lemma commute_transport_left_id:
+  "commute f g \<Longrightarrow> commute (myComp myId f) g"
+  unfolding commute_def
+  by (simp add: comp_id_l)
+
+lemma commute_transport_right_id:
+  "commute f g \<Longrightarrow> commute f (myComp myId g)"
+  unfolding commute_def
+  by (simp add: comp_id_l)
+
+end

src_data/babel-formal/proofs/isabelle/galois.thy

@@ -0,0 +1,175 @@
+theory galois
+  imports Main
+begin
+
+
+
+
+
+locale field_like =
+  fixes zero_F one_F :: "'f"
+    and add_F :: "'f \<Rightarrow> 'f \<Rightarrow> 'f"  (infixl "+F" 65)
+    and mul_F :: "'f \<Rightarrow> 'f \<Rightarrow> 'f"  (infixl "*F" 70)
+    and opp_F :: "'f \<Rightarrow> 'f"
+    and inv_F :: "'f \<Rightarrow> 'f"
+  assumes add_comm    : "\<And>x y. x +F y = y +F x"
+    and   add_assoc   : "\<And>x y z. (x +F y) +F z = x +F (y +F z)"
+    and   add_zero    : "\<And>x. x +F zero_F = x"
+    and   add_inv_l   : "\<And>x. opp_F x +F x = zero_F"
+    and   mul_comm    : "\<And>x y. x *F y = y *F x"
+    and   mul_assoc   : "\<And>x y z. (x *F y) *F z = x *F (y *F z)"
+    and   mul_one_l   : "\<And>x. one_F *F x = x"
+    and   mul_inv_l   : "\<And>x. x \<noteq> zero_F \<Longrightarrow> inv_F x *F x = one_F"
+    and   distrib_l   : "\<And>x y z. x *F (y +F z) = (x *F y) +F (x *F z)"
+    and   zero_neq_one: "zero_F \<noteq> one_F"
+    and   inv_nonzero : "\<And>x. x \<noteq> zero_F \<Longrightarrow> inv_F x \<noteq> zero_F"
+begin
+
+
+lemma zero_add: "zero_F +F x = x"
+  by (simp add: add_comm add_zero)
+
+lemma mul_one_r: "x *F one_F = x"
+  by (simp add: mul_comm mul_one_l)
+
+lemma mul_inv_r: "x \<noteq> zero_F \<Longrightarrow> x *F inv_F x = one_F"
+proof -
+  assume hx: "x \<noteq> zero_F"
+  have "x *F inv_F x = inv_F x *F x" by (rule mul_comm)
+  also have "\<dots> = one_F"             by (rule mul_inv_l[OF hx])
+  finally show ?thesis .
+qed
+
+
+
+lemma add_cancel_l: "x +F y = x +F z \<Longrightarrow> y = z"
+proof -
+  assume H: "x +F y = x +F z"
+  have "y = opp_F x +F (x +F y)"
+    by (simp add: add_assoc [symmetric] add_inv_l zero_add)
+  also have "\<dots> = opp_F x +F (x +F z)" using H by simp
+  also have "\<dots> = z"
+    by (simp add: add_assoc [symmetric] add_inv_l zero_add)
+  finally show ?thesis .
+qed
+
+lemma add_cancel_r: "y +F x = z +F x \<Longrightarrow> y = z"
+proof -
+  assume H: "y +F x = z +F x"
+  have "x +F y = x +F z" by (metis H add_comm)
+  then show ?thesis by (rule add_cancel_l)
+qed
+
+lemma mul_cancel_l: "x \<noteq> zero_F \<Longrightarrow> x *F y = x *F z \<Longrightarrow> y = z"
+proof -
+  assume hx: "x \<noteq> zero_F" and H: "x *F y = x *F z"
+  have "y = one_F *F y"                  by (simp add: mul_one_l)
+  also have "\<dots> = (inv_F x *F x) *F y"  by (simp add: mul_inv_l hx)
+  also have "\<dots> = inv_F x *F (x *F y)"  by (simp add: mul_assoc)
+  also have "\<dots> = inv_F x *F (x *F z)"  using H by simp
+  also have "\<dots> = (inv_F x *F x) *F z"  by (simp add: mul_assoc)
+  also have "\<dots> = one_F *F z"           by (simp add: mul_inv_l hx)
+  also have "\<dots> = z"                    by (simp add: mul_one_l)
+  finally show ?thesis .
+qed
+
+lemma mul_cancel_r: "x \<noteq> zero_F \<Longrightarrow> y *F x = z *F x \<Longrightarrow> y = z"
+proof -
+  assume hx: "x \<noteq> zero_F" and H: "y *F x = z *F x"
+  have "x *F y = x *F z" by (metis H mul_comm)
+  then show ?thesis by (rule mul_cancel_l[OF hx])
+qed
+
+lemma inv_unique: "x \<noteq> zero_F \<Longrightarrow> x *F y = one_F \<Longrightarrow> y = inv_F x"
+proof -
+  assume hx: "x \<noteq> zero_F" and H: "x *F y = one_F"
+  have "y = one_F *F y"                 by (simp add: mul_one_l)
+  also have "\<dots> = (inv_F x *F x) *F y" by (simp add: mul_inv_l hx)
+  also have "\<dots> = inv_F x *F (x *F y)" by (simp add: mul_assoc)
+  also have "\<dots> = inv_F x *F one_F"    using H by simp
+  also have "\<dots> = inv_F x"             by (simp add: mul_one_r)
+  finally show ?thesis .
+qed
+
+lemma inv_involutive: "x \<noteq> zero_F \<Longrightarrow> inv_F (inv_F x) = x"
+proof -
+  assume hx: "x \<noteq> zero_F"
+  have "x = inv_F (inv_F x)"
+    using inv_unique[OF inv_nonzero[OF hx] mul_inv_l[OF hx]] .
+  then show ?thesis by simp
+qed
+
+end
+
+
+
+
+
+
+
+
+
+locale tower =
+  fixes S    :: "'p \<Rightarrow> bool"
+    and mp   :: "'p \<Rightarrow> 'p"
+    and splt :: "'p \<Rightarrow> bool"
+  assumes scalar_tower : "\<And>p q. S p \<Longrightarrow> S (mp q) \<Longrightarrow> S q"
+    and   map_solv     : "\<And>p. S p \<Longrightarrow> S (mp p)"
+    and   splits_solv  : "\<And>p. splt p \<Longrightarrow> S p"
+begin
+
+lemma gal_isSolvable_tower:
+  "S p \<Longrightarrow> S (mp q) \<Longrightarrow> S q"
+  by (rule scalar_tower)
+
+lemma gal_isSolvable_double_tower:
+  "S p \<Longrightarrow> S (mp q) \<Longrightarrow> S (mp r) \<Longrightarrow> S r"
+  by (blast intro: scalar_tower)
+
+lemma gal_isSolvable_triple_tower:
+  "S p \<Longrightarrow> S (mp q) \<Longrightarrow> S (mp r) \<Longrightarrow> S (mp s) \<Longrightarrow> S s"
+  by (blast intro: scalar_tower)
+
+lemma gal_isSolvable_quadruple_tower:
+  "S p \<Longrightarrow> S (mp q) \<Longrightarrow> S (mp r) \<Longrightarrow> S (mp s) \<Longrightarrow> S (mp t) \<Longrightarrow> S t"
+  by (blast intro: scalar_tower)
+
+lemma gal_isSolvable_map_poly:
+  "S p \<Longrightarrow> S (mp p)"
+  by (rule map_solv)
+
+lemma gal_isSolvable_of_split:
+  "splt p \<Longrightarrow> S p"
+  by (rule splits_solv)
+
+lemma gal_isSolvable_split_tower:
+  "splt q \<Longrightarrow> S q"
+  by (rule splits_solv)
+
+lemma gal_isSolvable_two_step_map:
+  "S p \<Longrightarrow> S (mp (mp p))"
+  by (blast intro: map_solv)
+
+lemma gal_isSolvable_three_step_map:
+  "S p \<Longrightarrow> S (mp (mp (mp p)))"
+  by (blast intro: map_solv)
+
+lemma gal_isSolvable_map_poly_comp:
+  "S p \<Longrightarrow> S (mp (mp p))"
+  by (blast intro: map_solv)
+
+lemma gal_isSolvable_mutual_split:
+  "splt p \<Longrightarrow> splt q \<Longrightarrow> S p \<and> S q"
+  by (blast intro: splits_solv)
+
+lemma gal_isSolvable_map_after_split:
+  "splt p \<Longrightarrow> S (mp p)"
+  by (blast intro: splits_solv map_solv)
+
+lemma gal_isSolvable_tower_split:
+  "splt q \<Longrightarrow> S (mp r) \<Longrightarrow> S r"
+  by (blast intro: scalar_tower splits_solv)
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/graph_paths.thy

@@ -0,0 +1,108 @@
+theory graph_paths
+  imports Main
+begin
+
+inductive Path :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool"
+  for E :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
+where
+  Pnil:  "Path E v v"
+| Pstep: "Path E u v \<Longrightarrow> E v w \<Longrightarrow> Path E u w"
+
+definition undirected :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
+  where "undirected E \<equiv> \<forall>x y. E x y \<longrightarrow> E y x"
+
+definition Erev :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool"
+  where "Erev E x y \<equiv> E y x"
+
+lemma path_refl: "Path E v v"
+  by (rule Pnil)
+
+lemma path_trans:
+  assumes "Path E u v" "Path E v w" shows "Path E u w"
+  using assms(2) assms(1)
+proof (induction arbitrary: u)
+  case Pnil then show ?case .
+next
+  case Pstep then show ?case by (blast intro: Path.Pstep)
+qed
+
+lemma trans: "Path E u v \<Longrightarrow> Path E v w \<Longrightarrow> Path E u w"
+  by (rule path_trans)
+
+
+lemma edge_path: "E u v \<Longrightarrow> Path E u v"
+  apply (rule Pstep)
+  apply (rule Pnil)
+  apply assumption
+  done
+
+lemma concat_edge_right: "Path E u v \<Longrightarrow> E v w \<Longrightarrow> Path E u w"
+  by (rule Pstep)
+
+lemma concat: "Path E u v \<Longrightarrow> Path E v w \<Longrightarrow> Path E u w"
+  by (rule path_trans)
+
+lemma concat_edge_left: "E u v \<Longrightarrow> Path E v w \<Longrightarrow> Path E u w"
+  by (rule path_trans[OF edge_path])
+
+lemma concat3:
+  "Path E u v \<Longrightarrow> Path E v w \<Longrightarrow> Path E w t \<Longrightarrow> Path E u t"
+  by (rule path_trans[OF path_trans])
+
+
+lemma reverse_cons:
+  assumes hE: "undirected E" and e: "E m v" and ih: "Path E m u"
+  shows "Path E v u"
+proof -
+  have evm: "E v m" using hE e unfolding undirected_def by blast
+  have pvm: "Path E v m"
+    apply (rule Pstep)
+    apply (rule Pnil)
+    apply (rule evm)
+    done
+  show ?thesis by (rule path_trans[OF pvm ih])
+qed
+
+lemma reverse_path:
+  assumes hE: "undirected E" and p: "Path E u v"
+  shows "Path E v u"
+  using p
+proof (induction rule: Path.induct)
+  case Pnil show ?case by (rule Pnil)
+next
+  case Pstep
+
+  then show ?case using hE by (blast intro: reverse_cons)
+qed
+
+
+lemma reverse_cons_Erev:
+  assumes e: "E m v" and ih: "Path (Erev E) m u"
+  shows "Path (Erev E) v u"
+proof -
+  have evm: "Erev E v m" unfolding Erev_def using e by simp
+  have pvm: "Path (Erev E) v m"
+    apply (rule Pstep)
+    apply (rule Pnil)
+    apply (rule evm)
+    done
+  show ?thesis by (rule path_trans[OF pvm ih])
+qed
+
+lemma reverse_in_Erev:
+  assumes p: "Path E u v"
+  shows "Path (Erev E) v u"
+  using p
+proof (induction rule: Path.induct)
+  case Pnil show ?case by (rule Pnil)
+next
+  case Pstep
+
+  then show ?case by (blast intro: reverse_cons_Erev)
+qed
+
+lemma cycle_refl:
+  "Path E v w \<Longrightarrow> Path E w v \<Longrightarrow> Path E v v"
+  by (rule path_trans)
+
+end

src_data/babel-formal/proofs/isabelle/group.thy

@@ -0,0 +1,238 @@
+theory group
+  imports Main
+begin
+
+
+
+locale group =
+  fixes mul :: "'a => 'a => 'a"  (infixl "**" 70)
+    and one :: "'a"
+    and inv :: "'a => 'a"
+  assumes mul_assoc : "a ** (b ** c) = (a ** b) ** c"
+    and   mul_one   : "a ** one = a"
+    and   one_mul   : "one ** a = a"
+    and   mul_inv_l : "inv a ** a = one"
+    and   mul_inv_r : "a ** inv a = one"
+begin
+
+
+
+lemma mul_left_cancel:
+  assumes h: "a ** b = a ** c"
+  shows "b = c"
+proof -
+  have "inv a ** (a ** b) = inv a ** (a ** c)"
+    using h by simp
+  then show ?thesis
+    by (simp add: mul_assoc mul_inv_l one_mul)
+qed
+
+lemma mul_right_cancel:
+  assumes h: "b ** a = c ** a"
+  shows "b = c"
+proof -
+  have "(b ** a) ** inv a = (c ** a) ** inv a"
+    using h by simp
+  then show ?thesis
+    by (simp add: mul_assoc [symmetric] mul_inv_r mul_one)
+qed
+
+lemma inv_inv: "inv (inv a) = a"
+proof (rule mul_right_cancel)
+  show "inv (inv a) ** inv a = a ** inv a"
+    by (simp add: mul_inv_l mul_inv_r)
+qed
+
+lemma inv_mul: "inv (a ** b) = inv b ** inv a"
+proof (rule mul_right_cancel)
+  have lhs: "inv (a ** b) ** (a ** b) = one"
+    by (simp add: mul_inv_l)
+  have rhs: "(inv b ** inv a) ** (a ** b) = one"
+    by (simp add: mul_assoc mul_assoc [symmetric] mul_inv_l one_mul mul_inv_l)
+  show "inv (a ** b) ** (a ** b) = (inv b ** inv a) ** (a ** b)"
+    by (simp add: lhs rhs)
+qed
+
+lemma inv_eq_of_mul_eq_one:
+  assumes h: "a ** b = one"
+  shows "b = inv a"
+proof -
+  have "inv a ** (a ** b) = inv a ** one"
+    using h by simp
+  then show ?thesis
+    by (simp add: mul_assoc mul_inv_l one_mul mul_one)
+qed
+
+end
+
+
+
+
+locale group_comm = group +
+  assumes mul_comm : "a ** b = b ** a"
+begin
+
+lemma mul_rotate': "a ** (b ** c) = b ** (c ** a)"
+proof -
+  have "a ** (b ** c) = (b ** c) ** a" by (simp add: mul_comm)
+  also have "... = b ** (c ** a)" by (simp only: mul_assoc [symmetric])
+  finally show ?thesis .
+qed
+
+end
+
+
+
+
+locale group_action =
+  group mul one inv
+    for mul :: "'a => 'a => 'a"  (infixl "**" 70)
+    and one :: "'a"
+    and inv :: "'a => 'a" +
+  fixes act :: "'a => 'b => 'b"  (infixr "acts" 73)
+  assumes act_one : "one acts x = x"
+    and   act_mul : "(g ** h) acts x = g acts (h acts x)"
+begin
+
+
+
+lemma act_inv: "inv g acts (g acts x) = x"
+proof -
+  have "(inv g ** g) acts x = x"
+    by (simp add: mul_inv_l act_one)
+  then show ?thesis
+    by (simp add: act_mul)
+qed
+
+lemma act_inv_r: "g acts (inv g acts x) = x"
+proof -
+  have "(g ** inv g) acts x = x"
+    by (simp add: mul_inv_r act_one)
+  then show ?thesis
+    by (simp add: act_mul)
+qed
+
+definition orbit :: "'b => 'b => bool"
+  where "orbit x y == (EX g. g acts x = y)"
+
+definition stabilizer :: "'b => 'a => bool"
+  where "stabilizer x g == g acts x = x"
+
+lemma orbit_refl: "orbit x x"
+  unfolding orbit_def
+  by (rule exI[of _ one]) (simp add: act_one)
+
+lemma orbit_sym:
+  assumes "orbit x y"
+  shows "orbit y x"
+proof -
+  obtain g where hg: "g acts x = y"
+    using assms unfolding orbit_def by blast
+  show ?thesis
+    unfolding orbit_def
+    by (rule exI[of _ "inv g"])
+       (simp add: hg [symmetric] act_mul [symmetric] mul_inv_l act_one)
+qed
+
+lemma orbit_trans:
+  assumes "orbit x y" "orbit y z"
+  shows "orbit x z"
+proof -
+  obtain g1 where hg1: "g1 acts x = y"
+    using assms(1) unfolding orbit_def by blast
+  obtain g2 where hg2: "g2 acts y = z"
+    using assms(2) unfolding orbit_def by blast
+  show ?thesis
+    unfolding orbit_def
+    by (rule exI[of _ "g2 ** g1"])
+       (simp add: act_mul hg1 hg2)
+qed
+
+lemma orbit_partition:
+  assumes hxy: "orbit x y"
+  shows "orbit x z = orbit y z"
+proof
+  assume hz: "orbit x z"
+  obtain g1 where hg1: "g1 acts x = y"
+    using hxy unfolding orbit_def by blast
+  obtain g2 where hg2: "g2 acts x = z"
+    using hz unfolding orbit_def by blast
+  show "orbit y z"
+    unfolding orbit_def
+  proof (rule exI[of _ "g2 ** inv g1"])
+    have h1: "inv g1 acts y = x"
+    proof -
+      have "inv g1 acts y = inv g1 acts (g1 acts x)" by (simp add: hg1)
+      also have "... = x" by (simp add: act_inv)
+      finally show ?thesis .
+    qed
+    show "(g2 ** inv g1) acts y = z"
+      by (simp add: act_mul h1 hg2)
+  qed
+next
+  assume hz: "orbit y z"
+  obtain g1 where hg1: "g1 acts x = y"
+    using hxy unfolding orbit_def by blast
+  obtain g2 where hg2: "g2 acts y = z"
+    using hz unfolding orbit_def by blast
+  show "orbit x z"
+    unfolding orbit_def
+    by (rule exI[of _ "g2 ** g1"])
+       (simp add: act_mul hg1 hg2)
+qed
+
+lemma stabilizer_mul:
+  assumes "stabilizer x g" "stabilizer x h"
+  shows "stabilizer x (g ** h)"
+  using assms unfolding stabilizer_def
+  by (simp add: act_mul)
+
+lemma stabilizer_inv:
+  assumes hg: "stabilizer x g"
+  shows "stabilizer x (inv g)"
+  unfolding stabilizer_def
+  using hg unfolding stabilizer_def
+  by (metis act_inv act_mul mul_inv_l act_one)
+
+lemma stabilizer_one: "stabilizer x one"
+  unfolding stabilizer_def
+  by (simp add: act_one)
+
+lemma stabilizer_conjugate:
+  assumes hh: "stabilizer x h"
+  shows "stabilizer (g acts x) (g ** h ** inv g)"
+  using assms unfolding stabilizer_def
+  by (simp add: act_mul act_inv)
+
+lemma stabilizer_conjugate_orbit:
+  assumes hxy: "g acts x = y"
+  shows "stabilizer y h = stabilizer x (inv g ** h ** g)"
+proof
+  assume hy: "stabilizer y h"
+  show "stabilizer x (inv g ** h ** g)"
+    unfolding stabilizer_def
+  proof -
+    have hy': "h acts y = y" using hy unfolding stabilizer_def .
+    have h1: "(inv g ** h ** g) acts x = inv g acts (h acts (g acts x))"
+      by (simp add: act_mul)
+    have h2: "h acts (g acts x) = g acts x" by (simp add: hxy hy')
+    show "(inv g ** h ** g) acts x = x" by (simp add: h1 h2 act_inv)
+  qed
+next
+  assume hh: "stabilizer x (inv g ** h ** g)"
+  show "stabilizer y h"
+    unfolding stabilizer_def
+  proof -
+    have hh': "(inv g ** h ** g) acts x = x"
+      using hh unfolding stabilizer_def .
+    have expand: "inv g acts (h acts (g acts x)) = x"
+      by (simp add: act_mul [symmetric] mul_assoc hh')
+    have hacts: "h acts (g acts x) = g acts x"
+      using act_inv_r [of g "h acts (g acts x)"] expand by simp
+    show "h acts y = y" by (simp add: hxy [symmetric] hacts)
+  qed
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/ideals.thy

@@ -0,0 +1,131 @@
+theory ideals
+  imports Main
+begin
+
+locale cring =
+  fixes zero :: "'r"
+    and one  :: "'r"
+    and add  :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl "+R" 65)
+    and mul  :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl "*R" 70)
+    and opp  :: "'r \<Rightarrow> 'r"
+  assumes add_comm  : "\<And>x y. x +R y = y +R x"
+    and   add_assoc : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and   add_zero  : "\<And>x. x +R zero = x"
+    and   add_opp   : "\<And>x. x +R opp x = zero"
+    and   mul_comm  : "\<And>x y. x *R y = y *R x"
+    and   mul_assoc : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+    and   mul_one   : "\<And>x. x *R one = x"
+    and   dist_l    : "\<And>a x y. a *R (x +R y) = (a *R x) +R (a *R y)"
+    and   opp_add   : "\<And>x y. opp (x +R y) = opp x +R opp y"
+begin
+
+
+lemma add_left_comm: "x +R (y +R z) = y +R (x +R z)"
+proof -
+  have "x +R (y +R z) = (x +R y) +R z" by (rule add_assoc [symmetric])
+  also have "\<dots> = (y +R x) +R z"       by (simp add: add_comm)
+  also have "\<dots> = y +R (x +R z)"       by (rule add_assoc)
+  finally show ?thesis .
+qed
+
+lemma zero_add: "zero +R x = x"
+  by (simp add: add_comm add_zero)
+
+
+
+
+
+definition IsIdeal :: "('r \<Rightarrow> bool) \<Rightarrow> bool"
+  where "IsIdeal I \<equiv>
+    I zero \<and>
+    (\<forall>x y. I x \<longrightarrow> I y \<longrightarrow> I (x +R y)) \<and>
+    (\<forall>x.   I x \<longrightarrow> I (opp x)) \<and>
+    (\<forall>a x. I x \<longrightarrow> I (a *R x))"
+
+
+
+
+
+definition Inter :: "('i \<Rightarrow> 'r \<Rightarrow> bool) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "Inter F \<equiv> \<lambda>x. \<forall>i. F i x"
+
+lemma inter_isIdeal:
+  assumes h: "\<forall>i. IsIdeal (F i)"
+  shows "IsIdeal (Inter F)"
+  unfolding IsIdeal_def Inter_def
+  using h unfolding IsIdeal_def
+  by blast
+
+
+
+
+
+definition isum :: "('r \<Rightarrow> bool) \<Rightarrow> ('r \<Rightarrow> bool) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "isum I J \<equiv> \<lambda>x. \<exists>a b. I a \<and> J b \<and> x = a +R b"
+
+lemma sum_isIdeal:
+  assumes hI: "IsIdeal I" and hJ: "IsIdeal J"
+  shows "IsIdeal (isum I J)"
+proof -
+  from hI have hI0   : "I zero"
+           and hIadd : "\<And>x y. I x \<Longrightarrow> I y \<Longrightarrow> I (x +R y)"
+           and hIopp : "\<And>x. I x \<Longrightarrow> I (opp x)"
+           and hImul : "\<And>a x. I x \<Longrightarrow> I (a *R x)"
+    unfolding IsIdeal_def by blast+
+  from hJ have hJ0   : "J zero"
+           and hJadd : "\<And>x y. J x \<Longrightarrow> J y \<Longrightarrow> J (x +R y)"
+           and hJopp : "\<And>x. J x \<Longrightarrow> J (opp x)"
+           and hJmul : "\<And>a x. J x \<Longrightarrow> J (a *R x)"
+    unfolding IsIdeal_def by blast+
+  show ?thesis
+    unfolding IsIdeal_def isum_def
+  proof (intro conjI allI impI)
+
+    show "\<exists>a b. I a \<and> J b \<and> zero = a +R b"
+      using hI0 hJ0 by (metis add_zero)
+
+
+    fix x y
+    assume hx: "\<exists>a b. I a \<and> J b \<and> x = a +R b"
+    assume hy: "\<exists>a b. I a \<and> J b \<and> y = a +R b"
+    show "\<exists>a b. I a \<and> J b \<and> x +R y = a +R b"
+    proof -
+      from hx obtain a  b  where ha  : "I a"  and hb  : "J b"  and hxeq : "x = a  +R b"  by blast
+      from hy obtain a' b' where ha' : "I a'" and hb' : "J b'" and hyeq : "y = a' +R b'" by blast
+      have rearrange : "(a +R b) +R (a' +R b') = (a +R a') +R (b +R b')"
+      proof -
+        have "(a +R b) +R (a' +R b') = a +R (b +R (a' +R b'))"  by (rule add_assoc)
+        also have "\<dots> = a +R (a' +R (b +R b'))"                  by (simp add: add_left_comm)
+        also have "\<dots> = (a +R a') +R (b +R b')"                  by (rule add_assoc [symmetric])
+        finally show ?thesis .
+      qed
+      show ?thesis
+        using ha ha' hb hb' hxeq hyeq rearrange
+        by (metis hIadd hJadd)
+    qed
+
+
+    fix x
+    assume hx: "\<exists>a b. I a \<and> J b \<and> x = a +R b"
+    show "\<exists>a b. I a \<and> J b \<and> opp x = a +R b"
+    proof -
+      from hx obtain a b where ha: "I a" and hb: "J b" and hxeq: "x = a +R b" by blast
+      have "opp (a +R b) = opp a +R opp b" by (rule opp_add)
+      with hxeq ha hb hIopp hJopp show ?thesis by blast
+    qed
+
+
+    fix c x
+    assume hx: "\<exists>a b. I a \<and> J b \<and> x = a +R b"
+    show "\<exists>a b. I a \<and> J b \<and> c *R x = a +R b"
+    proof -
+      from hx obtain a b where ha: "I a" and hb: "J b" and hxeq: "x = a +R b" by blast
+      have "c *R (a +R b) = (c *R a) +R (c *R b)" by (rule dist_l)
+      with hxeq ha hb hImul hJmul show ?thesis by blast
+    qed
+  qed
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/inner_product.thy

@@ -0,0 +1,153 @@
+theory inner_product
+  imports Main
+begin
+
+locale inner_product =
+  fixes zero_R one_R :: "'r"
+    and add_R :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl "+R" 65)
+    and mul_R :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl "*R" 70)
+    and opp_R :: "'r \<Rightarrow> 'r"
+    and zeroV :: "'v"
+    and addV  :: "'v \<Rightarrow> 'v \<Rightarrow> 'v"  (infixl "+V" 65)
+    and oppV  :: "'v \<Rightarrow> 'v"
+    and smul  :: "'r \<Rightarrow> 'v \<Rightarrow> 'v"
+    and ip    :: "'v \<Rightarrow> 'v \<Rightarrow> 'r"
+
+  assumes add_R_comm    : "\<And>x y. x +R y = y +R x"
+    and   add_R_assoc   : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and   add_R_zero    : "\<And>x. x +R zero_R = x"
+    and   zero_R_add    : "\<And>x. zero_R +R x = x"
+    and   add_R_opp     : "\<And>x. x +R opp_R x = zero_R"
+    and   mul_R_comm    : "\<And>x y. x *R y = y *R x"
+    and   mul_R_assoc   : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+    and   mul_R_one     : "\<And>x. x *R one_R = x"
+    and   mul_opp_one   : "\<And>x. opp_R one_R *R x = opp_R x"
+    and   opp_R_opp     : "\<And>x. opp_R (opp_R x) = x"
+
+    and   addV_comm     : "\<And>u v. u +V v = v +V u"
+    and   addV_assoc    : "\<And>u v w. (u +V v) +V w = u +V (v +V w)"
+    and   addV_zero     : "\<And>u. u +V zeroV = u"
+    and   smul_addV     : "\<And>a u v. smul a (u +V v) = smul a u +V smul a v"
+    and   one_smul      : "\<And>u. smul one_R u = u"
+    and   opp_smul_one  : "\<And>u. oppV u = smul (opp_R one_R) u"
+
+    and   lin_left_add  : "\<And>u v w. ip (u +V v) w = ip u w +R ip v w"
+    and   lin_left_smul : "\<And>a u v. ip (smul a u) v = a *R ip u v"
+    and   lin_right_add : "\<And>u v w. ip u (v +V w) = ip u v +R ip u w"
+    and   lin_right_smul: "\<And>a u v. ip u (smul a v) = a *R ip u v"
+    and   ip_symm       : "\<And>u v. ip u v = ip v u"
+begin
+
+
+
+
+
+definition subV :: "'v \<Rightarrow> 'v \<Rightarrow> 'v"  (infixl "-V" 65)
+  where "u -V v \<equiv> u +V oppV v"
+
+lemma add_R_left_comm: "x +R (y +R z) = y +R (x +R z)"
+proof -
+  have "x +R (y +R z) = (x +R y) +R z" by (rule add_R_assoc [symmetric])
+  also have "\<dots> = (y +R x) +R z"       by (simp add: add_R_comm)
+  also have "\<dots> = y +R (x +R z)"       by (rule add_R_assoc)
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma ip_neg_left: "ip (oppV u) v = opp_R (ip u v)"
+proof -
+  have "ip (oppV u) v = ip (smul (opp_R one_R) u) v" by (simp add: opp_smul_one)
+  also have "\<dots> = opp_R one_R *R ip u v"              by (rule lin_left_smul)
+  also have "\<dots> = opp_R (ip u v)"                     by (rule mul_opp_one)
+  finally show ?thesis .
+qed
+
+lemma ip_neg_right: "ip u (oppV v) = opp_R (ip u v)"
+proof -
+  have "ip u (oppV v) = ip u (smul (opp_R one_R) v)" by (simp add: opp_smul_one)
+  also have "\<dots> = opp_R one_R *R ip u v"              by (rule lin_right_smul)
+  also have "\<dots> = opp_R (ip u v)"                     by (rule mul_opp_one)
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma ip_add_add:
+  "ip (u +V v) (u +V v) =
+    (ip u u +R ip v u) +R (ip u v +R ip v v)"
+proof -
+  have H : "ip (u +V v) (u +V v) = ip (u +V v) u +R ip (u +V v) v"
+    by (rule lin_right_add)
+  have H1: "ip (u +V v) u = ip u u +R ip v u" by (rule lin_left_add)
+  have H2: "ip (u +V v) v = ip u v +R ip v v" by (rule lin_left_add)
+  show ?thesis by (simp add: H H1 H2)
+qed
+
+
+
+
+
+lemma ip_neg_neg: "ip (oppV v) (oppV v) = ip v v"
+proof -
+  have "ip (oppV v) (oppV v) = opp_R (ip (oppV v) v)" by (rule ip_neg_right)
+  also have "\<dots> = opp_R (opp_R (ip v v))"
+    by (simp add: ip_neg_left)
+  also have "\<dots> = ip v v" by (rule opp_R_opp)
+  finally show ?thesis .
+qed
+
+lemma ip_sub_sub:
+  "ip (u -V v) (u -V v) =
+    (ip u u +R opp_R (ip v u)) +R (opp_R (ip u v) +R ip v v)"
+proof -
+  have H : "ip (u -V v) (u -V v)
+          = ip (u -V v) u +R ip (u -V v) (oppV v)"
+    unfolding subV_def by (rule lin_right_add)
+  have H1: "ip (u -V v) u
+          = ip u u +R ip (oppV v) u"
+    unfolding subV_def by (rule lin_left_add)
+  have H2: "ip (u -V v) (oppV v)
+          = ip u (oppV v) +R ip (oppV v) (oppV v)"
+    unfolding subV_def by (rule lin_left_add)
+  have Hn1: "ip (oppV v) u = opp_R (ip v u)"   by (rule ip_neg_left)
+  have Hn2: "ip u (oppV v) = opp_R (ip u v)"   by (rule ip_neg_right)
+  have Hnn: "ip (oppV v) (oppV v) = ip v v"    by (rule ip_neg_neg)
+  show ?thesis by (simp add: H H1 H2 Hn1 Hn2 Hnn)
+qed
+
+
+
+
+
+lemma pythagoras:
+  assumes h: "ip u v = zero_R"
+  shows "ip (u +V v) (u +V v) = ip u u +R ip v v"
+proof -
+  have hvu: "ip v u = zero_R" by (simp add: ip_symm h)
+  have "ip (u +V v) (u +V v) = (ip u u +R ip v u) +R (ip u v +R ip v v)"
+    by (rule ip_add_add)
+  also have "\<dots> = (ip u u +R zero_R) +R (zero_R +R ip v v)"
+    by (simp add: h hvu)
+  also have "\<dots> = ip u u +R ip v v"
+    by (simp add: add_R_zero zero_R_add)
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma parallelogram:
+  "ip (u +V v) (u +V v) +R ip (u -V v) (u -V v) =
+    ((ip u u +R ip v u) +R (ip u v +R ip v v)) +R
+    ((ip u u +R opp_R (ip v u)) +R (opp_R (ip u v) +R ip v v))"
+  by (simp add: ip_add_add ip_sub_sub)
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/integral_comp_neg_Iic.thy

@@ -0,0 +1,271 @@
+theory integral_comp_neg_Iic
+  imports Main
+begin
+
+locale integrals_setup =
+  fixes zero one  :: "'r"
+    and add       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "+R" 65)
+    and opp       :: "'r \<Rightarrow> 'r"
+    and mul       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "*R" 70)
+    and leR       :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "\<le>R" 50)
+    and ltR       :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "<R" 50)
+    and absR      :: "'r \<Rightarrow> 'r"
+    and sigma     :: "('r \<Rightarrow> bool) \<Rightarrow> ('r \<Rightarrow> 'r) \<Rightarrow> 'r"
+
+  assumes
+    add_comm      : "\<And>x y.   x +R y = y +R x"
+    and add_assoc : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and add_zero  : "\<And>x.     x +R zero = x"
+    and add_opp   : "\<And>x.     opp x +R x = zero"
+    and add_right_cancel : "\<And>x y z. x +R z = y +R z \<Longrightarrow> x = y"
+    and mul_comm  : "\<And>x y.   x *R y = y *R x"
+    and mul_assoc : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+    and mul_one   : "\<And>x.     x *R one = x"
+    and dist_l    : "\<And>x y z. x *R (y +R z) = (x *R y) +R (x *R z)"
+    and opp_inv   : "\<And>x.     opp (opp x) = x"
+    and add_le_compat : "\<And>x y z. x \<le>R y \<Longrightarrow> (x +R z) \<le>R (y +R z)"
+    and le_opp    : "\<And>x y.   x \<le>R y \<Longrightarrow> opp y \<le>R opp x"
+    and le_antisymm : "\<And>x y. x \<le>R y \<Longrightarrow> y \<le>R x \<Longrightarrow> x = y"
+    and lt_opp    : "\<And>x y.   x <R y \<Longrightarrow> opp y <R opp x"
+    and le_refl   : "\<And>x.     x \<le>R x"
+    and le_trans  : "\<And>x y z. x \<le>R y \<Longrightarrow> y \<le>R z \<Longrightarrow> x \<le>R z"
+    and le_total  : "\<And>x y.   x \<le>R y \<or> y \<le>R x"
+    and lt_def    : "\<And>x y.   (x <R y) \<longleftrightarrow> (x \<le>R y \<and> x \<noteq> y)"
+    and abs_pos   : "\<And>x.     zero \<le>R x \<Longrightarrow> absR x = x"
+    and abs_neg   : "\<And>x.     x \<le>R zero \<Longrightarrow> absR x = opp x"
+    and abs_nonneg : "\<And>x.    zero \<le>R absR x"
+    and abs_opp   : "\<And>x.     absR (opp x) = absR x"
+    and abs_triangle : "\<And>x y. absR (x +R y) \<le>R (absR x +R absR y)"
+
+    and sigma_mul_const : "\<And>D f c. sigma D (\<lambda>x. c *R f x) = c *R sigma D f"
+    and sigma_congr : "\<And>D f g. (\<forall>x. D x \<longrightarrow> f x = g x) \<Longrightarrow> sigma D f = sigma D g"
+    and sigma_zero  : "\<And>D.     sigma D (\<lambda>_. zero) = zero"
+    and sigma_add   : "\<And>D f g. sigma D (\<lambda>x. f x +R g x) = sigma D f +R sigma D g"
+    and sigma_union_disjoint :
+          "\<And>D E f. (\<forall>x. D x \<longrightarrow> E x \<longrightarrow> False) \<Longrightarrow>
+            sigma (\<lambda>x. D x \<or> E x) f = sigma D f +R sigma E f"
+    and sigma_le    : "\<And>D f g. (\<forall>x. D x \<longrightarrow> f x \<le>R g x) \<Longrightarrow> sigma D f \<le>R sigma D g"
+    and sigma_dom_congr :
+          "\<And>D E f. (\<forall>x. D x \<longleftrightarrow> E x) \<Longrightarrow> sigma D f = sigma E f"
+begin
+
+
+
+
+
+definition Iic :: "'r \<Rightarrow> 'r \<Rightarrow> bool" where "Iic c x \<equiv> x \<le>R c"
+definition Ioi :: "'r \<Rightarrow> 'r \<Rightarrow> bool" where "Ioi c x \<equiv> c <R x"
+definition Iio :: "'r \<Rightarrow> 'r \<Rightarrow> bool" where "Iio c x \<equiv> x <R c"
+
+definition preimage :: "('r \<Rightarrow> 'r) \<Rightarrow> ('r \<Rightarrow> bool) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "preimage g D x \<equiv> D (g x)"
+
+
+
+
+
+lemma add_opp_r: "x +R opp x = zero"
+  using add_opp[of x] add_comm[of x "opp x"] by simp
+
+
+
+
+
+lemma lt_irrefl: "\<not> (x <R x)"
+  using lt_def by blast
+
+lemma lt_trans_strict: "x <R y \<Longrightarrow> y <R z \<Longrightarrow> x <R z"
+  using lt_def le_trans by blast
+
+
+
+
+
+lemma preimage_union:
+  "preimage g (\<lambda>x. D x \<or> E x) x \<longleftrightarrow> preimage g D x \<or> preimage g E x"
+  unfolding preimage_def by blast
+
+lemma preimage_inter:
+  "preimage g (\<lambda>x. D x \<and> E x) x \<longleftrightarrow> preimage g D x \<and> preimage g E x"
+  unfolding preimage_def by blast
+
+lemma preimage_neg_Ioi: "preimage opp (Ioi c) x \<longleftrightarrow> x <R opp c"
+  unfolding preimage_def Ioi_def
+  by (metis lt_opp opp_inv)
+
+lemma preimage_neg_Iic: "preimage opp (Iic c) x \<longleftrightarrow> opp c \<le>R x"
+  unfolding preimage_def Iic_def
+  by (metis le_opp opp_inv)
+
+lemma preimage_comp:
+  "preimage g (preimage h D) x \<longleftrightarrow> preimage (\<lambda>x. h (g x)) D x"
+  unfolding preimage_def by simp
+
+
+
+
+
+lemma integral_neg: "sigma D (\<lambda>x. opp (f x)) = opp (sigma D f)"
+proof -
+  have h: "sigma D (\<lambda>x. opp (f x)) +R sigma D f =
+           opp (sigma D f) +R sigma D f"
+  proof -
+    have lhs: "sigma D (\<lambda>x. opp (f x)) +R sigma D f = zero"
+    proof -
+      have "sigma D (\<lambda>x. opp (f x)) +R sigma D f =
+            sigma D (\<lambda>x. opp (f x) +R f x)"
+        by (rule sigma_add[symmetric])
+      also have "\<dots> = sigma D (\<lambda>_. zero)"
+        by (rule sigma_congr) (simp add: add_opp)
+      also have "\<dots> = zero"
+        by (rule sigma_zero)
+      finally show ?thesis .
+    qed
+    have rhs: "opp (sigma D f) +R sigma D f = zero"
+      by (rule add_opp)
+    show ?thesis by (simp only: lhs rhs)
+  qed
+  from add_right_cancel[OF h] show ?thesis .
+qed
+
+lemma integral_sub:
+  "sigma D (\<lambda>x. f x +R opp (g x)) = sigma D f +R opp (sigma D g)"
+  by (simp add: sigma_add integral_neg)
+
+
+
+
+
+lemma sigma_empty: "sigma (\<lambda>_. False) f = zero"
+proof -
+  have "sigma (\<lambda>_. False) f = sigma (\<lambda>_. False) (\<lambda>_. zero)"
+    by (rule sigma_congr) blast
+  thus ?thesis by (simp add: sigma_zero)
+qed
+
+
+
+
+
+lemma sigma_bilinear:
+  "sigma D (\<lambda>x. (c *R f x) +R (d *R g x)) =
+   (c *R sigma D f) +R (d *R sigma D g)"
+  by (simp add: sigma_add sigma_mul_const)
+
+
+
+
+
+lemma sigma_le_monotone:
+  "(\<forall>x. D x \<longrightarrow> f x \<le>R g x) \<Longrightarrow> sigma D f \<le>R sigma D g"
+  by (rule sigma_le)
+
+lemma sigma_nonneg:
+  "(\<forall>x. D x \<longrightarrow> zero \<le>R f x) \<Longrightarrow> zero \<le>R sigma D f"
+proof -
+  assume h: "\<forall>x. D x \<longrightarrow> zero \<le>R f x"
+  have "sigma D (\<lambda>_. zero) \<le>R sigma D f"
+    by (rule sigma_le) (simp add: h)
+  thus ?thesis by (simp add: sigma_zero)
+qed
+
+
+
+
+
+lemma sigma_split:
+  "sigma D f =
+   sigma (\<lambda>x. D x \<and> P x) f +R sigma (\<lambda>x. D x \<and> \<not> P x) f"
+proof -
+  let ?E = "\<lambda>x. D x \<and> P x"
+  let ?F = "\<lambda>x. D x \<and> \<not> P x"
+  have dom_eq: "\<forall>x. D x \<longleftrightarrow> (?E x \<or> ?F x)" by blast
+  have "sigma D f = sigma (\<lambda>x. ?E x \<or> ?F x) f"
+    by (rule sigma_dom_congr) (rule dom_eq)
+  also have "\<dots> = sigma ?E f +R sigma ?F f"
+    by (rule sigma_union_disjoint) blast
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma sigma_preimage_neg_Ioi:
+  "sigma (preimage opp (Ioi c)) f = sigma (Iio (opp c)) f"
+  by (rule sigma_dom_congr) (simp add: preimage_neg_Ioi Iio_def)
+
+
+
+
+
+lemma sigma_abs_bound:
+  "absR (sigma D f) \<le>R sigma D (\<lambda>x. absR (f x))"
+proof -
+  let ?P    = "\<lambda>x. zero \<le>R f x"
+  let ?E    = "\<lambda>x. D x \<and> ?P x"
+  let ?F    = "\<lambda>x. D x \<and> \<not> ?P x"
+  let ?Ipos = "sigma ?E f"
+  let ?Ineg = "sigma ?F f"
+
+  have split: "sigma D f = ?Ipos +R ?Ineg"
+    by (rule sigma_split)
+
+
+  have Hpos_nonneg: "zero \<le>R ?Ipos"
+    by (rule sigma_nonneg) blast
+
+
+  have Hfx_le0: "\<forall>x. ?F x \<longrightarrow> f x \<le>R zero"
+    using le_total by blast
+
+
+  have Hneg_nonpos: "?Ineg \<le>R zero"
+  proof -
+    have "?Ineg \<le>R sigma ?F (\<lambda>_. zero)"
+      by (rule sigma_le) (simp add: Hfx_le0)
+    thus ?thesis by (simp add: sigma_zero)
+  qed
+
+
+  have Hpos_eq: "absR ?Ipos = sigma ?E (\<lambda>x. absR (f x))"
+  proof -
+    have "absR ?Ipos = ?Ipos"
+      by (rule abs_pos[OF Hpos_nonneg])
+    also have "\<dots> = sigma ?E (\<lambda>x. absR (f x))"
+      by (rule sigma_congr) (auto simp add: abs_pos)
+    finally show ?thesis .
+  qed
+
+
+  have Hneg_eq: "absR ?Ineg = sigma ?F (\<lambda>x. absR (f x))"
+  proof -
+    have "absR ?Ineg = opp ?Ineg"
+      by (rule abs_neg[OF Hneg_nonpos])
+    also have "\<dots> = sigma ?F (\<lambda>x. opp (f x))"
+      by (simp add: integral_neg)
+    also have "\<dots> = sigma ?F (\<lambda>x. absR (f x))"
+      by (rule sigma_congr) (auto simp add: abs_neg Hfx_le0)
+    finally show ?thesis .
+  qed
+
+
+  have split_abs:
+    "sigma D (\<lambda>x. absR (f x)) =
+     sigma ?E (\<lambda>x. absR (f x)) +R sigma ?F (\<lambda>x. absR (f x))"
+    by (rule sigma_split)
+
+
+  have step1: "absR (?Ipos +R ?Ineg) \<le>R absR ?Ipos +R absR ?Ineg"
+    by (rule abs_triangle)
+  have step2: "absR ?Ipos +R absR ?Ineg = sigma D (\<lambda>x. absR (f x))"
+    by (simp only: Hpos_eq Hneg_eq split_abs[symmetric])
+  have h1: "absR (sigma D f) \<le>R absR ?Ipos +R absR ?Ineg"
+    by (simp only: split, rule step1)
+  show ?thesis
+    by (rule le_trans[OF h1], simp only: step2[symmetric], rule le_refl)
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/lattice_like.thy

@@ -0,0 +1,58 @@
+theory lattice_like
+  imports Main
+begin
+
+locale lattice_like =
+  fixes le  :: "'a \<Rightarrow> 'a \<Rightarrow> bool"  (infix "\<preceq>" 50)
+    and inf :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"   (infixl "\<sqinter>" 60)
+    and sup :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"   (infixl "\<squnion>" 65)
+  assumes le_refl   : "\<And>x. x \<preceq> x"
+    and   le_trans  : "\<And>x y z. x \<preceq> y \<Longrightarrow> y \<preceq> z \<Longrightarrow> x \<preceq> z"
+    and   le_antisym: "\<And>x y. x \<preceq> y \<Longrightarrow> y \<preceq> x \<Longrightarrow> x = y"
+    and   le_inf_left  : "\<And>a b. inf a b \<preceq> a"
+    and   le_inf_right : "\<And>a b. inf a b \<preceq> b"
+    and   le_inf_intro : "\<And>c a b. c \<preceq> a \<Longrightarrow> c \<preceq> b \<Longrightarrow> c \<preceq> inf a b"
+    and   le_sup_left  : "\<And>a b. a \<preceq> sup a b"
+    and   le_sup_right : "\<And>a b. b \<preceq> sup a b"
+    and   sup_le_intro : "\<And>a b c. a \<preceq> c \<Longrightarrow> b \<preceq> c \<Longrightarrow> sup a b \<preceq> c"
+begin
+
+lemma inf_comm: "a \<sqinter> b = b \<sqinter> a"
+  by (rule le_antisym)
+     (auto intro: le_inf_intro le_inf_left le_inf_right)
+
+lemma sup_comm: "a \<squnion> b = b \<squnion> a"
+  by (rule le_antisym)
+     (auto intro: sup_le_intro le_sup_left le_sup_right)
+
+lemma inf_assoc: "(a \<sqinter> b) \<sqinter> c = a \<sqinter> (b \<sqinter> c)"
+proof (rule le_antisym)
+  show "(a \<sqinter> b) \<sqinter> c \<preceq> a \<sqinter> (b \<sqinter> c)"
+    by (intro le_inf_intro)
+       (blast intro: le_trans le_inf_left le_inf_right)+
+  show "a \<sqinter> (b \<sqinter> c) \<preceq> (a \<sqinter> b) \<sqinter> c"
+    by (intro le_inf_intro)
+       (blast intro: le_trans le_inf_left le_inf_right)+
+qed
+
+lemma sup_assoc: "(a \<squnion> b) \<squnion> c = a \<squnion> (b \<squnion> c)"
+proof (rule le_antisym)
+  show "(a \<squnion> b) \<squnion> c \<preceq> a \<squnion> (b \<squnion> c)"
+    by (intro sup_le_intro)
+       (blast intro: le_trans le_sup_left le_sup_right)+
+  show "a \<squnion> (b \<squnion> c) \<preceq> (a \<squnion> b) \<squnion> c"
+    by (intro sup_le_intro)
+       (blast intro: le_trans le_sup_left le_sup_right)+
+qed
+
+lemma inf_absorption: "a \<sqinter> (a \<squnion> b) = a"
+  by (rule le_antisym)
+     (auto intro: le_inf_intro le_inf_left le_refl le_sup_left)
+
+lemma sup_absorption: "a \<squnion> (a \<sqinter> b) = a"
+  by (rule le_antisym)
+     (auto intro: sup_le_intro le_sup_left le_refl le_inf_left)
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/limits_uniqueness.thy

@@ -0,0 +1,109 @@
+theory limits_uniqueness
+  imports Main
+begin
+
+locale abs_field =
+  fixes zero    :: "'r"
+    and one     :: "'r"
+    and add     :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "+R" 65)
+    and mul     :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "*R" 70)
+    and opp     :: "'r \<Rightarrow> 'r"
+    and absV    :: "'r \<Rightarrow> 'r"
+    and le      :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "\<preceq>" 50)
+    and lt      :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "\<prec>" 50)
+
+    and natLe   :: "'n \<Rightarrow> 'n \<Rightarrow> bool"
+    and natMax  :: "'n \<Rightarrow> 'n \<Rightarrow> 'n"
+  assumes le_max_left    : "\<And>x y. natLe x (natMax x y)"
+    and   le_max_right   : "\<And>x y. natLe y (natMax x y)"
+    and   add_comm       : "\<And>x y. x +R y = y +R x"
+    and   add_assoc      : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and   add_zero       : "\<And>x. x +R zero = x"
+    and   add_opp        : "\<And>x. x +R opp x = zero"
+    and   opp_add        : "\<And>x y. opp (x +R y) = opp x +R opp y"
+    and   le_refl        : "\<And>x. x \<preceq> x"
+    and   le_trans       : "\<And>x y z. x \<preceq> y \<Longrightarrow> y \<preceq> z \<Longrightarrow> x \<preceq> z"
+    and   add_le_add     : "\<And>a b c d. a \<preceq> b \<Longrightarrow> c \<preceq> d \<Longrightarrow> a +R c \<preceq> b +R d"
+    and   abs_nonneg     : "\<And>x. zero \<preceq> absV x"
+    and   abs_triangle   : "\<And>x y. absV (x +R y) \<preceq> absV x +R absV y"
+    and   abs_sub_symm   : "\<And>x y. absV (x +R opp y) = absV (y +R opp x)"
+    and   sub_decomp     : "\<And>x y z. x +R opp z = (x +R opp y) +R (y +R opp z)"
+    and   sub_eq_zero    : "\<And>x y. x +R opp y = zero \<Longrightarrow> x = y"
+    and   eq_of_forall_eps2 :
+            "\<And>x. (\<forall>eps. zero \<prec> eps \<longrightarrow> absV x \<preceq> eps +R eps) \<Longrightarrow> x = zero"
+begin
+
+
+
+
+
+definition sub :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"
+  where "sub x y \<equiv> x +R opp y"
+
+definition limit :: "('n \<Rightarrow> 'r) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "limit u l \<equiv>
+    \<forall>eps. zero \<prec> eps \<longrightarrow>
+      (\<exists>N. \<forall>n. natLe N n \<longrightarrow> absV (sub (u n) l) \<preceq> eps)"
+
+
+
+
+
+lemma sub_self_zero: "sub x x = zero"
+  unfolding sub_def by (rule add_opp)
+
+lemma sub_decomp_lem: "sub x z = (sub x y) +R (sub y z)"
+  unfolding sub_def by (rule sub_decomp)
+
+lemma abs_sub_triangle:
+  "absV (sub x z) \<preceq> absV (sub x y) +R absV (sub y z)"
+proof -
+  have "sub x z = sub x y +R sub y z" by (rule sub_decomp_lem)
+  hence "absV (sub x z) = absV (sub x y +R sub y z)" by simp
+  also have "\<dots> \<preceq> absV (sub x y) +R absV (sub y z)" by (rule abs_triangle)
+  finally show ?thesis .
+qed
+
+lemma abs_sub_symm_lem: "absV (sub x y) = absV (sub y x)"
+  unfolding sub_def by (rule abs_sub_symm)
+
+
+
+
+
+theorem limit_unique:
+  assumes Hl: "limit u l" and Hm: "limit u m"
+  shows "l = m"
+proof -
+
+  have Hbound: "\<forall>eps. zero \<prec> eps \<longrightarrow> absV (sub l m) \<preceq> eps +R eps"
+  proof (intro allI impI)
+    fix eps assume Heps: "zero \<prec> eps"
+    from Hl Heps obtain N1
+      where HN1: "\<forall>n. natLe N1 n \<longrightarrow> absV (sub (u n) l) \<preceq> eps"
+      unfolding limit_def by blast
+    from Hm Heps obtain N2
+      where HN2: "\<forall>n. natLe N2 n \<longrightarrow> absV (sub (u n) m) \<preceq> eps"
+      unfolding limit_def by blast
+    define N where "N \<equiv> natMax N1 N2"
+    have H1 : "absV (sub (u N) l) \<preceq> eps"
+      using HN1 le_max_left unfolding N_def by blast
+    have H2 : "absV (sub (u N) m) \<preceq> eps"
+      using HN2 le_max_right unfolding N_def by blast
+    have Htri : "absV (sub l m) \<preceq> absV (sub l (u N)) +R absV (sub (u N) m)"
+      by (rule abs_sub_triangle)
+    have H1' : "absV (sub l (u N)) \<preceq> eps"
+      using H1 by (simp add: abs_sub_symm_lem)
+    show "absV (sub l m) \<preceq> eps +R eps"
+      using le_trans[OF Htri] add_le_add[OF H1' H2] by blast
+  qed
+
+  have Hz : "sub l m = zero"
+    using Hbound by (rule eq_of_forall_eps2)
+  show "l = m"
+    using sub_eq_zero[OF Hz[unfolded sub_def]] .
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/linear_map.thy

@@ -0,0 +1,86 @@
+theory linear_map
+  imports Main
+begin
+
+
+
+
+
+locale linear_map_setup =
+  fixes zeroV :: "'v"
+    and addV  :: "'v \<Rightarrow> 'v \<Rightarrow> 'v"         (infixl "+V" 65)
+    and smul  :: "'r \<Rightarrow> 'v \<Rightarrow> 'v"           (infixr "\<cdot>V" 70)
+    and zeroW :: "'w"
+    and addW  :: "'w \<Rightarrow> 'w \<Rightarrow> 'w"         (infixl "+W" 65)
+    and smulW :: "'r \<Rightarrow> 'w \<Rightarrow> 'w"           (infixr "\<cdot>W" 70)
+    and toFun :: "'v \<Rightarrow> 'w"
+
+  assumes addV_comm  : "\<And>u v. u +V v = v +V u"
+    and   addV_assoc : "\<And>u v w. (u +V v) +V w = u +V (v +V w)"
+    and   addV_zero  : "\<And>u. u +V zeroV = u"
+    and   smul_zeroV : "\<And>a. a \<cdot>V zeroV = zeroV"
+
+    and   addW_comm  : "\<And>u v. u +W v = v +W u"
+    and   addW_assoc : "\<And>u v w. (u +W v) +W w = u +W (v +W w)"
+    and   addW_zero  : "\<And>u. u +W zeroW = u"
+    and   smulW_zero : "\<And>a. a \<cdot>W zeroW = zeroW"
+
+    and   map_add    : "\<And>u v. toFun (u +V v) = toFun u +W toFun v"
+    and   map_smul   : "\<And>a u. toFun (a \<cdot>V u) = a \<cdot>W toFun u"
+begin
+
+
+
+
+
+definition ker :: "'v \<Rightarrow> bool"
+  where "ker x \<equiv> toFun x = zeroW"
+
+definition im :: "'w \<Rightarrow> bool"
+  where "im y \<equiv> \<exists>x. toFun x = y"
+
+
+
+
+
+lemma ker_add:
+  assumes "ker x" "ker y" shows "ker (x +V y)"
+proof -
+  have "toFun (x +V y) = toFun x +W toFun y" by (rule map_add)
+  also have "\<dots> = zeroW +W zeroW"
+    using assms unfolding ker_def by simp
+  also have "\<dots> = zeroW"
+    by (simp add: addW_comm addW_zero)
+  finally show ?thesis unfolding ker_def .
+qed
+
+lemma ker_smul:
+  assumes "ker x" shows "ker (a \<cdot>V x)"
+  unfolding ker_def
+  using assms unfolding ker_def
+  by (simp add: map_smul smulW_zero)
+
+
+
+
+
+lemma im_add:
+  assumes "im y" "im z" shows "im (y +W z)"
+proof -
+  from assms(1) obtain x  where hx  : "toFun x  = y" unfolding im_def by blast
+  from assms(2) obtain x' where hx' : "toFun x' = z" unfolding im_def by blast
+  have "toFun (x +V x') = toFun x +W toFun x'" by (rule map_add)
+  with hx hx' show ?thesis unfolding im_def by blast
+qed
+
+lemma im_smul:
+  assumes "im y" shows "im (a \<cdot>W y)"
+proof -
+  from assms obtain x where hx : "toFun x = y" unfolding im_def by blast
+  have "toFun (a \<cdot>V x) = a \<cdot>W toFun x" by (rule map_smul)
+  with hx show ?thesis unfolding im_def by blast
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/polynomial.thy

@@ -0,0 +1,534 @@
+theory polynomial
+  imports Main
+begin
+
+
+
+
+
+
+datatype mynat = Nat_O | Nat_S mynat
+
+fun mynat_add :: "mynat \<Rightarrow> mynat \<Rightarrow> mynat" where
+  "mynat_add Nat_O m = m"
+| "mynat_add (Nat_S n') m = Nat_S (mynat_add n' m)"
+
+lemma mynat_add_O_left: "mynat_add Nat_O m = m"
+  by simp
+
+lemma mynat_add_S_left: "mynat_add (Nat_S n) m = Nat_S (mynat_add n m)"
+  by simp
+
+inductive mynat_le :: "mynat \<Rightarrow> mynat \<Rightarrow> bool" where
+  le_n : "mynat_le n n"
+| le_S : "mynat_le n m \<Longrightarrow> mynat_le n (Nat_S m)"
+
+lemma mynat_zero_le: "mynat_le Nat_O n"
+  by (induction n) (auto intro: mynat_le.intros)
+
+lemma mynat_add_zero_r: "mynat_add n Nat_O = n"
+  by (induction n) auto
+
+lemma mynat_succ_le_succ: "mynat_le n m \<Longrightarrow> mynat_le (Nat_S n) (Nat_S m)"
+  by (induction rule: mynat_le.induct) (auto intro: mynat_le.intros)
+
+lemma mynat_add_S_r: "mynat_add m (Nat_S n) = Nat_S (mynat_add m n)"
+  by (induction m) auto
+
+lemma mynat_add_comm: "mynat_add n m = mynat_add m n"
+  by (induction n) (auto simp: mynat_add_zero_r mynat_add_S_r)
+
+
+
+
+
+datatype 'a mylist = NilL | ConsL 'a "'a mylist"
+
+inductive InL :: "'a \<Rightarrow> 'a mylist \<Rightarrow> bool" where
+  In_head : "InL x (ConsL x xs)"
+| In_tail : "InL x xs \<Longrightarrow> InL x (ConsL y xs)"
+
+inductive NoDupL :: "'a mylist \<Rightarrow> bool" where
+  ND_nil  : "NoDupL NilL"
+| ND_cons : "\<not> InL x xs \<Longrightarrow> NoDupL xs \<Longrightarrow> NoDupL (ConsL x xs)"
+
+fun lengthL :: "'a mylist \<Rightarrow> mynat" where
+  "lengthL NilL = Nat_O"
+| "lengthL (ConsL _ rest) = Nat_S (lengthL rest)"
+
+
+
+
+
+locale polynomial_setup =
+  fixes zero_r :: "'r"
+    and one_r  :: "'r"
+    and opp_r  :: "'r \<Rightarrow> 'r"
+    and add_r  :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl \<open>+R\<close> 65)
+    and mul_r  :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"  (infixl \<open>*R\<close> 70)
+    and zero_p :: "'p"
+    and one_p  :: "'p"
+    and opp_p  :: "'p \<Rightarrow> 'p"
+    and add_p  :: "'p \<Rightarrow> 'p \<Rightarrow> 'p"  (infixl \<open>+P\<close> 65)
+    and mul_p  :: "'p \<Rightarrow> 'p \<Rightarrow> 'p"  (infixl \<open>*P\<close> 70)
+    and degree   :: "'p \<Rightarrow> mynat"
+    and monomial :: "mynat \<Rightarrow> 'r \<Rightarrow> 'p"
+    and eval     :: "'p \<Rightarrow> 'r \<Rightarrow> 'r"
+  assumes
+    r_one_neq_zero  : "one_r \<noteq> zero_r"
+  and r_add_comm    : "\<And>x y.   x +R y = y +R x"
+  and r_add_assoc   : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+  and r_add_zero    : "\<And>x.     x +R zero_r = x"
+  and r_add_opp     : "\<And>x.     x +R opp_r x = zero_r"
+  and r_mul_comm    : "\<And>x y.   x *R y = y *R x"
+  and r_mul_assoc   : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+  and r_mul_one     : "\<And>x.     x *R one_r = x"
+  and r_dist_l      : "\<And>x y z. x *R (y +R z) = (x *R y) +R (x *R z)"
+  and r_mul_zero    : "\<And>x.     x *R zero_r = zero_r"
+  and r_no_zero_div : "\<And>x y.   x *R y = zero_r \<Longrightarrow> x = zero_r \<or> y = zero_r"
+  and p_one_neq_zero : "one_p \<noteq> zero_p"
+  and p_add_comm    : "\<And>x y.   x +P y = y +P x"
+  and p_add_assoc   : "\<And>x y z. (x +P y) +P z = x +P (y +P z)"
+  and p_add_zero    : "\<And>x.     x +P zero_p = x"
+  and p_add_opp     : "\<And>x.     x +P opp_p x = zero_p"
+  and p_mul_comm    : "\<And>x y.   x *P y = y *P x"
+  and p_mul_assoc   : "\<And>x y z. (x *P y) *P z = x *P (y *P z)"
+  and p_mul_one     : "\<And>x.     x *P one_p = x"
+  and p_dist_l      : "\<And>x y z. x *P (y +P z) = (x *P y) +P (x *P z)"
+  and p_mul_zero    : "\<And>x.     x *P zero_p = zero_p"
+  and p_no_zero_div : "\<And>x y.   x *P y = zero_p \<Longrightarrow> x = zero_p \<or> y = zero_p"
+  and deg_zero      : "degree zero_p = Nat_O"
+  and eval_add      : "\<And>p q x. eval (p +P q) x = eval p x +R eval q x"
+  and eval_mul      : "\<And>p q x. eval (p *P q) x = eval p x *R eval q x"
+  and eval_C_ax     : "\<And>c x.   eval (monomial Nat_O c) x = c"
+  and eval_X_ax     : "\<And>x.     eval (monomial (Nat_S Nat_O) one_r) x = x"
+  and deg_C_ax      : "\<And>c.     c \<noteq> zero_r \<Longrightarrow> degree (monomial Nat_O c) = Nat_O"
+  and deg_constant  : "\<And>p.     (degree p = Nat_O) \<longleftrightarrow> (\<exists>c. p = monomial Nat_O c)"
+  and deg_X_minus_ax : "\<And>a.    degree (monomial (Nat_S Nat_O) one_r +P monomial Nat_O (opp_r a)) = Nat_S Nat_O"
+  and deg_mul       : "\<And>p q.   p \<noteq> zero_p \<Longrightarrow> q \<noteq> zero_p \<Longrightarrow>
+                                 degree (p *P q) = mynat_add (degree p) (degree q)"
+  and C_zero_ax     : "monomial Nat_O zero_r = zero_p"
+  and C_one_ax      : "monomial Nat_O one_r = one_p"
+  and euclid_X_minus_ax :
+       "\<And>p a. \<exists>q r.
+          p = q *P (monomial (Nat_S Nat_O) one_r +P monomial Nat_O (opp_r a)) +P r
+          \<and> degree r = Nat_O"
+begin
+
+
+
+
+
+definition X :: "'p" where
+  "X = monomial (Nat_S Nat_O) one_r"
+
+definition C :: "'r \<Rightarrow> 'p" where
+  "C c = monomial Nat_O c"
+
+definition X_minus :: "'r \<Rightarrow> 'p" where
+  "X_minus a = X +P C (opp_r a)"
+
+fun poly_of_roots :: "'r mylist \<Rightarrow> 'p" where
+  "poly_of_roots NilL = one_p"
+| "poly_of_roots (ConsL a xs) = X_minus a *P poly_of_roots xs"
+
+definition is_root :: "'r \<Rightarrow> 'p \<Rightarrow> bool" where
+  "is_root a p \<longleftrightarrow> eval p a = zero_r"
+
+
+
+
+
+lemma X_minus_unfold:
+  "X_minus a = monomial (Nat_S Nat_O) one_r +P monomial Nat_O (opp_r a)"
+  unfolding X_minus_def X_def C_def by simp
+
+lemma eval_C: "eval (C c) x = c"
+  unfolding C_def by (rule eval_C_ax)
+
+lemma eval_X: "eval X x = x"
+  unfolding X_def by (rule eval_X_ax)
+
+lemma deg_X_minus: "degree (X_minus a) = Nat_S Nat_O"
+  by (simp only: X_minus_unfold deg_X_minus_ax)
+
+lemma C_zero: "C zero_r = zero_p"
+  unfolding C_def by (rule C_zero_ax)
+
+lemma C_one: "C one_r = one_p"
+  unfolding C_def by (rule C_one_ax)
+
+lemma deg_C: "c \<noteq> zero_r \<Longrightarrow> degree (C c) = Nat_O"
+  unfolding C_def by (rule deg_C_ax)
+
+lemma euclid_X_minus: "\<exists>q r. p = q *P X_minus a +P r \<and> degree r = Nat_O"
+  using euclid_X_minus_ax[of p a]
+  by (simp only: X_minus_unfold)
+
+
+
+
+
+lemma r_opp_add: "opp_r x +R x = zero_r"
+  by (metis r_add_comm r_add_opp)
+
+lemma r_add_zero_l: "zero_r +R x = x"
+  by (metis r_add_comm r_add_zero)
+
+
+
+
+
+lemma sub_eq_zero_l: "x +R opp_r y = zero_r \<Longrightarrow> x = y"
+proof -
+  assume h: "x +R opp_r y = zero_r"
+  have opp_cancel: "opp_r y +R y = zero_r"
+    by (metis r_add_comm r_add_opp)
+  have "x = x +R zero_r"
+    by (simp only: r_add_zero)
+  also have "\<dots> = x +R (opp_r y +R y)"
+    by (simp only: opp_cancel)
+  also have "\<dots> = (x +R opp_r y) +R y"
+    by (simp only: r_add_assoc)
+  also have "\<dots> = zero_r +R y"
+    by (simp only: h)
+  also have "\<dots> = y +R zero_r"
+    by (simp only: r_add_comm)
+  also have "\<dots> = y"
+    by (simp only: r_add_zero)
+  finally show "x = y" .
+qed
+
+
+
+
+
+lemma eval_X_minus: "eval (X_minus a) b = b +R opp_r a"
+  unfolding X_minus_def
+  by (simp only: eval_add eval_X eval_C)
+
+
+
+
+
+lemma X_minus_nonzero: "X_minus a \<noteq> zero_p"
+proof
+  assume h: "X_minus a = zero_p"
+  have hdeg: "degree (X_minus a) = Nat_S Nat_O" by (rule deg_X_minus)
+  have h1: "degree zero_p = Nat_S Nat_O" by (simp only: h[symmetric] hdeg)
+  then show False using deg_zero by simp
+qed
+
+
+
+
+
+lemma p_add_zero_l: "zero_p +P x = x"
+  by (metis p_add_comm p_add_zero)
+
+lemma p_mul_zero_l: "zero_p *P x = zero_p"
+  by (metis p_mul_comm p_mul_zero)
+
+lemma p_mul_one_l: "one_p *P x = x"
+  by (metis p_mul_comm p_mul_one)
+
+
+
+
+
+lemma root_factor: "is_root a p \<Longrightarrow> \<exists>q. p = q *P X_minus a"
+proof -
+  assume hp: "is_root a p"
+  obtain q r where heq: "p = q *P X_minus a +P r" and hdeg: "degree r = Nat_O"
+    using euclid_X_minus[of p a] by blast
+
+  have hr0: "eval r a = zero_r"
+  proof -
+    have hpz: "eval p a = zero_r"
+      using hp unfolding is_root_def .
+    have h1: "eval (q *P X_minus a) a +R eval r a = zero_r"
+      using hpz by (simp only: heq eval_add)
+    have h2: "eval (q *P X_minus a) a = eval q a *R zero_r"
+      by (simp only: eval_mul eval_X_minus r_add_opp)
+    have h3: "eval (q *P X_minus a) a = zero_r"
+      by (simp only: h2 r_mul_zero)
+    have h4: "zero_r +R eval r a = zero_r"
+      by (rule h1[simplified h3])
+    show ?thesis using h4[simplified r_add_zero_l] .
+  qed
+
+  obtain c where hc: "r = monomial Nat_O c"
+    using deg_constant[of r] hdeg by blast
+
+  have hcz: "c = zero_r"
+    using hr0 by (simp only: hc eval_C_ax)
+
+  have hrz: "r = zero_p"
+    by (simp only: hc hcz C_zero_ax)
+
+  show "\<exists>q. p = q *P X_minus a"
+    by (rule exI[of _ q], simp only: heq hrz p_add_zero)
+qed
+
+
+
+
+
+lemma root_transfer:
+  "p = q *P X_minus a \<Longrightarrow> b \<noteq> a \<Longrightarrow> is_root b p \<Longrightarrow> is_root b q"
+proof -
+  assume hp:  "p = q *P X_minus a"
+  assume hba: "b \<noteq> a"
+  assume hpb: "is_root b p"
+  have h_zero: "eval q b *R eval (X_minus a) b = zero_r"
+    using hpb unfolding is_root_def hp by (simp only: eval_mul)
+  have hxb: "eval (X_minus a) b = b +R opp_r a"
+    by (rule eval_X_minus)
+  have hmul: "eval q b *R (b +R opp_r a) = zero_r"
+    by (metis h_zero hxb)
+  have hdisj: "eval q b = zero_r \<or> b +R opp_r a = zero_r"
+    by (rule r_no_zero_div[OF hmul])
+  show "is_root b q" unfolding is_root_def
+  proof (rule ccontr)
+    assume hne: "eval q b \<noteq> zero_r"
+    have hba': "b +R opp_r a = zero_r" using hdisj hne by blast
+    have "b = a" by (rule sub_eq_zero_l[OF hba'])
+    then show False using hba by blast
+  qed
+qed
+
+
+
+
+
+lemma roots_le_degree:
+  "NoDupL xs \<Longrightarrow> (\<forall>a. InL a xs \<longrightarrow> is_root a p) \<Longrightarrow> p \<noteq> zero_p \<Longrightarrow>
+   mynat_le (lengthL xs) (degree p)"
+proof (induction xs arbitrary: p)
+  case NilL
+  show ?case by (simp only: lengthL.simps, rule mynat_zero_le)
+next
+  case (ConsL x xs)
+  from ConsL.prems(1) have hnd_tl: "NoDupL xs" and hnotin: "\<not> InL x xs"
+    by (auto elim: NoDupL.cases)
+  have InLx: "InL x (ConsL x xs)" by (rule InL.In_head)
+  have ha: "is_root x p"
+    using ConsL.prems(2)[rule_format, OF InLx] .
+  obtain q where hpq: "p = q *P X_minus x"
+    using root_factor[OF ha] by blast
+  have qnz: "q \<noteq> zero_p"
+  proof
+    assume hq: "q = zero_p"
+    have "p = zero_p"
+      by (simp only: hpq hq p_mul_zero_l)
+    then show False using ConsL.prems(3) by blast
+  qed
+  have hdeg: "degree p = Nat_S (degree q)"
+  proof -
+    have hxnz: "X_minus x \<noteq> zero_p" by (rule X_minus_nonzero)
+    have hmul: "degree (q *P X_minus x) = mynat_add (degree q) (degree (X_minus x))"
+      by (rule deg_mul[OF qnz hxnz])
+    have hxd: "degree (X_minus x) = Nat_S Nat_O" by (rule deg_X_minus)
+    have h1: "degree p = mynat_add (degree q) (Nat_S Nat_O)"
+      by (simp only: hpq hmul hxd)
+    show ?thesis
+      by (simp only: h1 mynat_add_S_r mynat_add_zero_r)
+  qed
+  have hF: "\<forall>b. InL b xs \<longrightarrow> is_root b q"
+  proof (intro allI impI)
+    fix b assume hb: "InL b xs"
+    have hba: "b \<noteq> x" using hb hnotin by blast
+    have hbroot: "is_root b p"
+      using ConsL.prems(2) InL.In_tail[OF hb] by blast
+    show "is_root b q"
+      by (rule root_transfer[OF hpq hba hbroot])
+  qed
+  have ihRes: "mynat_le (lengthL xs) (degree q)"
+    by (rule ConsL.IH[OF hnd_tl hF qnz])
+  show ?case
+    by (simp only: lengthL.simps hdeg, rule mynat_succ_le_succ[OF ihRes])
+qed
+
+
+
+
+
+lemma constant_root_zero:
+  "degree p = Nat_O \<Longrightarrow> is_root a p \<Longrightarrow> p = zero_p"
+proof -
+  assume hdeg: "degree p = Nat_O"
+  assume hroot: "is_root a p"
+  obtain c where hc: "p = monomial Nat_O c"
+    using deg_constant[of p] hdeg by blast
+  have hcz: "c = zero_r"
+    using hroot unfolding is_root_def hc by (simp only: eval_C_ax)
+  show "p = zero_p"
+    by (simp only: hc hcz C_zero_ax)
+qed
+
+
+
+
+
+lemma root_of_product:
+  "is_root a (p *P q) \<Longrightarrow> is_root a p \<or> is_root a q"
+proof -
+  assume h: "is_root a (p *P q)"
+  have hmul: "eval p a *R eval q a = zero_r"
+    using h unfolding is_root_def by (simp only: eval_mul)
+  have hdisj: "eval p a = zero_r \<or> eval q a = zero_r"
+    by (rule r_no_zero_div[OF hmul])
+  then show "is_root a p \<or> is_root a q"
+    unfolding is_root_def by blast
+qed
+
+
+
+
+
+lemma root_scale_constant:
+  "c \<noteq> zero_r \<Longrightarrow> (is_root a p \<longleftrightarrow> is_root a (C c *P p))"
+proof -
+  assume hc: "c \<noteq> zero_r"
+  show "is_root a p \<longleftrightarrow> is_root a (C c *P p)"
+  proof
+    assume hp: "is_root a p"
+    have hpa0: "eval p a = zero_r" using hp unfolding is_root_def .
+    have hmul: "c *R eval p a = zero_r"
+      by (simp only: hpa0 r_mul_zero)
+    show "is_root a (C c *P p)"
+      unfolding is_root_def
+      by (simp only: eval_mul eval_C hmul)
+  next
+    assume hcp: "is_root a (C c *P p)"
+    have hmul: "c *R eval p a = zero_r"
+      using hcp unfolding is_root_def by (simp only: eval_mul eval_C)
+    have hdisj: "c = zero_r \<or> eval p a = zero_r"
+      by (rule r_no_zero_div[OF hmul])
+    show "is_root a p" unfolding is_root_def
+      using hdisj hc by blast
+  qed
+qed
+
+
+
+
+
+lemma poly_of_roots_nonzero: "poly_of_roots xs \<noteq> zero_p"
+proof (induction xs)
+  case NilL
+  show ?case by (simp only: poly_of_roots.simps, rule p_one_neq_zero)
+next
+  case (ConsL a xs)
+  show ?case
+  proof
+    assume h: "poly_of_roots (ConsL a xs) = zero_p"
+    have h': "X_minus a *P poly_of_roots xs = zero_p"
+    proof -
+      have heq: "poly_of_roots (ConsL a xs) = X_minus a *P poly_of_roots xs"
+        by (simp only: poly_of_roots.simps)
+      show ?thesis using heq h by simp
+    qed
+    have hdisj: "X_minus a = zero_p \<or> poly_of_roots xs = zero_p"
+      by (rule p_no_zero_div[OF h'])
+    from hdisj show False
+    proof
+      assume "X_minus a = zero_p" then show False using X_minus_nonzero by blast
+    next
+      assume "poly_of_roots xs = zero_p" then show False using ConsL.IH by blast
+    qed
+  qed
+qed
+
+
+
+
+
+lemma deg_poly_of_roots: "degree (poly_of_roots xs) = lengthL xs"
+proof (induction xs)
+  case NilL
+  have h1: "poly_of_roots NilL = one_p" by simp
+  have h2: "degree one_p = Nat_O"
+    by (simp only: C_one_ax[symmetric] deg_C_ax[OF r_one_neq_zero])
+  show ?case by (simp only: h1 h2 lengthL.simps)
+next
+  case (ConsL a xs)
+  have hx: "X_minus a \<noteq> zero_p" by (rule X_minus_nonzero)
+  have hp: "poly_of_roots xs \<noteq> zero_p" by (rule poly_of_roots_nonzero)
+  have hmul: "degree (X_minus a *P poly_of_roots xs) =
+              mynat_add (degree (X_minus a)) (degree (poly_of_roots xs))"
+    by (rule deg_mul[OF hx hp])
+  have hxd: "degree (X_minus a) = Nat_S Nat_O" by (rule deg_X_minus)
+  have hrec: "degree (poly_of_roots xs) = lengthL xs" by (rule ConsL.IH)
+  show ?case
+    by (simp only: poly_of_roots.simps hmul hxd hrec mynat_add.simps lengthL.simps)
+qed
+
+
+
+
+
+lemma root_factor_list:
+  "NoDupL xs \<Longrightarrow> (\<forall>a. InL a xs \<longrightarrow> is_root a p) \<Longrightarrow>
+   \<exists>q. p = q *P poly_of_roots xs"
+proof (induction xs arbitrary: p)
+  case NilL
+  show ?case
+    by (rule exI[of _ p], simp only: poly_of_roots.simps p_mul_one)
+next
+  case (ConsL a xs)
+  from ConsL.prems(1) have hnd': "NoDupL xs" and hnotin: "\<not> InL a xs"
+    by (auto elim: NoDupL.cases)
+  have InLa: "InL a (ConsL a xs)" by (rule InL.In_head)
+  have ha: "is_root a p" using ConsL.prems(2)[rule_format, OF InLa] .
+  obtain r where hpr: "p = r *P X_minus a"
+    using root_factor[OF ha] by blast
+  have hF: "\<forall>b. InL b xs \<longrightarrow> is_root b r"
+  proof (intro allI impI)
+    fix b assume hb: "InL b xs"
+    have hba: "b \<noteq> a" using hb hnotin by blast
+    have hbroot: "is_root b p" using ConsL.prems(2) InL.In_tail[OF hb] by blast
+    show "is_root b r" by (rule root_transfer[OF hpr hba hbroot])
+  qed
+  obtain q where hrq: "r = q *P poly_of_roots xs"
+    using ConsL.IH[of r, OF hnd' hF] by blast
+  show ?case
+  proof (rule exI[of _ q])
+    have step1: "p = (q *P poly_of_roots xs) *P X_minus a"
+      by (simp only: hpr hrq)
+    have step2: "(q *P poly_of_roots xs) *P X_minus a =
+                  q *P (poly_of_roots xs *P X_minus a)"
+      by (simp only: p_mul_assoc)
+    have step3: "poly_of_roots xs *P X_minus a = X_minus a *P poly_of_roots xs"
+      by (simp only: p_mul_comm)
+    have step4: "X_minus a *P poly_of_roots xs = poly_of_roots (ConsL a xs)"
+      by (simp only: poly_of_roots.simps)
+    show "p = q *P poly_of_roots (ConsL a xs)"
+      by (simp only: step1 step2 step3 step4)
+  qed
+qed
+
+
+
+
+
+lemma degree_factorisation:
+  "p = q *P poly_of_roots xs \<Longrightarrow> q \<noteq> zero_p \<Longrightarrow>
+   degree p = mynat_add (degree q) (lengthL xs)"
+proof -
+  assume hp: "p = q *P poly_of_roots xs"
+  assume hq: "q \<noteq> zero_p"
+  have hz: "poly_of_roots xs \<noteq> zero_p" by (rule poly_of_roots_nonzero)
+  have h1: "degree p = degree (q *P poly_of_roots xs)"
+    by (simp only: hp)
+  have h2: "degree (q *P poly_of_roots xs) = mynat_add (degree q) (degree (poly_of_roots xs))"
+    by (rule deg_mul[OF hq hz])
+  have h3: "degree (poly_of_roots xs) = lengthL xs"
+    by (rule deg_poly_of_roots)
+  show ?thesis
+    by (simp only: h1 h2 h3)
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/probability.thy

@@ -0,0 +1,479 @@
+theory probability
+  imports Main
+begin
+
+datatype 'a mylist = NilL | ConsL 'a "'a mylist"
+
+primrec mapL :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a mylist \<Rightarrow> 'b mylist" where
+  "mapL f NilL        = NilL"
+| "mapL f (ConsL x xs) = ConsL (f x) (mapL f xs)"
+
+primrec fold_addL :: "('a \<Rightarrow> 'a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a mylist \<Rightarrow> 'a" where
+  "fold_addL add z NilL        = z"
+| "fold_addL add z (ConsL x xs) = add x (fold_addL add z xs)"
+
+inductive InL :: "'a \<Rightarrow> 'a mylist \<Rightarrow> bool" where
+  In_head : "InL x (ConsL x xs)"
+| In_tail : "InL x xs \<Longrightarrow> InL x (ConsL y xs)"
+
+inductive NoDupL :: "'a mylist \<Rightarrow> bool" where
+  ND_nil  : "NoDupL NilL"
+| ND_cons : "\<lbrakk>\<not> InL x xs; NoDupL xs\<rbrakk> \<Longrightarrow> NoDupL (ConsL x xs)"
+
+type_synonym 'a event = "'a \<Rightarrow> bool"
+
+definition ev_false :: "'a event" where "ev_false \<equiv> \<lambda>_. False"
+definition ev_true  :: "'a event" where "ev_true  \<equiv> \<lambda>_. True"
+definition ev_inter :: "'a event \<Rightarrow> 'a event \<Rightarrow> 'a event"
+  where "ev_inter A B \<equiv> \<lambda>\<omega>. A \<omega> \<and> B \<omega>"
+definition ev_union :: "'a event \<Rightarrow> 'a event \<Rightarrow> 'a event"
+  where "ev_union A B \<equiv> \<lambda>\<omega>. A \<omega> \<or> B \<omega>"
+definition ev_compl :: "'a event \<Rightarrow> 'a event"
+  where "ev_compl A \<equiv> \<lambda>\<omega>. \<not> A \<omega>"
+definition ev_diff  :: "'a event \<Rightarrow> 'a event \<Rightarrow> 'a event"
+  where "ev_diff A B \<equiv> \<lambda>\<omega>. A \<omega> \<and> \<not> B \<omega>"
+
+definition disjoint :: "'a event \<Rightarrow> 'a event \<Rightarrow> bool"
+  where "disjoint A B \<equiv> \<forall>\<omega>. \<not> (A \<omega> \<and> B \<omega>)"
+
+fun pairwise_disjoint :: "('a event) mylist \<Rightarrow> bool" where
+  "pairwise_disjoint NilL = True"
+| "pairwise_disjoint (ConsL _ NilL) = True"
+| "pairwise_disjoint (ConsL A (ConsL B xs)) =
+     (disjoint A B \<and>
+      (\<forall>C. InL C (ConsL B xs) \<longrightarrow> disjoint A C) \<and>
+      pairwise_disjoint (ConsL B xs))"
+
+primrec bigUnion :: "('a event) mylist \<Rightarrow> 'a event" where
+  "bigUnion NilL         = ev_false"
+| "bigUnion (ConsL A xs) = ev_union A (bigUnion xs)"
+
+
+
+lemma ev_inter_comm:
+  "\<forall>\<omega>. ev_inter A B \<omega> \<longleftrightarrow> ev_inter B A \<omega>"
+  unfolding ev_inter_def by blast
+
+lemma ev_union_comm:
+  "\<forall>\<omega>. ev_union A B \<omega> \<longleftrightarrow> ev_union B A \<omega>"
+  unfolding ev_union_def by blast
+
+lemma ev_inter_assoc:
+  "\<forall>\<omega>. ev_inter (ev_inter A B) C \<omega> \<longleftrightarrow> ev_inter A (ev_inter B C) \<omega>"
+  unfolding ev_inter_def by blast
+
+lemma ev_union_assoc:
+  "\<forall>\<omega>. ev_union (ev_union A B) C \<omega> \<longleftrightarrow> ev_union A (ev_union B C) \<omega>"
+  unfolding ev_union_def by blast
+
+lemma ev_inter_distrib_left:
+  "\<forall>\<omega>. ev_inter A (ev_union B C) \<omega> \<longleftrightarrow> ev_union (ev_inter A B) (ev_inter A C) \<omega>"
+  unfolding ev_inter_def ev_union_def by blast
+
+
+lemma disjoint_bigUnion:
+  "(\<forall>C. InL C xs \<longrightarrow> disjoint A C) \<Longrightarrow> disjoint A (bigUnion xs)"
+proof (induction xs)
+  case NilL
+  show ?case by (simp add: disjoint_def ev_false_def)
+next
+  case (ConsL B xs)
+  have hB: "disjoint A B"
+    using ConsL.prems In_head[of B xs] by blast
+  have hxs: "\<forall>C. InL C xs \<longrightarrow> disjoint A C"
+    using ConsL.prems by (blast intro: In_tail)
+  have hIH: "disjoint A (bigUnion xs)"
+    by (rule ConsL.IH[OF hxs])
+  show ?case
+    using hB hIH
+    by (metis disjoint_def ev_inter_def ev_union_def bigUnion.simps(2))
+qed
+
+locale probability_setup =
+  fixes zero one :: "'r"
+    and add       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "+R" 65)
+    and opp       :: "'r \<Rightarrow> 'r"
+    and mul       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "*R" 70)
+    and prob      :: "('a \<Rightarrow> bool) \<Rightarrow> 'r"
+    and cprob     :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'r"
+
+  assumes
+    add_comm      : "\<And>x y.   x +R y = y +R x"
+    and add_assoc : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and add_zero  : "\<And>x.     x +R zero = x"
+    and add_opp   : "\<And>x.     x +R opp x = zero"
+    and mul_comm  : "\<And>x y.   x *R y = y *R x"
+    and mul_assoc : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+    and mul_one   : "\<And>x.     x *R one = x"
+    and dist_l    : "\<And>x y z. x *R (y +R z) = (x *R y) +R (x *R z)"
+    and mul_zero  : "\<And>x.     x *R zero = zero"
+    and opp_zero  : "opp zero = zero"
+    and opp_opp   : "\<And>x.     opp (opp x) = x"
+    and opp_mul_right : "\<And>x y. x *R opp y = opp (x *R y)"
+    and opp_mul_left  : "\<And>x y. opp x *R y = opp (x *R y)"
+
+    and prob_ext  : "\<And>A B. (\<forall>\<omega>. A \<omega> \<longleftrightarrow> B \<omega>) \<Longrightarrow> prob A = prob B"
+    and prob_false_ax : "prob ev_false = zero"
+    and prob_true_ax  : "prob ev_true  = one"
+    and prob_union_ax :
+          "\<And>A B. prob (ev_union A B) =
+           prob A +R (prob B +R opp (prob (ev_inter A B)))"
+    and prob_compl_ax : "\<And>A. prob (ev_compl A) = one +R opp (prob A)"
+    and cprob_mul     : "\<And>A B. prob (ev_inter A B) = cprob A B *R prob B"
+    and prob_union_disjoint :
+          "\<And>A B. disjoint A B \<Longrightarrow>
+           prob (ev_union A B) = prob A +R prob B"
+    and disjoint_head_tail :
+          "\<And>A xs. pairwise_disjoint (ConsL A xs) \<Longrightarrow>
+           disjoint A (bigUnion xs)"
+    and indep_compl_both_ax :
+          "\<And>A B. prob (ev_inter A B) = prob A *R prob B \<Longrightarrow>
+           prob (ev_inter (ev_compl A) (ev_compl B)) =
+           prob (ev_compl A) *R prob (ev_compl B)"
+    and inclusion_exclusion_three :
+          "\<And>A B C.
+           prob (ev_union (ev_union A B) C) =
+           prob A +R (prob B +R (prob C +R
+             opp (prob (ev_inter A B) +R
+                  (prob (ev_inter A C) +R
+                   (prob (ev_inter B C) +R
+                    opp (prob (ev_inter (ev_inter A B) C)))))))"
+begin
+
+
+
+
+
+lemma zero_add: "zero +R x = x"
+  using add_comm[of zero x] add_zero[of x] by simp
+
+lemma add_opp_comm: "opp x +R x = zero"
+  using add_opp[of x] add_comm[of x "opp x"] by simp
+
+
+lemma sub_of_eq: "a = b +R c \<Longrightarrow> c = a +R opp b"
+proof -
+  assume h: "a = b +R c"
+  have "a +R opp b = (b +R c) +R opp b" by (simp only: h)
+  also have "\<dots> = b +R (c +R opp b)" by (rule add_assoc)
+  also have "\<dots> = b +R (opp b +R c)"
+    by (simp only: add_comm[of c "opp b"])
+  also have "\<dots> = (b +R opp b) +R c" by (rule add_assoc[symmetric])
+  also have "\<dots> = zero +R c" by (simp only: add_opp)
+  also have "\<dots> = c +R zero" by (rule add_comm)
+  also have "\<dots> = c" by (rule add_zero)
+  finally show ?thesis by (rule sym)
+qed
+
+
+
+
+
+definition indep :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool"
+  where "indep A B \<equiv> prob (ev_inter A B) = prob A *R prob B"
+
+
+
+
+
+lemma prob_union_comm:
+  "prob (ev_union A B) = prob (ev_union B A)"
+  by (rule prob_ext) (auto simp: ev_union_def)
+
+lemma prob_union_idem:
+  "prob (ev_union A A) = prob A"
+proof -
+  have hcap: "prob (ev_inter A A) = prob A"
+    by (rule prob_ext) (simp add: ev_inter_def)
+  have "prob (ev_union A A) =
+        prob A +R (prob A +R opp (prob A))"
+    by (simp only: prob_union_ax hcap)
+  also have "\<dots> = prob A +R zero" by (simp only: add_opp)
+  also have "\<dots> = prob A"        by (rule add_zero)
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma prob_diff:
+  "prob (ev_diff A B) = prob A +R opp (prob (ev_inter A B))"
+proof -
+  have heq_diff: "prob (ev_diff A B) = prob (ev_inter A (ev_compl B))"
+    by (rule prob_ext) (simp add: ev_diff_def ev_inter_def ev_compl_def)
+  have hdisjoint: "disjoint (ev_inter A B) (ev_inter A (ev_compl B))"
+    unfolding disjoint_def ev_inter_def ev_compl_def by blast
+  have hpart: "\<forall>\<omega>. A \<omega> \<longleftrightarrow> ev_union (ev_inter A B) (ev_inter A (ev_compl B)) \<omega>"
+    unfolding ev_union_def ev_inter_def ev_compl_def by blast
+  have hsumA: "prob A = prob (ev_inter A B) +R prob (ev_inter A (ev_compl B))"
+  proof -
+    have h1: "prob A = prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B)))"
+      by (rule prob_ext) (rule hpart)
+    show ?thesis by (simp only: h1, rule prob_union_disjoint[OF hdisjoint])
+  qed
+  have hsub: "prob (ev_inter A (ev_compl B)) = prob A +R opp (prob (ev_inter A B))"
+    by (rule sub_of_eq[OF hsumA])
+  show ?thesis by (simp only: heq_diff hsub)
+qed
+
+
+
+
+
+lemma bayes_symm:
+  "cprob A B *R prob B = cprob B A *R prob A"
+proof -
+  have h1: "cprob A B *R prob B = prob (ev_inter A B)"
+    by (rule cprob_mul[symmetric])
+  have h2: "prob (ev_inter A B) = prob (ev_inter B A)"
+    by (rule prob_ext) (rule ev_inter_comm)
+  have h3: "prob (ev_inter B A) = cprob B A *R prob A"
+    by (rule cprob_mul)
+  show ?thesis by (simp only: h1 h2 h3)
+qed
+
+
+
+
+
+lemma law_total_prob:
+  "prob A =
+   cprob A B *R prob B +R cprob A (ev_compl B) *R prob (ev_compl B)"
+proof -
+  have hpart: "\<forall>\<omega>. A \<omega> \<longleftrightarrow> ev_union (ev_inter A B) (ev_inter A (ev_compl B)) \<omega>"
+    unfolding ev_union_def ev_inter_def ev_compl_def by blast
+  have hdisjoint: "disjoint (ev_inter A B) (ev_inter A (ev_compl B))"
+    unfolding disjoint_def ev_inter_def ev_compl_def by blast
+  have hsumA: "prob A = prob (ev_inter A B) +R prob (ev_inter A (ev_compl B))"
+  proof -
+    have h1: "prob A = prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B)))"
+      by (rule prob_ext) (rule hpart)
+    show ?thesis by (simp only: h1, rule prob_union_disjoint[OF hdisjoint])
+  qed
+  have h1: "prob (ev_inter A B) = cprob A B *R prob B"
+    by (rule cprob_mul)
+  have h2: "prob (ev_inter A (ev_compl B)) = cprob A (ev_compl B) *R prob (ev_compl B)"
+    by (rule cprob_mul)
+  show ?thesis by (simp only: hsumA h1 h2)
+qed
+
+
+
+
+
+lemma prob_union_indep:
+  "indep A B \<Longrightarrow>
+   prob (ev_union A B) =
+   prob A +R (prob B +R opp (prob A *R prob B))"
+proof -
+  assume hI: "indep A B"
+  have hIeq: "prob (ev_inter A B) = prob A *R prob B"
+    using hI unfolding indep_def .
+  show ?thesis by (simp only: prob_union_ax hIeq)
+qed
+
+
+
+
+
+lemma indep_symm: "indep A B \<Longrightarrow> indep B A"
+proof -
+  assume hI: "indep A B"
+  have hIeq: "prob (ev_inter A B) = prob A *R prob B"
+    using hI unfolding indep_def .
+  have hcap: "prob (ev_inter B A) = prob (ev_inter A B)"
+    by (rule prob_ext) (rule ev_inter_comm)
+  show "indep B A"
+    unfolding indep_def
+    by (simp only: hcap hIeq mul_comm)
+qed
+
+lemma indep_compl_right: "indep A B \<Longrightarrow> indep A (ev_compl B)"
+proof -
+  assume hI: "indep A B"
+  have hIeq: "prob (ev_inter A B) = prob A *R prob B"
+    using hI unfolding indep_def .
+
+  have h1: "prob (ev_inter A (ev_compl B)) = prob A +R opp (prob (ev_inter A B))"
+  proof -
+    have heq: "prob (ev_diff A B) = prob (ev_inter A (ev_compl B))"
+      by (rule prob_ext) (simp add: ev_diff_def ev_inter_def ev_compl_def)
+    show ?thesis using prob_diff by (simp only: heq[symmetric])
+  qed
+
+  have h2: "prob (ev_inter A (ev_compl B)) =
+            prob A +R opp (prob A *R prob B)"
+    by (simp only: h1 hIeq)
+
+  have halg: "prob A +R opp (prob A *R prob B) =
+              prob A *R prob (ev_compl B)"
+  proof -
+    have rhs_eq: "prob A *R prob (ev_compl B) =
+                  prob A +R opp (prob A *R prob B)"
+    proof -
+      have "prob A *R prob (ev_compl B) = prob A *R (one +R opp (prob B))"
+        by (simp only: prob_compl_ax)
+      also have "\<dots> = prob A *R one +R prob A *R opp (prob B)"
+        by (rule dist_l)
+      also have "\<dots> = prob A +R prob A *R opp (prob B)"
+        by (simp only: mul_one)
+      also have "\<dots> = prob A +R opp (prob A *R prob B)"
+        by (simp only: opp_mul_right)
+      finally show ?thesis .
+    qed
+    show ?thesis by (rule rhs_eq[symmetric])
+  qed
+  show "indep A (ev_compl B)"
+    unfolding indep_def by (simp only: h2 halg)
+qed
+
+lemma indep_compl_left: "indep A B \<Longrightarrow> indep (ev_compl A) B"
+proof -
+  assume hI: "indep A B"
+  have hBA  : "indep B A"             by (rule indep_symm[OF hI])
+  have hBcA : "indep B (ev_compl A)"  by (rule indep_compl_right[OF hBA])
+  show ?thesis                         by (rule indep_symm[OF hBcA])
+qed
+
+lemma indep_compl_both: "indep A B \<Longrightarrow> indep (ev_compl A) (ev_compl B)"
+  unfolding indep_def
+  by (rule indep_compl_both_ax)
+
+
+
+
+
+lemma prob_bigUnion_disjoint:
+  "pairwise_disjoint xs \<Longrightarrow>
+   prob (bigUnion xs) = fold_addL (+R) zero (mapL prob xs)"
+proof (induction xs)
+  case NilL
+  show ?case
+    by (simp add: prob_false_ax)
+next
+  case (ConsL A xs)
+  assume hpw: "pairwise_disjoint (ConsL A xs)"
+  show "prob (bigUnion (ConsL A xs)) = fold_addL (+R) zero (mapL prob (ConsL A xs))"
+  proof (cases xs)
+    case NilL
+    have hunion: "prob (ev_union A ev_false) = prob A"
+      by (rule prob_ext) (simp add: ev_union_def ev_false_def)
+    show ?thesis
+      by (simp add: NilL add_zero hunion)
+  next
+    case (ConsL B xs')
+
+    have hpw_exp: "disjoint A B \<and>
+                   (\<forall>C. InL C (ConsL B xs') \<longrightarrow> disjoint A C) \<and>
+                   pairwise_disjoint (ConsL B xs')"
+      using hpw by (simp add: ConsL)
+    have hpw' : "pairwise_disjoint (ConsL B xs')"
+      using hpw_exp by blast
+
+    have hAdisj: "disjoint A (bigUnion (ConsL B xs'))"
+    proof -
+      have "\<forall>C. InL C (ConsL B xs') \<longrightarrow> disjoint A C"
+        using hpw_exp by blast
+      from disjoint_bigUnion[OF this] show ?thesis .
+    qed
+
+    have hU: "prob (bigUnion (ConsL A (ConsL B xs'))) =
+              prob A +R prob (bigUnion (ConsL B xs'))"
+    proof -
+      have eq: "bigUnion (ConsL A (ConsL B xs')) =
+                ev_union A (bigUnion (ConsL B xs'))"
+        by simp
+      show ?thesis by (simp only: eq, rule prob_union_disjoint[OF hAdisj])
+    qed
+
+    have hIH: "prob (bigUnion (ConsL B xs')) =
+               fold_addL (+R) zero (mapL prob (ConsL B xs'))"
+    proof -
+      have hpw_xs: "pairwise_disjoint xs" by (simp add: ConsL hpw')
+      from ConsL.IH[OF hpw_xs] show ?thesis by (simp add: ConsL)
+    qed
+    show ?thesis
+      by (simp only: ConsL hU hIH mapL.simps fold_addL.simps)
+  qed
+qed
+
+
+
+
+
+lemma prob_bigUnion_disjoint_zero:
+  "pairwise_disjoint xs \<Longrightarrow>
+   (\<forall>A. InL A xs \<longrightarrow> prob A = zero) \<Longrightarrow>
+   prob (bigUnion xs) = zero"
+proof (induction xs)
+  case NilL
+  show ?case by (simp add: prob_false_ax)
+next
+  case (ConsL A xs)
+  assume hpw   : "pairwise_disjoint (ConsL A xs)"
+  assume hzero : "\<forall>B. InL B (ConsL A xs) \<longrightarrow> prob B = zero"
+  show "prob (bigUnion (ConsL A xs)) = zero"
+  proof (cases xs)
+    case NilL
+    have hA0: "prob A = zero" using hzero In_head[of A xs] by blast
+    have hunion: "prob (ev_union A ev_false) = prob A"
+      by (rule prob_ext) (simp add: ev_union_def ev_false_def)
+    show ?thesis by (simp add: NilL hunion hA0)
+  next
+    case (ConsL B xs')
+    have hpw_exp: "disjoint A B \<and>
+                   (\<forall>C. InL C (ConsL B xs') \<longrightarrow> disjoint A C) \<and>
+                   pairwise_disjoint (ConsL B xs')"
+      using hpw by (simp add: ConsL)
+    then obtain hpw' where hpw': "pairwise_disjoint (ConsL B xs')"
+      by blast
+    have hAdisj: "disjoint A (bigUnion (ConsL B xs'))"
+    proof -
+      have "\<forall>C. InL C (ConsL B xs') \<longrightarrow> disjoint A C"
+        using hpw_exp by blast
+      from disjoint_bigUnion[OF this] show ?thesis .
+    qed
+    have hA0: "prob A = zero"
+      using hzero In_head[of A xs] by blast
+    have htailzero: "\<forall>C. InL C (ConsL B xs') \<longrightarrow> prob C = zero"
+    proof (intro allI impI)
+      fix C
+      assume hC: "InL C (ConsL B xs')"
+      have "InL C (ConsL A (ConsL B xs'))"
+        by (rule In_tail[OF hC])
+      then show "prob C = zero"
+        using hzero ConsL by blast
+    qed
+    have htail0: "prob (bigUnion (ConsL B xs')) = zero"
+    proof -
+      have hpw_xs: "pairwise_disjoint xs"
+        using hpw' by (simp add: ConsL)
+      have hzero_xs: "\<And>C. InL C xs \<Longrightarrow> prob C = zero"
+        using htailzero by (simp add: ConsL)
+      have hzero_xs_obj: "\<forall>C. InL C xs \<longrightarrow> prob C = zero"
+        using hzero_xs by blast
+      have "prob (bigUnion xs) = zero"
+        using ConsL.IH[OF hpw_xs] hzero_xs_obj by blast
+      then show ?thesis by (simp add: ConsL)
+    qed
+    have hU: "prob (bigUnion (ConsL A (ConsL B xs'))) =
+              prob A +R prob (bigUnion (ConsL B xs'))"
+    proof -
+      have eq: "bigUnion (ConsL A (ConsL B xs')) =
+                ev_union A (bigUnion (ConsL B xs'))"
+        by simp
+      show ?thesis by (simp only: eq, rule prob_union_disjoint[OF hAdisj])
+    qed
+    have hfull0: "prob (bigUnion (ConsL A (ConsL B xs'))) = zero"
+      using hU hA0 htail0 by (simp add: add_zero)
+    have hfull0': "prob (ev_union A (ev_union B (bigUnion xs'))) = zero"
+      using hfull0 by simp
+    show ?thesis
+      by (simp add: ConsL hfull0')
+  qed
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/set_algebra.thy

@@ -0,0 +1,30 @@
+theory set_algebra
+  imports Main
+begin
+
+definition sUnion :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool)"
+  where "sUnion A B \<equiv> \<lambda>x. A x \<or> B x"
+
+definition sInter :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool)"
+  where "sInter A B \<equiv> \<lambda>x. A x \<and> B x"
+
+definition sCompl :: "('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool)"
+  where "sCompl A \<equiv> \<lambda>x. \<not> A x"
+
+lemma inter_distrib_left:
+  "\<forall>x. sInter A (sUnion B C) x \<longleftrightarrow> sUnion (sInter A B) (sInter A C) x"
+  unfolding sInter_def sUnion_def by blast
+
+lemma inter_distrib_right:
+  "\<forall>x. sInter (sUnion A B) C x \<longleftrightarrow> sUnion (sInter A C) (sInter B C) x"
+  unfolding sInter_def sUnion_def by blast
+
+lemma de_morgan_union:
+  "\<forall>x. sCompl (sUnion A B) x \<longleftrightarrow> sInter (sCompl A) (sCompl B) x"
+  unfolding sCompl_def sUnion_def sInter_def by blast
+
+lemma de_morgan_inter:
+  "\<forall>x. sCompl (sInter A B) x \<longleftrightarrow> sUnion (sCompl A) (sCompl B) x"
+  unfolding sCompl_def sInter_def sUnion_def by blast
+
+end

src_data/babel-formal/proofs/isabelle/supinf.thy

@@ -0,0 +1,255 @@
+theory supinf
+  imports Main
+begin
+
+locale complete_ordered_field =
+  fixes zero_nat  :: "'n"
+    and succ      :: "'n \<Rightarrow> 'n"
+    and nat_le    :: "'n \<Rightarrow> 'n \<Rightarrow> bool"
+    and zero one  :: "'r"
+    and add       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "+R" 65)
+    and mul       :: "'r \<Rightarrow> 'r \<Rightarrow> 'r"   (infixl "*R" 70)
+    and opp inv   :: "'r \<Rightarrow> 'r"
+    and rle       :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "\<le>R" 50)
+    and rlt       :: "'r \<Rightarrow> 'r \<Rightarrow> bool"  (infix "<R" 50)
+    and rabs      :: "'r \<Rightarrow> 'r"
+    and inr       :: "'n \<Rightarrow> 'r"
+  assumes nat_le_refl   : "\<And>n. nat_le n n"
+    and   le_succ_of_le : "\<And>n m. nat_le n m \<Longrightarrow> nat_le n (succ m)"
+    and   le_succ       : "\<And>n. nat_le n (succ n)"
+    and   add_comm      : "\<And>x y. x +R y = y +R x"
+    and   add_assoc     : "\<And>x y z. (x +R y) +R z = x +R (y +R z)"
+    and   add_zero      : "\<And>x. x +R zero = x"
+    and   add_opp       : "\<And>x. opp x +R x = zero"
+    and   mul_comm      : "\<And>x y. x *R y = y *R x"
+    and   mul_assoc     : "\<And>x y z. (x *R y) *R z = x *R (y *R z)"
+    and   mul_one       : "\<And>x. x *R one = x"
+    and   dist_l        : "\<And>x y z. x *R (y +R z) = (x *R y) +R (x *R z)"
+    and   sub_zero      : "\<And>x. x +R opp zero = x"
+    and   rle_refl      : "\<And>x. x \<le>R x"
+    and   rle_trans     : "\<And>x y z. x \<le>R y \<Longrightarrow> y \<le>R z \<Longrightarrow> x \<le>R z"
+    and   rle_antisym   : "\<And>x y. x \<le>R y \<Longrightarrow> y \<le>R x \<Longrightarrow> x = y"
+    and   rlt_def       : "\<And>x y. (x <R y) \<longleftrightarrow> (x \<le>R y \<and> x \<noteq> y)"
+    and   rle_abs       : "\<And>x. x +R opp zero \<le>R rabs x"
+    and   rinv_pos      : "\<And>x. zero <R x \<Longrightarrow> zero <R inv x"
+    and   rplus_le_compat_l : "\<And>x y z. y \<le>R z \<Longrightarrow> x +R y \<le>R x +R z"
+    and   rinv_involutive    : "\<And>x. zero <R x \<Longrightarrow> inv (inv x) = x"
+    and   inr_pos       : "\<And>n. zero <R inr (succ n)"
+    and   inr_le        : "\<And>m n. nat_le m n \<Longrightarrow> inr m \<le>R inr n"
+    and   inr_zero      : "inr zero_nat = zero"
+    and   inr_succ      : "\<And>n. inr (succ n) = inr n +R one"
+    and   rtotal_order  : "\<And>x y. (x <R y) \<or> x = y \<or> (y <R x)"
+    and   rle_inv_contravar :
+            "\<And>a b. zero <R a \<Longrightarrow> zero <R b \<Longrightarrow> a \<le>R b \<Longrightarrow> inv b \<le>R inv a"
+    and   eps_between   :
+            "\<And>x y. x <R y \<Longrightarrow> \<exists>eps. zero <R eps \<and> x +R eps <R y"
+    and   archimedean   : "\<And>x. \<exists>n. x \<le>R inr n"
+    and   completeness  :
+            "\<And>A. (\<exists>ub. \<forall>a. A a \<longrightarrow> ub \<le>R a) \<Longrightarrow>
+              \<exists>sup. (\<forall>a. A a \<longrightarrow> a \<le>R sup) \<and>
+                    (\<forall>y. (\<forall>a. A a \<longrightarrow> a \<le>R y) \<longrightarrow> sup \<le>R y)"
+begin
+
+
+
+
+
+lemma add_opp_r: "x +R opp x = zero"
+  using add_opp[of x] add_comm[of x "opp x"] by simp
+
+lemma rlt_le: "x <R y \<Longrightarrow> x \<le>R y"
+  using rlt_def by blast
+
+lemma rlt_ne: "x <R y \<Longrightarrow> x \<noteq> y"
+  using rlt_def by blast
+
+lemma rlt_intro: "x \<le>R y \<Longrightarrow> x \<noteq> y \<Longrightarrow> x <R y"
+  using rlt_def by blast
+
+
+
+
+
+definition up_bounds :: "('r \<Rightarrow> bool) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "up_bounds A x \<equiv> \<forall>a. A a \<longrightarrow> a \<le>R x"
+
+definition is_maximum :: "'r \<Rightarrow> ('r \<Rightarrow> bool) \<Rightarrow> bool"
+  where "is_maximum a A \<equiv> A a \<and> up_bounds A a"
+
+definition low_bounds :: "('r \<Rightarrow> bool) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "low_bounds A x \<equiv> \<forall>a. A a \<longrightarrow> x \<le>R a"
+
+definition is_inf :: "'r \<Rightarrow> ('r \<Rightarrow> bool) \<Rightarrow> bool"
+  where "is_inf x A \<equiv> is_maximum x (low_bounds A)"
+
+definition limit :: "('n \<Rightarrow> 'r) \<Rightarrow> 'r \<Rightarrow> bool"
+  where "limit u l \<equiv>
+    \<forall>eps. zero <R eps \<longrightarrow>
+      (\<exists>N. \<forall>n. nat_le N n \<longrightarrow> rabs (u n +R opp l) \<le>R eps)"
+
+
+
+
+
+lemma add_sub_cancel_r: "a +R (b +R opp a) = b"
+proof -
+  have "a +R (b +R opp a) = b +R (a +R opp a)"
+  proof -
+    have "a +R (b +R opp a) = (a +R b) +R opp a" by (rule add_assoc [symmetric])
+    also have "\<dots> = (b +R a) +R opp a"           by (simp add: add_comm)
+    also have "\<dots> = b +R (a +R opp a)"            by (rule add_assoc)
+    finally show ?thesis .
+  qed
+  also have "\<dots> = b +R zero" by (simp add: add_opp_r)
+  also have "\<dots> = b"         by (rule add_zero)
+  finally show ?thesis .
+qed
+
+
+
+
+
+lemma rabs_pos: "t \<le>R rabs t"
+  using rle_abs[of t] sub_zero[of t] by simp
+
+
+
+
+
+lemma unique_max:
+  assumes "is_maximum x A" "is_maximum y A"
+  shows "x = y"
+proof -
+  from assms(1) have hxA: "A x" and hx: "up_bounds A x"
+    unfolding is_maximum_def by blast+
+  from assms(2) have hyA: "A y" and hy: "up_bounds A y"
+    unfolding is_maximum_def by blast+
+  have "x \<le>R y" using hy hxA unfolding up_bounds_def by blast
+  have "y \<le>R x" using hx hyA unfolding up_bounds_def by blast
+  show ?thesis by (rule rle_antisym) fact+
+qed
+
+
+
+
+
+lemma inf_lt:
+  assumes hinf: "is_inf x A" and hlt: "x <R y"
+  shows "\<exists>a. A a \<and> a <R y"
+proof (rule ccontr)
+  assume hnex: "\<not> (\<exists>a. A a \<and> a <R y)"
+  from hinf have hxlb : "low_bounds A x"
+           and  hmax  : "\<And>z. low_bounds A z \<Longrightarrow> z \<le>R x"
+    unfolding is_inf_def is_maximum_def up_bounds_def by blast+
+  have hlby: "low_bounds A y"
+    unfolding low_bounds_def
+  proof (intro allI impI)
+    fix a assume ha: "A a"
+    from hnex have not_lt: "\<not> (a <R y)" using ha by blast
+    show "y \<le>R a"
+      using rtotal_order[of y a] rlt_le rle_refl not_lt by blast
+  qed
+  have hyx: "y \<le>R x" by (rule hmax[OF hlby])
+  have hxy: "x \<le>R y" using hlt rlt_le by blast
+  have "x = y" by (rule rle_antisym) fact+
+  moreover have "x \<noteq> y" using hlt rlt_ne by blast
+  ultimately show False by blast
+qed
+
+
+
+
+
+lemma le_of_le_add_eps:
+  assumes H: "\<forall>eps. zero <R eps \<longrightarrow> y \<le>R x +R eps"
+  shows "y \<le>R x"
+proof (rule ccontr)
+  assume hne: "\<not> y \<le>R x"
+  have hgt: "x <R y"
+    using rtotal_order[of x y] hne rlt_le rle_refl by blast
+  obtain eps where heps: "zero <R eps" and hxp: "x +R eps <R y"
+    using eps_between[OF hgt] by blast
+  have hyle  : "y \<le>R x +R eps"      using H heps by blast
+  have hxple : "x +R eps \<le>R y"      using hxp rlt_le by blast
+  have heq   : "x +R eps = y"        by (rule rle_antisym) fact+
+  have hneq  : "x +R eps \<noteq> y"       using hxp rlt_ne by blast
+  from heq hneq show False by blast
+qed
+
+
+
+
+
+lemma le_lim:
+  assumes hlim : "limit u x"
+      and hle  : "\<forall>n. y \<le>R u n"
+  shows "y \<le>R x"
+proof -
+  have key : "\<forall>eps. zero <R eps \<longrightarrow> y \<le>R x +R eps"
+  proof (intro allI impI)
+    fix eps assume heps: "zero <R eps"
+    from hlim heps obtain N
+      where HN: "\<forall>n. nat_le N n \<longrightarrow> rabs (u n +R opp x) \<le>R eps"
+      unfolding limit_def by blast
+    have hyuN : "y \<le>R u N" using hle by blast
+    have heq  : "x +R (u N +R opp x) = u N"
+      using add_sub_cancel_r[of x "u N"] by (simp add: add_comm)
+    have huNx : "u N \<le>R x +R (u N +R opp x)"
+      by (subst heq; rule rle_refl)
+    have hepN : "rabs (u N +R opp x) \<le>R eps"
+      using HN nat_le_refl[of N] by blast
+    have hchain : "u N +R opp x \<le>R eps"
+      by (rule rle_trans[OF rabs_pos hepN])
+    have hcompat : "x +R (u N +R opp x) \<le>R x +R eps"
+      by (rule rplus_le_compat_l[OF hchain])
+    have huNxeps : "u N \<le>R x +R eps"
+      by (rule rle_trans[OF huNx hcompat])
+    show "y \<le>R x +R eps"
+      by (rule rle_trans[OF hyuN huNxeps])
+  qed
+  show ?thesis by (rule le_of_le_add_eps[OF key])
+qed
+
+
+
+
+
+lemma inv_succ_pos: "zero <R inv (inr (succ n))"
+  by (rule rinv_pos[OF inr_pos])
+
+
+
+
+
+lemma limit_inv_succ:
+  assumes heps: "zero <R eps"
+  shows "\<exists>N. \<forall>n. nat_le N n \<longrightarrow> inv (inr (succ n)) \<le>R eps"
+proof -
+  define x where "x \<equiv> inv eps"
+  have hx_pos: "zero <R x" unfolding x_def by (rule rinv_pos[OF heps])
+  obtain N where harch: "x \<le>R inr N" using archimedean by blast
+  define N1 where "N1 \<equiv> succ N"
+  show ?thesis
+  proof (intro exI[of _ N1] allI impI)
+    fix n assume hn: "nat_le N1 n"
+    have hINR_le: "inr N1 \<le>R inr (succ n)"
+      by (rule inr_le, rule le_succ_of_le[OF hn])
+    have hINR_pos: "zero <R inr (succ n)" by (rule inr_pos)
+    have hINR_N_pos: "zero <R inr N1" unfolding N1_def by (rule inr_pos)
+    have step1: "inv (inr (succ n)) \<le>R inv (inr N1)"
+      by (rule rle_inv_contravar[OF hINR_N_pos hINR_pos hINR_le])
+    have harch1: "x \<le>R inr N1"
+      unfolding N1_def
+      using rle_trans[OF harch inr_le[OF le_succ[of N]]] .
+    have step2: "inv (inr N1) \<le>R inv x"
+      by (rule rle_inv_contravar[OF hx_pos hINR_N_pos harch1])
+    have step3: "inv x = eps"
+      unfolding x_def by (rule rinv_involutive[OF heps])
+    show "inv (inr (succ n)) \<le>R eps"
+      using rle_trans[OF step1 step2] step3 by simp
+  qed
+qed
+
+end
+
+end

src_data/babel-formal/proofs/isabelle/zero_le_one_elem.thy

@@ -0,0 +1,65 @@
+theory zero_le_one_elem
+  imports Main
+begin
+
+locale zero_le_one_setup =
+  fixes decEq      :: "'m \<Rightarrow> 'm \<Rightarrow> bool"
+    and zero       :: "'a"
+    and one        :: "'a"
+    and le         :: "'a \<Rightarrow> 'a \<Rightarrow> bool"   (infix "\<preceq>" 50)
+    and le_antisym :: "'a \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool"
+  assumes le_refl      : "\<And>x. x \<preceq> x"
+    and   le_trans     : "\<And>x y z. x \<preceq> y \<Longrightarrow> y \<preceq> z \<Longrightarrow> x \<preceq> z"
+    and   zero_le_one  : "zero \<preceq> one"
+    and   zero_le_zero : "zero \<preceq> zero"
+    and   le_antisym   : "\<And>x y. x \<preceq> y \<Longrightarrow> y \<preceq> x \<Longrightarrow> x = y"
+begin
+
+definition One_matrix :: "'m \<Rightarrow> 'm \<Rightarrow> 'a"
+  where "One_matrix i j \<equiv> if decEq i j then one else zero"
+
+definition Zero_matrix :: "'m \<Rightarrow> 'm \<Rightarrow> 'a"
+  where "Zero_matrix \<equiv> \<lambda>_ _. zero"
+
+definition matrix_le :: "('m \<Rightarrow> 'm \<Rightarrow> 'a) \<Rightarrow> ('m \<Rightarrow> 'm \<Rightarrow> 'a) \<Rightarrow> bool"
+  where "matrix_le A B \<equiv> \<forall>i j. A i j \<preceq> B i j"
+
+definition matrix_eq :: "('m \<Rightarrow> 'm \<Rightarrow> 'a) \<Rightarrow> ('m \<Rightarrow> 'm \<Rightarrow> 'a) \<Rightarrow> bool"
+  where "matrix_eq A B \<equiv> \<forall>i j. A i j = B i j"
+
+lemma zero_le_one_elem: "zero \<preceq> One_matrix i j"
+  unfolding One_matrix_def
+  by (simp add: zero_le_one zero_le_zero)
+
+lemma Zero_le_One_matrix: "matrix_le Zero_matrix One_matrix"
+  unfolding matrix_le_def Zero_matrix_def
+  by (simp add: zero_le_one_elem)
+
+lemma matrix_le_refl: "matrix_le A A"
+  unfolding matrix_le_def
+  by (simp add: le_refl)
+
+lemma matrix_le_trans: "matrix_le A B \<Longrightarrow> matrix_le B C \<Longrightarrow> matrix_le A C"
+  unfolding matrix_le_def
+  using le_trans by blast
+
+lemma matrix_eq_refl: "matrix_eq A A"
+  unfolding matrix_eq_def by simp
+
+lemma matrix_eq_sym: "matrix_eq A B \<Longrightarrow> matrix_eq B A"
+  unfolding matrix_eq_def by simp
+
+lemma matrix_eq_trans: "matrix_eq A B \<Longrightarrow> matrix_eq B C \<Longrightarrow> matrix_eq A C"
+  unfolding matrix_eq_def by simp
+
+lemma matrix_eq_le: "matrix_eq A B \<Longrightarrow> matrix_le A B \<and> matrix_le B A"
+  unfolding matrix_eq_def matrix_le_def
+  using le_refl by auto
+
+lemma matrix_le_antisymm: "matrix_le A B \<Longrightarrow> matrix_le B A \<Longrightarrow> matrix_eq A B"
+  unfolding matrix_le_def matrix_eq_def
+  using le_antisym by blast
+
+end
+
+end

src_data/babel-formal/proofs/lean4/circle_average.lean

@@ -0,0 +1,142 @@
+class AddMonoid (R : Type) where
+  zero      : R
+  add       : R → R → R
+  add_zero  : ∀ x, add x zero = x
+  add_comm  : ∀ x y, add x y = add y x
+  add_assoc : ∀ x y z, add (add x y) z = add x (add y z)
+
+namespace CircleAverage
+variable {R : Type} [AddMonoid R]
+
+axiom integral       : (R → R) → R
+axiom integral_ext   : ∀ (g h : R → R), (∀ θ, g θ = h θ) → integral g = integral h
+axiom integral_const : ∀ (c : R), integral (fun _ => c) = c
+axiom integral_add   : ∀ (f g : R → R),
+  integral (fun θ => AddMonoid.add (f θ) (g θ)) =
+  AddMonoid.add (integral f) (integral g)
+axiom integral_shift : ∀ (f : R → R) (c : R),
+  integral (fun θ => f (AddMonoid.add θ c)) = integral f
+
+def circleMap (c θ : R) : R := AddMonoid.add θ c
+noncomputable def circleAverage (f : R → R) (c : R) : R :=
+  integral (fun θ => f (circleMap c θ))
+
+theorem circleMap_zero (θ : R) :
+  circleMap AddMonoid.zero θ = θ := by
+  dsimp [circleMap]
+  rw [AddMonoid.add_zero]
+
+theorem circleAverage_zero (f : R → R) :
+  circleAverage f AddMonoid.zero = integral f := by
+  dsimp [circleAverage]
+  apply integral_ext; intro θ
+  dsimp [circleMap]
+  rw [AddMonoid.add_zero]
+
+theorem circleAverage_add (f g : R → R) (c : R) :
+  circleAverage (fun z => AddMonoid.add (f z) (g z)) c =
+  AddMonoid.add (circleAverage f c) (circleAverage g c) := by
+  dsimp [circleAverage]
+  rw [integral_add]
+
+theorem circleAverage_fun_add (f : R → R) (c : R) :
+  circleAverage (fun z => f (AddMonoid.add z c)) AddMonoid.zero =
+  circleAverage f c := by
+  dsimp [circleAverage, circleMap]
+  apply integral_ext; intro θ
+  rw [AddMonoid.add_comm]
+  rw [←AddMonoid.add_assoc]
+  rw [AddMonoid.add_zero]
+  rw [AddMonoid.add_comm]
+
+theorem circleMap_add (c d θ : R) :
+  circleMap (AddMonoid.add c d) θ =
+  circleMap c (circleMap d θ) := by
+  dsimp [circleMap]
+  rw [AddMonoid.add_comm c d]
+  rw [AddMonoid.add_assoc]
+
+theorem circleAverage_shift (f : R → R) (c d : R) :
+  circleAverage f (AddMonoid.add c d) =
+  circleAverage (fun z => f (AddMonoid.add z d)) c := by
+  dsimp [circleAverage]
+  apply integral_ext; intro θ
+  dsimp [circleMap]
+  rw [AddMonoid.add_assoc]
+
+theorem circleAverage_const (k c : R) :
+  circleAverage (fun _ => k) c = k := by
+  dsimp [circleAverage]
+  rw [integral_const]
+
+theorem circleAverage_add_const (f : R → R) (k c : R) :
+  circleAverage (fun z => AddMonoid.add (f z) k) c =
+  AddMonoid.add (circleAverage f c) k := by
+  dsimp [circleAverage]
+  rw [integral_add]
+  rw [integral_const]
+
+theorem circleAverage_comm_add (f g : R → R) (c : R) :
+  circleAverage (fun z => AddMonoid.add (f z) (g z)) c =
+  circleAverage (fun z => AddMonoid.add (g z) (f z)) c := by
+  dsimp [circleAverage]
+  apply integral_ext; intro θ
+  dsimp [circleMap]
+  rw [AddMonoid.add_comm]
+
+theorem circleAverage_add_assoc (f g h : R → R) (c : R) :
+  circleAverage (fun z => AddMonoid.add (AddMonoid.add (f z) (g z)) (h z)) c =
+  AddMonoid.add (circleAverage f c)
+              (AddMonoid.add (circleAverage g c) (circleAverage h c)) := by
+  dsimp [circleAverage]
+  rw [integral_add]
+  rw [integral_add]
+  rw [AddMonoid.add_assoc]
+
+theorem circleAverage_center_comm (f : R → R) (c d : R) :
+  circleAverage f (AddMonoid.add c d) =
+  circleAverage f (AddMonoid.add d c) := by
+  dsimp [circleAverage, circleMap]
+  apply integral_ext; intro θ
+  simp [AddMonoid.add_comm]
+
+theorem circleAverage_center_independent (f : R → R) (c : R) :
+  circleAverage f c = integral f := by
+  dsimp [circleAverage]
+  apply integral_shift
+
+theorem circleAverage_center_eq (f : R → R) (c d : R) :
+  circleAverage f c = circleAverage f d := by
+  have h1 := circleAverage_center_independent f c
+  have h2 := circleAverage_center_independent f d
+  exact Eq.trans h1 (Eq.symm h2)
+
+theorem circleAverage_idempotent (f : R → R) (c : R) :
+  circleAverage (fun z => circleAverage f z) c = circleAverage f c := by
+  dsimp [circleAverage]
+  have h1 := by
+    apply integral_ext; intro θ
+    apply circleAverage_center_independent f (circleMap c θ)
+  have h2 := integral_const (integral f)
+  have h3 := circleAverage_center_independent f c
+  exact Eq.trans (Eq.trans h1 h2) (Eq.symm h3)
+
+theorem circleAverage_of_zero_integral (f : R → R) (c : R) (H : integral f = AddMonoid.zero) :
+  circleAverage f c = AddMonoid.zero := by
+  rw [circleAverage_center_independent f c]
+  exact H
+
+theorem circleAverage_linear (f g : R → R) (c : R) :
+  circleAverage (fun z => AddMonoid.add (f z) (g z)) c =
+  AddMonoid.add (circleAverage f c) (circleAverage g c) := by
+  dsimp [circleAverage]
+  rw [integral_add]
+
+theorem circleAverage_shift_commute (f : R → R) (c d : R) :
+  circleAverage (fun z => f (circleMap d z)) c =
+  circleAverage f (AddMonoid.add c d) := by
+  dsimp [circleAverage, circleMap]
+  apply integral_ext; intro θ
+  rw [AddMonoid.add_assoc]
+
+end CircleAverage

src_data/babel-formal/proofs/lean4/comp_commute.lean

@@ -0,0 +1,69 @@
+universe u v w
+
+namespace CompCommute
+
+variable {α : Type u} {β : Type v} {γ : Type w}
+
+def comp {α β γ} (g : β → γ) (f : α → β) : α → γ := fun x => g (f x)
+def id {α} : α → α := fun x => x
+
+axiom comp_assoc : ∀ {α β γ δ} (h : γ → δ) (g : β → γ) (f : α → β), comp h (comp g f) = comp (comp h g) f
+axiom comp_id_l  : ∀ {α β} (f : α → β), comp (id) f = f
+axiom comp_id_r  : ∀ {α β} (f : α → β), comp f id = f
+
+def commute {α} (f g : α → α) : Prop := comp f g = comp g f
+
+theorem commute_symm {α} (f g : α → α) : commute f g → commute g f :=
+by
+  intro H
+  have : comp f g = comp g f := H
+  have Hsym : comp g f = comp f g := by
+    exact Eq.symm this
+  exact Hsym
+
+theorem commute_with_id_l {α} (f : α → α) : commute f (id) :=
+by
+  unfold commute
+  have H1 : comp f id = f := comp_id_r f
+  have H2 : comp id f = f := comp_id_l f
+  have : comp f id = comp id f := by
+    simp [H1, H2]
+  exact this
+
+theorem commute_with_id_r {α} (f : α → α) : commute (id) f :=
+by
+  unfold commute
+  have H1 : comp id f = f := comp_id_l f
+  have H2 : comp f id = f := comp_id_r f
+  have : comp id f = comp f id := by
+    simp [H1, H2]
+  exact this
+
+theorem commute_refl {α} (f : α → α) : commute f f :=
+by
+  unfold commute
+  rfl
+
+theorem commute_congr {α} (f1 f2 g1 g2 : α → α) :
+  f1 = f2 → g1 = g2 → commute f1 g1 → commute f2 g2 :=
+by
+  intro Hf Hg Hc
+  subst Hf
+  subst Hg
+  exact Hc
+
+theorem commute_transport_left_id {α} (f g : α → α) :
+  commute f g → commute (comp (id) f) g :=
+by
+  intro H
+  unfold commute at *
+  simpa [comp_id_l] using H
+
+theorem commute_transport_right_id {α} (f g : α → α) :
+  commute f g → commute f (comp (id) g) :=
+by
+  intro H
+  unfold commute at *
+  simpa [comp_id_l] using H
+
+end CompCommute

src_data/babel-formal/proofs/lean4/galois.lean

@@ -0,0 +1,208 @@
+class Field (F : Type) where
+  zero_F    : F
+  one_F     : F
+  add_F     : F → F → F
+  mul_F     : F → F → F
+  opp_F     : F → F
+  inv_F     : F → F
+
+  add_comm    : ∀ x y, add_F x y = add_F y x
+  add_assoc   : ∀ x y z, add_F (add_F x y) z = add_F x (add_F y z)
+  add_zero    : ∀ x, add_F x zero_F = x
+  add_inv_l   : ∀ x, add_F (opp_F x) x = zero_F
+
+  mul_comm    : ∀ x y, mul_F x y = mul_F y x
+  mul_assoc   : ∀ x y z, mul_F (mul_F x y) z = mul_F x (mul_F y z)
+  mul_one_l   : ∀ x, mul_F one_F x = x
+  mul_inv_l   : ∀ x, x ≠ zero_F → mul_F (inv_F x) x = one_F
+
+  distrib_l   : ∀ x y z, mul_F x (add_F y z) = add_F (mul_F x y) (mul_F x z)
+
+  zero_neq_one : zero_F ≠ one_F
+  inv_nonzero  : ∀ x, x ≠ zero_F → inv_F x ≠ zero_F
+
+namespace FieldProperties
+variable {F : Type} [HF : Field F]
+open Field
+
+infixl:65 "+" => add_F
+infixl:70 "*" => mul_F
+prefix:100 "-" => opp_F
+prefix:100 "/" => inv_F
+
+theorem add_cancel_l (x y z : F) : x + y = x + z → y = z := by
+  intro H
+  have H₁ := congrArg (fun w => -x + w) H
+  change -x + (x+y) = -x + (x+z) at H₁
+  rw [← add_assoc]       at H₁
+  rw [add_inv_l]         at H₁
+  rw [add_comm]          at H₁
+  rw [add_zero]          at H₁
+  rw [<- add_assoc, add_comm, add_inv_l]          at H₁
+  rw [add_zero]          at H₁
+  exact H₁
+
+theorem add_cancel_r (x y z : F) : y + x = z + x → y = z := by
+  intro H
+  rw [add_comm y x, add_comm z x] at H
+  apply add_cancel_l
+  assumption
+
+theorem mul_cancel_l (x y z : F) (h : x ≠ zero_F) : x * y = x * z → y = z := by
+  intro H
+  have H₁ := congrArg (fun w => inv_F x * w) H
+  change inv_F x * (x * y) = inv_F x * (x * z) at H₁
+
+  rw [← mul_assoc]        at H₁
+  rw [mul_inv_l _ h]      at H₁
+  rw [mul_one_l]          at H₁
+  rw [← mul_assoc]        at H₁
+  rw [mul_inv_l _ h]      at H₁
+  rw [mul_one_l]          at H₁
+
+  exact H₁
+
+theorem mul_cancel_r (x y z : F) (h : x ≠ zero_F) : y * x = z * x → y = z := by
+  intro H
+  rw [mul_comm y x, mul_comm z x] at H
+  apply mul_cancel_l x y z h
+  assumption
+
+theorem inv_unique (x y : F) (h : x ≠ zero_F) (H : x * y = one_F) : y = inv_F x := by
+  have H₁ := congrArg (fun w => inv_F x * w) H
+  change inv_F x * (x * y) = inv_F x * one_F at H₁
+  rw [← mul_assoc]    at H₁
+  rw [mul_inv_l _ h]  at H₁
+  rw [mul_one_l]      at H₁
+  rw [mul_comm]       at H₁
+  rw [mul_one_l]      at H₁
+  exact H₁
+
+theorem inv_involutive (x : F) (h : x ≠ zero_F) : inv_F (inv_F x) = x := by
+  apply Eq.symm
+  apply inv_unique
+  · exact inv_nonzero x h
+  · exact mul_inv_l x h
+
+end FieldProperties
+
+class IsSolvable (G : Type) : Prop
+
+namespace Tower
+variable {polynomial      : Type → Type}
+variable {SplittingField  : ∀ {F : Type}, polynomial F → Type}
+variable {algebraMap      : ∀ {F K : Type}, F → K}
+variable {Splits          : ∀ {F K : Type}, polynomial F → (F → K) → Prop}
+variable {map_poly        : ∀ {F K : Type}, polynomial F → (F → K) → polynomial K}
+variable {Gal             : ∀ {F : Type}, polynomial F → Type}
+
+variable {F : Type}
+variable (p q r s t : polynomial F)
+variable (K L : Type)
+
+axiom map_poly_comp : ∀ {F K L : Type} (p : polynomial F)
+  (f : F → K) (g : K → L), map_poly (map_poly p f) g = map_poly p (fun x => g (f x))
+axiom isSolvable_of_isScalarTower : ∀ {F K : Type} {p q : polynomial F},
+  IsSolvable (Gal p) → IsSolvable (Gal (map_poly q (@algebraMap F K))) → IsSolvable (Gal q)
+axiom isSolvable_map_poly : ∀ {F K : Type} (p : polynomial F),
+  IsSolvable (Gal p) → IsSolvable (Gal (map_poly p (@algebraMap F K)))
+axiom isSolvable_of_splits : ∀ {F K : Type} (p : polynomial F) (f : F → K),
+  Splits p f → IsSolvable (Gal p)
+
+theorem gal_isSolvable_tower
+  (hp : IsSolvable (Gal p))
+  (hq : IsSolvable (Gal (map_poly q (@algebraMap F (SplittingField p))))) :
+  IsSolvable (Gal q) := by
+  apply isSolvable_of_isScalarTower hp hq
+
+theorem gal_isSolvable_double_tower
+  (hp : IsSolvable (Gal p))
+  (hq : IsSolvable (Gal (map_poly q (@algebraMap F (SplittingField p)))))
+  (hr : IsSolvable (Gal (map_poly r (@algebraMap F (SplittingField q))))) :
+  IsSolvable (Gal r) := by
+  have Hq := isSolvable_of_isScalarTower hp hq
+  apply isSolvable_of_isScalarTower Hq hr
+
+theorem gal_isSolvable_triple_tower
+  (hp : IsSolvable (Gal p))
+  (hq : IsSolvable (Gal (map_poly q (@algebraMap F (SplittingField p)))))
+  (hr : IsSolvable (Gal (map_poly r (@algebraMap F (SplittingField q)))))
+  (hs : IsSolvable (Gal (map_poly s (@algebraMap F (SplittingField r))))) :
+  IsSolvable (Gal s) := by
+  have Hq := isSolvable_of_isScalarTower hp hq
+  have Hr := isSolvable_of_isScalarTower Hq hr
+  apply isSolvable_of_isScalarTower Hr hs
+
+theorem gal_isSolvable_quadruple_tower
+  (hp : IsSolvable (Gal p))
+  (hq : IsSolvable (Gal (map_poly q (@algebraMap F (SplittingField p)))))
+  (hr : IsSolvable (Gal (map_poly r (@algebraMap F (SplittingField q)))))
+  (hs : IsSolvable (Gal (map_poly s (@algebraMap F (SplittingField r)))))
+  (ht : IsSolvable (Gal (map_poly t (@algebraMap F (SplittingField s))))) :
+  IsSolvable (Gal t) := by
+  have Hq := isSolvable_of_isScalarTower hp hq
+  have Hr := isSolvable_of_isScalarTower Hq hr
+  have Hs := isSolvable_of_isScalarTower Hr hs
+  apply isSolvable_of_isScalarTower Hs ht
+
+theorem gal_isSolvable_map_poly (hp : IsSolvable (Gal p)) :
+  IsSolvable (Gal (map_poly p (@algebraMap F K))) := by
+  apply isSolvable_map_poly p hp
+
+theorem gal_isSolvable_of_split
+  (hsplit : Splits p (@algebraMap F (SplittingField p))) :
+  IsSolvable (Gal p) := by
+  apply isSolvable_of_splits p (@algebraMap F (SplittingField p)) hsplit
+
+theorem gal_isSolvable_split_tower
+  (hsplit : Splits q (@algebraMap F (SplittingField p))) :
+  IsSolvable (Gal q) := by
+  apply isSolvable_of_splits q (@algebraMap F (SplittingField p)) hsplit
+
+theorem gal_isSolvable_two_step_map (hp : IsSolvable (Gal p)) :
+  IsSolvable (Gal (map_poly (map_poly p (@algebraMap F K)) (@algebraMap K L))) := by
+  apply isSolvable_map_poly
+  apply isSolvable_map_poly
+  exact hp
+
+theorem gal_isSolvable_three_step_map {M : Type}
+  (hp : IsSolvable (Gal p)) :
+  IsSolvable (Gal (map_poly (map_poly (map_poly p (@algebraMap F K))
+                                           (@algebraMap K L))
+                                 (@algebraMap L M))) := by
+  apply isSolvable_map_poly
+  apply isSolvable_map_poly
+  apply isSolvable_map_poly
+  exact hp
+
+theorem gal_isSolvable_map_poly_comp (hp : IsSolvable (Gal p)) :
+  IsSolvable (Gal (map_poly (map_poly p (@algebraMap F K)) (@algebraMap K L))) := by
+  apply isSolvable_map_poly
+  apply isSolvable_map_poly
+  exact hp
+
+theorem gal_isSolvable_mutual_split
+  (hsplit_p : Splits p (@algebraMap F (SplittingField q)))
+  (hsplit_q : Splits q (@algebraMap F (SplittingField p))) :
+  IsSolvable (Gal p) ∧ IsSolvable (Gal q) := by
+  constructor
+  · apply isSolvable_of_splits p (@algebraMap F (SplittingField q)) hsplit_p
+  · apply isSolvable_of_splits q (@algebraMap F (SplittingField p)) hsplit_q
+
+theorem gal_isSolvable_tower_split
+  (hsplit_q : Splits q (@algebraMap F (SplittingField p)))
+  (hr : IsSolvable (Gal (map_poly r (@algebraMap F (SplittingField q))))) :
+  IsSolvable (Gal r) := by
+  apply isSolvable_of_isScalarTower
+  · apply isSolvable_of_splits
+    exact hsplit_q
+  · exact hr
+
+theorem gal_isSolvable_map_after_split
+  (hsplit : Splits p (@algebraMap F (SplittingField p))) :
+  IsSolvable (Gal (map_poly p (@algebraMap F K))) := by
+  apply isSolvable_map_poly
+  apply isSolvable_of_splits
+  exact hsplit
+
+end Tower

src_data/babel-formal/proofs/lean4/graph_paths.lean

@@ -0,0 +1,68 @@
+universe u
+
+namespace GraphPath
+
+variable {V : Type u}
+
+def Edge (V : Type u) := V → V → Prop
+
+inductive Path (E : Edge V) : V → V → Prop
+| nil  : ∀ v, Path E v v
+| step : ∀ {u v w}, Path E u v → E v w → Path E u w
+
+
+variable {E : Edge V}
+
+theorem refl (v : V) : Path (E:=E) v v := Path.nil v
+
+theorem trans {u v w : V} : Path (E:=E) u v → Path (E:=E) v w → Path (E:=E) u w :=
+by
+  intro p1 p2; induction p2 with
+  | nil => simpa using p1
+  | step p2' evw ih => exact Path.step ih evw
+
+def Erev (E : Edge V) : Edge V := fun x y => E y x
+
+def undirected (E : Edge V) : Prop := ∀ x y, E x y → E y x
+
+theorem reverse_path {u v : V} (hE : undirected E) :
+  Path (E:=E) u v → Path (E:=E) v u :=
+by
+  intro p; induction p with
+  | nil => exact Path.nil _
+  | step p' evw ih =>
+      have hwv : Path (E:=E) _ _ := Path.step (E:=E) (Path.nil _) (hE _ _ evw)
+      exact trans (E:=E) hwv ih
+
+theorem concat_edge_right {u v w : V} :
+  Path (E:=E) u v → E v w → Path (E:=E) u w := by
+  intro p evw; exact Path.step p evw
+
+theorem concat {u v w : V} :
+  Path (E:=E) u v → Path (E:=E) v w → Path (E:=E) u w := by
+  intro p q; exact trans p q
+
+theorem edge_path {u v : V} : E u v → Path (E:=E) u v := by
+ intro euv; exact Path.step (Path.nil u) euv
+
+theorem concat_edge_left {u v w : V} :
+  E u v → Path (E:=E) v w → Path (E:=E) u w := by
+ intro euv pvw; exact trans (edge_path (E:=E) euv) pvw
+
+theorem concat3 {u v w t : V} :
+  Path (E:=E) u v → Path (E:=E) v w → Path (E:=E) w t → Path (E:=E) u t := by
+  intro puv pvw pwt; exact trans (trans puv pvw) pwt
+
+theorem reverse_in_Erev {u v : V} :
+  Path (E:=E) u v → Path (E:=Erev E) v u := by
+  intro p; induction p with
+  | nil => exact Path.nil _
+  | step p' evw ih =>
+      have hwv : Path (E:=Erev E) _ _ := Path.step (Path.nil _) evw
+      exact trans hwv ih
+
+theorem cycle_refl {v w : V} :
+  Path (E:=E) v w → Path (E:=E) w v → Path (E:=E) v v := by
+  intro pvw pwv; exact trans pvw pwv
+
+end GraphPath

src_data/babel-formal/proofs/lean4/group.lean

@@ -0,0 +1,173 @@
+class Group (G : Type) where
+  inv : G → G
+  one : G
+  mul : G → G → G
+  mul_assoc : ∀ a b c : G, mul a (mul b c) = mul (mul a b) c
+  mul_one   : ∀ a : G, mul a one = a
+  one_mul   : ∀ a : G, mul one a = a
+  mul_inv_l : ∀ a : G, mul (inv a) a = one
+  mul_inv_r : ∀ a : G, mul a (inv a) = one
+
+namespace Group
+
+infixl:70 " * " => Group.mul
+postfix:max "⁻¹" => Group.inv
+
+class GroupComm (G : Type) [Group G] where
+  mul_comm : ∀ a b : G, a * b = b * a
+
+section MulRotate
+  variable {G : Type} [Group G] [GroupComm G]
+
+  theorem mul_rotate' (a b c : G) : a * (b * c) = b * (c * a) := by
+    rw [GroupComm.mul_comm]
+    rw [← Group.mul_assoc]
+
+end MulRotate
+section GroupLemmas
+  variable {G : Type} [Group G]
+
+  theorem mul_left_cancel (a b c : G) (h : a * b = a * c) : b = c := by
+    have h' : a⁻¹ * (a * b) = a⁻¹ * (a * c) := by rw [h]
+    repeat rw [Group.mul_assoc] at h'
+    repeat rw [Group.mul_inv_l] at h'
+    repeat rw [Group.one_mul] at h'
+    exact h'
+
+  theorem mul_right_cancel (a b c : G) (h : b * a = c * a) : b = c := by
+    have h' : (b * a) * a⁻¹ = (c * a) * a⁻¹ := by rw [h]
+    repeat rw [← Group.mul_assoc] at h'
+    repeat rw [Group.mul_inv_r] at h'
+    repeat rw [Group.mul_one] at h'
+    exact h'
+
+  theorem inv_inv (a : G) : (a⁻¹)⁻¹ = a := by
+    have h : (a⁻¹)⁻¹ * a⁻¹ = a * a⁻¹ := by
+      rw [Group.mul_inv_l, Group.mul_inv_r]
+    exact mul_right_cancel _ _ _ h
+
+  theorem inv_mul (a b : G) : (a * b)⁻¹ = b⁻¹ * a⁻¹ := by
+    have h : (a * b)⁻¹ * (a * b) = (b⁻¹ * a⁻¹) * (a * b) := by
+      rw [Group.mul_inv_l]
+      repeat rw [← Group.mul_assoc]
+      rw [Group.mul_assoc (a⁻¹) a b]
+      rw [Group.mul_inv_l]
+      rw [Group.one_mul]
+      rw [Group.mul_inv_l]
+    exact mul_right_cancel _ _ _ h
+
+  theorem inv_eq_of_mul_eq_one (a b : G) (h : a * b = one) : b = a⁻¹ := by
+    have h' : a⁻¹ * (a * b) = a⁻¹ * one := by rw [h]
+    rw [Group.mul_assoc, Group.mul_inv_l, Group.one_mul, Group.mul_one] at h'
+    exact h'
+
+end GroupLemmas
+
+class Act (G : Type) (X : Type) [Group G] where
+  act : G → X → X
+  act_one : ∀ x : X, act one x = x
+  act_mul : ∀ g h : G, ∀ x : X, act (g * h) x = act g (act h x)
+
+
+section ActionLemmas
+  variable {G : Type} {X : Type}
+  [Group G] [Act G X]
+
+  infixr:73 " • " => Act.act
+
+  theorem act_inv (g : G) (x : X) : g⁻¹ • (g • x) = x := by
+    have h : (g⁻¹ * g) • x = x := by
+      rw [Group.mul_inv_l]
+      apply Act.act_one
+    rw [Act.act_mul] at h
+    exact h
+
+  theorem act_inv_r (g : G) (x : X) : g • (g⁻¹ • x) = x := by
+    have h : (g * g⁻¹) • x = x := by
+      rw [Group.mul_inv_r]
+      apply Act.act_one
+    rw [Act.act_mul] at h
+    exact h
+
+  def orbit {G : Type} {X : Type} [Group G] [Act G X] (x : X) : X → Prop :=
+    fun y => ∃ g : G, g • x = y
+
+  def stabilizer (x : X) : G → Prop := fun g => g • x = x
+
+  theorem orbit_refl
+    (x : X) : orbit (G:=G) x x := by
+    exists one
+    exact Act.act_one x
+
+  theorem orbit_sym (x y : X) (h : orbit (G:=G) x y) : orbit (G:=G) y x := by
+    rcases h with ⟨g, hg⟩
+    exists g⁻¹
+    rw [← hg, ← Act.act_mul, Group.mul_inv_l, Act.act_one]
+
+  theorem orbit_trans (x y z : X) (h1 : orbit (G:=G) x y) (h2 : orbit (G:=G) y z) : orbit (G:=G) x z := by
+    rcases h1 with ⟨g1, hg1⟩
+    rcases h2 with ⟨g2, hg2⟩
+    exists (g2 * g1)
+    rw [Act.act_mul, hg1, hg2]
+
+  theorem orbit_partition (x y : X) (hxy : orbit (G:=G) x y) (z : X) :
+      orbit (G:=G) x z ↔ orbit (G:=G) y z := by
+    constructor
+    · intro hz
+      rcases hxy with ⟨g1, hg1⟩
+      rcases hz with ⟨g2, hg2⟩
+      exists (g2 * g1⁻¹)
+      rw [Act.act_mul, ← hg1]
+      repeat rw [← Act.act_mul]
+      rw [← Group.mul_assoc, Group.mul_inv_l, Group.mul_one]
+      exact hg2
+    · intro hz
+      rcases hxy with ⟨g1, hg1⟩
+      rcases hz with ⟨g2, hg2⟩
+      exists (g2 * g1)
+      rw [Act.act_mul, hg1, hg2]
+
+  theorem stabilizer_mul (x : X) (g h : G)
+    (hg : stabilizer x g) (hh : stabilizer x h) : stabilizer x (g * h) := by
+    unfold stabilizer at *
+    rw [Act.act_mul, hh, hg]
+
+  theorem stabilizer_inv (x : X) (g : G) (hg : stabilizer x g) : stabilizer x g⁻¹ := by
+    dsimp [stabilizer] at *
+    calc
+      g⁻¹ • x = g⁻¹ • (g • x) := by rw [hg]
+      _ = (g⁻¹ * g) • x := by rw [Act.act_mul]
+      _ = x := by rw [mul_inv_l, Act.act_one]
+
+  theorem stabilizer_one (x : X) : stabilizer (G:=G) x one := by
+    unfold stabilizer
+    apply Act.act_one
+
+  theorem stabilizer_conjugate (x : X) (g h : G)
+    (hh : stabilizer x h) : stabilizer (g • x) (g * h * g⁻¹) := by
+    unfold stabilizer at *
+    rw [← Act.act_mul, ← Group.mul_assoc, Group.mul_inv_l, Group.mul_one, Act.act_mul, hh]
+
+  theorem stabilizer_conjugate_orbit (x y : X) (g : G) (hxy : g • x = y) (h : G) :
+      stabilizer y h ↔ stabilizer x (g⁻¹ * h * g) := by
+    unfold stabilizer
+    constructor
+    · intro hy
+      rw [<- hxy] at hy
+      have hy' : g⁻¹ • h • (g • x) = x := by
+        rw [hy]
+        rw [<- Act.act_mul]
+        rw [mul_inv_l, Act.act_one]
+      repeat rw [Act.act_mul]
+      exact hy'
+    · intro hh
+      have hh' : g • ((g⁻¹ * h * g) • x) = g • x := by rw [hh]
+      rw [hxy] at hh'
+      simp [mul_assoc, <- Act.act_mul, mul_inv_r, one_mul] at hh'
+      rw [Act.act_mul] at hh'
+      rw [hxy] at hh'
+      exact hh'
+
+end ActionLemmas
+
+end Group

src_data/babel-formal/proofs/lean4/ideals.lean

@@ -0,0 +1,95 @@
+class CRing (R : Type) where
+  zero  : R
+  one   : R
+  add   : R → R → R
+  mul   : R → R → R
+  opp   : R → R
+
+  add_comm  : ∀ x y, add x y = add y x
+  add_assoc : ∀ x y z, add (add x y) z = add x (add y z)
+  add_zero  : ∀ x, add x zero = x
+  add_opp   : ∀ x, add x (opp x) = zero
+
+  mul_comm  : ∀ x y, mul x y = mul y x
+  mul_assoc : ∀ x y z, mul (mul x y) z = mul x (mul y z)
+  mul_one   : ∀ x, mul x one = x
+  dist_l    : ∀ a x y, mul a (add x y) = add (mul a x) (mul a y)
+  opp_add   : ∀ x y, opp (add x y) = add (opp x) (opp y)
+
+namespace Ideals
+
+variable {R : Type} [CR : CRing R]
+open CRing
+
+infixl:65 "+R" => CRing.add
+infixl:70 "*R" => CRing.mul
+prefix:100 "-R" => CRing.opp
+
+def IsIdeal (I : R → Prop) : Prop :=
+  (I CR.zero) ∧
+  (∀ x y, I x → I y → I (x +R y)) ∧
+  (∀ x, I x → I (-R x)) ∧
+  (∀ a x, I x → I (a *R x))
+
+def Inter {ι : Type} (F : ι → (R → Prop)) : R → Prop :=
+  fun x => ∀ i, F i x
+
+theorem inter_isIdeal {ι : Type} (F : ι → (R → Prop))
+  (h : ∀ i, IsIdeal (F i)) : IsIdeal (Inter F) :=
+by
+  unfold IsIdeal Inter at *
+  constructor
+  · intro i; exact (h i).1
+  constructor
+  · intro x y hx hy i
+    exact (h i).2.1 x y (hx i) (hy i)
+  constructor
+  · intro x hx i; exact (h i).2.2.1 x (hx i)
+  · intro a x hx i; exact (h i).2.2.2 a x (hx i)
+
+def sum (I J : R → Prop) : R → Prop :=
+  fun x => ∃ a b, I a ∧ J b ∧ x = a +R b
+
+theorem sum_isIdeal (I J : R → Prop) (hI : IsIdeal I) (hJ : IsIdeal J) :
+  IsIdeal (sum I J) :=
+by
+  unfold IsIdeal sum at *
+  constructor
+  · exists CR.zero, CR.zero
+    constructor
+    · exact hI.1
+    constructor
+    · exact hJ.1
+    · simp [CR.add_zero]
+  constructor
+  · intro x y hx hy
+    rcases hx with ⟨a, b, ha, hb, rfl⟩
+    rcases hy with ⟨a', b', ha', hb', rfl⟩
+    have hadd : (a +R b) +R (a' +R b') = (a +R a') +R (b +R b') := by
+      have := by
+        calc
+          (a +R b) +R (a' +R b')
+              = ((a +R b) +R a') +R b' := by simp [CR.add_assoc]
+          _   = (a +R (b +R a')) +R b' := by simp [CR.add_assoc]
+          _   = (a +R (a' +R b)) +R b' := by simp [CR.add_comm]
+          _   = ((a +R a') +R b) +R b' := by simp [CR.add_assoc]
+          _   = (a +R a') +R (b +R b') := by simp [CR.add_assoc]
+      exact this
+    have hsumA : I (a +R a') := hI.2.1 a a' ha ha'
+    have hsumB : J (b +R b') := hJ.2.1 b b' hb hb'
+    exact ⟨a +R a', b +R b', hsumA, hsumB, hadd⟩
+  constructor
+  · intro x hx
+    rcases hx with ⟨a, b, ha, hb, rfl⟩
+    have : -R (a +R b) = (-R a) +R (-R b) := CR.opp_add a b
+    have ha' : I (-R a) := hI.2.2.1 a ha
+    have hb' : J (-R b) := hJ.2.2.1 b hb
+    exact ⟨-R a, -R b, ha', hb', this⟩
+  · intro c x hx
+    rcases hx with ⟨a, b, ha, hb, rfl⟩
+    have : c *R (a +R b) = (c *R a) +R (c *R b) := CR.dist_l c a b
+    have ha' : I (c *R a) := hI.2.2.2 c a ha
+    have hb' : J (c *R b) := hJ.2.2.2 c b hb
+    exact ⟨c *R a, c *R b, ha', hb', this⟩
+
+end Ideals

src_data/babel-formal/proofs/lean4/inner_product.lean

@@ -0,0 +1,212 @@
+namespace Linear
+
+class Field (R : Type) where
+  zero    : R
+  one     : R
+  add     : R → R → R
+  mul     : R → R → R
+  opp     : R → R
+
+  add_comm    : ∀ x y, add x y = add y x
+  add_assoc   : ∀ x y z, add (add x y) z = add x (add y z)
+  add_zero    : ∀ x, add x zero = x
+  zero_add    : ∀ x, add zero x = x
+  add_opp     : ∀ x, add x (opp x) = zero
+
+  mul_comm    : ∀ x y, mul x y = mul y x
+  mul_assoc   : ∀ x y z, mul (mul x y) z = mul x (mul y z)
+  mul_one     : ∀ x, mul x one = x
+  dist_l      : ∀ x y z, mul x (add y z) = add (mul x y) (mul x z)
+
+  opp_add     : ∀ x y, opp (add x y) = add (opp x) (opp y)
+  mul_opp_one : ∀ x, mul (opp one) x = opp x
+  opp_opp     : ∀ x, opp (opp x) = x
+
+infixl:65  "+R"  => Field.add
+infixl:70  "*R"  => Field.mul
+prefix:100 "-R"  => Field.opp
+
+class VSpace (R : Type) [Field R] (V : Type) where
+  zeroV : V
+  addV  : V → V → V
+  oppV  : V → V
+  smul  : R → V → V
+
+  addV_comm  : ∀ u v, addV u v = addV v u
+  addV_assoc : ∀ u v w, addV (addV u v) w = addV u (addV v w)
+  addV_zero  : ∀ u, addV u zeroV = u
+  addV_opp   : ∀ u, addV u (oppV u) = zeroV
+
+  smul_addV  : ∀ a u v, smul a (addV u v) = addV (smul a u) (smul a v)
+  addR_smul  : ∀ a b u, smul (a +R b) u = addV (smul a u) (smul b u)
+  mul_smul   : ∀ a b u, smul (a *R b) u = smul a (smul b u)
+  one_smul   : ∀ u, smul Field.one u = u
+  smul_zero  : ∀ a, smul a zeroV = zeroV
+  opp_smul_one : ∀ u, oppV u = smul (Field.opp Field.one) u
+
+infixl:65  "+V"  => VSpace.addV
+prefix:100 "-V"  => VSpace.oppV
+notation:70 a " •V " u => VSpace.smul a u
+
+def subV {R : Type} {V : Type} [Field R] [VSpace R V] (u v : V) : V :=
+  VSpace.addV (R := R) (V := V) u (VSpace.oppV (R := R) (V := V) v)
+infixl:65  " -V " => subV
+
+class Inner (R : Type) (V : Type) [Field R] [VSpace R V] where
+  ip : V → V → R
+
+  lin_left_add  : ∀ u v w,
+    ip (VSpace.addV (R := R) (V := V) u v) w = (ip u w) +R (ip v w)
+  lin_left_smul : ∀ a u v,
+    ip (VSpace.smul (R := R) (V := V) a u) v = a *R (ip u v)
+
+  lin_right_add  : ∀ u v w,
+    ip u (VSpace.addV (R := R) (V := V) v w) = (ip u v) +R (ip u w)
+  lin_right_smul : ∀ a u v,
+    ip u (VSpace.smul (R := R) (V := V) a v) = a *R (ip u v)
+
+  symm : ∀ u v, ip u v = ip v u
+
+
+variable {R : Type} {V : Type}
+variable [Field R] [VSpace R V] [Inner R V]
+
+theorem ip_neg_left (u v : V) :
+  Inner.ip (R := R) (V := V)
+    (VSpace.oppV (R := R) (V := V) u) v
+    = Field.opp (Inner.ip (R := R) (V := V) u v) := by
+  have h := Inner.lin_left_smul (R := R) (V := V)
+    (a := Field.opp (Field.one)) u v
+  simpa [VSpace.opp_smul_one, Field.mul_opp_one] using h
+
+theorem ip_neg_right (u v : V) :
+  Inner.ip (R := R) (V := V) u
+    (VSpace.oppV (R := R) (V := V) v)
+    = Field.opp (Inner.ip (R := R) (V := V) u v) := by
+  have h := Inner.lin_right_smul (R := R) (V := V)
+    (a := Field.opp (Field.one)) u v
+  simpa [VSpace.opp_smul_one, Field.mul_opp_one] using h
+
+theorem ip_add_add (u v : V) :
+  Inner.ip (R := R) (V := V)
+      (VSpace.addV (R := R) (V := V) u v)
+      (VSpace.addV (R := R) (V := V) u v)
+    = ((Inner.ip (R := R) (V := V) u u +R Inner.ip (R := R) (V := V) v u)
+       +R (Inner.ip (R := R) (V := V) u v +R Inner.ip (R := R) (V := V) v v)) := by
+  have H := Inner.lin_right_add (R := R) (V := V)
+    (u := VSpace.addV (R := R) (V := V) u v) (v := u) (w := v)
+  have H1 :
+    Inner.ip (R := R) (V := V)
+        (VSpace.addV (R := R) (V := V) u v) u
+      = Inner.ip (R := R) (V := V) u u +R Inner.ip (R := R) (V := V) v u :=
+    Inner.lin_left_add (R := R) (V := V) (u := u) (v := v) (w := u)
+  have H2 :
+    Inner.ip (R := R) (V := V)
+        (VSpace.addV (R := R) (V := V) u v) v
+      = Inner.ip (R := R) (V := V) u v +R Inner.ip (R := R) (V := V) v v :=
+    Inner.lin_left_add (R := R) (V := V) (u := u) (v := v) (w := v)
+  simpa [H1, H2, Field.add_assoc] using H
+
+theorem ip_sub_sub (u v : V) :
+  Inner.ip (R := R) (V := V)
+      (subV (R := R) (V := V) u v)
+      (subV (R := R) (V := V) u v)
+    = ((Inner.ip (R := R) (V := V) u u +R Field.opp (Inner.ip (R := R) (V := V) v u))
+       +R (Field.opp (Inner.ip (R := R) (V := V) u v) +R Inner.ip (R := R) (V := V) v v)) := by
+  have H := Inner.lin_right_add (R := R) (V := V)
+    (u := subV (R := R) (V := V) u v) (v := u)
+    (w := VSpace.oppV (R := R) (V := V) v)
+  have H1 :
+    Inner.ip (R := R) (V := V) (subV (R := R) (V := V) u v) u =
+      Inner.ip (R := R) (V := V) u u
+        +R Inner.ip (R := R) (V := V)
+              (VSpace.oppV (R := R) (V := V) v) u := by
+      simpa using
+        Inner.lin_left_add (R := R) (V := V)
+          (u := u)
+          (v := VSpace.oppV (R := R) (V := V) v)
+          (w := u)
+  have H2 :
+    Inner.ip (R := R) (V := V)
+        (subV (R := R) (V := V) u v)
+        (VSpace.oppV (R := R) (V := V) v)
+      = Inner.ip (R := R) (V := V) u (VSpace.oppV (R := R) (V := V) v)
+        +R Inner.ip (R := R) (V := V)
+              (VSpace.oppV (R := R) (V := V) v)
+              (VSpace.oppV (R := R) (V := V) v) := by
+      simpa using
+        Inner.lin_left_add (R := R) (V := V)
+          (u := u)
+          (v := VSpace.oppV (R := R) (V := V) v)
+          (w := VSpace.oppV (R := R) (V := V) v)
+  have Huv_neg :
+      Inner.ip (R := R) (V := V)
+        (VSpace.oppV (R := R) (V := V) v) u
+        = Field.opp (Inner.ip (R := R) (V := V) v u) :=
+    ip_neg_left (v := u) v
+  have Huu :
+      Inner.ip (R := R) (V := V) u (VSpace.oppV (R := R) (V := V) v)
+        = Field.opp (Inner.ip (R := R) (V := V) u v) :=
+    ip_neg_right (u := u) v
+  have Hvv1 :
+      Inner.ip (R := R) (V := V)
+        (VSpace.oppV (R := R) (V := V) v)
+        (VSpace.oppV (R := R) (V := V) v)
+        = Field.opp (Inner.ip (R := R) (V := V)
+                        (VSpace.oppV (R := R) (V := V) v) v) :=
+    ip_neg_right (u := VSpace.oppV (R := R) (V := V) v) v
+  have Hvv2 :
+      Inner.ip (R := R) (V := V)
+        (VSpace.oppV (R := R) (V := V) v) v
+        = Field.opp (Inner.ip (R := R) (V := V) v v) :=
+    ip_neg_left v v
+  have Hvv :
+      Inner.ip (R := R) (V := V)
+        (VSpace.oppV (R := R) (V := V) v)
+        (VSpace.oppV (R := R) (V := V) v)
+        = Inner.ip (R := R) (V := V) v v := by
+    have :
+        Inner.ip (R := R) (V := V)
+          (VSpace.oppV (R := R) (V := V) v)
+          (VSpace.oppV (R := R) (V := V) v)
+        = Field.opp (Field.opp (Inner.ip (R := R) (V := V) v v)) := by
+      simpa [Hvv2] using Hvv1
+    simpa [Field.opp_opp] using this
+  simpa [H1, H2, Huv_neg, Huu, Hvv, Field.add_assoc, Field.add_comm]
+    using H
+
+theorem pythagoras (u v : V)
+  (h : Inner.ip (R := R) (V := V) u v = Field.zero) :
+  Inner.ip (R := R) (V := V)
+      (VSpace.addV (R := R) (V := V) u v)
+      (VSpace.addV (R := R) (V := V) u v)
+    = (Inner.ip (R := R) (V := V) u u +R Inner.ip (R := R) (V := V) v v) := by
+  have H := ip_add_add (R := R) (V := V) u v
+  have hvu : Inner.ip (R := R) (V := V) v u = Field.zero := by
+    simpa [Inner.symm (R := R) (V := V) v u] using h
+  have :
+      Inner.ip (R := R) (V := V)
+        (VSpace.addV (R := R) (V := V) u v)
+        (VSpace.addV (R := R) (V := V) u v)
+        = ((Inner.ip (R := R) (V := V) u u +R Field.zero)
+            +R (Field.zero +R Inner.ip (R := R) (V := V) v v)) := by
+    simp [H, h, hvu]
+  simpa [Field.add_zero, Field.zero_add, Field.add_comm, Field.add_assoc] using this
+
+theorem parallelogram (u v : V) :
+  (Inner.ip (R := R) (V := V)
+      (VSpace.addV (R := R) (V := V) u v)
+      (VSpace.addV (R := R) (V := V) u v)
+     +R Inner.ip (R := R) (V := V)
+          (subV (R := R) (V := V) u v)
+          (subV (R := R) (V := V) u v))
+    = (((Inner.ip (R := R) (V := V) u u +R Inner.ip (R := R) (V := V) v u)
+         +R (Inner.ip (R := R) (V := V) u v +R Inner.ip (R := R) (V := V) v v))
+       +R ((Inner.ip (R := R) (V := V) u u +R Field.opp (Inner.ip (R := R) (V := V) v u))
+           +R ((Field.opp (Inner.ip (R := R) (V := V) u v))
+               +R Inner.ip (R := R) (V := V) v v))) := by
+  have H1 := ip_add_add (R := R) (V := V) u v
+  have H2 := ip_sub_sub (R := R) (V := V) u v
+  simp [H1, H2]
+
+end Linear

src_data/babel-formal/proofs/lean4/integral_comp_neg_Iic.lean

@@ -0,0 +1,265 @@
+class RField (R : Type) where
+  zero   : R
+  one    : R
+  add    : R → R → R
+  opp    : R → R
+  mul    : R → R → R
+  le     : R → R → Prop
+  lt     : R → R → Prop
+  abs    : R → R
+
+  add_comm      : ∀ x y, add x y = add y x
+  add_assoc     : ∀ x y z, add (add x y) z = add x (add y z)
+  add_zero      : ∀ x, add x zero = x
+  add_opp       : ∀ x, add (opp x) x = zero
+  add_right_cancel : ∀ x y z, add x z = add y z → x = y
+
+  mul_comm      : ∀ x y, mul x y = mul y x
+  mul_assoc     : ∀ x y z, mul (mul x y) z = mul x (mul y z)
+  mul_one       : ∀ x, mul x one = x
+  dist_l        : ∀ x y z, mul x (add y z) = add (mul x y) (mul x z)
+  opp_involutive : ∀ x, opp (opp x) = x
+
+  add_le_compat : ∀ x y z, le x y → le (add x z) (add y z)
+  mul_le_compat : ∀ x y z, le zero z → le x y → le (mul x z) (mul y z)
+  zero_le_one   : le zero one
+  le_total      : ∀ x y, le x y ∨ le y x
+
+  le_dec : ∀ x y, (le x y) ∨ ¬ (le x y)
+
+  le_opp        : ∀ x y, le x y → le (opp y) (opp x)
+  le_antisymm   : ∀ x y, le x y → le y x → x = y
+  lt_opp        : ∀ x y, lt x y → lt (opp y) (opp x)
+  le_refl       : ∀ x, le x x
+  le_trans      : ∀ x y z, le x y → le y z → le x z
+  lt_def        : ∀ x y, lt x y ↔ (le x y ∧ x ≠ y)
+
+  abs_pos       : ∀ x, le zero x → abs x = x
+  abs_neg       : ∀ x, le x zero → abs x = opp x
+  abs_nonneg    : ∀ x, le zero (abs x)
+  abs_opp       : ∀ x, abs (opp x) = abs x
+  abs_triangle  : ∀ x y, le (abs (add x y)) (add (abs x) (abs y))
+
+class Integral (R : Type) [RField R] where
+  sigma       : (R → Prop) → (R → R) → R
+  sigma_mul_const : ∀ (D : R → Prop) (f : R → R) (c : R),
+    sigma D (fun x => RField.mul c (f x)) = RField.mul c (sigma D f)
+  sigma_congr : ∀ D f g, (∀ x, D x → f x = g x) → sigma D f = sigma D g
+  sigma_zero  : ∀ D, sigma D (fun _ => RField.zero) = RField.zero
+  sigma_add   : ∀ D f g, sigma D (fun x => RField.add (f x) (g x)) = RField.add (sigma D f) (sigma D g)
+
+  sigma_union_disjoint : ∀ (D E : R → Prop) (f : R → R),
+    (∀ x, D x → E x → False) →
+    sigma (fun x => D x ∨ E x) f = RField.add (sigma D f) (sigma E f)
+  sigma_le : ∀ D f g, (∀ x, D x → RField.le (f x) (g x)) → RField.le (sigma D f) (sigma D g)
+  sigma_dom_congr : ∀ D E f, (∀ x, D x ↔ E x) → sigma D f = sigma E f
+
+namespace Integrals
+
+variable {R : Type} [RF : RField R] [I : Integral R]
+open RField
+open Integral
+
+-- Notations
+prefix:100 "-" => opp
+infixl:65 " + " => add
+infixl:70 " * " => mul
+infixl:70 " <= " => le
+infixl:70 " < " => lt
+
+-- Domains
+def Iic (c : R) : R → Prop := fun x => x <= c
+def Ioi (c : R) : R → Prop := fun x => c < x
+def Iio (c : R) : R → Prop := fun x => x < c
+def union (D E : R → Prop) : R → Prop := fun x => D x ∨ E x
+def inter (D E : R → Prop) : R → Prop := fun x => D x ∧ E x
+
+-- Lemma lt_irrefl
+theorem lt_irrefl (x : R) : ¬ (x < x) :=
+by
+  intro H2
+  rw [lt_def] at H2
+  rcases H2 with ⟨Hle, Hneq⟩
+  exact Hneq rfl
+
+-- Lemma lt_trans_strict
+theorem lt_trans_strict (x y z : R) (Hxy : x < y) (Hyz : y < z) : x < z :=
+by
+  rw [lt_def] at *
+  constructor
+  · apply le_trans _ _ _ Hxy.1 Hyz.1
+  · intro Heq
+    subst z
+    rcases Hxy with ⟨Hxy_le, Hxy_neq⟩
+    rcases Hyz with ⟨Hyz_le, Hyz_neq⟩
+    apply Hxy_neq
+    apply le_antisymm <;> assumption
+
+-- Preimage
+def preimage (g : R → R) (D : R → Prop) : R → Prop :=
+  fun x => D (g x)
+
+theorem preimage_union (D E : R → Prop) (g : R → R) (x : R) :
+  preimage g (union D E) x ↔ preimage g D x ∨ preimage g E x :=
+by
+  unfold preimage union; trivial
+
+theorem preimage_inter (D E : R → Prop) (g : R → R) (x : R) :
+  preimage g (inter D E) x ↔ preimage g D x ∧ preimage g E x :=
+by
+  unfold preimage inter; trivial
+
+theorem preimage_neg_Ioi (c x : R) :
+  preimage opp (Ioi c) x ↔ x < opp c :=
+by
+  unfold preimage Ioi
+  constructor
+  · intro Ha
+    have := lt_opp c (opp x) Ha
+    rw [opp_involutive] at this
+    exact this
+  · intro Ha
+    have := lt_opp x (opp c) Ha
+    rw [opp_involutive] at this
+    exact this
+
+theorem preimage_neg_Iic (c x : R) :
+  preimage opp (Iic c) x ↔ Iic x (opp c) :=
+by
+  unfold preimage Iic
+  constructor
+  · intro Ha
+    have h := le_opp (-x) c Ha
+    rw [opp_involutive] at h
+    exact h
+  · intro Ha
+    have h := le_opp (-c) x Ha
+    rw [opp_involutive] at h
+    exact h
+
+theorem preimage_comp (D : R → Prop) (g h : R → R) (x : R) :
+  preimage g (preimage h D) x ↔ preimage (fun x => h (g x)) D x :=
+by
+  rfl
+
+theorem integral_neg (D : R → Prop) (f : R → R) :
+  sigma D (fun x => opp (f x)) = opp (sigma D f) :=
+by
+  apply add_right_cancel
+    (sigma D (fun x => opp (f x)))
+    (opp (sigma D f))
+    (sigma D f)
+  rw [add_opp]
+  rw [←sigma_add]
+  have Hpointwise : ∀ x, D x → opp (f x) + f x = zero :=
+    by intros x _; rw [add_opp]
+  rw [sigma_congr D (fun x => opp (f x) + f x) (fun _ => zero) Hpointwise]
+  rw [sigma_zero]
+
+theorem integral_sub (D : R → Prop) (f g : R → R) :
+  sigma D (fun x => add (f x) (opp (g x))) = add (sigma D f) (opp (sigma D g)) :=
+by
+  rw [sigma_add]
+  rw [integral_neg]
+
+theorem sigma_empty (f : R → R) :
+  sigma (fun _ => False) f = zero :=
+by
+  have : sigma (fun _ => False) f = sigma (fun _ => False) (fun _ => zero) :=
+    by
+      apply sigma_congr
+      intros x Ha
+      cases Ha
+  rw [this, sigma_zero]
+
+theorem sigma_bilinear (D : R → Prop) (f g : R → R) (c d : R) :
+  sigma D (fun x => add (mul c (f x)) (mul d (g x))) =
+    add (mul c (sigma D f)) (mul d (sigma D g)) :=
+by
+  rw [sigma_add]
+  rw [sigma_mul_const]
+  rw [sigma_mul_const]
+
+theorem sigma_le_monotone (D : R → Prop) (f g : R → R) :
+  (∀ x, D x → le (f x) (g x)) → le (sigma D f) (sigma D g) :=
+by
+  exact sigma_le D f g
+
+theorem sigma_nonneg (D : R → Prop) (f : R → R) :
+  (∀ x, D x → le zero (f x)) → le zero (sigma D f) :=
+by
+  intro H0f
+  rw [←sigma_zero D]
+  exact sigma_le D (fun x => zero) f H0f
+
+theorem sigma_split (D : R → Prop) (P : R → Prop) (f : R → R)
+  (P_dec : ∀ x, D x → P x ∨ ¬ P x) :
+  sigma D f =
+    add (sigma (fun x => D x ∧ P x) f)
+        (sigma (fun x => D x ∧ ¬ P x) f) :=
+by
+  let E := fun x => D x ∧ P x
+  let F := fun x => D x ∧ ¬ P x
+  have Disj : ∀ x, E x → F x → False := by
+    intros x Ex Fx
+    let ⟨HDx, HPx⟩ := Ex
+    let ⟨_, HnPx⟩ := Fx
+    exact HnPx HPx
+  have EqDom : ∀ x, D x ↔ (E x ∨ F x) := by
+    intro x; constructor
+    · intro HDx
+      cases P_dec x HDx with
+      | inl HPx => left; exact ⟨HDx, HPx⟩
+      | inr HnPx => right; exact ⟨HDx, HnPx⟩
+    · intro h
+      cases h with
+      | inl hE =>
+        exact hE.1
+      | inr hF =>
+        exact hF.1
+  rw [sigma_dom_congr D (fun x => E x ∨ F x) f EqDom]
+  exact sigma_union_disjoint E F f Disj
+
+theorem sigma_preimage_neg_Ioi (f : R → R) (c : R) :
+  sigma (preimage opp (Ioi c)) f = sigma (Iio (opp c)) f :=
+by
+  apply sigma_dom_congr
+  intro x; exact preimage_neg_Ioi c x
+
+theorem sigma_abs_bound (D : R → Prop) (f : R → R) :
+  le (abs (sigma D f)) (sigma D (fun x => abs (f x))) :=
+by
+  let P := fun x => zero <= f x
+  have P_dec : ∀ x, D x → P x ∨ ¬ P x :=
+    fun x _ => le_dec zero (f x)
+  rw [sigma_split D P f P_dec]
+  let I_pos := sigma (fun x => D x ∧ P x) f
+  let I_neg := sigma (fun x => D x ∧ ¬ P x) f
+  apply le_trans (abs (I_pos + I_neg)) (abs I_pos + abs I_neg) (sigma D (fun x => abs (f x)))
+  · exact abs_triangle I_pos I_neg
+  have Hpos_nonneg : zero <= I_pos :=
+    sigma_nonneg (fun x => D x ∧ P x) f (by intros x h; exact h.2)
+  have Hpos_eq : abs I_pos = sigma (fun x => D x ∧ P x) (fun x => abs (f x)) :=
+    by
+      rw [abs_pos I_pos Hpos_nonneg]
+      apply sigma_congr; intros x h; symm; exact abs_pos (f x) h.2
+  have Hfx_le0 : ∀ x, D x ∧ ¬ P x → f x <= zero :=
+    fun x h =>
+      match le_total zero (f x) with
+      | Or.inl H3 => False.elim (h.2 H3)
+      | Or.inr H3 => H3
+  have Hneg_nonpos : sigma (fun x => D x ∧ ¬P x) f <= zero :=
+    by
+      apply le_trans _ (sigma (fun x => D x ∧ ¬P x) (fun _ => zero))
+      · exact sigma_le (fun x => D x ∧ ¬ P x) f (fun _ => zero) Hfx_le0
+      · rw [sigma_zero]; exact le_refl zero
+  have Hneg_eq : abs I_neg = sigma (fun x => D x ∧ ¬P x) (fun x => abs (f x)) :=
+    by
+      rw [abs_neg I_neg Hneg_nonpos]
+      rw [←integral_neg]
+      apply sigma_congr; intros x Hx; symm; apply abs_neg; apply Hfx_le0; exact Hx
+  rw [Hpos_eq, Hneg_eq]
+  rw [sigma_split D P (fun x => abs (f x)) P_dec]
+  exact le_refl _
+
+end Integrals

src_data/babel-formal/proofs/lean4/lattice_like.lean

@@ -0,0 +1,115 @@
+universe u
+
+class LatticeLike (A : Type u) where
+  le   : A → A → Prop
+  inf  : A → A → A
+  sup  : A → A → A
+
+  le_refl  : ∀ x, le x x
+  le_trans : ∀ {x y z}, le x y → le y z → le x z
+  le_antisym : ∀ {x y}, le x y → le y x → x = y
+
+  le_inf_left  : ∀ a b, le (inf a b) a
+  le_inf_right : ∀ a b, le (inf a b) b
+  le_inf_intro : ∀ {c a b}, le c a → le c b → le c (inf a b)
+
+  le_sup_left  : ∀ a b, le a (sup a b)
+  le_sup_right : ∀ a b, le b (sup a b)
+  sup_le_intro : ∀ {a b c}, le a c → le b c → le (sup a b) c
+
+namespace LatticeLike
+
+variable {A : Type u} [L : LatticeLike A]
+
+infix:50 " ≤ " => LatticeLike.le
+infixl:65 " ⊓ " => LatticeLike.inf
+infixl:70 " ⊔ " => LatticeLike.sup
+
+theorem inf_comm (a b : A) : a ⊓ b = b ⊓ a :=
+by
+  apply LatticeLike.le_antisym
+  · have h1 : a ⊓ b ≤ b := LatticeLike.le_inf_right a b
+    have h2 : a ⊓ b ≤ a := LatticeLike.le_inf_left a b
+    have : a ⊓ b ≤ b ⊓ a := LatticeLike.le_inf_intro h1 h2
+    exact this
+  · have h1 : b ⊓ a ≤ a := LatticeLike.le_inf_right b a
+    have h2 : b ⊓ a ≤ b := LatticeLike.le_inf_left b a
+    have : b ⊓ a ≤ a ⊓ b := LatticeLike.le_inf_intro h1 h2
+    exact this
+
+theorem sup_comm (a b : A) : a ⊔ b = b ⊔ a :=
+by
+  apply LatticeLike.le_antisym
+  · have Ha : a ≤ b ⊔ a := LatticeLike.le_sup_right b a
+    have Hb : b ≤ b ⊔ a := LatticeLike.le_sup_left b a
+    have : a ⊔ b ≤ b ⊔ a := LatticeLike.sup_le_intro Ha Hb
+    exact this
+  · have Hb : b ≤ a ⊔ b := LatticeLike.le_sup_right a b
+    have Ha : a ≤ a ⊔ b := LatticeLike.le_sup_left a b
+    have : b ⊔ a ≤ a ⊔ b := LatticeLike.sup_le_intro Hb Ha
+    exact this
+
+theorem inf_assoc (a b c : A) : (a ⊓ b) ⊓ c = a ⊓ (b ⊓ c) :=
+by
+  apply LatticeLike.le_antisym
+  · have h1 : (a ⊓ b) ⊓ c ≤ a ⊓ b := LatticeLike.le_inf_left _ _
+    have h2 : a ⊓ b ≤ a := LatticeLike.le_inf_left _ _
+    have h3 : (a ⊓ b) ⊓ c ≤ a := LatticeLike.le_trans h1 h2
+    have h4 : (a ⊓ b) ⊓ c ≤ c := LatticeLike.le_inf_right _ _
+    have h5 : (a ⊓ b) ⊓ c ≤ b ⊓ c := LatticeLike.le_inf_intro
+      (show (a ⊓ b) ⊓ c ≤ b from LatticeLike.le_trans (LatticeLike.le_inf_left _ _) (LatticeLike.le_inf_right _ _))
+      h4
+    have : (a ⊓ b) ⊓ c ≤ a ⊓ (b ⊓ c) :=
+      LatticeLike.le_inf_intro h3 h5
+    exact this
+  · have h1 : a ⊓ (b ⊓ c) ≤ a := LatticeLike.le_inf_left _ _
+    have h2 : a ⊓ (b ⊓ c) ≤ b ⊓ c := LatticeLike.le_inf_right _ _
+    have h3 : b ⊓ c ≤ b := LatticeLike.le_inf_left _ _
+    have h4 : a ⊓ (b ⊓ c) ≤ b := LatticeLike.le_trans h2 h3
+    have h5 : a ⊓ (b ⊓ c) ≤ c := LatticeLike.le_trans h2 (LatticeLike.le_inf_right _ _)
+    have : a ⊓ (b ⊓ c) ≤ (a ⊓ b) ⊓ c :=
+      LatticeLike.le_inf_intro (LatticeLike.le_inf_intro h1 h4) h5
+    exact this
+
+theorem sup_assoc (a b c : A) : (a ⊔ b) ⊔ c = a ⊔ (b ⊔ c) :=
+by
+  apply LatticeLike.le_antisym
+  · have Ha_to : a ≤ a ⊔ (b ⊔ c) := LatticeLike.le_sup_left _ _
+    have Hb_bc : b ≤ b ⊔ c := LatticeLike.le_sup_left _ _
+    have Hb_to : b ≤ a ⊔ (b ⊔ c) := LatticeLike.le_trans Hb_bc (LatticeLike.le_sup_right _ _)
+    have Hab_to : a ⊔ b ≤ a ⊔ (b ⊔ c) := LatticeLike.sup_le_intro Ha_to Hb_to
+    have Hc_bc : c ≤ b ⊔ c := LatticeLike.le_sup_right _ _
+    have Hc_to : c ≤ a ⊔ (b ⊔ c) := LatticeLike.le_trans Hc_bc (LatticeLike.le_sup_right _ _)
+    have : (a ⊔ b) ⊔ c ≤ a ⊔ (b ⊔ c) := LatticeLike.sup_le_intro Hab_to Hc_to
+    exact this
+  · have Ha_ab : a ≤ a ⊔ b := LatticeLike.le_sup_left _ _
+    have Hab_to : a ⊔ b ≤ (a ⊔ b) ⊔ c := LatticeLike.le_sup_left _ _
+    have Ha_to : a ≤ (a ⊔ b) ⊔ c := LatticeLike.le_trans Ha_ab Hab_to
+    have Hb_ab : b ≤ a ⊔ b := LatticeLike.le_sup_right _ _
+    have Hb_to : b ≤ (a ⊔ b) ⊔ c := LatticeLike.le_trans Hb_ab Hab_to
+    have Hc_to : c ≤ (a ⊔ b) ⊔ c := LatticeLike.le_sup_right _ _
+    have Hbc_to : b ⊔ c ≤ (a ⊔ b) ⊔ c := LatticeLike.sup_le_intro Hb_to Hc_to
+    have : a ⊔ (b ⊔ c) ≤ (a ⊔ b) ⊔ c := LatticeLike.sup_le_intro Ha_to Hbc_to
+    exact this
+
+theorem inf_absorption (a b : A) : a ⊓ (a ⊔ b) = a :=
+by
+  apply LatticeLike.le_antisym
+  · have h1 : a ⊓ (a ⊔ b) ≤ a := LatticeLike.le_inf_left _ _
+    exact h1
+  · have h1 : a ≤ a := LatticeLike.le_refl _
+    have h2 : a ≤ a ⊔ b := LatticeLike.le_sup_left _ _
+    have : a ≤ a ⊓ (a ⊔ b) := LatticeLike.le_inf_intro h1 h2
+    exact this
+
+theorem sup_absorption (a b : A) : a ⊔ (a ⊓ b) = a :=
+by
+  apply LatticeLike.le_antisym
+  · have h1 : a ≤ a := LatticeLike.le_refl _
+    have h2 : a ⊓ b ≤ a := LatticeLike.le_inf_left _ _
+    have : a ⊔ (a ⊓ b) ≤ a := LatticeLike.sup_le_intro h1 h2
+    exact this
+  · have h1 : a ≤ a ⊔ (a ⊓ b) := LatticeLike.le_sup_left _ _
+    exact h1
+
+end LatticeLike

src_data/babel-formal/proofs/lean4/limits_uniqueness.lean

@@ -0,0 +1,109 @@
+class AbsField (R : Type) where
+  zero  : R
+  one   : R
+  add   : R → R → R
+  mul   : R → R → R
+  opp   : R → R
+  abs   : R → R
+  le    : R → R → Prop
+  lt    : R → R → Prop
+
+
+  NatAlt     : Type
+  NatAltle   : NatAlt → NatAlt → Prop
+  NatAltMax  : NatAlt → NatAlt → NatAlt
+  le_max_left  : ∀ x y, NatAltle x (NatAltMax x y)
+  le_max_right : ∀ x y, NatAltle y (NatAltMax x y)
+
+  add_comm  : ∀ x y, add x y = add y x
+  add_assoc : ∀ x y z, add (add x y) z = add x (add y z)
+  add_zero  : ∀ x, add x zero = x
+  add_opp   : ∀ x, add x (opp x) = zero
+  opp_add   : ∀ x y, opp (add x y) = add (opp x) (opp y)
+  mul_comm  : ∀ x y, mul x y = mul y x
+  mul_assoc : ∀ x y z, mul (mul x y) z = mul x (mul y z)
+  mul_one   : ∀ x, mul x one = x
+
+  le_refl   : ∀ x, le x x
+  le_trans  : ∀ x y z, le x y → le y z → le x z
+  add_le_add : ∀ a b c d, le a b → le c d → le (add a c) (add b d)
+
+  abs_nonneg : ∀ x, le zero (abs x)
+  abs_triangle : ∀ x y, le (abs (add x y)) (add (abs x) (abs y))
+  abs_opp : ∀ x, abs (opp x) = abs x
+  abs_sub_symm : ∀ x y, abs (add x (opp y)) = abs (add y (opp x))
+
+
+  sub_decomp : ∀ x y z, add x (opp z) = add (add x (opp y)) (add y (opp z))
+  sub_eq_zero : ∀ x y, add x (opp y) = zero → x = y
+
+  eq_of_forall_eps2 : ∀ x, (∀ eps, lt zero eps → le (abs x) (add eps eps)) → x = zero
+
+namespace Limits
+
+variable {R : Type} [AR : AbsField R]
+
+
+
+
+def sub (x y : R) : R := AbsField.add x (AbsField.opp y)
+
+def limit (u : (AbsField.NatAlt (R := R)) → R) (l : R) : Prop :=
+  ∀ eps : R, AbsField.lt AbsField.zero eps →
+    ∃ N : AbsField.NatAlt (R := R),
+      ∀ n : AbsField.NatAlt (R := R),
+        AbsField.NatAltle (R := R) N n →
+          AbsField.le (AbsField.abs (sub (u n) l)) eps
+
+theorem sub_self_zero (x : R) : sub x x = AbsField.zero := by
+  unfold sub
+
+  simpa using AbsField.add_opp x
+
+theorem sub_decomp (x y z : R) : sub x z = AR.add (sub x y) (sub y z) := by
+
+  unfold sub
+  simpa using (AbsField.sub_decomp (R := R) x y z)
+
+theorem abs_sub_triangle (x y z : R) :
+  AbsField.le (AbsField.abs (sub x z)) (AbsField.add (AbsField.abs (sub x y)) (AbsField.abs (sub y z))) := by
+
+  have : sub x z = AbsField.add (sub x y) (sub y z) := sub_decomp x y z
+  simpa [this] using AbsField.abs_triangle (sub x y) (sub y z)
+
+theorem abs_sub_nonneg (x y : R) : AR.le AR.zero (AR.abs (sub x y)) := by
+  unfold sub
+  exact AbsField.abs_nonneg _
+
+
+theorem limit_unique (u : (AbsField.NatAlt (R := R)) → R) (l m : R) :
+  limit u l → limit u m → l = m :=
+by
+  intro Hl Hm
+
+  have Hbound' : ∀ eps, AR.lt AR.zero eps → AR.le (AR.abs (sub l m)) (AR.add eps eps) := by
+    intro eps Heps
+    rcases Hl eps Heps with ⟨N1, HN1⟩
+    rcases Hm eps Heps with ⟨N2, HN2⟩
+    let N := AbsField.NatAltMax (R := R) N1 N2
+    have H1 : AbsField.le (AbsField.abs (sub (u N) l)) eps := by
+      apply HN1
+      exact AbsField.le_max_left (R := R) _ _
+    have H2 : AbsField.le (AbsField.abs (sub (u N) m)) eps := by
+      apply HN2
+      exact AbsField.le_max_right (R := R) _ _
+
+    have Htri : AbsField.le (AbsField.abs (sub l m)) (AbsField.add (AbsField.abs (sub l (u N))) (AbsField.abs (sub (u N) m))) := by
+      simpa using abs_sub_triangle l (u N) m
+
+
+    have H1' : AbsField.le (AbsField.abs (sub l (u N))) eps := by
+
+      simpa [sub, AbsField.abs_sub_symm (u N) l] using H1
+    exact AbsField.le_trans _ _ _ Htri (AbsField.add_le_add _ _ _ _ H1' H2)
+
+  have Hz : sub l m = AbsField.zero := AbsField.eq_of_forall_eps2 (sub l m) Hbound'
+
+  exact AbsField.sub_eq_zero l m (by simpa [sub] using Hz)
+
+end Limits

src_data/babel-formal/proofs/lean4/linear_map.lean

@@ -0,0 +1,100 @@
+class Field (R : Type) where
+  zero    : R
+  one     : R
+  add     : R → R → R
+  mul     : R → R → R
+  opp     : R → R
+  add_comm  : ∀ x y, add x y = add y x
+  add_assoc : ∀ x y z, add (add x y) z = add x (add y z)
+  add_zero  : ∀ x, add x zero = x
+  add_opp   : ∀ x, add x (opp x) = zero
+  mul_comm  : ∀ x y, mul x y = mul y x
+  mul_assoc : ∀ x y z, mul (mul x y) z = mul x (mul y z)
+  mul_one   : ∀ x, mul x one = x
+  dist_l    : ∀ a x y, mul a (add x y) = add (mul a x) (mul a y)
+
+namespace Lin
+
+variable {R : Type} [FR : Field R]
+open Field
+
+infixl:65  "+R"  => Field.add
+infixl:70  "*R"  => Field.mul
+prefix:100 "-R"  => Field.opp
+
+class VSpace (R : Type) [Field R] (V : Type) where
+  zeroV : V
+  addV  : V → V → V
+  oppV  : V → V
+  smul  : R → V → V
+  addV_comm  : ∀ u v, addV u v = addV v u
+  addV_assoc : ∀ u v w, addV (addV u v) w = addV u (addV v w)
+  addV_zero  : ∀ u, addV u zeroV = u
+  addV_opp   : ∀ u, addV u (oppV u) = zeroV
+  smul_addV  : ∀ a u v, smul a (addV u v) = addV (smul a u) (smul a v)
+  addR_smul  : ∀ a b u, smul (a +R b) u = addV (smul a u) (smul b u)
+  mul_smul   : ∀ a b u, smul (a *R b) u = smul a (smul b u)
+  one_smul   : ∀ u, smul Field.one u = u
+  smul_zero  : ∀ a, smul a zeroV = zeroV
+
+attribute [simp] VSpace.addV_zero VSpace.smul_zero
+
+infixl:65  "+V"  => VSpace.addV
+notation:70 a " •V " u => VSpace.smul a u
+
+structure LMap (V W : Type) [VSpace R V] [VSpace R W] where
+  toFun : V → W
+  map_add : ∀ u v, toFun (VSpace.addV (R:=R) u v)
+             = VSpace.addV (R:=R) (toFun u) (toFun v)
+  map_smul : ∀ a u, toFun (VSpace.smul (R:=R) a u)
+             = VSpace.smul (R:=R) a (toFun u)
+
+attribute [simp] LMap.map_add LMap.map_smul
+
+variable {V W U : Type}
+variable [VSpace R V] [VSpace R W] [VSpace R U]
+
+def ker (L : LMap (R:=R) V W) : V → Prop := fun x => L.toFun x = VSpace.zeroV (R:=R)
+def im  (L : LMap (R:=R) V W) : W → Prop := fun y => ∃ x, L.toFun x = y
+
+def comp (g : LMap (R:=R) W U) (f : LMap (R:=R) V W) : LMap (R:=R) V U :=
+{ toFun := fun x => g.toFun (f.toFun x)
+, map_add := by
+    intro u v
+    simp
+, map_smul := by
+    intro a u
+    simp
+}
+
+theorem ker_add {L : LMap (R:=R) V W} {x y : V} :
+  ker L x → ker L y → ker L (VSpace.addV (R:=R) x y) :=
+by
+  intro hx hy
+  unfold ker at hx hy ⊢
+  simp [hx, hy]
+
+theorem ker_smul {L : LMap (R:=R) V W} {a : R} {x : V} :
+  ker L x → ker L (VSpace.smul (R:=R) a x) :=
+by
+  intro hx
+  unfold ker at *
+  simp [hx]
+
+theorem im_add {L : LMap (R:=R) V W} {y z : W} :
+  im L y → im L z → im L (VSpace.addV (R:=R) y z) :=
+by
+  intro hy hz
+  rcases hy with ⟨x, rfl⟩
+  rcases hz with ⟨x', rfl⟩
+  refine ⟨VSpace.addV (R:=R) x x', ?_⟩
+  simp
+
+theorem im_smul {L : LMap (R:=R) V W} {a : R} {y : W} :
+  im L y → im L (VSpace.smul (R:=R) a y) :=
+by
+  intro hy; rcases hy with ⟨x, rfl⟩
+  refine ⟨VSpace.smul (R:=R) a x, ?_⟩
+  simp
+
+end Lin

src_data/babel-formal/proofs/lean4/polynomial.lean

@@ -0,0 +1,512 @@
+inductive mynat : Type
+| O  : mynat
+| S  : mynat → mynat
+deriving DecidableEq
+
+open mynat
+
+def mynat_add : mynat → mynat → mynat
+| O,        m => m
+| (S n'),   m => S (mynat_add n' m)
+
+theorem mynat_add_O_left (m : mynat) :
+  mynat_add O m = m := rfl
+
+theorem mynat_add_S_left (n m : mynat) :
+  mynat_add (S n) m = S (mynat_add n m) := rfl
+
+inductive mynat_le : mynat → mynat → Prop
+| le_n  : ∀ n, mynat_le n n
+| le_S  : ∀ n m, mynat_le n m → mynat_le n (S m)
+
+open mynat_le
+
+theorem mynat_zero_le (n : mynat) : mynat_le O n := by
+  induction n with
+  | O =>
+      exact le_n O
+  | S n ih =>
+      exact le_S O n ih
+
+theorem mynat_add_zero_r : ∀ n, mynat_add n O = n
+| O      => rfl
+| (S n') => by
+  simp [mynat_add, mynat_add_zero_r n']
+
+theorem mynat_succ_le_succ {n m : mynat} :
+  mynat_le n m → mynat_le (S n) (S m) := by
+  intro h; induction h with
+  | le_n =>
+      exact le_n (S n)
+  | le_S m h ih =>
+      exact le_S (S n) (S m) ih
+
+theorem mynat_add_S_r : ∀ m n, mynat_add m (S n) = S (mynat_add m n)
+| O,      n => rfl
+| (S m'), n => by
+  simp [mynat_add, mynat_add_S_r m' n]
+
+theorem mynat_add_comm : ∀ n m, mynat_add n m = mynat_add m n
+| O,      m => by simp [mynat_add, mynat_add_zero_r]
+| (S n'), m => by
+  simp [mynat_add, mynat_add_comm n' m, mynat_add_S_r m n']
+
+inductive mylist (A : Type) : Type
+| nilL  : mylist A
+| consL : A → mylist A → mylist A
+
+namespace mylist
+
+notation h "::L" t => mylist.consL  h t
+
+end mylist
+
+open mylist
+
+
+inductive InL {A : Type} (x : A) : mylist A → Prop
+| In_head : ∀ xs, InL x (x ::L xs)
+| In_tail : ∀ y xs, InL (x := x) xs → InL (x := x) (y ::L xs)
+
+inductive NoDupL {A : Type} : mylist A → Prop
+| ND_nil  : NoDupL mylist.nilL
+| ND_cons : ∀ x xs, (¬ InL x xs) → NoDupL xs → NoDupL (x ::L xs)
+
+def lengthL {A : Type} : mylist A → mynat
+| mylist.nilL    => O
+| (_ ::L tl)=> S (lengthL tl)
+
+class ring (R : Type) where
+  (zero      : R)
+  (opp       : R → R)
+  (one       : R)
+  (add       : R → R → R)
+  (mul       : R → R → R)
+
+  (one_neq_zero  : one ≠ zero)
+
+  (add_comm  : ∀ x y,    add x y = add y x)
+  (add_assoc : ∀ x y z,  add (add x y) z = add x (add y z))
+  (add_zero  : ∀ x,      add x zero = x)
+  (add_opp   : ∀ x,      add x (opp x) = zero)
+
+  (mul_comm  : ∀ x y,    mul x y = mul y x)
+  (mul_assoc : ∀ x y z,  mul (mul x y) z = mul x (mul y z))
+  (mul_one   : ∀ x,      mul x one = x)
+  (dist_l    : ∀ x y z,  mul x (add y z) = add (mul x y) (mul x z))
+  (mul_zero  : ∀ x,      mul x zero = zero)
+
+  (no_zero_div :
+    ∀ x y, mul x y = zero → x = zero ∨ y = zero)
+
+notation:35 "-R " x   => ring.opp x
+section Polynomial
+
+variable {R : Type} [rR : ring R]
+variable {polynomial : Type} [rP : ring polynomial]
+
+
+variable (degree    : polynomial → mynat)
+variable (monomial  : mynat → R → polynomial)
+variable (eval      : polynomial → R → R)
+
+
+
+local notation:55 x " -R " y => rR.add x (rR.opp y)
+
+
+def X (monomial : mynat → R → polynomial) : polynomial :=
+  monomial (S O) rR.one
+
+def C (monomial : mynat → R → polynomial) (c : R) : polynomial :=
+  monomial O c
+
+def X_minus (monomial : mynat → R → polynomial) (a : R) : polynomial :=
+  rP.add (X monomial) (C monomial (rR.opp a))
+
+
+axiom C_zero    : C monomial rR.zero = rP.zero
+axiom C_one     : C monomial rR.one  = rP.one
+
+axiom deg_zero  : degree rP.zero = O
+
+axiom eval_add  : ∀ (p q : polynomial) (x : R), eval (rP.add p q) x = rR.add (eval p x) (eval q x)
+axiom eval_mul  : ∀ (p q : polynomial) (x : R), eval (rP.mul p q) x = rR.mul (eval p x) (eval q x)
+axiom eval_C    : ∀ (c : R) (x : R),   eval (C monomial c) x = c
+axiom eval_X    : ∀ (x : R),     eval (X monomial) x     = x
+
+axiom deg_C        : ∀ (c : R), c ≠ rR.zero → degree (C monomial c) = O
+axiom deg_constant : ∀ (p : polynomial), degree p = O ↔ ∃ c : R, p = C monomial c
+axiom deg_X_minus  : ∀ (a : R), degree (X_minus monomial a) = S O
+axiom deg_mul      : ∀ (p q : polynomial), p ≠ rP.zero → q ≠ rP.zero →
+                      degree (rP.mul p q) = mynat_add (degree p) (degree q)
+
+
+
+axiom euclid_X_minus :
+  ∀ p a, ∃ (q r' : polynomial),
+    (p = rP.add (rP.mul q (X_minus monomial a)) r') ∧ (degree r' = O)
+
+
+
+
+
+
+
+theorem sub_eq_zero_l : ∀ a b : R, rR.add a (rR.opp b) = rR.zero → a = b := by
+  intro a b h
+  have h' : rR.add (rR.add a (rR.opp b)) b = rR.add rR.zero b := by
+    simpa using congrArg (fun t : R => rR.add t b) h
+
+  have := h'
+
+
+
+  have L1 : rR.add (rR.add a (rR.opp b)) b = rR.add a (rR.add (rR.opp b) b) := by
+    simpa using (rR.add_assoc a (rR.opp b) b)
+  have L2 : rR.add (rR.opp b) b = rR.zero := by
+    calc
+      rR.add (rR.opp b) b = rR.add b (rR.opp b) := by simpa using (rR.add_comm (rR.opp b) b)
+      _ = rR.zero := by simpa using (rR.add_opp b)
+  have L3 : rR.add a (rR.add (rR.opp b) b) = rR.add a rR.zero := by simp [L2]
+  have L4 : rR.add a rR.zero = a := rR.add_zero a
+
+  have R1 : rR.add rR.zero b = b := by
+    calc
+      rR.add rR.zero b = rR.add b rR.zero := by simpa using (rR.add_comm rR.zero b)
+      _ = b := by simpa using (rR.add_zero b)
+
+  have : a = b := by
+    simpa [L1, L2, L3, L4, R1] using h'
+  exact this
+
+
+def is_root (eval : polynomial → R → R) (a : R) (p : polynomial) : Prop := eval p a = rR.zero
+
+
+
+
+theorem root_factor
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R)
+  (p : polynomial) (a : R) :
+  is_root eval a p → ∃ q : polynomial, p = rP.mul q (X_minus monomial a)
+:= by
+  intro hp
+  --
+  rcases (euclid_X_minus (degree := degree) (monomial := monomial) p a) with
+    ⟨q, r, h_eq, h_deg⟩
+
+  have hr0 : eval r a = rR.zero := by
+
+    have hsum : eval (rP.add (rP.mul q (X_minus monomial a)) r) a = rR.zero := by
+      simpa [h_eq] using hp
+
+    have hsum' : rR.add (eval (rP.mul q (X_minus monomial a)) a) (eval r a) = rR.zero := by
+      simpa [eval_add] using hsum
+
+    have hmul : eval (rP.mul q (X_minus monomial a)) a
+                  = rR.mul (eval q a) (eval (X_minus monomial a) a) := by
+      simp [eval_mul]
+    have : rR.add (rR.mul (eval q a) (eval (X_minus monomial a) a)) (eval r a) = rR.zero := by
+      simpa [hmul] using hsum'
+
+    have hx : eval (X_minus monomial a) a = rR.add a (rR.opp a) := by
+      simp [X_minus, eval_add, eval_X, eval_C]
+    have : rR.add (rR.mul (eval q a) (rR.add a (rR.opp a))) (eval r a) = rR.zero := by
+      simpa [hx] using this
+    have : rR.add (rR.mul (eval q a) rR.zero) (eval r a) = rR.zero := by
+      simpa [rR.add_opp] using this
+    have : rR.add rR.zero (eval r a) = rR.zero := by
+      simpa [rR.mul_zero] using this
+    have : rR.add (eval r a) rR.zero = rR.zero := by
+      simpa [rR.add_comm] using this
+    simpa [rR.add_zero] using this
+
+  rcases (deg_constant (degree := degree) (monomial := monomial) r).mp h_deg with ⟨c, hc⟩
+  subst hc
+
+  have : c = rR.zero := by
+    simpa [eval_C] using hr0
+  subst this
+
+  have : p = rP.mul q (X_minus monomial a) := by
+    simpa [C_zero, rP.add_zero] using h_eq
+  exact ⟨q, this⟩
+
+theorem root_transfer
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R)
+  (p q : polynomial) (a b : R) :
+  p = rP.mul q (X_minus monomial a) →
+  b ≠ a →
+  is_root eval b p →
+  is_root eval b q
+:= by
+  intro hp hba hpb
+
+  have := hpb
+  have hb0 :
+    eval (rP.mul q (X_minus monomial a)) b = rR.zero := by
+    simpa [hp] using hpb
+  have : rR.mul (eval q b) (eval (X_minus monomial a) b) = rR.zero := by
+    simpa [eval_mul] using hb0
+
+  have hx : eval (X_minus monomial a) b
+              = rR.add b (rR.opp a) := by
+    simp [X_minus, eval_add, eval_X, eval_C]
+
+  have h' := rR.no_zero_div (eval q b) (b -R a) (by simpa [hx] using this)
+  rcases h' with hq | hba'
+  · exact hq
+  · have : b = a := sub_eq_zero_l (a := b) (b := a) hba'
+    exact (hba this).elim
+
+
+theorem roots_le_degree
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R)
+  (p : polynomial) (xs : mylist R) :
+  NoDupL xs →
+  (∀ a, InL a xs → is_root eval a p) →
+  p ≠ rP.zero →
+  mynat_le (lengthL xs) (degree p)
+:= by
+  intro hnd hrt hp0
+
+  have main : ∀ (xs : mylist R), NoDupL xs →
+      ∀ (p : polynomial), (∀ a, InL a xs → is_root eval a p) → p ≠ rP.zero →
+      mynat_le (lengthL xs) (degree p) := by
+    intro xs
+    induction xs with
+    | nilL =>
+        intro _ p _ _
+        simpa using mynat_zero_le (degree p)
+    | consL a xs ih =>
+        intro hnd_xs p hrt' hp0'
+
+        have ha : is_root eval a p :=
+          hrt' a (InL.In_head xs)
+
+        rcases root_factor degree monomial eval p a ha with ⟨q, hpq⟩
+
+        cases hnd_xs with
+        | ND_cons _ _ hnotin hnd_tl =>
+
+            have qnz : q ≠ rP.zero := by
+              intro h
+              have hq0 : rP.mul q (X_minus monomial a) = rP.zero := by
+                simp [h, rP.mul_comm, rP.mul_zero]
+              have : p = rP.zero := by simp [hpq, hq0]
+              exact hp0' this
+
+            have xnz : (X_minus monomial a) ≠ rP.zero := by
+              intro h
+              have hx0 : rP.mul q (X_minus monomial a) = rP.zero := by
+                simp [h, rP.mul_zero]
+              have : p = rP.zero := by simp [hpq, hx0]
+              exact hp0' this
+
+            have hdeg : degree p = S (degree q) := by
+              have := (deg_mul (degree := degree)
+                          (p := q) (q := X_minus monomial a)) qnz xnz
+
+
+              simpa [hpq, deg_X_minus, mynat_add_comm, mynat_add_zero_r, mynat_add_S_r] using this
+
+            have hF : ∀ b, InL b xs → is_root eval b q := by
+              intro b hb
+
+              have hba : b ≠ a := by
+                intro hbaeq; subst hbaeq
+                exact hnotin hb
+
+              have hbroot : is_root eval b p :=
+                hrt' b (InL.In_tail (y := a) (xs := xs) hb)
+
+              exact root_transfer degree monomial eval p q a b hpq hba hbroot
+
+            have ihRes := ih hnd_tl q hF qnz
+
+            simpa [hdeg, lengthL] using mynat_succ_le_succ ihRes
+
+  exact main xs hnd p hrt hp0
+
+
+def poly_of_roots (monomial : mynat → R → polynomial) : mylist R → polynomial
+| mylist.nilL       => rP.one
+| mylist.consL a xs => rP.mul (X_minus monomial a) (poly_of_roots monomial xs)
+
+
+theorem X_minus_nonzero
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial) :
+  ∀ a, (X_minus monomial a) ≠ rP.zero := by
+  intro a h
+  have hdeg : degree (X_minus monomial a) = S O :=
+    deg_X_minus (degree := degree) (monomial := monomial) a
+  have : degree rP.zero = S O := by simpa [h] using hdeg
+  have : O = S O := by simp [deg_zero] at this
+  cases this
+
+
+theorem constant_root_zero
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R)
+  (p : polynomial) (a : R) :
+  degree p = O → is_root eval a p → p = rP.zero := by
+  intro hdeg hroot
+  rcases (deg_constant (degree := degree) (monomial := monomial) p).mp hdeg with ⟨c, hc⟩
+  subst hc
+  have : c = rR.zero := by simpa [is_root, eval_C] using hroot
+  subst this
+  simp [C_zero]
+
+
+theorem root_of_product
+  (eval : polynomial → R → R)
+  (p q : polynomial) (a : R) :
+  is_root eval a (rP.mul p q) → is_root eval a p ∨ is_root eval a q := by
+  intro hpq
+  have : rR.mul (eval p a) (eval q a) = rR.zero := by simpa [is_root, eval_mul] using hpq
+  simpa [is_root] using rR.no_zero_div (eval p a) (eval q a) this
+
+
+theorem root_scale_constant
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R)
+  (p : polynomial) (c a : R) :
+  c ≠ rR.zero → (is_root eval a p ↔ is_root eval a (rP.mul (C monomial c) p)) := by
+  intro hc
+  constructor
+  · intro hp
+
+
+    have hpa0 : eval p a = rR.zero := hp
+    have : rR.mul c (eval p a) = rR.zero := by
+      simp [hpa0, rR.mul_zero]
+    simpa [is_root, eval_mul, eval_C] using this
+  · intro hcp
+    have hz : rR.mul c (eval p a) = rR.zero := by
+      simpa [is_root, eval_mul, eval_C] using hcp
+    have hdisj : c = rR.zero ∨ eval p a = rR.zero := rR.no_zero_div c (eval p a) hz
+    cases hdisj with
+    | inl hcz => exact (hc hcz).elim
+    | inr hp0 => simpa [is_root] using hp0
+
+
+theorem poly_of_roots_nonzero
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial) :
+  ∀ (xs : mylist R), poly_of_roots monomial xs ≠ rP.zero
+| mylist.nilL => rP.one_neq_zero
+| mylist.consL a xs =>
+    by
+      intro h
+
+      have := rP.no_zero_div (X_minus monomial a) (poly_of_roots monomial xs) h
+      rcases this with hx | hxs
+      · exact (X_minus_nonzero (degree := degree) (monomial := monomial) a) hx
+      · exact (poly_of_roots_nonzero (degree := degree) (monomial := monomial) xs) hxs
+
+
+theorem deg_poly_of_roots
+  (xs : mylist R) :
+  degree (poly_of_roots monomial xs) = lengthL xs := by
+  induction xs with
+  | nilL =>
+      calc
+        degree (poly_of_roots monomial mylist.nilL)
+            = degree rP.one := by simp [poly_of_roots]
+        _   = degree (C monomial rR.one) := by simp [C_one]
+        _   = O := by simp [deg_C, rR.one_neq_zero]
+  | consL a xs ih =>
+      have hx : (X_minus monomial a) ≠ rP.zero :=
+        X_minus_nonzero (degree := degree) (monomial := monomial) a
+      have hp : (poly_of_roots monomial xs) ≠ rP.zero :=
+        poly_of_roots_nonzero (degree := degree) (monomial := monomial) xs
+      have hmul :
+          degree (poly_of_roots monomial (mylist.consL a xs))
+            = mynat_add (degree (X_minus monomial a))
+                        (degree (poly_of_roots monomial xs)) := by
+        simpa [poly_of_roots] using
+          (deg_mul (degree := degree)
+            (p := X_minus monomial a) (q := poly_of_roots monomial xs) hx hp)
+
+      have hxdeg : degree (X_minus monomial a) = S O :=
+        deg_X_minus (degree := degree) (monomial := monomial) a
+
+      have hstep :
+          degree (poly_of_roots monomial (mylist.consL a xs))
+            = S (degree (poly_of_roots monomial xs)) := by
+        simpa [hxdeg, mynat_add_comm, mynat_add_S_r, mynat_add_zero_r] using hmul
+
+      simpa [lengthL, hstep] using congrArg S ih
+
+
+theorem root_factor_list
+  (degree : polynomial → mynat)
+  (monomial : mynat → R → polynomial)
+  (eval : polynomial → R → R) :
+  ∀ (p : polynomial) (xs : mylist R),
+    NoDupL xs →
+    (∀ a, InL a xs → is_root eval a p) →
+    ∃ q, p = rP.mul q (poly_of_roots monomial xs)
+:= by
+  intro p xs; revert p
+  induction xs with
+  | nilL =>
+      intro p _ _
+      exact ⟨p, by simp [poly_of_roots, rP.mul_one]⟩
+  | consL a xs ih =>
+      intro p hnd hroots
+
+      cases hnd with
+      | ND_cons _ _ hnotin hnd' =>
+
+          have Ha : InL a (a ::L xs) := InL.In_head xs
+          have hroot_pa : is_root eval a p := hroots a Ha
+          rcases root_factor (degree := degree) (monomial := monomial) (eval := eval) p a hroot_pa with ⟨q, hpq⟩
+
+          have Hq : ∀ b, InL b xs → is_root eval b q := by
+            intro b hb
+            have hba : b ≠ a := by
+              intro hbaeq; subst hbaeq; exact hnotin hb
+            have hbroot : is_root eval b p := hroots b (InL.In_tail (y := a) (xs := xs) hb)
+            exact root_transfer (degree := degree) (monomial := monomial) (eval := eval)
+              p q a b hpq hba hbroot
+
+          rcases ih q hnd' Hq with ⟨q0, hq0⟩
+          refine ⟨q0, ?_⟩
+
+
+
+          calc
+            p = rP.mul q (X_minus monomial a) := by simp [hpq]
+            _ = rP.mul (rP.mul q0 (poly_of_roots monomial xs)) (X_minus monomial a) := by
+                  simp [hq0]
+            _ = rP.mul q0 (rP.mul (poly_of_roots monomial xs) (X_minus monomial a)) := by
+                  simp [rP.mul_assoc]
+            _ = rP.mul q0 (rP.mul (X_minus monomial a) (poly_of_roots monomial xs)) := by
+                  simp [rP.mul_comm]
+
+
+
+theorem degree_factorisation :
+  ∀ (p : polynomial) (xs : mylist R) (q : polynomial),
+    p = rP.mul q (poly_of_roots monomial xs) →
+    q ≠ rP.zero →
+    degree p = mynat_add (degree q) (lengthL xs)
+:= by
+  intro p xs q hp hq
+  have hz : poly_of_roots monomial xs ≠ rP.zero :=
+    poly_of_roots_nonzero (degree := degree) (monomial := monomial) xs
+  simp [hp,
+         (deg_mul (degree := degree) _ _ hq hz),
+         deg_poly_of_roots (degree := degree) (monomial := monomial) xs]
+
+end Polynomial

src_data/babel-formal/proofs/lean4/probability.lean

@@ -0,0 +1,456 @@
+inductive mynat : Type
+| O  : mynat
+| S  : mynat → mynat
+deriving DecidableEq
+
+open mynat
+
+def mynat_add : mynat → mynat → mynat
+| O,        m => m
+| (S n'),   m => S (mynat_add n' m)
+
+theorem mynat_add_O_left (m : mynat) :
+  mynat_add O m = m := rfl
+
+theorem mynat_add_S_left (n m : mynat) :
+  mynat_add (S n) m = S (mynat_add n m) := rfl
+
+inductive mylist (A : Type) : Type
+| nilL  : mylist A
+| consL : A → mylist A → mylist A
+
+namespace mylist
+
+notation h "::L" t => mylist.consL h t
+
+def mapL {A B : Type} (f : A → B) : mylist A → mylist B
+| mylist.nilL    => mylist.nilL
+| (x ::L xs)     => f x ::L mapL f xs
+
+def fold_add {R : Type} (add : R → R → R) (z : R) : mylist R → R
+| mylist.nilL    => z
+| (x ::L xs)     => add x (fold_add add z xs)
+
+end mylist
+
+open mylist
+
+inductive InL {A : Type} (x : A) : mylist A → Prop
+| In_head : ∀ xs, InL x (x ::L xs)
+| In_tail : ∀ y xs, InL (x := x) xs → InL (x := x) (y ::L xs)
+
+inductive NoDupL {A : Type} : mylist A → Prop
+| ND_nil  : NoDupL mylist.nilL
+| ND_cons : ∀ x xs, (¬ InL x xs) → NoDupL xs → NoDupL (x ::L xs)
+
+class ring (R : Type) where
+  (zero      : R)
+  (opp       : R → R)
+  (one       : R)
+  (add       : R → R → R)
+  (mul       : R → R → R)
+
+  (one_neq_zero  : one ≠ zero)
+
+  (add_comm  : ∀ x y,    add x y = add y x)
+  (add_assoc : ∀ x y z,  add (add x y) z = add x (add y z))
+  (add_zero  : ∀ x,      add x zero = x)
+  (add_opp   : ∀ x,      add x (opp x) = zero)
+
+  (mul_comm  : ∀ x y,    mul x y = mul y x)
+  (mul_assoc : ∀ x y z,  mul (mul x y) z = mul x (mul y z))
+  (mul_one   : ∀ x,      mul x one = x)
+  (dist_l    : ∀ x y z,  mul x (add y z) = add (mul x y) (mul x z))
+  (mul_zero  : ∀ x,      mul x zero = zero)
+
+  (no_zero_div :
+    ∀ x y, mul x y = zero → x = zero ∨ y = zero)
+
+notation:35 "-R " x   => ring.opp x
+
+section Probability
+
+variable {R : Type} [rR : ring R]
+variable {Ω : Type}
+
+def event (Ω : Type) := Ω → Prop
+
+def ev_false : event Ω := fun _ => False
+def ev_true  : event Ω := fun _ => True
+
+def ev_inter (A B : event Ω) : event Ω := fun ω => A ω ∧ B ω
+def ev_union (A B : event Ω) : event Ω := fun ω => A ω ∨ B ω
+def ev_compl (A : event Ω)   : event Ω := fun ω => ¬ A ω
+def ev_diff (A B : event Ω)  : event Ω := fun ω => A ω ∧ ¬ B ω
+
+theorem ev_inter_comm (A B : event Ω) : ∀ ω, (ev_inter A B) ω ↔ (ev_inter B A) ω := by
+  intro ω; constructor <;> intro h
+  · exact And.intro h.right h.left
+  · exact And.intro h.right h.left
+
+theorem ev_union_comm (A B : event Ω) : ∀ ω, (ev_union A B) ω ↔ (ev_union B A) ω := by
+  intro ω; constructor <;> intro h
+  · cases h with
+    | inl hA => exact Or.inr hA
+    | inr hB => exact Or.inl hB
+  · cases h with
+    | inl hB => exact Or.inr hB
+    | inr hA => exact Or.inl hA
+
+theorem ev_inter_assoc (A B C : event Ω) : ∀ ω,
+  (ev_inter (ev_inter A B) C) ω ↔ (ev_inter A (ev_inter B C)) ω := by
+  intro ω; constructor <;> intro h
+  · rcases h with ⟨hAB, hC⟩; rcases hAB with ⟨hA, hB⟩; exact ⟨hA, ⟨hB, hC⟩⟩
+  · rcases h with ⟨hA, hBC⟩; rcases hBC with ⟨hB, hC⟩; exact ⟨⟨hA, hB⟩, hC⟩
+
+theorem ev_union_assoc (A B C : event Ω) : ∀ ω,
+  (ev_union (ev_union A B) C) ω ↔ (ev_union A (ev_union B C)) ω := by
+  intro ω; constructor <;> intro h
+  · rcases h with h | h
+    · rcases h with hA | hB
+      · exact Or.inl hA
+      · exact Or.inr (Or.inl hB)
+    · exact Or.inr (Or.inr h)
+  · rcases h with hA | hBC
+    · exact Or.inl (Or.inl hA)
+    · rcases hBC with hB | hC
+      · exact Or.inl (Or.inr hB)
+      · exact Or.inr hC
+
+theorem ev_inter_distrib_left (A B C : event Ω) : ∀ ω,
+  (ev_inter A (ev_union B C)) ω ↔ (ev_union (ev_inter A B) (ev_inter A C)) ω := by
+  intro ω; constructor <;> intro h
+  · rcases h with ⟨hA, hBC⟩; rcases hBC with hB | hC
+    · exact Or.inl ⟨hA, hB⟩
+    · exact Or.inr ⟨hA, hC⟩
+  · rcases h with hAB | hAC
+    · rcases hAB with ⟨hA, hB⟩; exact ⟨hA, Or.inl hB⟩
+    · rcases hAC with ⟨hA, hC⟩; exact ⟨hA, Or.inr hC⟩
+
+def disjoint (A B : event Ω) : Prop := ∀ ω, ¬ ((ev_inter A B) ω)
+
+def pairwise_disjoint : mylist (event Ω) → Prop
+| mylist.nilL      => True
+| (_ ::L mylist.nilL) => True
+| (A ::L (B ::L xs))  => disjoint A B ∧ (∀ C, InL C (B ::L xs) → disjoint A C) ∧ pairwise_disjoint (B ::L xs)
+
+def bigUnion : mylist (event Ω) → event Ω
+| mylist.nilL      => ev_false
+| (A ::L xs)       => ev_union A (bigUnion xs)
+
+variable (prob : event Ω → R)
+
+axiom prob_ext : ∀ {A B : event Ω}, (∀ ω, A ω ↔ B ω) → prob A = prob B
+axiom prob_false : prob ev_false = rR.zero
+axiom prob_true  : prob ev_true  = rR.one
+
+axiom prob_union : ∀ (A B : event Ω),
+  prob (ev_union A B) = rR.add (prob A) (rR.add (prob B) (rR.opp (prob (ev_inter A B))))
+
+axiom prob_compl : ∀ (A : event Ω), prob (ev_compl A) = rR.add rR.one (rR.opp (prob A))
+
+axiom em : ∀ p : Prop, p ∨ ¬ p
+
+axiom cprob : event Ω → event Ω → R
+axiom cprob_mul : ∀ A B, prob (ev_inter A B) = rR.mul (cprob A B) (prob B)
+
+def indep (A B : event Ω) : Prop := prob (ev_inter A B) = rR.mul (prob A) (prob B)
+
+local notation:55 x " -R " y => rR.add x (rR.opp y)
+
+axiom opp_zero  : rR.opp rR.zero = rR.zero
+axiom opp_opp   : ∀ x, rR.opp (rR.opp x) = x
+axiom opp_mul_right : ∀ x y, rR.mul x (rR.opp y) = rR.opp (rR.mul x y)
+axiom opp_mul_left  : ∀ x y, rR.mul (rR.opp x) y = rR.opp (rR.mul x y)
+
+axiom prob_union_disjoint : ∀ (A B : event Ω), disjoint A B → prob (ev_union A B) = rR.add (prob A) (prob B)
+axiom disjoint_head_tail : ∀ (A : event Ω) (xs : mylist (event Ω)), pairwise_disjoint (A ::L xs) → disjoint A (bigUnion xs)
+
+theorem prob_union_comm (A B : event Ω) :
+  prob (ev_union A B) = prob (ev_union B A) := by
+  have h₁ := prob_union (prob := prob) A B
+  have h₂ := prob_union (prob := prob) B A
+  have hcap : prob (ev_inter A B) = prob (ev_inter B A) := by
+    have := prob_ext (prob := prob) (A := ev_inter A B) (B := ev_inter B A) (ev_inter_comm A B)
+    exact this
+  have hunion : prob (ev_union A B) = prob (ev_union B A) := by
+    exact prob_ext (prob := prob) (A := ev_union A B) (B := ev_union B A) (ev_union_comm A B)
+  exact hunion
+
+theorem prob_union_idem (A : event Ω) :
+  prob (ev_union A A) = prob A := by
+  have h := prob_union (prob := prob) A A
+  -- (A ∧ A) ↔ A, written as a pure term (no `by`)
+  have hAA : ∀ ω, ev_inter A A ω ↔ A ω :=
+    fun ω => Iff.intro (fun h => h.left) (fun h => And.intro h h)
+  have hcap : prob (ev_inter A A) = prob A :=
+    prob_ext (prob := prob) (A := ev_inter A A) (B := A) hAA
+  have h2 : rR.add (prob A) (rR.opp (prob A)) = rR.zero := rR.add_opp (prob A)
+  have h3 : rR.add (prob A) (rR.add (prob A) (rR.opp (prob A))) = rR.add (prob A) rR.zero := by simp [h2]
+  have h4 : rR.add (prob A) rR.zero = prob A := rR.add_zero (prob A)
+  have : prob (ev_union A A) = rR.add (prob A) (rR.add (prob A) (rR.opp (prob A))) := by
+    simpa [hcap]
+    using h
+  simpa [h3, h4]
+
+
+
+
+
+theorem prob_diff (A B : event Ω) :
+  prob (ev_diff A B) = prob A -R prob (ev_inter A B) := by
+  have hpart : ∀ ω, (A ω) ↔ (ev_union (ev_inter A B) (ev_inter A (ev_compl B))) ω := by
+    intro ω; constructor
+    · intro hA
+      have hb := em (B ω)
+      cases hb with
+      | inl hB => exact Or.inl ⟨hA, hB⟩
+      | inr hB => exact Or.inr ⟨hA, hB⟩
+    · intro hU; cases hU with
+      | inl hAB => exact hAB.left
+      | inr hAcB => exact hAcB.left
+  have hcap_disj : ∀ ω, (ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) ω ↔ False := by
+    intro ω; constructor <;> intro h
+    · rcases h with ⟨hAB, hAcB⟩; exact hAcB.right hAB.right
+    · cases h
+  have hAeq := prob_ext (prob := prob) (A := A) (B := ev_union (ev_inter A B) (ev_inter A (ev_compl B))) hpart
+  have hcap0 : prob (ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) = rR.zero := by
+    have := prob_ext (prob := prob) (A := ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) (B := ev_false) hcap_disj
+    simpa [prob_false] using this
+  have h := prob_union (prob := prob) (ev_inter A B) (ev_inter A (ev_compl B))
+  have hsumA : prob A = rR.add (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B))) := by
+    have : prob A = prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B))) := by
+      simpa using hAeq
+    have hU := h
+    have hzero_opp : rR.opp (prob (ev_inter (ev_inter A B) (ev_inter A (ev_compl B)))) = rR.opp rR.zero := by
+      simp [hcap0]
+    have hopp0 : rR.opp rR.zero = rR.zero := opp_zero
+    simpa [this, hzero_opp, hopp0, rR.add_assoc, rR.add_zero]
+      using hU
+  have heq_diff : prob (ev_diff A B) = prob (ev_inter A (ev_compl B)) := by
+    exact prob_ext (prob := prob) (A := ev_diff A B) (B := ev_inter A (ev_compl B)) (by intro ω; constructor <;> intro h; exact h; exact h)
+  have hsub : rR.add (prob A) (rR.opp (prob (ev_inter A B)))
+              = prob (ev_inter A (ev_compl B)) := by
+    calc
+      rR.add (prob A) (rR.opp (prob (ev_inter A B)))
+          = rR.add (rR.add (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B)))) (rR.opp (prob (ev_inter A B))) := by
+              simp [hsumA]
+      _ = rR.add (prob (ev_inter A B)) (rR.add (prob (ev_inter A (ev_compl B))) (rR.opp (prob (ev_inter A B)))) := by
+              simpa using (rR.add_assoc (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B))) (rR.opp (prob (ev_inter A B))))
+      _ = rR.add (rR.add (prob (ev_inter A (ev_compl B))) (rR.opp (prob (ev_inter A B)))) (prob (ev_inter A B)) := by
+              simpa using (rR.add_comm (prob (ev_inter A B)) (rR.add (prob (ev_inter A (ev_compl B))) (rR.opp (prob (ev_inter A B)))))
+      _ = rR.add (prob (ev_inter A (ev_compl B))) (rR.add (rR.opp (prob (ev_inter A B))) (prob (ev_inter A B))) := by
+              simpa using (rR.add_assoc (prob (ev_inter A (ev_compl B))) (rR.opp (prob (ev_inter A B))) (prob (ev_inter A B)))
+      _ = rR.add (prob (ev_inter A (ev_compl B))) (rR.add (prob (ev_inter A B)) (rR.opp (prob (ev_inter A B)))) := by
+              have := rR.add_comm (rR.opp (prob (ev_inter A B))) (prob (ev_inter A B))
+              simpa using congrArg (fun t => rR.add (prob (ev_inter A (ev_compl B))) t) this
+      _ = rR.add (prob (ev_inter A (ev_compl B))) rR.zero := by
+              simp [rR.add_opp]
+      _ = prob (ev_inter A (ev_compl B)) := by
+              simp [rR.add_zero]
+  simpa [heq_diff] using hsub.symm
+
+theorem bayes_symm (A B : event Ω) :
+  rR.mul (cprob A B) (prob B) = rR.mul (cprob B A) (prob A) := by
+  calc
+    rR.mul (cprob A B) (prob B) = prob (ev_inter A B) := by simpa using (cprob_mul (prob := prob) A B).symm
+    _ = prob (ev_inter B A) := by
+          have := prob_ext (prob := prob) (A := ev_inter A B) (B := ev_inter B A) (ev_inter_comm A B)
+          simpa using this
+    _ = rR.mul (cprob B A) (prob A) := by simpa using (cprob_mul (prob := prob) B A)
+
+theorem law_total_prob (A B : event Ω) :
+  prob A = rR.add (rR.mul (cprob A B) (prob B)) (rR.mul (cprob A (ev_compl B)) (prob (ev_compl B))) := by
+  have hpart : ∀ ω, (A ω) ↔ (ev_union (ev_inter A B) (ev_inter A (ev_compl B))) ω := by
+    intro ω; constructor
+    · intro hA; cases em (B ω) with
+      | inl hB => exact Or.inl ⟨hA, hB⟩
+      | inr hB => exact Or.inr ⟨hA, hB⟩
+    · intro hU; cases hU with
+      | inl hAB  => exact hAB.left
+      | inr hAcB => exact hAcB.left
+  have hAeq := prob_ext (prob := prob) (A := A) (B := ev_union (ev_inter A B) (ev_inter A (ev_compl B))) hpart
+  have hcap0 : prob (ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) = rR.zero := by
+    have : ∀ ω, (ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) ω ↔ False := by
+      intro ω; constructor <;> intro h
+      · rcases h with ⟨hAB, hAcB⟩; exact hAcB.right hAB.right
+      · cases h
+    have := prob_ext (prob := prob) (A := ev_inter (ev_inter A B) (ev_inter A (ev_compl B))) (B := ev_false) this
+    simpa [prob_false] using this
+  have h := prob_union (prob := prob) (ev_inter A B) (ev_inter A (ev_compl B))
+  have hsumA : prob A = rR.add (prob (ev_inter A B)) (prob (ev_inter A (ev_compl B))) := by
+    have : prob A = prob (ev_union (ev_inter A B) (ev_inter A (ev_compl B))) := by
+      simpa using hAeq
+    have hU := h
+    have hzero_opp : rR.opp (prob (ev_inter (ev_inter A B) (ev_inter A (ev_compl B)))) = rR.opp rR.zero := by
+      simp [hcap0]
+    have hopp0 : rR.opp rR.zero = rR.zero := opp_zero
+    simpa [this, hzero_opp, hopp0, rR.add_assoc, rR.add_zero]
+      using hU
+  simp [hsumA, cprob_mul (prob := prob) A B, cprob_mul (prob := prob) A (ev_compl B)]
+
+theorem prob_union_indep (A B : event Ω) :
+  indep (prob := prob) A B →
+  prob (ev_union A B) = rR.add (prob A) (rR.add (prob B) (rR.opp (rR.mul (prob A) (prob B)))) := by
+  intro hI
+  have hU := prob_union (prob := prob) A B
+  have hIeq : prob (ev_inter A B) = rR.mul (prob A) (prob B) := hI
+  simpa [hIeq] using hU
+
+theorem indep_compl_right (A B : event Ω) :
+  indep (prob := prob) A B → indep (prob := prob) A (ev_compl B) := by
+  intro hI
+  have hdiff := prob_diff (prob := prob) A B
+  have heq_diff : prob (ev_inter A (ev_compl B)) = rR.add (prob A) (rR.opp (prob (ev_inter A B))) := by
+    have hset : prob (ev_diff A B) = prob (ev_inter A (ev_compl B)) :=
+      prob_ext (prob := prob) (A := ev_diff A B) (B := ev_inter A (ev_compl B))
+        (by intro ω; constructor <;> intro h <;> exact h)
+    simpa [hset] using hdiff
+  have hIeq : prob (ev_inter A B) = rR.mul (prob A) (prob B) := hI
+  have hlhs : prob (ev_inter A (ev_compl B)) = rR.add (prob A) (rR.opp (rR.mul (prob A) (prob B))) := by
+    simpa [hIeq]
+      using heq_diff
+  have hdist : rR.add (rR.mul (prob A) rR.one) (rR.mul (prob A) (rR.opp (prob B)))
+                = rR.mul (prob A) (rR.add rR.one (rR.opp (prob B))) := by
+    simpa using (rR.dist_l (prob A) rR.one (rR.opp (prob B))).symm
+  have hmul1 : rR.mul (prob A) rR.one = prob A := rR.mul_one (prob A)
+  have hmul2 : rR.mul (prob A) (rR.opp (prob B)) = rR.opp (rR.mul (prob A) (prob B)) := by
+    simpa using (opp_mul_right (prob A) (prob B))
+  have halg : rR.add (prob A) (rR.opp (rR.mul (prob A) (prob B)))
+              = rR.mul (prob A) (rR.add rR.one (rR.opp (prob B))) := by
+    simpa [hmul1, hmul2] using hdist
+  have : prob (ev_inter A (ev_compl B)) = rR.mul (prob A) (prob (ev_compl B)) := by
+    simpa [prob_compl (prob := prob) B, halg] using hlhs
+  exact this
+
+theorem indep_symm (A B : event Ω) :
+  indep (prob := prob) A B → indep (prob := prob) B A := by
+  intro hI
+  unfold indep at hI
+  unfold indep
+  have hcap : prob (ev_inter B A) = prob (ev_inter A B) := by
+    have := prob_ext (prob := prob) (A := ev_inter B A) (B := ev_inter A B) (ev_inter_comm B A)
+    simpa using this
+  have hmul : rR.mul (prob A) (prob B) = rR.mul (prob B) (prob A) := by
+    simpa using (rR.mul_comm (prob A) (prob B))
+  calc
+    prob (ev_inter B A) = prob (ev_inter A B) := hcap
+    _ = rR.mul (prob A) (prob B) := hI
+    _ = rR.mul (prob B) (prob A) := by simpa using hmul
+
+theorem indep_compl_left (A B : event Ω) :
+  indep (prob := prob) A B → indep (prob := prob) (ev_compl A) B := by
+  intro hI
+  have hBA : indep (prob := prob) B A := indep_symm (prob := prob) A B hI
+  have hBnotA : indep (prob := prob) B (ev_compl A) :=
+    indep_compl_right (prob := prob) B A hBA
+  exact indep_symm (prob := prob) B (ev_compl A) hBnotA
+
+axiom indep_compl_both (A B : event Ω) :
+  indep (prob := prob) A B → indep (prob := prob) (ev_compl A) (ev_compl B)
+
+theorem prob_bigUnion_disjoint
+  (xs : mylist (event Ω))
+  (hp : pairwise_disjoint xs) :
+  prob (bigUnion xs)
+    = mylist.fold_add rR.add rR.zero (mylist.mapL prob xs) := by
+  revert hp
+  induction xs with
+  | nilL =>
+      intro _
+      simp [bigUnion, mylist.fold_add, mylist.mapL, prob_false]
+  | consL A xs ih =>
+      intro hp
+      cases xs with
+      | nilL =>
+          have hunionA : prob (ev_union A ev_false) = prob A :=
+            prob_ext (prob := prob) (A := ev_union A ev_false) (B := A)
+              (by
+                intro ω; constructor
+                · intro h; cases h with
+                  | inl hA => exact hA
+                  | inr hf => exact False.elim hf
+                · intro hA; exact Or.inl hA)
+          simp [bigUnion, mylist.fold_add, mylist.mapL, rR.add_zero, hunionA]
+      | consL B xs' =>
+          rcases hp with ⟨hAB, hrest, hpw⟩
+          have hAdisj : disjoint A (bigUnion (B ::L xs')) :=
+            disjoint_head_tail A (B ::L xs') (by
+              exact And.intro hAB (And.intro hrest hpw))
+          have hU' :
+              prob (bigUnion (A ::L (B ::L xs'))) =
+              rR.add (prob A) (prob (bigUnion (B ::L xs'))) := by
+            simpa [bigUnion] using
+              (prob_union_disjoint (prob := prob) A (bigUnion (B ::L xs')) hAdisj)
+          have htail :
+              prob (bigUnion (B ::L xs')) =
+              mylist.fold_add rR.add rR.zero (mylist.mapL prob (B ::L xs')) :=
+            ih hpw
+          have hsum :
+              prob (bigUnion (A ::L (B ::L xs'))) =
+              rR.add (prob A)
+                (mylist.fold_add rR.add rR.zero (mylist.mapL prob (B ::L xs'))) := by
+            simpa [htail] using hU'
+          simpa [bigUnion, mylist.mapL, mylist.fold_add, rR.add_assoc] using hsum
+
+theorem prob_bigUnion_disjoint_zero
+  (xs : mylist (event Ω))
+  (hp : pairwise_disjoint xs)
+  (hzero : ∀ A, InL A xs → prob A = rR.zero) :
+  prob (bigUnion xs) = rR.zero := by
+  revert hp hzero
+  induction xs with
+  | nilL =>
+      intro _ _
+      simp [bigUnion, prob_false]
+  | consL A xs ih =>
+      intro hp hzero
+      cases xs with
+      | nilL =>
+          have hA0 : prob A = ring.zero := hzero A (InL.In_head _)
+          have hunionA : prob (ev_union A ev_false) = prob A :=
+            prob_ext (prob := prob) (A := ev_union A ev_false) (B := A)
+              (by
+                intro ω; constructor
+                · intro h; cases h with
+                  | inl hA => exact hA
+                  | inr hf => exact False.elim hf
+                · intro hA; exact Or.inl hA)
+          simp [bigUnion, hunionA, hA0]
+      | consL B xs' =>
+          rcases hp with ⟨hAB, hrest, hpw⟩
+          have hAdisj : disjoint A (bigUnion (B ::L xs')) :=
+            disjoint_head_tail A (B ::L xs') (by exact And.intro hAB (And.intro hrest hpw))
+          have hA0 : prob A = rR.zero := hzero A (InL.In_head _)
+          have htail0 : ∀ C, InL C (B ::L xs') → prob C = rR.zero := by
+            intro C hC; exact hzero C (InL.In_tail (y := A) (xs := B ::L xs') hC)
+          have htail : prob (bigUnion (B ::L xs')) = rR.zero := ih hpw htail0
+          have hU :
+            prob (bigUnion (A ::L (B ::L xs'))) =
+            rR.add (prob A) (prob (bigUnion (B ::L xs'))) := by
+            simpa [bigUnion] using
+              (prob_union_disjoint (prob := prob) A (bigUnion (B ::L xs')) hAdisj)
+          have hsum00 :
+            rR.add (prob A) (prob (bigUnion (B ::L xs'))) =
+            rR.add rR.zero rR.zero := by
+            simp [hA0, htail]
+          have : prob (bigUnion (A ::L (B ::L xs'))) =
+                rR.add rR.zero rR.zero := by
+            simpa [hsum00] using hU
+          have hz : rR.add rR.zero rR.zero = rR.zero := by
+            simp [rR.add_zero]
+          simp [this, hz]
+
+
+
+axiom inclusion_exclusion_three (A B C : event Ω) :
+  prob (ev_union (ev_union A B) C)
+    = rR.add (prob A)
+      (rR.add (prob B)
+        (rR.add (prob C)
+          (rR.opp (rR.add (prob (ev_inter A B))
+                 (rR.add (prob (ev_inter A C))
+                         (rR.add (prob (ev_inter B C))
+                                 (rR.opp (prob (ev_inter (ev_inter A B) C)))))))))
+
+end Probability

src_data/babel-formal/proofs/lean4/set_algebra.lean

@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+universe u
+
+namespace SetAlgebra
+
+variable {X : Type u}
+
+axiom classic : ∀ P : Prop, P ∨ ¬ P
+
+def sUnion (A B : X → Prop) : X → Prop := fun x => A x ∨ B x
+def sInter (A B : X → Prop) : X → Prop := fun x => A x ∧ B x
+def sCompl (A : X → Prop) : X → Prop := fun x => ¬ A x
+
+infixl:65  " ∪s " => sUnion
+infixl:70  " ∩s " => sInter
+prefix:100 "ᶜs" => sCompl
+
+theorem inter_distrib_left (A B C : X → Prop) :
+  ∀ x, (A ∩s (B ∪s C)) x ↔ ((A ∩s B) ∪s (A ∩s C)) x :=
+by
+  intro x; constructor
+  · intro h; rcases h with ⟨hA, hBC⟩; cases hBC with
+    | inl hB => exact Or.inl ⟨hA, hB⟩
+    | inr hC => exact Or.inr ⟨hA, hC⟩
+  · intro h; cases h with
+    | inl hAB => exact ⟨hAB.1, Or.inl hAB.2⟩
+    | inr hAC => exact ⟨hAC.1, Or.inr hAC.2⟩
+
+theorem inter_distrib_right (A B C : X → Prop) :
+  ∀ x, ((A ∪s B) ∩s C) x ↔ ((A ∩s C) ∪s (B ∩s C)) x :=
+by
+  intro x; constructor
+  · intro h; rcases h with ⟨hAB, hC⟩; cases hAB with
+    | inl hA => exact Or.inl ⟨hA, hC⟩
+    | inr hB => exact Or.inr ⟨hB, hC⟩
+  · intro h; cases h with
+    | inl hAC => exact ⟨Or.inl hAC.1, hAC.2⟩
+    | inr hBC => exact ⟨Or.inr hBC.1, hBC.2⟩
+
+theorem de_morgan_union (A B : X → Prop) :
+  ∀ x, (ᶜs (A ∪s B)) x ↔ (ᶜs A ∩s ᶜs B) x :=
+by
+  intro x; constructor
+  · intro h; exact ⟨fun hA => h (Or.inl hA), fun hB => h (Or.inr hB)⟩
+  · intro h; intro hAB; cases h with
+    | intro hA hB => cases hAB with
+      | inl hA' => exact (hA hA')
+      | inr hB' => exact (hB hB')
+
+theorem de_morgan_inter (A B : X → Prop) :
+  ∀ x, (ᶜs (A ∩s B)) x ↔ (ᶜs A ∪s ᶜs B) x :=
+by
+  intro x; constructor
+  · intro h
+    cases classic (A x) with
+    | inl hA =>
+        right; intro hB; exact h ⟨hA, hB⟩
+    | inr hA =>
+        left; exact hA
+  · intro h; intro hAB; cases hAB with
+    | intro hA hB => cases h with
+      | inl hA' => exact hA' hA
+      | inr hB' => exact hB' hB
+
+end SetAlgebra

src_data/babel-formal/proofs/lean4/supinf.lean

@@ -0,0 +1,197 @@
+class CompleteOrderedField where
+  R       : Type
+  NatAlt  : Type
+  zero_nat : NatAlt
+  Succ : NatAlt -> NatAlt
+  NatAltle : NatAlt -> NatAlt -> Prop
+
+  zero    : R
+  one     : R
+  add     : R → R → R
+  mul     : R → R → R
+  opp     : R → R
+  inv     : R → R
+  Rle     : R → R → Prop
+  Rlt     : R → R → Prop
+  Rabs    : R → R
+  INR     : NatAlt → R
+
+  NatAltle_n : ∀ n : NatAlt, NatAltle n n
+  le_succ_of_le : ∀ n m: NatAlt, NatAltle n m → NatAltle n (Succ m)
+  le_succ : ∀ n : NatAlt, NatAltle n (Succ n)
+
+  add_comm      : ∀ x y : R, add x y = add y x
+  add_assoc     : ∀ x y z : R, add (add x y) z = add x (add y z)
+  add_zero      : ∀ x : R, add x zero = x
+  add_opp       : ∀ x : R, add (opp x) x = zero
+  mul_comm      : ∀ x y : R, mul x y = mul y x
+  mul_assoc     : ∀ x y z : R, mul (mul x y) z = mul x (mul y z)
+  mul_one       : ∀ x : R, mul x one = x
+  dist_l        : ∀ x y z : R, mul x (add y z) = add (mul x y) (mul x z)
+  sub_zero      : ∀ x : R, add x (opp zero) = x
+  Rle_refl      : ∀ x : R, Rle x x
+  Rle_trans     : ∀ x y z : R, Rle x y → Rle y z → Rle x z
+  Rle_antisym   : ∀ x y : R, Rle x y → Rle y x → x = y
+  Rlt_def       : ∀ x y : R, Rlt x y ↔ (Rle x y ∧ x ≠ y)
+  Rle_abs       : ∀ x : R, Rle (add x (opp zero)) (Rabs x)
+  Rinv_0_lt_compat : ∀ x : R, Rlt zero x → Rlt zero (inv x)
+  Rplus_le_compat_l : ∀ x y z : R, Rle y z → Rle (add x y) (add x z)
+  Rinv_involutive   : ∀ x : R, Rlt zero x → inv (inv x) = x
+  INR_pos       : ∀ n, Rlt zero (INR (Succ n))
+  INR_le        : ∀ m n, (NatAltle m n) → Rle (INR m) (INR n)
+  INR_0         : INR zero_nat = zero
+  INR_S         : ∀ n, INR (Succ n) = add (INR n) one
+  Rtotal_order  : ∀ x y : R, Rlt x y ∨ x = y ∨ Rlt y x
+  Rle_inv_contravar : ∀ a b : R, Rlt zero a → Rlt zero b → Rle a b → Rle (inv b) (inv a)
+  eps_between   : ∀ x y : R, Rlt x y → ∃ eps, Rlt zero eps ∧ Rlt (add x eps) y
+  archimedean   : ∀ x : R, ∃ n, Rle x (INR n)
+  completeness  : ∀ (A : R → Prop),
+    (∃ ub, ∀ a, A a → Rle ub a) →
+    ∃ sup, (∀ a, A a → Rle a sup) ∧ ∀ y, (∀ a, A a → Rle a y) → Rle sup y
+
+namespace SupInf
+
+variable [F : CompleteOrderedField]
+open CompleteOrderedField (R zero one add mul opp inv Rle Rlt Rabs INR NatAltle)
+
+infixl:65 " + " => add
+infixl:70 " * " => mul
+prefix:100 "-" => opp
+notation x " - " y:65 => add x (opp y)
+prefix:100 "/" => inv
+infixl:70 " <= " => NatAltle
+infixl:70 " <=R " => Rle
+infixl:70 " <R " => Rlt
+infixl:70 " >R " => (fun x y => Rlt y x)
+notation "|" x "|" => Rabs x
+
+
+local notation "R" => F.R
+
+def up_bounds (A : R → Prop) : R → Prop :=
+  fun x => ∀ a, A a → a <=R x
+
+def is_maximum (a : R) (A : R → Prop) : Prop :=
+  A a ∧ up_bounds A a
+
+infix:70 " is_a_max_of " => is_maximum
+
+theorem add_sub_cancel_r (a b : R) :
+    a + (b - a) = b := by
+  rw [←F.add_assoc]
+  rw [F.add_comm]
+  rw [←F.add_assoc]
+  rw [F.add_opp]
+  rw [F.add_comm]
+  rw [F.add_zero]
+
+theorem Rabs_pos (t : R) : t <=R |t| := by
+  have H := F.Rle_abs t
+  rw [F.sub_zero] at H
+  exact H
+
+theorem unique_max (A : R → Prop) (x y : R) :
+    x is_a_max_of A → y is_a_max_of A → x = y := by
+  rintro ⟨HxA, Hx⟩ ⟨HyA, Hy⟩
+  apply F.Rle_antisym
+  · apply Hy; exact HxA
+  · apply Hx; exact HyA
+
+def low_bounds (A : R → Prop) : R → Prop :=
+  fun x => ∀ a, A a → x <=R a
+
+def is_inf (x : R) (A : R → Prop) : Prop :=
+  is_maximum x (low_bounds A)
+
+infix:70 " is_an_inf_of " => is_inf
+
+axiom classic : ∀ P : Prop, P ∨ ¬P
+
+theorem inf_lt (A : R → Prop) (x : R) :
+    x is_an_inf_of A → ∀ y, x <R y → ∃ a, A a ∧ a <R y := by
+  intro Hinf y Hlt
+  rcases Hinf with ⟨Hlow, Hmax⟩
+  cases classic (∃ a, A a ∧ a <R y) with
+  | inl Hex => exact Hex
+  | inr Hnex =>
+      have Hlb : low_bounds A y :=
+        fun a Ha =>
+          match F.Rtotal_order y a with
+          | Or.inl Hya =>
+              (F.Rlt_def y a).mp Hya |>.1
+          | Or.inr (Or.inl Heq) =>
+              Heq ▸ F.Rle_refl y
+          | Or.inr (Or.inr Hay) =>
+              False.elim (Hnex ⟨a, Ha, Hay⟩)
+      let Hmax_y := Hmax y Hlb
+      specialize Hmax y Hlb
+      let ⟨Hxly, Hneq⟩ := (F.Rlt_def x y).mp Hlt
+      have Hxy := F.Rle_antisym x y Hxly Hmax_y
+      subst Hxy
+      contradiction
+
+
+theorem le_of_le_add_eps (x y : R) :
+    (∀ eps, eps >R F.zero → y <=R (x + eps)) → y <=R x := by
+  intro H
+  match F.Rtotal_order y x with
+  | Or.inl Hlt =>
+      exact (F.Rlt_def y x).mp Hlt |>.1
+  | Or.inr (Or.inl Heq) =>
+      rw [Heq]; exact F.Rle_refl x
+  | Or.inr (Or.inr Hgt) =>
+      obtain ⟨eps, Heps, Hxp⟩ := F.eps_between x y Hgt
+      specialize H eps Heps
+      let ⟨Hxp_le, Hxp_neq⟩ := (F.Rlt_def (x + eps) y).mp Hxp
+      exfalso
+      apply Hxp_neq
+      exact F.Rle_antisym (x + eps) y Hxp_le H
+
+
+def limit (u : F.NatAlt → R) (l : R) : Prop :=
+  ∀ eps, eps >R F.zero → ��� N : F.NatAlt, ∀ n : F.NatAlt, N <= n → |u n - l| <=R eps
+
+theorem le_lim (x y : R) (u : F.NatAlt → R) :
+    limit u x → (∀ n : F.NatAlt, y <=R u n) → y <=R x := by
+  intros Hlim Hle
+  apply le_of_le_add_eps
+  intro eps Heps
+  obtain ⟨N, HN⟩ := Hlim eps Heps
+  apply F.Rle_trans y (u N) (x + eps) (Hle N)
+  apply F.Rle_trans (u N) (x + (u N - x)) (x + eps)
+  · rw [add_sub_cancel_r]
+    exact F.Rle_refl (u N)
+  · apply F.Rplus_le_compat_l
+    apply F.Rle_trans (u N - x) (|u N - x|) eps
+    · apply Rabs_pos
+    · exact HN N (F.NatAltle_n N)
+
+theorem inv_succ_pos (n : F.NatAlt) : F.zero <R /F.INR (F.Succ n) := by
+  apply F.Rinv_0_lt_compat
+  apply F.INR_pos
+
+theorem limit_inv_succ (eps : R) (Heps : eps >R F.zero) :
+    ∃ N, ∀ n : F.NatAlt, N <= n → /F.INR (F.Succ n) <=R eps := by
+  let x := /eps
+  have Hx_pos : F.zero <R x := by
+    apply F.Rinv_0_lt_compat
+    exact Heps
+  obtain ⟨N, Harch⟩ := F.archimedean x
+  let N1 := F.Succ N
+  exists N1
+  intros n Hn
+  have H_INR_le : F.INR N1 <=R F.INR (F.Succ n) :=
+    F.INR_le N1 (F.Succ n) (F.le_succ_of_le N1 n Hn)
+  have H_INR_pos : F.zero <R F.INR (F.Succ n) :=
+    F.INR_pos n
+  have H_INR_N_pos : F.zero <R F.INR N1 :=
+    F.INR_pos N
+  apply F.Rle_trans
+  · exact F.Rle_inv_contravar (F.INR N1) (F.INR (F.Succ n)) H_INR_N_pos H_INR_pos H_INR_le
+  have Harch1 : x <=R F.INR N1 := F.Rle_trans x (F.INR N) (F.INR N1) Harch (F.INR_le N N1 (F.le_succ N))
+  apply F.Rle_trans
+  · exact F.Rle_inv_contravar x (F.INR N1) Hx_pos H_INR_N_pos Harch1
+  rw [F.Rinv_involutive _ Heps]
+  exact F.Rle_refl eps
+
+end SupInf