Mercurial > hg > Members > kono > Proof > ZF-in-agda
annotate src/zorn.agda @ 530:06a655ca04b8
...
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 22 Apr 2022 12:52:25 +0900 |
parents | 6e94ea146fc1 |
children | 5ca59261a4aa |
rev | line source |
---|---|
478 | 1 {-# OPTIONS --allow-unsolved-metas #-} |
508 | 2 open import Level hiding ( suc ; zero ) |
431 | 3 open import Ordinals |
497 | 4 import OD |
5 module zorn {n : Level } (O : Ordinals {n}) (_<_ : (x y : OD.HOD O ) → Set n ) where | |
431 | 6 |
7 open import zf | |
477 | 8 open import logic |
9 -- open import partfunc {n} O | |
10 | |
11 open import Relation.Nullary | |
12 open import Relation.Binary | |
13 open import Data.Empty | |
431 | 14 open import Relation.Binary |
15 open import Relation.Binary.Core | |
477 | 16 open import Relation.Binary.PropositionalEquality |
17 import BAlgbra | |
431 | 18 |
19 | |
20 open inOrdinal O | |
21 open OD O | |
22 open OD.OD | |
23 open ODAxiom odAxiom | |
477 | 24 import OrdUtil |
25 import ODUtil | |
431 | 26 open Ordinals.Ordinals O |
27 open Ordinals.IsOrdinals isOrdinal | |
28 open Ordinals.IsNext isNext | |
29 open OrdUtil O | |
477 | 30 open ODUtil O |
31 | |
32 | |
33 import ODC | |
34 | |
35 | |
36 open _∧_ | |
37 open _∨_ | |
38 open Bool | |
431 | 39 |
40 | |
41 open HOD | |
42 | |
528
8facdd7cc65a
TransitiveClosure with x <= f x is possible
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
527
diff
changeset
|
43 _≤_ : (x y : HOD) → Set (Level.suc n) |
8facdd7cc65a
TransitiveClosure with x <= f x is possible
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
527
diff
changeset
|
44 x ≤ y = ( x ≡ y ) ∨ ( x < y ) |
8facdd7cc65a
TransitiveClosure with x <= f x is possible
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
527
diff
changeset
|
45 |
508 | 46 record Element (A : HOD) : Set (Level.suc n) where |
469 | 47 field |
48 elm : HOD | |
49 is-elm : A ∋ elm | |
50 | |
51 open Element | |
52 | |
509 | 53 _<A_ : {A : HOD} → (x y : Element A ) → Set n |
54 x <A y = elm x < elm y | |
55 _≡A_ : {A : HOD} → (x y : Element A ) → Set (Level.suc n) | |
56 x ≡A y = elm x ≡ elm y | |
57 | |
508 | 58 IsPartialOrderSet : ( A : HOD ) → Set (Level.suc n) |
509 | 59 IsPartialOrderSet A = IsStrictPartialOrder (_≡A_ {A}) _<A_ |
490 | 60 |
492 | 61 open _==_ |
62 open _⊆_ | |
63 | |
495 | 64 isA : { A B : HOD } → B ⊆ A → (x : Element B) → Element A |
65 isA B⊆A x = record { elm = elm x ; is-elm = incl B⊆A (is-elm x) } | |
494 | 66 |
497 | 67 ⊆-IsPartialOrderSet : { A B : HOD } → B ⊆ A → IsPartialOrderSet A → IsPartialOrderSet B |
68 ⊆-IsPartialOrderSet {A} {B} B⊆A PA = record { | |
69 isEquivalence = record { refl = refl ; sym = sym ; trans = trans } ; trans = λ {x} {y} {z} → trans1 {x} {y} {z} | |
498 | 70 ; irrefl = λ {x} {y} → irrefl1 {x} {y} ; <-resp-≈ = resp0 |
493 | 71 } where |
495 | 72 _<B_ : (x y : Element B ) → Set n |
73 x <B y = elm x < elm y | |
74 trans1 : {x y z : Element B} → x <B y → y <B z → x <B z | |
75 trans1 {x} {y} {z} x<y y<z = IsStrictPartialOrder.trans PA {isA B⊆A x} {isA B⊆A y} {isA B⊆A z} x<y y<z | |
76 irrefl1 : {x y : Element B} → elm x ≡ elm y → ¬ ( x <B y ) | |
77 irrefl1 {x} {y} x=y x<y = IsStrictPartialOrder.irrefl PA {isA B⊆A x} {isA B⊆A y} x=y x<y | |
78 open import Data.Product | |
79 resp0 : ({x y z : Element B} → elm y ≡ elm z → x <B y → x <B z) × ({x y z : Element B} → elm y ≡ elm z → y <B x → z <B x) | |
80 resp0 = Data.Product._,_ (λ {x} {y} {z} → proj₁ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z }) | |
81 (λ {x} {y} {z} → proj₂ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z }) | |
492 | 82 |
497 | 83 -- open import Relation.Binary.Properties.Poset as Poset |
496 | 84 |
508 | 85 IsTotalOrderSet : ( A : HOD ) → Set (Level.suc n) |
509 | 86 IsTotalOrderSet A = IsStrictTotalOrder (_≡A_ {A}) _<A_ |
490 | 87 |
469 | 88 me : { A a : HOD } → A ∋ a → Element A |
89 me {A} {a} lt = record { elm = a ; is-elm = lt } | |
90 | |
504 | 91 A∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (A ∋ x) ≡ (A ∋ y ) |
92 A∋x-irr A {x} {y} refl = refl | |
93 | |
506 | 94 me-elm-refl : (A : HOD) → (x : Element A) → elm (me {A} (d→∋ A (is-elm x))) ≡ elm x |
95 me-elm-refl A record { elm = ex ; is-elm = ax } = *iso | |
504 | 96 |
97 open import Relation.Binary.HeterogeneousEquality as HE using (_≅_ ) | |
98 | |
526 | 99 -- Don't use Element other than Order, you'll be in a trouble |
517 | 100 -- postulate -- may be proved by transfinite induction and functional extentionality |
101 -- ∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (ax : A ∋ x) (ay : A ∋ y ) → ax ≅ ay | |
102 -- odef-irr : (A : OD) {x y : Ordinal} → x ≡ y → (ax : def A x) (ay : def A y ) → ax ≅ ay | |
504 | 103 |
517 | 104 -- is-elm-irr : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y |
105 -- is-elm-irr A {x} {y} eq = ∋x-irr A eq (is-elm x) (is-elm y ) | |
504 | 106 |
107 El-irr2 : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y → x ≡ y | |
108 El-irr2 A {x} {y} refl HE.refl = refl | |
109 | |
517 | 110 -- El-irr : {A : HOD} → {x y : Element A } → elm x ≡ elm y → x ≡ y |
111 -- El-irr {A} {x} {y} eq = El-irr2 A eq ( is-elm-irr A eq ) | |
504 | 112 |
527 | 113 record _Set≈_ (A B : Ordinal ) : Set n where |
526 | 114 field |
115 fun← : {x : Ordinal } → odef (* A) x → Ordinal | |
116 fun→ : {x : Ordinal } → odef (* B) x → Ordinal | |
117 funB : {x : Ordinal } → ( lt : odef (* A) x ) → odef (* B) ( fun← lt ) | |
118 funA : {x : Ordinal } → ( lt : odef (* B) x ) → odef (* A) ( fun→ lt ) | |
119 fiso← : {x : Ordinal } → ( lt : odef (* B) x ) → fun← ( funA lt ) ≡ x | |
120 fiso→ : {x : Ordinal } → ( lt : odef (* A) x ) → fun→ ( funB lt ) ≡ x | |
121 | |
527 | 122 open _Set≈_ |
123 record _OS≈_ {A B : HOD} (TA : IsTotalOrderSet A ) (TB : IsTotalOrderSet B ) : Set (Level.suc n) where | |
526 | 124 field |
527 | 125 iso : (& A ) Set≈ (& B) |
526 | 126 fmap : {x y : Ordinal} → (ax : odef A x) → (ay : odef A y) → * x < * y |
127 → * (fun← iso (subst (λ k → odef k x) (sym *iso) ax)) < * (fun← iso (subst (λ k → odef k y) (sym *iso) ay)) | |
128 | |
129 Cut< : ( A x : HOD ) → HOD | |
130 Cut< A x = record { od = record { def = λ y → ( odef A y ) ∧ ( x < * y ) } ; odmax = & A | |
131 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k ) (sym &iso) (proj1 lt))) } | |
132 | |
527 | 133 Cut<T : {A : HOD} → (TA : IsTotalOrderSet A ) ( x : HOD )→ IsTotalOrderSet ( Cut< A x ) |
134 Cut<T {A} TA x = record { isEquivalence = record { refl = refl ; trans = trans ; sym = sym } | |
526 | 135 ; trans = λ {x} {y} {z} → IsStrictTotalOrder.trans TA {me (proj1 (is-elm x))} {me (proj1 (is-elm y))} {me (proj1 (is-elm z))} ; |
527 | 136 compare = λ x y → IsStrictTotalOrder.compare TA (me (proj1 (is-elm x))) (me (proj1 (is-elm y))) } |
526 | 137 |
527 | 138 record _OS<_ {A B : HOD} (TA : IsTotalOrderSet A ) (TB : IsTotalOrderSet B ) : Set (Level.suc n) where |
139 field | |
140 x : HOD | |
141 iso : TA OS≈ (Cut<T TA x) | |
142 | |
529 | 143 -- OS<-cmp : {x : HOD} → Trichotomous {_} {IsTotalOrderSet x} _OS≈_ _OS<_ |
144 -- OS<-cmp A B = {!!} | |
498 | 145 |
530 | 146 -- tree structure |
498 | 147 data IChain (A : HOD) : Ordinal → Set n where |
148 ifirst : {ox : Ordinal} → odef A ox → IChain A ox | |
149 inext : {ox oy : Ordinal} → odef A oy → * ox < * oy → IChain A ox → IChain A oy | |
150 | |
506 | 151 -- * ox < .. < * oy |
152 ic-connect : {A : HOD} {oy : Ordinal} → (ox : Ordinal) → (iy : IChain A oy) → Set n | |
153 ic-connect {A} ox (ifirst {oy} ay) = Lift n ⊥ | |
154 ic-connect {A} ox (inext {oy} {oz} ay y<z iz) = (ox ≡ oy) ∨ ic-connect ox iz | |
155 | |
156 ic→odef : {A : HOD} {ox : Ordinal} → IChain A ox → odef A ox | |
157 ic→odef {A} {ox} (ifirst ax) = ax | |
158 ic→odef {A} {ox} (inext ax x<y ic) = ax | |
159 | |
521 | 160 ic→< : {A : HOD} → IsPartialOrderSet A → (x : Ordinal) → odef A x → {y : Ordinal} → (iy : IChain A y) → ic-connect {A} {y} x iy → * x < * y |
506 | 161 ic→< {A} PO x ax {y} (ifirst ay) () |
162 ic→< {A} PO x ax {y} (inext ay x<y iy) (case1 refl) = x<y | |
163 ic→< {A} PO x ax {y} (inext {oy} ay x<y iy) (case2 ic) = IsStrictPartialOrder.trans PO | |
164 {me (subst (λ k → odef A k) (sym &iso) ax )} {me (subst (λ k → odef A k) (sym &iso) (ic→odef {A} {oy} iy) ) } {me (subst (λ k → odef A k) (sym &iso) ay) } | |
165 (ic→< {A} PO x ax iy ic ) x<y | |
166 | |
167 record IChained (A : HOD) (x y : Ordinal) : Set n where | |
168 field | |
169 iy : IChain A y | |
170 ic : ic-connect x iy | |
498 | 171 |
530 | 172 -- |
173 -- all tree from x | |
174 -- | |
523 | 175 IChainSet : (A : HOD) {x : Ordinal} → odef A x → HOD |
176 IChainSet A {x} ax = record { od = record { def = λ y → odef A y ∧ IChained A x y } | |
498 | 177 ; odmax = & A ; <odmax = λ {y} lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k) (sym &iso) (proj1 lt))) } |
178 | |
523 | 179 IChainSet⊆A : {A : HOD} → {x : Ordinal } → (ax : odef A x ) → IChainSet A ax ⊆ A |
512 | 180 IChainSet⊆A {A} x = record { incl = λ {oy} y → proj1 y } |
181 | |
521 | 182 ¬IChained-refl : (A : HOD) {x : Ordinal} → IsPartialOrderSet A → ¬ IChained A x x |
183 ¬IChained-refl A {x} PO record { iy = iy ; ic = ic } = IsStrictPartialOrder.irrefl PO | |
184 {me (subst (λ k → odef A k ) (sym &iso) ic0) } {me (subst (λ k → odef A k ) (sym &iso) ic0) } refl (ic→< {A} PO x ic0 iy ic ) where | |
185 ic0 : odef A x | |
186 ic0 = ic→odef {A} iy | |
187 | |
498 | 188 -- there is a y, & y > & x |
189 | |
501 | 190 record OSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where |
498 | 191 field |
501 | 192 y : Ordinal |
523 | 193 icy : odef (IChainSet A ax ) y |
501 | 194 y>x : x o< y |
498 | 195 |
505 | 196 record IChainSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where |
197 field | |
198 y : Ordinal | |
199 A∋y : odef A y | |
200 y>x : * x < * y | |
201 | |
498 | 202 -- finite IChain |
530 | 203 -- |
204 -- tree structured | |
498 | 205 |
523 | 206 ic→A∋y : (A : HOD) {x y : Ordinal} (ax : A ∋ * x) → odef (IChainSet A ax) y → A ∋ * y |
511 | 207 ic→A∋y A {x} {y} ax ⟪ ay , _ ⟫ = subst (λ k → odef A k) (sym &iso) ay |
208 | |
525 | 209 record InfiniteChain (A : HOD) (max : Ordinal) {x : Ordinal} (ax : A ∋ * x) : Set n where |
498 | 210 field |
523 | 211 chain<x : (y : Ordinal ) → odef (IChainSet A ax) y → y o< max |
212 c-infinite : (y : Ordinal ) → (cy : odef (IChainSet A ax) y ) | |
511 | 213 → IChainSup> A (ic→A∋y A ax cy) |
509 | 214 |
528
8facdd7cc65a
TransitiveClosure with x <= f x is possible
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
527
diff
changeset
|
215 open import Data.Nat hiding (_<_ ; _≤_ ) |
510 | 216 import Data.Nat.Properties as NP |
217 open import nat | |
218 | |
514 | 219 data Chain (A : HOD) (s : Ordinal) (next : Ordinal → Ordinal ) : ( x : Ordinal ) → Set n where |
513 | 220 cfirst : odef A s → Chain A s next s |
514 | 221 csuc : (x : Ordinal ) → (ax : odef A x ) → Chain A s next x → odef A (next x) → Chain A s next (next x ) |
512 | 222 |
514 | 223 ct∈A : (A : HOD ) (s : Ordinal) → (next : Ordinal → Ordinal ) → {x : Ordinal} → Chain A s next x → odef A x |
513 | 224 ct∈A A s next {x} (cfirst x₁) = x₁ |
514 | 225 ct∈A A s next {.(next x )} (csuc x ax t anx) = anx |
509 | 226 |
517 | 227 -- |
228 -- extract single chain from countable infinite chains | |
229 -- | |
527 | 230 TransitiveClosure : (A : HOD) (s : Ordinal) → (next : Ordinal → Ordinal ) → HOD |
231 TransitiveClosure A s next = record { od = record { def = λ x → Chain A s next x } ; odmax = & A ; <odmax = cc01 } where | |
513 | 232 cc01 : {y : Ordinal} → Chain A s next y → y o< & A |
233 cc01 {y} cy = subst (λ k → k o< & A ) &iso ( c<→o< (subst (λ k → odef A k ) (sym &iso) ( ct∈A A s next cy ) ) ) | |
509 | 234 |
514 | 235 cton0 : (A : HOD ) (s : Ordinal) → (next : Ordinal → Ordinal ) {y : Ordinal } → Chain A s next y → ℕ |
513 | 236 cton0 A s next (cfirst _) = zero |
237 cton0 A s next (csuc x ax z _) = suc (cton0 A s next z) | |
527 | 238 cton : (A : HOD ) (s : Ordinal) → (next : Ordinal → Ordinal ) → Element (TransitiveClosure A s next) → ℕ |
513 | 239 cton A s next y = cton0 A s next (is-elm y) |
510 | 240 |
525 | 241 cinext : (A : HOD) {x max : Ordinal } → (ax : A ∋ * x ) → (ifc : InfiniteChain A max ax ) → Ordinal → Ordinal |
523 | 242 cinext A ax ifc y with ODC.∋-p O (IChainSet A ax) (* y) |
525 | 243 ... | yes ics-y = IChainSup>.y ( InfiniteChain.c-infinite ifc y (subst (λ k → odef (IChainSet A ax) k) &iso ics-y )) |
514 | 244 ... | no _ = o∅ |
245 | |
522 | 246 InFCSet : (A : HOD) → {x max : Ordinal} (ax : A ∋ * x) |
525 | 247 → (ifc : InfiniteChain A max ax ) → HOD |
527 | 248 InFCSet A {x} ax ifc = TransitiveClosure (IChainSet A ax) x (cinext A ax ifc ) |
509 | 249 |
525 | 250 InFCSet⊆A : (A : HOD) → {x max : Ordinal} (ax : A ∋ * x) → (ifc : InfiniteChain A max ax ) → InFCSet A ax ifc ⊆ A |
523 | 251 InFCSet⊆A A {x} ax ifc = record { incl = λ {y} lt → incl (IChainSet⊆A ax) ( |
252 ct∈A (IChainSet A ax) x (cinext A ax ifc) lt ) } | |
512 | 253 |
525 | 254 cinext→IChainSup : (A : HOD) {x max : Ordinal } → (ax : A ∋ * x ) → (ifc : InfiniteChain A max ax ) → (y : Ordinal ) |
255 → (ay1 : IChainSet A ax ∋ * y ) → IChainSup> A (subst (odef A) (sym &iso) (proj1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1))) | |
256 cinext→IChainSup A {x} ax ifc y ay with ODC.∋-p O (IChainSet A ax) (* y) | |
257 ... | no not = ⊥-elim ( not ay ) | |
258 ... | yes ay1 = InfiniteChain.c-infinite ifc y (subst (λ k → odef (IChainSet A ax) k) &iso ay ) | |
259 | |
527 | 260 TransitiveClosure-is-total : (A : HOD) → {x max : Ordinal} (ax : A ∋ * x) |
509 | 261 → IsPartialOrderSet A |
525 | 262 → (ifc : InfiniteChain A max ax ) |
509 | 263 → IsTotalOrderSet ( InFCSet A ax ifc ) |
527 | 264 TransitiveClosure-is-total A {x} ax PO ifc = record { isEquivalence = IsStrictPartialOrder.isEquivalence IPO |
509 | 265 ; trans = λ {x} {y} {z} → IsStrictPartialOrder.trans IPO {x} {y} {z} ; compare = cmp } where |
266 IPO : IsPartialOrderSet (InFCSet A ax ifc ) | |
512 | 267 IPO = ⊆-IsPartialOrderSet record { incl = λ {y} lt → incl (InFCSet⊆A A {x} ax ifc) lt} PO |
523 | 268 B = IChainSet A ax |
529 | 269 cnext = cinext A ax ifc |
513 | 270 ct02 : {oy : Ordinal} → (y : Chain B x cnext oy ) → A ∋ * oy |
523 | 271 ct02 y = incl (IChainSet⊆A {A} ax) (subst (λ k → odef (IChainSet A ax) k) (sym &iso) (ct∈A B x cnext y) ) |
513 | 272 ct-inject : {ox oy : Ordinal} → (x1 : Chain B x cnext ox ) → (y : Chain B x cnext oy ) |
273 → (cton0 B x cnext x1) ≡ (cton0 B x cnext y) → ox ≡ oy | |
274 ct-inject {ox} {ox} (cfirst x) (cfirst x₁) refl = refl | |
514 | 275 ct-inject {.(cnext x₀ )} {.(cnext x₃ )} (csuc x₀ ax x₁ x₂) (csuc x₃ ax₁ y x₄) eq = cong cnext ct05 where |
513 | 276 ct06 : {x y : ℕ} → suc x ≡ suc y → x ≡ y |
277 ct06 refl = refl | |
278 ct05 : x₀ ≡ x₃ | |
279 ct05 = ct-inject x₁ y (ct06 eq) | |
280 ct-monotonic : {ox oy : Ordinal} → (x1 : Chain B x cnext ox ) → (y : Chain B x cnext oy ) | |
281 → (cton0 B x cnext x1) Data.Nat.< (cton0 B x cnext y) → * ox < * oy | |
282 ct-monotonic {ox} {oy} x1 (csuc oy1 ay y _) (s≤s lt) with NP.<-cmp ( cton0 B x cnext x1 ) ( cton0 B x cnext y ) | |
514 | 283 ... | tri< a ¬b ¬c = ct07 where |
284 ct07 : * ox < * (cnext oy1) | |
523 | 285 ct07 with ODC.∋-p O (IChainSet A ax) (* oy1) |
286 ... | no not = ⊥-elim ( not (subst (λ k → odef (IChainSet A ax) k ) (sym &iso) ay ) ) | |
529 | 287 ... | yes ay1 = IsStrictPartialOrder.trans PO {me (ct02 x1) } {me (ct02 y)} {me ct031 } (ct-monotonic x1 y a ) ct011 where |
525 | 288 ct031 : A ∋ * (IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 ) )) |
514 | 289 ct031 = subst (λ k → odef A k ) (sym &iso) ( |
525 | 290 IChainSup>.A∋y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) ) |
291 ct011 : * oy1 < * ( IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) ) | |
292 ct011 = IChainSup>.y>x (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) | |
517 | 293 ... | tri≈ ¬a b ¬c = ct11 where |
294 ct11 : * ox < * (cnext oy1) | |
523 | 295 ct11 with ODC.∋-p O (IChainSet A ax) (* oy1) |
296 ... | no not = ⊥-elim ( not (subst (λ k → odef (IChainSet A ax) k ) (sym &iso) ay ) ) | |
529 | 297 ... | yes ay1 = subst (λ k → * k < _) (sym (ct-inject _ _ b)) ct011 where |
525 | 298 ct011 : * oy1 < * ( IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) ) |
299 ct011 = IChainSup>.y>x (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) | |
517 | 300 ... | tri> ¬a ¬b c = ⊥-elim ( nat-≤> lt c ) |
527 | 301 ct12 : {y z : Element (TransitiveClosure B x cnext) } → elm y ≡ elm z → elm y < elm z → ⊥ |
517 | 302 ct12 {y} {z} y=z y<z = IsStrictPartialOrder.irrefl IPO {y} {z} y=z y<z |
527 | 303 ct13 : {y z : Element (TransitiveClosure B x cnext) } → elm y < elm z → elm z < elm y → ⊥ |
517 | 304 ct13 {y} {z} y<z y>z = IsStrictPartialOrder.irrefl IPO {y} {y} refl ( IsStrictPartialOrder.trans IPO {y} {z} {y} y<z y>z ) |
527 | 305 ct17 : (x1 : Element (TransitiveClosure B x cnext)) → Chain B x cnext (& (elm x1)) |
517 | 306 ct17 x1 = is-elm x1 |
509 | 307 cmp : Trichotomous _ _ |
513 | 308 cmp x1 y with NP.<-cmp (cton B x cnext x1) (cton B x cnext y) |
517 | 309 ... | tri< a ¬b ¬c = tri< ct04 ct14 ct15 where |
513 | 310 ct04 : elm x1 < elm y |
311 ct04 = subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a) | |
517 | 312 ct14 : ¬ elm x1 ≡ elm y |
313 ct14 eq = ct12 {x1} {y} eq (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a ) ) | |
314 ct15 : ¬ (elm y < elm x1) | |
315 ct15 lt = ct13 {y} {x1} lt (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a ) ) | |
316 ... | tri≈ ¬a b ¬c = tri≈ (ct12 {x1} {y} ct16) ct16 (ct12 {y} {x1} (sym ct16)) where | |
317 ct16 : elm x1 ≡ elm y | |
318 ct16 = subst₂ (λ j k → j ≡ k ) *iso *iso (cong (*) (ct-inject {& (elm x1)} {& (elm y)} (is-elm x1) (is-elm y) b )) | |
319 ... | tri> ¬a ¬b c = tri> ct15 ct14 ct04 where | |
320 ct04 : elm y < elm x1 | |
321 ct04 = subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c) | |
322 ct14 : ¬ elm x1 ≡ elm y | |
323 ct14 eq = ct12 {y} {x1} (sym eq) (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c ) ) | |
324 ct15 : ¬ (elm x1 < elm y) | |
325 ct15 lt = ct13 {x1} {y} lt (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c ) ) | |
509 | 326 |
502 | 327 record IsFC (A : HOD) {x : Ordinal} (ax : A ∋ * x) (y : Ordinal) : Set n where |
501 | 328 field |
523 | 329 icy : odef (IChainSet A ax) y |
520 | 330 c-finite : ¬ IChainSup> A (subst (λ k → odef A k ) (sym &iso) (proj1 icy) ) |
497 | 331 |
508 | 332 record Maximal ( A : HOD ) : Set (Level.suc n) where |
503 | 333 field |
334 maximal : HOD | |
335 A∋maximal : A ∋ maximal | |
336 ¬maximal<x : {x : HOD} → A ∋ x → ¬ maximal < x -- A is Partial, use negative | |
337 | |
338 -- | |
339 -- possible three cases in a limit ordinal step | |
340 -- | |
530 | 341 -- case 1) < goes x o< |
503 | 342 -- case 2) no > x in some chain ( maximal ) |
530 | 343 -- case 3) countably infinite chain below x |
503 | 344 -- |
345 Zorn-lemma-3case : { A : HOD } | |
498 | 346 → o∅ o< & A |
347 → IsPartialOrderSet A | |
525 | 348 → (x : Ordinal ) → (ax : odef A x) → OSup> A (d→∋ A ax) ∨ Maximal A ∨ InfiniteChain A x (d→∋ A ax) |
523 | 349 Zorn-lemma-3case {A} 0<A PO x ax = zc2 where |
499 | 350 Gtx : HOD |
523 | 351 Gtx = record { od = record { def = λ y → odef ( IChainSet A ax ) y ∧ ( x o< y ) } ; odmax = & A |
501 | 352 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 (proj1 lt)))) } |
353 HG : HOD | |
523 | 354 HG = record { od = record { def = λ y → odef A y ∧ IsFC A (d→∋ A ax ) y } ; odmax = & A |
501 | 355 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 lt) )) } |
525 | 356 zc2 : OSup> A (d→∋ A ax) ∨ Maximal A ∨ InfiniteChain A x (d→∋ A ax ) |
499 | 357 zc2 with is-o∅ (& Gtx) |
504 | 358 ... | no not = case1 record { y = & y ; icy = zc4 ; y>x = proj2 zc3 } where |
359 y : HOD | |
360 y = ODC.minimal O Gtx (λ eq → not (=od∅→≡o∅ eq)) | |
523 | 361 zc3 : odef ( IChainSet A ax ) (& y) ∧ ( x o< (& y )) |
504 | 362 zc3 = ODC.x∋minimal O Gtx (λ eq → not (=od∅→≡o∅ eq)) |
523 | 363 zc4 : odef (IChainSet A (subst (OD.def (od A)) (sym &iso) ax)) (& y) |
364 zc4 = ⟪ proj1 (proj1 zc3) , (subst (λ k → IChained A k (& y)) (sym &iso) (proj2 (proj1 zc3))) ⟫ | |
501 | 365 ... | yes nogt with is-o∅ (& HG) |
505 | 366 ... | no finite-chain = case2 (case1 record { maximal = y ; A∋maximal = proj1 zc3 ; ¬maximal<x = zc4 } ) where |
504 | 367 y : HOD |
505 | 368 y = ODC.minimal O HG (λ eq → finite-chain (=od∅→≡o∅ eq)) |
523 | 369 zc3 : odef A (& y) ∧ IsFC A (d→∋ A ax ) (& y) |
505 | 370 zc3 = ODC.x∋minimal O HG (λ eq → finite-chain (=od∅→≡o∅ eq)) |
504 | 371 zc4 : {z : HOD} → A ∋ z → ¬ (y < z) |
523 | 372 zc4 {z} az y<z = IsFC.c-finite (proj2 zc3) record { y = & z ; A∋y = az ; y>x = subst₂ (λ j k → j < k ) (sym *iso) (sym *iso) y<z } |
373 ... | yes inifite = case2 (case2 record { c-infinite = zc91 ; chain<x = zc10 } ) where | |
518 | 374 B : HOD |
523 | 375 B = IChainSet A ax -- (me (subst (OD.def (od A)) (sym &iso) (is-elm x))) |
376 B1 : HOD | |
377 B1 = IChainSet A (subst (OD.def (od A)) (sym &iso) ax) | |
518 | 378 Nx : (y : Ordinal) → odef A y → HOD |
520 | 379 Nx y ay = record { od = record { def = λ x → odef A x ∧ ( * y < * x ) } ; odmax = & A |
518 | 380 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 lt))) } |
523 | 381 zc10 : (y : Ordinal) → odef (IChainSet A (subst (OD.def (od A)) (sym &iso) ax)) y → y o< x |
521 | 382 zc10 oy icsy = zc21 where |
523 | 383 zc20 : (y : HOD) → (IChainSet A ax) ∋ y → x o< & y → ⊥ |
521 | 384 zc20 y icsy lt = ¬A∋x→A≡od∅ Gtx ⟪ icsy , lt ⟫ nogt |
523 | 385 zc22 : IChainSet A ax ∋ * oy |
386 zc22 = ⟪ subst (λ k → odef A k) (sym &iso) (proj1 icsy) , subst₂ (λ j k → IChained A j k ) &iso (sym &iso) (proj2 icsy) ⟫ | |
387 zc21 : oy o< x | |
388 zc21 with trio< oy x | |
521 | 389 ... | tri< a ¬b ¬c = a |
523 | 390 ... | tri≈ ¬a b ¬c = ⊥-elim (¬IChained-refl A PO (subst₂ (λ j k → IChained A j k ) &iso b (proj2 icsy)) ) |
391 ... | tri> ¬a ¬b c = ⊥-elim ( zc20 (* oy) zc22 (subst (λ k → x o< k) (sym &iso) c )) | |
392 zc91 : (y : Ordinal) (cy : odef B1 y) → IChainSup> A (ic→A∋y A (subst (OD.def (od A)) (sym &iso) ax) cy) | |
393 zc91 y cy with is-o∅ (& (Nx y (proj1 cy) )) | |
519 | 394 ... | yes no-next = ⊥-elim zc16 where |
523 | 395 zc18 : ¬ IChainSup> A (subst (odef A) (sym &iso) (proj1 (subst (λ k → odef (IChainSet A (d→∋ A ax)) k) (sym &iso) cy))) |
520 | 396 zc18 ics = ¬A∋x→A≡od∅ (Nx y (proj1 cy) ) ⟪ subst (λ k → odef A k ) (sym &iso) (IChainSup>.A∋y ics) |
397 , subst₂ (λ j k → j < k ) *iso (cong (*) (sym &iso))( IChainSup>.y>x ics) ⟫ no-next | |
523 | 398 zc17 : IsFC A {x} (d→∋ A ax) (& (* y)) |
399 zc17 = record { icy = subst (λ k → odef (IChainSet A (d→∋ A ax)) k) (sym &iso) cy ; c-finite = zc18 } | |
519 | 400 zc16 : ⊥ |
401 zc16 = ¬A∋x→A≡od∅ HG ⟪ subst (λ k → odef A k ) (sym &iso) (proj1 cy ) , zc17 ⟫ inifite | |
520 | 402 ... | no not = record { y = & zc13 ; A∋y = proj1 zc12 ; y>x = proj2 zc12 } where |
519 | 403 zc13 = ODC.minimal O (Nx y (proj1 cy)) (λ eq → not (=od∅→≡o∅ eq )) |
520 | 404 zc12 : odef A (& zc13 ) ∧ ( * y < * ( & zc13 )) |
519 | 405 zc12 = ODC.x∋minimal O (Nx y (proj1 cy)) (λ eq → not (=od∅→≡o∅ eq )) |
499 | 406 |
517 | 407 all-climb-case : { A : HOD } → (0<A : o∅ o< & A) → IsPartialOrderSet A |
523 | 408 → (( x : Ordinal ) → (ax : odef A (& (* x))) → OSup> A ax ) |
524 | 409 → (x : HOD) ( ax : A ∋ x ) |
525 | 410 → InfiniteChain A (& A) (d→∋ A ax) |
524 | 411 all-climb-case {A} 0<A PO climb x ax = record { c-infinite = ac00 ; chain<x = ac01 } where |
523 | 412 B = IChainSet A ax |
524 | 413 ac01 : (y : Ordinal) → odef (IChainSet A (d→∋ A ax)) y → y o< & A |
522 | 414 ac01 y ⟪ ay , _ ⟫ = subst (λ k → k o< & A ) &iso (c<→o< (subst (λ k → odef A k ) (sym &iso) ay) ) |
523 | 415 ac00 : (y : Ordinal) (cy : odef (IChainSet A (d→∋ A ax)) y) → IChainSup> A (ic→A∋y A (d→∋ A ax) cy) |
416 ac00 y cy = record { y = z ; A∋y = az ; y>x = y<z} where | |
417 ay : odef A (& (* y)) | |
418 ay = subst (λ k → odef A k) (sym &iso) (proj1 cy) | |
522 | 419 z : Ordinal |
523 | 420 z = OSup>.y ( climb y ay) |
522 | 421 az : odef A z |
523 | 422 az = subst (λ k → odef A k) &iso ( incl (IChainSet⊆A {A} ay ) (subst (λ k → odef (IChainSet A ay) k ) (sym &iso) (OSup>.icy ( climb y ay)))) |
423 icy : odef (IChainSet A ay ) z | |
424 icy = OSup>.icy ( climb y ay ) | |
425 y<z : * y < * z | |
426 y<z = ic→< {A} PO y (subst (λ k → odef A k) &iso ay) (IChained.iy (proj2 icy)) | |
427 (subst (λ k → ic-connect k (IChained.iy (proj2 icy))) &iso (IChained.ic (proj2 icy))) | |
522 | 428 |
530 | 429 -- <-TransFinite : ( A : HOD ) → IsTotalOrderSet A |
430 -- → ( (x : Ordinal) → ((y : Ordinal) → y o< x → ZChain A y) → ZChain A x ) → (x : Ordinal ) → ZChain A x | |
431 -- <-TransFinite A TA ind x = TransFinite {ZChain A} ind x | |
529 | 432 |
530 | 433 -- |
434 -- inductive maxmum tree from x | |
435 -- tree structure | |
436 -- | |
437 | |
438 ≤-monotonic-f : (A : HOD) → ( Ordinal → Ordinal ) → Set (Level.suc n) | |
439 ≤-monotonic-f A f = (x : Ordinal ) → odef A x → ( * x ≤ * (f x) ) ∧ odef A (f x ) | |
440 | |
441 record ZChain ( A : HOD ) {x : Ordinal} (ax : A ∋ * x) (z : Ordinal) : Set (Level.suc n) where | |
529 | 442 field |
443 chain : HOD | |
530 | 444 chain⊆A : chain ⊆ A |
445 f-total : ( f : Ordinal → Ordinal ) → ≤-monotonic-f A f → IsTotalOrderSet chain | |
446 is-max : ( f : Ordinal → Ordinal ) → ≤-monotonic-f A f → {a b : Ordinal } → odef chain a → a o< z → * a < * b → odef chain b | |
529 | 447 |
508 | 448 record SUP ( A B : HOD ) : Set (Level.suc n) where |
503 | 449 field |
450 sup : HOD | |
451 A∋maximal : A ∋ sup | |
452 x<sup : {x : HOD} → B ∋ x → (x ≡ sup ) ∨ (x < sup ) -- B is Total, use positive | |
453 | |
497 | 454 Zorn-lemma : { A : HOD } |
464 | 455 → o∅ o< & A |
497 | 456 → IsPartialOrderSet A |
457 → ( ( B : HOD) → (B⊆A : B ⊆ A) → IsTotalOrderSet B → SUP A B ) -- SUP condition | |
458 → Maximal A | |
530 | 459 Zorn-lemma {A} 0<A PO supP = zorn00 where |
493 | 460 z01 : {a b : HOD} → A ∋ a → A ∋ b → (a ≡ b ) ∨ (a < b ) → b < a → ⊥ |
496 | 461 z01 {a} {b} A∋a A∋b (case1 a=b) b<a = IsStrictPartialOrder.irrefl PO {me A∋b} {me A∋a} (sym a=b) b<a |
524 | 462 z01 {a} {b} A∋a A∋b (case2 a<b) b<a = IsStrictPartialOrder.irrefl PO {me A∋b} {me A∋b} refl |
463 (IsStrictPartialOrder.trans PO {me A∋b} {me A∋a} {me A∋b} b<a a<b) | |
530 | 464 s : HOD |
465 s = ODC.minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A )) | |
466 sa : A ∋ * ( & s ) | |
467 sa = subst (λ k → odef A (& k) ) (sym *iso) ( ODC.x∋minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A )) ) | |
468 HasMaximal : HOD | |
469 HasMaximal = record { od = record { def = λ x → (m : Ordinal) → odef A m → odef A x ∧ (¬ (* x < * m))} ; odmax = & A ; <odmax = {!!} } where | |
470 z07 : {y : Ordinal} → ((m : Ordinal) → odef A y ∧ odef A m ∧ (¬ (* y < * m))) → y o< & A | |
471 z07 {y} p = subst (λ k → k o< & A) &iso ( c<→o< (subst (λ k → odef A k ) (sym &iso ) (proj1 (p (& s)) ))) | |
472 cf : ¬ Maximal A → Ordinal → Ordinal | |
473 cf = {!!} | |
474 cf-is-<-monotonic : (nmx : ¬ Maximal A ) → (x : Ordinal) → odef A x → ( * x < * (cf nmx x) ) ∧ odef A (cf nmx x ) | |
475 cf-is-<-monotonic = {!!} | |
476 cf-is-≤-monotonic : (nmx : ¬ Maximal A ) → ≤-monotonic-f A ( cf nmx ) | |
477 cf-is-≤-monotonic = {!!} | |
478 zsup : ZChain A sa (& A) → ( f : Ordinal → Ordinal ) → ≤-monotonic-f A f → Ordinal | |
479 zsup zc f mf = & ( SUP.sup (supP (ZChain.chain zc) (ZChain.chain⊆A zc) ( ZChain.f-total zc f mf ) ) ) | |
480 A∋zsup : (zc : ZChain A sa (& A)) → (nmx : ¬ Maximal A ) → A ∋ * (zsup zc (cf nmx) (cf-is-≤-monotonic nmx)) | |
481 A∋zsup zc nmx = {!!} | |
482 z03 : (zc : ZChain A sa (& A)) → ( f : Ordinal → Ordinal ) → (mf : ≤-monotonic-f A f ) → f (zsup zc f mf ) ≡ zsup zc f mf | |
483 z03 = {!!} | |
484 z04 : (zc : ZChain A sa (& A)) → ¬ Maximal A → ⊥ | |
485 z04 zc nmx = z01 {* (cf nmx c)} {* c} sa (A∋zsup zc nmx ) (case1 ( cong (*)( z03 zc (cf nmx) (cf-is-≤-monotonic nmx )))) | |
486 (proj1 (cf-is-<-monotonic nmx c ((subst λ k → odef A k ) &iso (A∋zsup zc nmx )))) where | |
487 c = zsup zc (cf nmx) (cf-is-≤-monotonic nmx) | |
478 | 488 -- ZChain is not compatible with the SUP condition |
530 | 489 ind : (x : Ordinal) → ((y : Ordinal) → y o< x → ZChain A sa y ∨ Maximal A ) |
490 → ZChain A sa x ∨ Maximal A | |
491 ind x prev with Oprev-p x | |
492 ... | yes op with ODC.∋-p O A (* x) | |
493 ... | no ¬Ax = zc1 where | |
494 -- we have previous ordinal and ¬ A ∋ x, use previous Zchain | |
495 px = Oprev.oprev op | |
496 zc1 : ZChain A sa x ∨ Maximal A | |
497 zc1 with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) | |
498 ... | case2 x = case2 x -- we have the Maximal | |
499 ... | case1 zc = case1 {!!} | |
500 ... | yes ax = zc4 where -- we have previous ordinal and A ∋ x | |
501 px = Oprev.oprev op | |
502 zc1 : OSup> A (subst (OD.def (od A)) (sym &iso) (subst (OD.def (od A)) &iso ax)) → ZChain A sa x ∨ Maximal A | |
503 zc1 os with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) | |
504 ... | case2 mx = case2 mx | |
505 ... | case1 zc = case1 {!!} | |
506 zc4 : ZChain A sa x ∨ Maximal A | |
507 zc4 with Zorn-lemma-3case 0<A PO x (subst (λ k → odef A k) &iso ax ) | |
508 ... | case1 y>x = zc1 y>x | |
509 ... | case2 (case1 mx) = case2 mx | |
510 ... | case2 (case2 ic) with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) | |
511 ... | case2 mx = case2 mx | |
512 ... | case1 zc = {!!} | |
513 ind x prev | no ¬ox with trio< (& A) x --- limit ordinal case | |
514 ... | t = {!!} | |
515 | |
516 zorn00 : Maximal A | |
517 zorn00 with is-o∅ ( & HasMaximal ) | |
518 ... | no not = record { maximal = ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) ; A∋maximal = zorn01 ; ¬maximal<x = zorn02 } where | |
519 -- yes we have the maximal | |
520 zorn03 : odef HasMaximal ( & ( ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) ) ) | |
521 zorn03 = ODC.x∋minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) | |
522 zorn01 : A ∋ ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) | |
523 zorn01 = proj1 (zorn03 (& s) (subst (λ k → odef A (& k) ) *iso sa) ) | |
524 zorn02 : {x : HOD} → A ∋ x → ¬ (ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) < x) | |
525 zorn02 {x} ax m<x = proj2 (zorn03 (& x) ax) (subst₂ (λ j k → j < k) (sym *iso) (sym *iso) m<x ) | |
526 ... | yes ¬Maximal = ⊥-elim ( z04 zorn03 zorn04 ) where | |
527 -- if we have no maximal, make ZChain, which contradict SUP condition | |
528 zorn04 : ¬ Maximal A | |
529 zorn04 mx = ∅< {HasMaximal} zc5 ( ≡o∅→=od∅ ¬Maximal ) where | |
530 zc5 : (y : Ordinal) → odef A y → odef A (& (Maximal.maximal mx )) ∧ (¬ (* (& (Maximal.maximal mx )) < * y )) | |
531 zc5 y ay = ⟪ Maximal.A∋maximal mx , (λ mx<y → Maximal.¬maximal<x mx (subst (λ k → odef A k ) (sym &iso) ay) (subst (λ k → k < * y) *iso mx<y) ) ⟫ | |
532 zorn03 : ZChain A sa (& A) | |
533 zorn03 with TransFinite ind (& A) | |
534 ... | case1 zc = zc | |
535 ... | case2 mx = ⊥-elim ( zorn04 mx ) | |
464 | 536 |
516 | 537 -- usage (see filter.agda ) |
538 -- | |
497 | 539 -- _⊆'_ : ( A B : HOD ) → Set n |
540 -- _⊆'_ A B = (x : Ordinal ) → odef A x → odef B x | |
482 | 541 |
497 | 542 -- MaximumSubset : {L P : HOD} |
543 -- → o∅ o< & L → o∅ o< & P → P ⊆ L | |
544 -- → IsPartialOrderSet P _⊆'_ | |
545 -- → ( (B : HOD) → B ⊆ P → IsTotalOrderSet B _⊆'_ → SUP P B _⊆'_ ) | |
546 -- → Maximal P (_⊆'_) | |
547 -- MaximumSubset {L} {P} 0<L 0<P P⊆L PO SP = Zorn-lemma {P} {_⊆'_} 0<P PO SP |