Mercurial > hg > Members > kono > Proof > ZF-in-agda

changeset 482:ce4f3f180b8e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 06 Apr 2022 07:57:37 +0900
parents 263d2d1a000e
children ed29002a02b6
files src/Topology.agda src/filter.agda src/zorn.agda
diffstat 3 files changed, 44 insertions(+), 42 deletions(-) [+]
line wrap: on
line diff
--- a/src/Topology.agda	Sun Apr 03 18:51:58 2022 +0900
+++ b/src/Topology.agda	Wed Apr 06 07:57:37 2022 +0900
@@ -32,14 +32,14 @@
 
 open import filter
 
-record Toplogy  ( L : HOD ) : Set (suc n) where
+record Topology  ( L : HOD ) : Set (suc n) where
    field
        OS    : HOD
        OS⊆PL :  OS ⊆ Power L 
        o∪ : { P : HOD }  →  P  ⊆ OS           → OS ∋ Union P
        o∩ : { p q : HOD } → OS ∋ p →  OS ∋ q  → OS ∋ (p ∩ q)
 
-open Toplogy
+open Topology
 
 record _covers_ ( P q : HOD  ) : Set (suc n) where
    field
@@ -58,7 +58,7 @@
 
 -- Limit point
 
-record LP ( L S x : HOD ) (top : Toplogy L) (S⊆PL :  S ⊆ Power L ) ( S∋x : S ∋ x ) : Set (suc n) where
+record LP ( L S x : HOD ) (top : Topology L) (S⊆PL :  S ⊆ Power L ) ( S∋x : S ∋ x ) : Set (suc n) where
    field
       neip   : {y : HOD} → OS top ∋ y → y ∋ x → HOD
       isNeip : {y : HOD} → (o∋y : OS top ∋ y ) → (y∋x : y ∋ x ) → ¬ ( x ≡ neip o∋y y∋x) ∧ ( y ∋ neip o∋y y∋x )
@@ -88,16 +88,16 @@
 
 -- FIP is Compact
 
-FIP→Compact : {L P : HOD} → Tolopogy L → FIP L P → Compact L P
-FIP→Compact = ?
+FIP→Compact : {L P : HOD} → Topology L → FIP L P → Compact L P
+FIP→Compact = {!!}
 
-Compact→FIP : {L P : HOD} → Tolopogy L → Compact L P → FIP L P
-Compact→FIP = ?
+Compact→FIP : {L P : HOD} → Topology L → Compact L P → FIP L P
+Compact→FIP = {!!}
 
 -- Product Topology
 
-_Top⊗_ : {P Q : HOD} → Topology P → Tolopogy Q → Topology ( P ⊗ Q )
-_Top⊗_ = ?
+_Top⊗_ : {P Q : HOD} → Topology P → Topology Q → Topology {!!}
+_Top⊗_ = {!!}
 
 -- existence of Ultra Filter 
 
--- a/src/filter.agda	Sun Apr 03 18:51:58 2022 +0900
+++ b/src/filter.agda	Wed Apr 06 07:57:37 2022 +0900
@@ -231,26 +231,17 @@
  
 open import zorn
 
+-- MaximumSubset' : {L P : HOD}
+--        → o∅ o< & L →  o∅ o< & P → P ⊆ L
+--        → PartialOrderSet O P (_⊆'_ O)
+--        → ( (B : HOD) → B ⊆ P → TotalOrderSet O B (_⊆'_ O) → SUP O P B (_⊆'_ O) )
+--        → Maximal O P (_⊆'_ O)
+-- MaximumSubset' {L} {P} 0<L 0<P P⊆L PO SP  = Zorn-lemma O {P} {_⊆'_ O } 0<P PO SP
+
 MaximumFilterExist : {L P : HOD} (LP : L ⊆ Power P) → ({p : HOD} → L ∋ p → L ∋ ( P ＼ p)) → ({p q : HOD} → L ∋ p → L ∋ q → L ∋ (p ∩ q))
        → (F : Filter LP) → o∅ o< & L →  o∅ o< & (filter F)  →  (¬ (filter F ∋ od∅)) → MaximumFilter LP 
-MaximumFilterExist {L} {P} LP NEG CAP F 0<L 0<F Fprop = record { mf = {!!} ; proper = {!!} ; is-maximum = {!!} } where
-     _⊆'_ : ( A B : HOD ) → Set n
-     _⊆'_ A B = (x : Ordinal ) → odef A x → odef B x
-     FL : HOD
-     FL = {!!}
-     0<FL :  o∅ o< & FL
-     0<FL = {!!}
-     PO : PartialOrderSet O FL _⊆'_
-     PO = {!!}
-     supP : (B : HOD) → B ⊆ FL → TotalOrderSet O B _⊆'_ → SUP O FL B _⊆'_
-     supP B B⊆FL cmp = record { sup = sup ; A∋maximal = A∋maximal ; x≤sup = x≤sup } where
-        sup : HOD
-        sup = {!!}
-        A∋maximal : B ∋ sup
-        A∋maximal = {!!}
-        x≤sup : {x : HOD} → B ∋ x → (x ≡ sup ) ∨ (x ⊆' sup )   
-        x≤sup = {!!}
-     maximum : Maximal O FL _⊆'_
-     maximum = Zorn-lemma O {FL} {_⊆'_} 0<FL {!!} {!!}
+MaximumFilterExist {L} {P} LP NEG CAP F 0<L 0<F Fprop = {!!} where
+      mf01 : Maximal O P (_⊆'_ O)
+      mf01 = MaximumSubset O 0<L {!!}  {!!} {!!} {!!} 
 
 
--- a/src/zorn.agda	Sun Apr 03 18:51:58 2022 +0900
+++ b/src/zorn.agda	Wed Apr 06 07:57:37 2022 +0900
@@ -92,13 +92,15 @@
      isSomeA : A ∋ someA
      isSomeA =  ODC.x∋minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A )) 
      HasMaximal : HOD
-     HasMaximal = record { od = record { def = λ x → (m : Ordinal) →  odef A m → odef A x ∧ (¬ (* x < * m))} ; odmax = & A ; <odmax = {!!} } where
-         z07 :  {y : Ordinal} → ((m : Ordinal) → odef A y ∧ odef A m ∧ (¬ (* y < * m))) → y o< & A
-         z07 {y} p = subst (λ k → k o< & A) &iso ( c<→o< (subst (λ k → odef A k ) (sym &iso ) (proj1 (p (& someA)) )))
-     no-maximum : HasMaximal =h= od∅ → (x : Ordinal) → ((m : Ordinal) →  odef A m →  odef A x ∧ (¬ (* x < * m) )) →  ⊥
-     no-maximum nomx x P = ¬x<0 (eq→ nomx {x} (λ m am → P m am )) 
+     HasMaximal = record { od = record { def = λ y → odef A y ∧ ((m : Ordinal) →  odef A m → ¬ (* y < * m))} ; odmax = & A ; <odmax = z08 } where
+         z08 : {y : Ordinal} → (odef A y ∧ ((m : Ordinal) →  odef A m → ¬ (* y < * m)))  → y o< & A
+         z08 {y} P = subst (λ k → k o< & A) &iso (c<→o< {* y} (subst (λ k → odef A k) (sym &iso) (proj1 P)))
+     no-maximal : HasMaximal =h= od∅ → (y : Ordinal) →  (odef A y ∧ ((m : Ordinal) →  odef A m → ¬ (* y < * m))) →  ⊥
+     no-maximal nomx y P = ¬x<0 (eq→ nomx {y} ⟪ proj1 P , (λ m am → (proj2 P) m am ) ⟫ ) 
      Gtx : { x : HOD} → A ∋ x → HOD
-     Gtx {x} ax = record { od = record { def = λ y → odef A y ∧ (x < (* y)) } ; odmax = & A ; <odmax = {!!} } 
+     Gtx {x} ax = record { od = record { def = λ y → odef A y ∧ (x < (* y)) } ; odmax = & A ; <odmax = z09 }  where
+         z09 : {y : Ordinal} → (odef A y ∧ (x < (* y)))  → y o< & A
+         z09 {y} P = subst (λ k → k o< & A) &iso (c<→o< {* y} (subst (λ k → odef A k) (sym &iso) (proj1 P)))
      z01 : {a b : HOD} → A ∋ a → A ∋ b  → (a ≡ b ) ∨ (a < b ) → b < a → ⊥
      z01 {a} {b} A∋a A∋b (case1 a=b) b<a = proj1 (proj2 (PO (me  A∋b) (me A∋a)) (sym a=b)) b<a
      z01 {a} {b} A∋a A∋b (case2 a<b) b<a = proj1 (PO (me  A∋b) (me A∋a)) b<a ⟪ a<b , (λ b=a → proj1 (proj2 (PO (me  A∋b) (me A∋a)) b=a ) b<a ) ⟫
@@ -132,9 +134,9 @@
           zc1 = prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) 
           z06 : ZChain A x _<_
           z06 with is-o∅ (& (Gtx ax))
-          ... | yes nogt = ⊥-elim (no-maximum nomx x x-is-maximal ) where -- no larger element, so it is maximal
-              x-is-maximal :  (m : Ordinal) → odef A m → odef A x ∧ (¬ (* x < * m))
-              x-is-maximal m am  = ⟪ subst (λ k → odef A k) &iso ax ,  ¬x<m  ⟫ where
+          ... | yes nogt = ⊥-elim (no-maximal nomx x ⟪ subst (λ k → odef A k) &iso ax , x-is-maximal ⟫ ) where -- no larger element, so it is maximal
+              x-is-maximal :  (m : Ordinal) → odef A m → ¬ (* x < * m)
+              x-is-maximal m am  =  ¬x<m   where
                  ¬x<m :  ¬ (* x < * m)
                  ¬x<m x<m = ∅< {Gtx ax} {* m} ⟪ subst (λ k → odef A k) (sym &iso) am , subst (λ k → * x < k ) (cong (*) (sym &iso)) x<m ⟫  (≡o∅→=od∅ nogt) 
           ... | no not = record { B = Bx     --  we have larger element, let's create ZChain
@@ -177,9 +179,9 @@
           B : HOD  -- Union (previous B)
           B = record { od = record { def = λ y → (y o< x) ∧ ((y<x : y o< x ) → odef (ZChain.B (prev y y<x)) y) } ; odmax = & A ; <odmax = {!!} } 
      ... | yes ax with is-o∅ (& (Gtx ax))
-     ... | yes nogt = ⊥-elim (no-maximum nomx x x-is-maximal ) where -- no larger element, so it is maximal
-              x-is-maximal :  (m : Ordinal) → odef A m → odef A x ∧ (¬ (* x < * m))
-              x-is-maximal m am  = ⟪ subst (λ k → odef A k) &iso ax ,  ¬x<m  ⟫ where
+     ... | yes nogt = ⊥-elim (no-maximal nomx x ⟪ subst (λ k → odef A k) &iso ax , x-is-maximal ⟫ ) where -- no larger element, so it is maximal
+              x-is-maximal :  (m : Ordinal) → odef A m → ¬ (* x < * m)
+              x-is-maximal m am  =  ¬x<m   where
                  ¬x<m :  ¬ (* x < * m)
                  ¬x<m x<m = ∅< {Gtx ax} {* m} ⟪ subst (λ k → odef A k) (sym &iso) am , subst (λ k → * x < k ) (cong (*) (sym &iso)) x<m ⟫  (≡o∅→=od∅ nogt) 
      ... | no not = {!!} where
@@ -192,12 +194,21 @@
          zorn03 :  odef HasMaximal ( & ( ODC.minimal O HasMaximal  (λ eq → not (=od∅→≡o∅ eq)) ) )
          zorn03 =  ODC.x∋minimal  O HasMaximal  (λ eq → not (=od∅→≡o∅ eq))
          zorn01 :  A ∋ ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq))
-         zorn01 =  proj1 (zorn03 (& someA) isSomeA ) 
+         zorn01 =  proj1 zorn03
          zorn02 : {x : HOD} → A ∋ x → ¬ (ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) < x)
-         zorn02 {x} ax m<x = proj2 (zorn03 (& x) ax) (subst₂ (λ j k → j < k) (sym *iso) (sym *iso) m<x )
+         zorn02 {x} ax m<x = ((proj2 zorn03) (& x) ax) (subst₂ (λ j k → j < k) (sym *iso) (sym *iso) m<x )
      ... | yes ¬Maximal = ⊥-elim ( ZChain→¬SUP (z (& A) (≡o∅→=od∅ ¬Maximal)) ( supP B (ZChain.B⊆A (z (& A) (≡o∅→=od∅ ¬Maximal))) (ZChain.total (z (& A) (≡o∅→=od∅ ¬Maximal))) )) where
          -- if we have no maximal, make ZChain, which contradict SUP condition
          z : (x : Ordinal) → HasMaximal =h= od∅  → ZChain A x _<_ 
          z x nomx = TransFinite (ind nomx) x
          B = ZChain.B (z (& A) (≡o∅→=od∅ ¬Maximal)  )
 
+_⊆'_ : ( A B : HOD ) → Set n
+_⊆'_ A B = (x : Ordinal ) → odef A x → odef B x
+
+MaximumSubset : {L P : HOD} 
+       → o∅ o< & L →  o∅ o< & P → P ⊆ L
+       → PartialOrderSet P _⊆'_
+       → ( (B : HOD) → B ⊆ P → TotalOrderSet B _⊆'_ → SUP P B _⊆'_ )
+       → Maximal P (_⊆'_)
+MaximumSubset {L} {P} 0<L 0<P P⊆L PO SP  = Zorn-lemma {P} {_⊆'_} 0<P PO SP