|
478
|
1 {-# OPTIONS --allow-unsolved-metas #-}
|
|
431
|
2 open import Level
|
|
|
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
|
|
469
|
43 record Element (A : HOD) : Set (suc n) where
|
|
|
44 field
|
|
|
45 elm : HOD
|
|
|
46 is-elm : A ∋ elm
|
|
|
47
|
|
|
48 open Element
|
|
|
49
|
|
497
|
50 IsPartialOrderSet : ( A : HOD ) → Set (suc n)
|
|
|
51 IsPartialOrderSet A = IsStrictPartialOrder _≡A_ _<A_ where
|
|
495
|
52 _<A_ : (x y : Element A ) → Set n
|
|
|
53 x <A y = elm x < elm y
|
|
490
|
54 _≡A_ : (x y : Element A ) → Set (suc n)
|
|
|
55 x ≡A y = elm x ≡ elm y
|
|
|
56
|
|
492
|
57 open _==_
|
|
|
58 open _⊆_
|
|
|
59
|
|
495
|
60 isA : { A B : HOD } → B ⊆ A → (x : Element B) → Element A
|
|
|
61 isA B⊆A x = record { elm = elm x ; is-elm = incl B⊆A (is-elm x) }
|
|
494
|
62
|
|
497
|
63 ⊆-IsPartialOrderSet : { A B : HOD } → B ⊆ A → IsPartialOrderSet A → IsPartialOrderSet B
|
|
|
64 ⊆-IsPartialOrderSet {A} {B} B⊆A PA = record {
|
|
|
65 isEquivalence = record { refl = refl ; sym = sym ; trans = trans } ; trans = λ {x} {y} {z} → trans1 {x} {y} {z}
|
|
498
|
66 ; irrefl = λ {x} {y} → irrefl1 {x} {y} ; <-resp-≈ = resp0
|
|
493
|
67 } where
|
|
495
|
68 _<B_ : (x y : Element B ) → Set n
|
|
|
69 x <B y = elm x < elm y
|
|
|
70 trans1 : {x y z : Element B} → x <B y → y <B z → x <B z
|
|
|
71 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
|
|
|
72 irrefl1 : {x y : Element B} → elm x ≡ elm y → ¬ ( x <B y )
|
|
|
73 irrefl1 {x} {y} x=y x<y = IsStrictPartialOrder.irrefl PA {isA B⊆A x} {isA B⊆A y} x=y x<y
|
|
|
74 open import Data.Product
|
|
|
75 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)
|
|
|
76 resp0 = Data.Product._,_ (λ {x} {y} {z} → proj₁ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z })
|
|
|
77 (λ {x} {y} {z} → proj₂ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z })
|
|
492
|
78
|
|
497
|
79 -- open import Relation.Binary.Properties.Poset as Poset
|
|
496
|
80
|
|
497
|
81 IsTotalOrderSet : ( A : HOD ) → Set (suc n)
|
|
|
82 IsTotalOrderSet A = IsStrictTotalOrder _≡A_ _<A_ where
|
|
496
|
83 _<A_ : (x y : Element A ) → Set n
|
|
|
84 x <A y = elm x < elm y
|
|
490
|
85 _≡A_ : (x y : Element A ) → Set (suc n)
|
|
|
86 x ≡A y = elm x ≡ elm y
|
|
|
87
|
|
469
|
88 me : { A a : HOD } → A ∋ a → Element A
|
|
|
89 me {A} {a} lt = record { elm = a ; is-elm = lt }
|
|
|
90
|
|
497
|
91 record ZChain ( A : HOD ) (y : Ordinal) : Set (suc n) where
|
|
464
|
92 field
|
|
497
|
93 max : HOD
|
|
|
94 A∋max : A ∋ max
|
|
|
95 y<max : y o< & max
|
|
|
96 chain : HOD
|
|
|
97 chain⊆A : chain ⊆ A
|
|
|
98 total : IsTotalOrderSet chain
|
|
|
99 chain-max : (x : HOD) → chain ∋ x → (x ≡ max ) ∨ ( x < max )
|
|
498
|
100
|
|
|
101 data IChain (A : HOD) : Ordinal → Set n where
|
|
|
102 ifirst : {ox : Ordinal} → odef A ox → IChain A ox
|
|
|
103 inext : {ox oy : Ordinal} → odef A oy → * ox < * oy → IChain A ox → IChain A oy
|
|
|
104
|
|
|
105 ic-connet : {A : HOD} {x : Ordinal} → (x : IChain A x) → Ordinal → Set n
|
|
|
106 ic-connet {A} (ifirst {ox} ax) oy = ox ≡ oy
|
|
|
107 ic-connet {A} (inext {ox} {oy} ay x<y iy) oz = (ox ≡ oz) ∨ ic-connet iy oz
|
|
|
108
|
|
|
109 IChainSet : {A : HOD} → Element A → HOD
|
|
|
110 IChainSet {A} ax = record { od = record { def = λ y → odef A y ∧ ( (iy : IChain A y ) → ic-connet iy (& (elm ax))) }
|
|
|
111 ; odmax = & A ; <odmax = λ {y} lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k) (sym &iso) (proj1 lt))) }
|
|
|
112
|
|
|
113 -- there is a y, & y > & x
|
|
|
114
|
|
501
|
115 record OSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
|
|
498
|
116 field
|
|
501
|
117 y : Ordinal
|
|
|
118 icy : odef (IChainSet {A} (me ax)) y
|
|
|
119 y>x : x o< y
|
|
498
|
120
|
|
|
121 -- finite IChain
|
|
|
122
|
|
501
|
123 record InFiniteIChain (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
|
|
498
|
124 field
|
|
501
|
125 chain<x : (y : Ordinal ) → odef (IChainSet {A} (me ax)) y → y o< x
|
|
|
126 c-infinite : (y : Ordinal ) → (cy : odef (IChainSet {A} (me ax)) y )
|
|
|
127 → OSup> (IChainSet {A} (me ax)) (d→∋ (IChainSet {A} (me ax)) cy)
|
|
|
128
|
|
502
|
129 record IsFC (A : HOD) {x : Ordinal} (ax : A ∋ * x) (y : Ordinal) : Set n where
|
|
501
|
130 field
|
|
|
131 icy : odef (IChainSet {A} (me ax)) y
|
|
|
132 c-finite : ¬ OSup> (IChainSet {A} (me ax)) (d→∋ (IChainSet {A} (me ax)) icy)
|
|
497
|
133
|
|
503
|
134 record Maximal ( A : HOD ) : Set (suc n) where
|
|
|
135 field
|
|
|
136 maximal : HOD
|
|
|
137 A∋maximal : A ∋ maximal
|
|
|
138 ¬maximal<x : {x : HOD} → A ∋ x → ¬ maximal < x -- A is Partial, use negative
|
|
|
139
|
|
|
140 --
|
|
|
141 -- possible three cases in a limit ordinal step
|
|
|
142 --
|
|
|
143 -- case 1) < goes > x
|
|
|
144 -- case 2) no > x in some chain ( maximal )
|
|
|
145 -- case 3) countably infinite chain below x
|
|
|
146 --
|
|
|
147 Zorn-lemma-3case : { A : HOD }
|
|
498
|
148 → o∅ o< & A
|
|
|
149 → IsPartialOrderSet A
|
|
501
|
150 → (x : Element A) → OSup> A (d→∋ A (is-elm x)) ∨ Maximal A ∨ InFiniteIChain A (d→∋ A (is-elm x))
|
|
503
|
151 Zorn-lemma-3case {A} 0<A PO x = zc2 where
|
|
499
|
152 Gtx : HOD
|
|
|
153 Gtx = record { od = record { def = λ y → odef ( IChainSet x ) y ∧ ( & (elm x) o< y ) } ; odmax = & A
|
|
501
|
154 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 (proj1 lt)))) }
|
|
|
155 HG : HOD
|
|
502
|
156 HG = record { od = record { def = λ y → odef A y ∧ IsFC A (d→∋ A (is-elm x) ) y } ; odmax = & A
|
|
501
|
157 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 lt) )) }
|
|
|
158 zc2 : OSup> A (d→∋ A (is-elm x)) ∨ Maximal A ∨ InFiniteIChain A (d→∋ A (is-elm x))
|
|
499
|
159 zc2 with is-o∅ (& Gtx)
|
|
501
|
160 ... | no nogt = case1 {!!}
|
|
|
161 ... | yes nogt with is-o∅ (& HG)
|
|
|
162 ... | no nohg = case2 (case1 {!!} )
|
|
|
163 ... | yes nohg = case2 (case2 {!!} )
|
|
499
|
164
|
|
498
|
165
|
|
503
|
166 record SUP ( A B : HOD ) : Set (suc n) where
|
|
|
167 field
|
|
|
168 sup : HOD
|
|
|
169 A∋maximal : A ∋ sup
|
|
|
170 x<sup : {x : HOD} → B ∋ x → (x ≡ sup ) ∨ (x < sup ) -- B is Total, use positive
|
|
|
171
|
|
497
|
172 Zorn-lemma : { A : HOD }
|
|
464
|
173 → o∅ o< & A
|
|
497
|
174 → IsPartialOrderSet A
|
|
|
175 → ( ( B : HOD) → (B⊆A : B ⊆ A) → IsTotalOrderSet B → SUP A B ) -- SUP condition
|
|
|
176 → Maximal A
|
|
|
177 Zorn-lemma {A} 0<A PO supP = zorn00 where
|
|
472
|
178 someA : HOD
|
|
477
|
179 someA = ODC.minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A ))
|
|
473
|
180 isSomeA : A ∋ someA
|
|
477
|
181 isSomeA = ODC.x∋minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A ))
|
|
467
|
182 HasMaximal : HOD
|
|
493
|
183 HasMaximal = record { od = record { def = λ y → odef A y ∧ ((m : Ordinal) → odef A m → ¬ (* y < * m))} ; odmax = & A ; <odmax = z08 } where
|
|
|
184 z08 : {y : Ordinal} → (odef A y ∧ ((m : Ordinal) → odef A m → ¬ (* y < * m))) → y o< & A
|
|
482
|
185 z08 {y} P = subst (λ k → k o< & A) &iso (c<→o< {* y} (subst (λ k → odef A k) (sym &iso) (proj1 P)))
|
|
493
|
186 no-maximal : HasMaximal =h= od∅ → (y : Ordinal) → (odef A y ∧ ((m : Ordinal) → odef A m → ¬ (* y < * m))) → ⊥
|
|
482
|
187 no-maximal nomx y P = ¬x<0 (eq→ nomx {y} ⟪ proj1 P , (λ m am → (proj2 P) m am ) ⟫ )
|
|
472
|
188 Gtx : { x : HOD} → A ∋ x → HOD
|
|
493
|
189 Gtx {x} ax = record { od = record { def = λ y → odef A y ∧ (x < (* y)) } ; odmax = & A ; <odmax = z09 } where
|
|
|
190 z09 : {y : Ordinal} → (odef A y ∧ (x < (* y))) → y o< & A
|
|
482
|
191 z09 {y} P = subst (λ k → k o< & A) &iso (c<→o< {* y} (subst (λ k → odef A k) (sym &iso) (proj1 P)))
|
|
493
|
192 z01 : {a b : HOD} → A ∋ a → A ∋ b → (a ≡ b ) ∨ (a < b ) → b < a → ⊥
|
|
496
|
193 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
|
|
|
194 z01 {a} {b} A∋a A∋b (case2 a<b) b<a = IsStrictPartialOrder.irrefl PO {me A∋b} {me A∋b} refl (IsStrictPartialOrder.trans PO {me A∋b} {me A∋a} {me A∋b} b<a a<b)
|
|
478
|
195 -- ZChain is not compatible with the SUP condition
|
|
491
|
196 record BX (x y : Ordinal) (fb : ( x : Ordinal ) → HOD ) : Set n where
|
|
484
|
197 field
|
|
|
198 bx : Ordinal
|
|
493
|
199 bx<y : bx o< y
|
|
491
|
200 is-fb : x ≡ & (fb bx )
|
|
497
|
201 bx<A : (z : ZChain A (& A) ) → {x : Ordinal } → (bx : BX x (& A) {!!}) → BX.bx bx o< & A
|
|
493
|
202 bx<A z {x} bx = BX.bx<y bx
|
|
497
|
203 z12 : (z : ZChain A (& A) ) → {y : Ordinal} → BX y (& A) {!!} → y o< & A
|
|
|
204 z12 z {y} bx = subst (λ k → k o< & A) (sym (BX.is-fb bx)) (c<→o< {!!})
|
|
|
205 B : (z : ZChain A (& A) ) → HOD
|
|
|
206 B z = {!!}
|
|
|
207 z11 : (z : ZChain A (& A) ) → (x : Element (B z)) → elm x ≡ {!!}
|
|
485
|
208 z11 z x = subst₂ (λ j k → j ≡ k ) *iso *iso ( cong (*) (BX.is-fb (is-elm x)) )
|
|
497
|
209 obx : (z : ZChain A (& A) ) → {x : HOD} → B z ∋ x → Ordinal
|
|
485
|
210 obx z {x} bx = BX.bx bx
|
|
497
|
211 obx=fb : (z : ZChain A (& A) ) → {x : HOD} → (bx : B z ∋ x ) → x ≡ {!!}
|
|
485
|
212 obx=fb z {x} bx = subst₂ (λ j k → j ≡ k ) *iso *iso (cong (*) (BX.is-fb bx))
|
|
497
|
213 B⊆A : (z : ZChain A (& A) ) → B z ⊆ A
|
|
|
214 B⊆A z = record { incl = λ {x} bx → subst (λ k → odef A k ) (sym (BX.is-fb bx)) {!!} }
|
|
|
215 -- PO-B : (z : ZChain A (& A) ) → IsPartialOrderSet (B z) _<_
|
|
|
216 -- PO-B z = ⊆-IsPartialOrderSet (B⊆A z) PO
|
|
|
217 bx-monotonic : (z : ZChain A (& A) ) → {x y : Element (B z)} → obx z (is-elm x) o< obx z (is-elm y) → elm x < elm y
|
|
|
218 bx-monotonic z {x} {y} a = subst₂ (λ j k → j < k ) (sym (z11 z x)) (sym (z11 z y)) {!!}
|
|
|
219 bcmp : (z : ZChain A (& A) ) → Trichotomous (λ (x : Element (B z)) y → elm x ≡ elm y ) (λ x y → elm x < elm y )
|
|
496
|
220 bcmp z x y with trio< (obx z (is-elm x)) (obx z (is-elm y))
|
|
|
221 ... | tri< a ¬b ¬c = tri< z15 (λ eq → z01 (incl (B⊆A z) (is-elm y)) (incl (B⊆A z) (is-elm x))(case1 (sym eq)) z15 ) z17 where
|
|
|
222 z15 : elm x < elm y
|
|
|
223 z15 = bx-monotonic z {x} {y} a
|
|
|
224 z17 : elm y < elm x → ⊥
|
|
|
225 z17 lt = z01 (incl (B⊆A z) (is-elm y)) (incl (B⊆A z) (is-elm x))(case2 lt) z15
|
|
|
226 ... | tri≈ ¬a b ¬c = tri≈ (IsStrictPartialOrder.irrefl PO {isA (B⊆A z) x} {isA (B⊆A z) y} z14) z14 z16 where
|
|
|
227 z14 : elm x ≡ elm y
|
|
497
|
228 z14 = {!!}
|
|
496
|
229 z16 = IsStrictPartialOrder.irrefl PO {isA (B⊆A z) y} {isA (B⊆A z) x} (sym z14)
|
|
|
230 ... | tri> ¬a ¬b c = tri> z17 (λ eq → z01 (incl (B⊆A z) (is-elm x)) (incl (B⊆A z) (is-elm y))(case1 eq) z15 ) z15 where
|
|
|
231 z15 : elm y < elm x
|
|
|
232 z15 = bx-monotonic z {y} {x} c
|
|
|
233 z17 : elm x < elm y → ⊥
|
|
|
234 z17 lt = z01 (incl (B⊆A z) (is-elm x)) (incl (B⊆A z) (is-elm y))(case2 lt) z15
|
|
497
|
235 B-is-total : (z : ZChain A (& A) ) → IsTotalOrderSet (B z)
|
|
496
|
236 B-is-total zc = record { isEquivalence = record { refl = refl ; sym = sym ; trans = trans }
|
|
|
237 ; trans = λ {x} {y} {z} x<y y<z → IsStrictPartialOrder.trans PO {isA (B⊆A zc) x} {isA (B⊆A zc) y} {isA (B⊆A zc) z} x<y y<z
|
|
|
238 ; compare = bcmp zc }
|
|
497
|
239 ind : (x : Ordinal) → ((y : Ordinal) → y o< x → ZChain A y ∨ Maximal A )
|
|
|
240 → ZChain A x ∨ Maximal A
|
|
|
241 -- has previous ordinal
|
|
|
242 -- has maximal use this
|
|
|
243 -- else has chain
|
|
|
244 -- & A < y A is a counter example of assumption
|
|
|
245 -- chack y is maximal
|
|
|
246 -- y < max use previous chain
|
|
|
247 -- y = max ( y > max cannot happen )
|
|
|
248 -- ¬ A ∋ y use previous chain
|
|
|
249 -- A ∋ y is use oridinaly min of y or previous
|
|
|
250 -- y is limit ordinal
|
|
|
251 -- has maximal in some lower use this
|
|
|
252 -- no maximal in all lower
|
|
|
253 -- & A < y A is a counter example of assumption
|
|
|
254 -- A ∋ y is maximal use this
|
|
|
255 -- ¬ A ∋ y use previous chain
|
|
|
256 -- check some y ≤ max
|
|
|
257 -- if none A < y is the counter example
|
|
|
258 -- else use the ordinaly smallest max as next chain
|
|
|
259 ind x prev with Oprev-p x
|
|
477
|
260 ... | yes op with ODC.∋-p O A (* x)
|
|
498
|
261 ... | no ¬Ax = zc1 where
|
|
476
|
262 -- we have previous ordinal and ¬ A ∋ x, use previous Zchain
|
|
471
|
263 px = Oprev.oprev op
|
|
498
|
264 zc1 : ZChain A x ∨ Maximal A
|
|
497
|
265 zc1 with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc)
|
|
498
|
266 ... | case2 x = case2 x -- we have the Maximal
|
|
|
267 ... | case1 z with trio< x (& (ZChain.max z))
|
|
|
268 ... | tri< a ¬b ¬c = case1 record { max = ZChain.max z ; y<max = a }
|
|
|
269 ... | tri≈ ¬a b ¬c = {!!} -- x = max so ¬ A ∋ max
|
|
|
270 ... | tri> ¬a ¬b c = {!!} -- can't happen
|
|
503
|
271 ... | yes ax = zc4 where -- we have previous ordinal and A ∋ x
|
|
472
|
272 px = Oprev.oprev op
|
|
503
|
273 zc1 : OSup> A (subst (OD.def (od A)) (sym &iso) ax) → ZChain A x ∨ Maximal A
|
|
|
274 zc1 os with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc)
|
|
498
|
275 ... | case2 x = case2 x
|
|
|
276 ... | case1 x with is-o∅ ( & (Gtx ax ))
|
|
|
277 ... | yes no-sup = case2 {!!}
|
|
|
278 ... | no sup = case1 {!!}
|
|
503
|
279 zc4 : ZChain A x ∨ Maximal A
|
|
|
280 zc4 with Zorn-lemma-3case 0<A PO (me ax)
|
|
|
281 ... | case1 y>x = zc1 y>x
|
|
|
282 ... | case2 (case1 x) = case2 x
|
|
|
283 ... | case2 (case2 x) = ⊥-elim (zc5 x) where
|
|
|
284 FC : HOD
|
|
|
285 FC = IChainSet {A} (me ax)
|
|
|
286 zc6 : InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax) → ¬ SUP A FC
|
|
|
287 zc6 = {!!}
|
|
|
288 FC-is-total : IsTotalOrderSet FC
|
|
|
289 FC-is-total = {!!}
|
|
|
290 FC⊆A : FC ⊆ A
|
|
|
291 FC⊆A = {!!}
|
|
|
292 zc5 : InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax) → ⊥
|
|
|
293 zc5 x = zc6 x ( supP FC FC⊆A FC-is-total )
|
|
497
|
294 ind x prev | no ¬ox with trio< (& A) x --- limit ordinal case
|
|
483
|
295 ... | tri< a ¬b ¬c = {!!} where
|
|
497
|
296 zc1 : ZChain A (& A)
|
|
|
297 zc1 with prev (& A) a
|
|
|
298 ... | t = {!!}
|
|
483
|
299 ... | tri≈ ¬a b ¬c = {!!} where
|
|
478
|
300 ... | tri> ¬a ¬b c with ODC.∋-p O A (* x)
|
|
|
301 ... | no ¬Ax = {!!} where
|
|
|
302 ... | yes ax with is-o∅ (& (Gtx ax))
|
|
497
|
303 ... | yes nogt = ⊥-elim {!!} where -- no larger element, so it is maximal
|
|
493
|
304 x-is-maximal : (m : Ordinal) → odef A m → ¬ (* x < * m)
|
|
|
305 x-is-maximal m am = ¬x<m where
|
|
|
306 ¬x<m : ¬ (* x < * m)
|
|
|
307 ¬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)
|
|
478
|
308 ... | no not = {!!} where
|
|
497
|
309 zorn03 : (x : Ordinal) → ZChain A x ∨ Maximal A
|
|
|
310 zorn03 x with TransFinite ind x
|
|
|
311 ... | t = {!!}
|
|
|
312 zorn04 : Maximal A
|
|
|
313 zorn04 with zorn03 (& A)
|
|
|
314 ... | case1 chain = {!!}
|
|
|
315 ... | case2 m = m
|
|
|
316 zorn00 : Maximal A
|
|
467
|
317 zorn00 with is-o∅ ( & HasMaximal )
|
|
493
|
318 ... | no not = record { maximal = ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) ; A∋maximal = zorn01 ; ¬maximal<x = zorn02 } where
|
|
478
|
319 -- yes we have the maximal
|
|
483
|
320 hasm : odef HasMaximal ( & ( ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) ) )
|
|
|
321 hasm = ODC.x∋minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq))
|
|
477
|
322 zorn01 : A ∋ ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq))
|
|
483
|
323 zorn01 = proj1 hasm
|
|
493
|
324 zorn02 : {x : HOD} → A ∋ x → ¬ (ODC.minimal O HasMaximal (λ eq → not (=od∅→≡o∅ eq)) < x)
|
|
|
325 zorn02 {x} ax m<x = ((proj2 hasm) (& x) ax) (subst₂ (λ j k → j < k) (sym *iso) (sym *iso) m<x )
|
|
497
|
326 ... | yes ¬Maximal = {!!} where
|
|
478
|
327 -- if we have no maximal, make ZChain, which contradict SUP condition
|
|
497
|
328 z : (x : Ordinal) → HasMaximal =h= od∅ → ZChain A x ∨ Maximal A
|
|
|
329 z x nomx with TransFinite {!!} x
|
|
|
330 ... | t = {!!}
|
|
464
|
331
|
|
497
|
332 -- _⊆'_ : ( A B : HOD ) → Set n
|
|
|
333 -- _⊆'_ A B = (x : Ordinal ) → odef A x → odef B x
|
|
482
|
334
|
|
497
|
335 -- MaximumSubset : {L P : HOD}
|
|
|
336 -- → o∅ o< & L → o∅ o< & P → P ⊆ L
|
|
|
337 -- → IsPartialOrderSet P _⊆'_
|
|
|
338 -- → ( (B : HOD) → B ⊆ P → IsTotalOrderSet B _⊆'_ → SUP P B _⊆'_ )
|
|
|
339 -- → Maximal P (_⊆'_)
|
|
|
340 -- MaximumSubset {L} {P} 0<L 0<P P⊆L PO SP = Zorn-lemma {P} {_⊆'_} 0<P PO SP
|
