|
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
|
|
508
|
43 record Element (A : HOD) : Set (Level.suc n) where
|
|
469
|
44 field
|
|
|
45 elm : HOD
|
|
|
46 is-elm : A ∋ elm
|
|
|
47
|
|
|
48 open Element
|
|
|
49
|
|
509
|
50 _<A_ : {A : HOD} → (x y : Element A ) → Set n
|
|
|
51 x <A y = elm x < elm y
|
|
|
52 _≡A_ : {A : HOD} → (x y : Element A ) → Set (Level.suc n)
|
|
|
53 x ≡A y = elm x ≡ elm y
|
|
|
54
|
|
508
|
55 IsPartialOrderSet : ( A : HOD ) → Set (Level.suc n)
|
|
509
|
56 IsPartialOrderSet A = IsStrictPartialOrder (_≡A_ {A}) _<A_
|
|
490
|
57
|
|
492
|
58 open _==_
|
|
|
59 open _⊆_
|
|
|
60
|
|
495
|
61 isA : { A B : HOD } → B ⊆ A → (x : Element B) → Element A
|
|
|
62 isA B⊆A x = record { elm = elm x ; is-elm = incl B⊆A (is-elm x) }
|
|
494
|
63
|
|
497
|
64 ⊆-IsPartialOrderSet : { A B : HOD } → B ⊆ A → IsPartialOrderSet A → IsPartialOrderSet B
|
|
|
65 ⊆-IsPartialOrderSet {A} {B} B⊆A PA = record {
|
|
|
66 isEquivalence = record { refl = refl ; sym = sym ; trans = trans } ; trans = λ {x} {y} {z} → trans1 {x} {y} {z}
|
|
498
|
67 ; irrefl = λ {x} {y} → irrefl1 {x} {y} ; <-resp-≈ = resp0
|
|
493
|
68 } where
|
|
495
|
69 _<B_ : (x y : Element B ) → Set n
|
|
|
70 x <B y = elm x < elm y
|
|
|
71 trans1 : {x y z : Element B} → x <B y → y <B z → x <B z
|
|
|
72 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
|
|
|
73 irrefl1 : {x y : Element B} → elm x ≡ elm y → ¬ ( x <B y )
|
|
|
74 irrefl1 {x} {y} x=y x<y = IsStrictPartialOrder.irrefl PA {isA B⊆A x} {isA B⊆A y} x=y x<y
|
|
|
75 open import Data.Product
|
|
|
76 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)
|
|
|
77 resp0 = Data.Product._,_ (λ {x} {y} {z} → proj₁ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z })
|
|
|
78 (λ {x} {y} {z} → proj₂ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z })
|
|
492
|
79
|
|
497
|
80 -- open import Relation.Binary.Properties.Poset as Poset
|
|
496
|
81
|
|
508
|
82 IsTotalOrderSet : ( A : HOD ) → Set (Level.suc n)
|
|
509
|
83 IsTotalOrderSet A = IsStrictTotalOrder (_≡A_ {A}) _<A_
|
|
490
|
84
|
|
469
|
85 me : { A a : HOD } → A ∋ a → Element A
|
|
|
86 me {A} {a} lt = record { elm = a ; is-elm = lt }
|
|
|
87
|
|
504
|
88 A∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (A ∋ x) ≡ (A ∋ y )
|
|
|
89 A∋x-irr A {x} {y} refl = refl
|
|
|
90
|
|
506
|
91 me-elm-refl : (A : HOD) → (x : Element A) → elm (me {A} (d→∋ A (is-elm x))) ≡ elm x
|
|
|
92 me-elm-refl A record { elm = ex ; is-elm = ax } = *iso
|
|
504
|
93
|
|
|
94 open import Relation.Binary.HeterogeneousEquality as HE using (_≅_ )
|
|
|
95
|
|
|
96 postulate
|
|
|
97 ∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (ax : A ∋ x) (ay : A ∋ y ) → ax ≅ ay
|
|
|
98 odef-irr : (A : OD) {x y : Ordinal} → x ≡ y → (ax : def A x) (ay : def A y ) → ax ≅ ay
|
|
|
99
|
|
|
100 is-elm-irr : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y
|
|
|
101 is-elm-irr A {x} {y} eq = ∋x-irr A eq (is-elm x) (is-elm y )
|
|
|
102
|
|
|
103 El-irr2 : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y → x ≡ y
|
|
|
104 El-irr2 A {x} {y} refl HE.refl = refl
|
|
|
105
|
|
|
106 El-irr : {A : HOD} → {x y : Element A } → elm x ≡ elm y → x ≡ y
|
|
|
107 El-irr {A} {x} {y} eq = El-irr2 A eq ( is-elm-irr A eq )
|
|
|
108
|
|
508
|
109 record ZChain ( A : HOD ) (y : Ordinal) : Set (Level.suc n) where
|
|
464
|
110 field
|
|
497
|
111 max : HOD
|
|
|
112 A∋max : A ∋ max
|
|
|
113 y<max : y o< & max
|
|
|
114 chain : HOD
|
|
|
115 chain⊆A : chain ⊆ A
|
|
|
116 total : IsTotalOrderSet chain
|
|
|
117 chain-max : (x : HOD) → chain ∋ x → (x ≡ max ) ∨ ( x < max )
|
|
498
|
118
|
|
|
119 data IChain (A : HOD) : Ordinal → Set n where
|
|
|
120 ifirst : {ox : Ordinal} → odef A ox → IChain A ox
|
|
|
121 inext : {ox oy : Ordinal} → odef A oy → * ox < * oy → IChain A ox → IChain A oy
|
|
|
122
|
|
506
|
123 -- * ox < .. < * oy
|
|
|
124 ic-connect : {A : HOD} {oy : Ordinal} → (ox : Ordinal) → (iy : IChain A oy) → Set n
|
|
|
125 ic-connect {A} ox (ifirst {oy} ay) = Lift n ⊥
|
|
|
126 ic-connect {A} ox (inext {oy} {oz} ay y<z iz) = (ox ≡ oy) ∨ ic-connect ox iz
|
|
|
127
|
|
|
128 ic→odef : {A : HOD} {ox : Ordinal} → IChain A ox → odef A ox
|
|
|
129 ic→odef {A} {ox} (ifirst ax) = ax
|
|
|
130 ic→odef {A} {ox} (inext ax x<y ic) = ax
|
|
|
131
|
|
|
132 ic→< : {A : HOD} → (IsPartialOrderSet A) → (x : Ordinal) → odef A x → {y : Ordinal} → (iy : IChain A y) → ic-connect {A} {y} x iy → * x < * y
|
|
|
133 ic→< {A} PO x ax {y} (ifirst ay) ()
|
|
|
134 ic→< {A} PO x ax {y} (inext ay x<y iy) (case1 refl) = x<y
|
|
|
135 ic→< {A} PO x ax {y} (inext {oy} ay x<y iy) (case2 ic) = IsStrictPartialOrder.trans PO
|
|
|
136 {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) }
|
|
|
137 (ic→< {A} PO x ax iy ic ) x<y
|
|
|
138
|
|
|
139 record IChained (A : HOD) (x y : Ordinal) : Set n where
|
|
|
140 field
|
|
|
141 iy : IChain A y
|
|
|
142 ic : ic-connect x iy
|
|
498
|
143
|
|
|
144 IChainSet : {A : HOD} → Element A → HOD
|
|
506
|
145 IChainSet {A} ax = record { od = record { def = λ y → odef A y ∧ IChained A (& (elm ax)) y }
|
|
498
|
146 ; odmax = & A ; <odmax = λ {y} lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k) (sym &iso) (proj1 lt))) }
|
|
|
147
|
|
|
148 -- there is a y, & y > & x
|
|
|
149
|
|
501
|
150 record OSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
|
|
498
|
151 field
|
|
501
|
152 y : Ordinal
|
|
|
153 icy : odef (IChainSet {A} (me ax)) y
|
|
|
154 y>x : x o< y
|
|
498
|
155
|
|
505
|
156 record IChainSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
|
|
|
157 field
|
|
|
158 y : Ordinal
|
|
|
159 A∋y : odef A y
|
|
|
160 y>x : * x < * y
|
|
|
161
|
|
498
|
162 -- finite IChain
|
|
|
163
|
|
511
|
164 ic→A∋y : (A : HOD) {x y : Ordinal} (ax : A ∋ * x) → odef (IChainSet {A} (me ax)) y → A ∋ * y
|
|
|
165 ic→A∋y A {x} {y} ax ⟪ ay , _ ⟫ = subst (λ k → odef A k) (sym &iso) ay
|
|
|
166
|
|
501
|
167 record InFiniteIChain (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
|
|
498
|
168 field
|
|
501
|
169 chain<x : (y : Ordinal ) → odef (IChainSet {A} (me ax)) y → y o< x
|
|
|
170 c-infinite : (y : Ordinal ) → (cy : odef (IChainSet {A} (me ax)) y )
|
|
511
|
171 → IChainSup> A (ic→A∋y A ax cy)
|
|
509
|
172
|
|
510
|
173 open import Data.Nat hiding (_<_)
|
|
|
174 import Data.Nat.Properties as NP
|
|
|
175 open import nat
|
|
|
176
|
|
509
|
177 data Chain (A : HOD) (next : (x : Ordinal ) → odef A x → Ordinal ) : ( x : Ordinal ) → Set n where
|
|
510
|
178 cfirst : (x : Ordinal ) → odef A x → Chain A next x
|
|
|
179 csuc : (x : Ordinal ) → (ax : odef A x ) → Chain A next x → Chain A next (next x ax )
|
|
509
|
180
|
|
|
181 ChainClosure : (A : HOD) → (next : (x : Ordinal ) → odef A x → Ordinal ) → HOD
|
|
|
182 ChainClosure A next = record { od = record { def = λ x → Chain A next x } ; odmax = {!!} ; <odmax = {!!} }
|
|
|
183
|
|
510
|
184 cton0 : (A : HOD ) → (next : (x : Ordinal ) → odef A x → Ordinal ) {y : Ordinal } → Chain A next y → ℕ
|
|
|
185 cton0 A next (cfirst _ x) = zero
|
|
|
186 cton0 A next (csuc x ax z) = suc (cton0 A next z)
|
|
|
187 cton : (A : HOD ) → (next : (x : Ordinal ) → odef A x → Ordinal ) → Element (ChainClosure A next) → ℕ
|
|
|
188 cton A next y = cton0 A next (is-elm y)
|
|
511
|
189 ct∈A : (A : HOD ) → (next : (x : Ordinal ) → odef A x → Ordinal ) → {x : Ordinal} → Chain A next x → odef A x
|
|
|
190 ct∈A = {!!}
|
|
510
|
191
|
|
509
|
192 InFCSet : (A : HOD) → {x : Ordinal} (ax : A ∋ * x)
|
|
|
193 → (ifc : InFiniteIChain A ax ) → HOD
|
|
|
194 InFCSet A ax ifc = ChainClosure (IChainSet {A} (me ax)) (λ y ay → IChainSup>.y ( InFiniteIChain.c-infinite ifc y ay ) )
|
|
|
195
|
|
|
196 ChainClosure-is-total : (A : HOD) → {x : Ordinal} (ax : A ∋ * x)
|
|
|
197 → IsPartialOrderSet A
|
|
|
198 → (ifc : InFiniteIChain A ax )
|
|
|
199 → IsTotalOrderSet ( InFCSet A ax ifc )
|
|
|
200 ChainClosure-is-total A {x} ax PO ifc = record { isEquivalence = IsStrictPartialOrder.isEquivalence IPO
|
|
|
201 ; trans = λ {x} {y} {z} → IsStrictPartialOrder.trans IPO {x} {y} {z} ; compare = cmp } where
|
|
|
202 IPO : IsPartialOrderSet (InFCSet A ax ifc )
|
|
|
203 IPO = ⊆-IsPartialOrderSet record { incl = λ {x} lt → {!!} } PO
|
|
511
|
204 B = IChainSet {A} (me ax)
|
|
|
205 cnext : (y : Ordinal ) → odef B y → Ordinal
|
|
510
|
206 cnext y ay = IChainSup>.y ( InFiniteIChain.c-infinite ifc y ay )
|
|
511
|
207 ct-monotonic : {ox oy : Ordinal} → (x : Chain B cnext ox ) → (y : Chain B cnext oy )
|
|
|
208 → (cton0 B cnext x) Data.Nat.< (cton0 B cnext y) → * ox < * oy
|
|
|
209 ct-monotonic x (csuc oy ax y) (s≤s lt) with NP.<-cmp ( cton0 B cnext x ) ( cton0 B cnext y )
|
|
|
210 ... | tri< a ¬b ¬c = IsStrictPartialOrder.trans PO {me {!!}} {me {!!}} (ct-monotonic x y a ) ct01 where
|
|
|
211 ct01 : * oy < * ( IChainSup>.y (InFiniteIChain.c-infinite ifc oy ax) )
|
|
|
212 ct01 = (IChainSup>.y>x (InFiniteIChain.c-infinite ifc oy ax))
|
|
|
213 ... | tri≈ ¬a b ¬c = {!!}
|
|
|
214 ... | tri> ¬a ¬b c = {!!}
|
|
509
|
215 cmp : Trichotomous _ _
|
|
511
|
216 cmp x y with NP.<-cmp (cton B cnext x) (cton B cnext y)
|
|
510
|
217 ... | tri< a ¬b ¬c = {!!}
|
|
|
218 ... | tri≈ ¬a b ¬c = {!!}
|
|
|
219 ... | tri> ¬a ¬b c = {!!}
|
|
509
|
220
|
|
501
|
221
|
|
502
|
222 record IsFC (A : HOD) {x : Ordinal} (ax : A ∋ * x) (y : Ordinal) : Set n where
|
|
501
|
223 field
|
|
|
224 icy : odef (IChainSet {A} (me ax)) y
|
|
505
|
225 c-finite : ¬ IChainSup> A ax
|
|
497
|
226
|
|
508
|
227 record Maximal ( A : HOD ) : Set (Level.suc n) where
|
|
503
|
228 field
|
|
|
229 maximal : HOD
|
|
|
230 A∋maximal : A ∋ maximal
|
|
|
231 ¬maximal<x : {x : HOD} → A ∋ x → ¬ maximal < x -- A is Partial, use negative
|
|
|
232
|
|
|
233 --
|
|
|
234 -- possible three cases in a limit ordinal step
|
|
|
235 --
|
|
507
|
236 -- case 1) < goes > x (will contradic in the transfinite induction )
|
|
503
|
237 -- case 2) no > x in some chain ( maximal )
|
|
507
|
238 -- case 3) countably infinite chain below x (will be prohibited by sup condtion )
|
|
503
|
239 --
|
|
|
240 Zorn-lemma-3case : { A : HOD }
|
|
498
|
241 → o∅ o< & A
|
|
|
242 → IsPartialOrderSet A
|
|
501
|
243 → (x : Element A) → OSup> A (d→∋ A (is-elm x)) ∨ Maximal A ∨ InFiniteIChain A (d→∋ A (is-elm x))
|
|
503
|
244 Zorn-lemma-3case {A} 0<A PO x = zc2 where
|
|
499
|
245 Gtx : HOD
|
|
|
246 Gtx = record { od = record { def = λ y → odef ( IChainSet x ) y ∧ ( & (elm x) o< y ) } ; odmax = & A
|
|
501
|
247 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 (proj1 lt)))) }
|
|
|
248 HG : HOD
|
|
502
|
249 HG = record { od = record { def = λ y → odef A y ∧ IsFC A (d→∋ A (is-elm x) ) y } ; odmax = & A
|
|
501
|
250 ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋ A (proj1 lt) )) }
|
|
|
251 zc2 : OSup> A (d→∋ A (is-elm x)) ∨ Maximal A ∨ InFiniteIChain A (d→∋ A (is-elm x))
|
|
499
|
252 zc2 with is-o∅ (& Gtx)
|
|
504
|
253 ... | no not = case1 record { y = & y ; icy = zc4 ; y>x = proj2 zc3 } where
|
|
|
254 y : HOD
|
|
|
255 y = ODC.minimal O Gtx (λ eq → not (=od∅→≡o∅ eq))
|
|
|
256 zc3 : odef ( IChainSet x ) (& y) ∧ ( & (elm x) o< (& y ))
|
|
|
257 zc3 = ODC.x∋minimal O Gtx (λ eq → not (=od∅→≡o∅ eq))
|
|
|
258 zc4 : odef (IChainSet (me (subst (OD.def (od A)) (sym &iso) (is-elm x)))) (& y)
|
|
506
|
259 zc4 = ⟪ proj1 (proj1 zc3) , subst (λ k → IChained A (& k) (& y) ) (sym *iso) (proj2 (proj1 zc3)) ⟫
|
|
501
|
260 ... | yes nogt with is-o∅ (& HG)
|
|
505
|
261 ... | no finite-chain = case2 (case1 record { maximal = y ; A∋maximal = proj1 zc3 ; ¬maximal<x = zc4 } ) where
|
|
504
|
262 y : HOD
|
|
505
|
263 y = ODC.minimal O HG (λ eq → finite-chain (=od∅→≡o∅ eq))
|
|
504
|
264 zc3 : odef A (& y) ∧ IsFC A (d→∋ A (is-elm x) ) (& y)
|
|
505
|
265 zc3 = ODC.x∋minimal O HG (λ eq → finite-chain (=od∅→≡o∅ eq))
|
|
504
|
266 zc5 : odef (IChainSet {A} (me (d→∋ A (is-elm x) ))) (& y)
|
|
|
267 zc5 = IsFC.icy (proj2 zc3)
|
|
|
268 zc4 : {z : HOD} → A ∋ z → ¬ (y < z)
|
|
506
|
269 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) zc6 } where
|
|
|
270 zc8 : ic-connect (& (* (& (elm x)))) (IChained.iy (proj2 zc5))
|
|
|
271 zc8 = IChained.ic (proj2 zc5)
|
|
|
272 zc7 : elm x < y
|
|
|
273 zc7 = subst₂ (λ j k → j < k ) *iso *iso ( ic→< {A} PO (& (elm x)) (is-elm x) (IChained.iy (proj2 zc5))
|
|
|
274 (subst (λ k → ic-connect (& k) (IChained.iy (proj2 zc5)) ) (me-elm-refl A x) (IChained.ic (proj2 zc5)) ) )
|
|
505
|
275 zc6 : elm x < z
|
|
506
|
276 zc6 = IsStrictPartialOrder.trans PO {x} {me (proj1 zc3)} {me az} zc7 y<z
|
|
507
|
277 ... | yes inifite = case2 (case2 record { chain<x = {!!} ; c-infinite = {!!} } )
|
|
499
|
278
|
|
498
|
279
|
|
508
|
280 record SUP ( A B : HOD ) : Set (Level.suc n) where
|
|
503
|
281 field
|
|
|
282 sup : HOD
|
|
|
283 A∋maximal : A ∋ sup
|
|
|
284 x<sup : {x : HOD} → B ∋ x → (x ≡ sup ) ∨ (x < sup ) -- B is Total, use positive
|
|
|
285
|
|
497
|
286 Zorn-lemma : { A : HOD }
|
|
464
|
287 → o∅ o< & A
|
|
497
|
288 → IsPartialOrderSet A
|
|
|
289 → ( ( B : HOD) → (B⊆A : B ⊆ A) → IsTotalOrderSet B → SUP A B ) -- SUP condition
|
|
|
290 → Maximal A
|
|
507
|
291 Zorn-lemma {A} 0<A PO supP = zorn04 where
|
|
493
|
292 z01 : {a b : HOD} → A ∋ a → A ∋ b → (a ≡ b ) ∨ (a < b ) → b < a → ⊥
|
|
496
|
293 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
|
|
|
294 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)
|
|
507
|
295 z02 : {x : Ordinal } → (ax : A ∋ * x ) → InFiniteIChain A ax → ⊥
|
|
|
296 z02 {x} ax ic = zc5 ic where
|
|
|
297 FC : HOD
|
|
|
298 FC = IChainSet {A} (me ax)
|
|
|
299 zc6 : InFiniteIChain A ax → ¬ SUP A FC
|
|
|
300 zc6 inf = {!!}
|
|
|
301 FC-is-total : IsTotalOrderSet FC
|
|
|
302 FC-is-total = {!!}
|
|
|
303 FC⊆A : FC ⊆ A
|
|
|
304 FC⊆A = record { incl = λ {x} lt → proj1 lt }
|
|
|
305 zc5 : InFiniteIChain A ax → ⊥
|
|
|
306 zc5 x = zc6 x ( supP FC FC⊆A FC-is-total )
|
|
478
|
307 -- ZChain is not compatible with the SUP condition
|
|
497
|
308 ind : (x : Ordinal) → ((y : Ordinal) → y o< x → ZChain A y ∨ Maximal A )
|
|
|
309 → ZChain A x ∨ Maximal A
|
|
|
310 -- has previous ordinal
|
|
|
311 -- has maximal use this
|
|
|
312 -- else has chain
|
|
|
313 -- & A < y A is a counter example of assumption
|
|
|
314 -- chack y is maximal
|
|
|
315 -- y < max use previous chain
|
|
|
316 -- y = max ( y > max cannot happen )
|
|
|
317 -- ¬ A ∋ y use previous chain
|
|
|
318 -- A ∋ y is use oridinaly min of y or previous
|
|
|
319 -- y is limit ordinal
|
|
|
320 -- has maximal in some lower use this
|
|
|
321 -- no maximal in all lower
|
|
|
322 -- & A < y A is a counter example of assumption
|
|
|
323 -- A ∋ y is maximal use this
|
|
|
324 -- ¬ A ∋ y use previous chain
|
|
|
325 -- check some y ≤ max
|
|
|
326 -- if none A < y is the counter example
|
|
|
327 -- else use the ordinaly smallest max as next chain
|
|
|
328 ind x prev with Oprev-p x
|
|
477
|
329 ... | yes op with ODC.∋-p O A (* x)
|
|
498
|
330 ... | no ¬Ax = zc1 where
|
|
476
|
331 -- we have previous ordinal and ¬ A ∋ x, use previous Zchain
|
|
471
|
332 px = Oprev.oprev op
|
|
498
|
333 zc1 : ZChain A x ∨ Maximal A
|
|
497
|
334 zc1 with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc)
|
|
498
|
335 ... | case2 x = case2 x -- we have the Maximal
|
|
|
336 ... | case1 z with trio< x (& (ZChain.max z))
|
|
|
337 ... | tri< a ¬b ¬c = case1 record { max = ZChain.max z ; y<max = a }
|
|
|
338 ... | tri≈ ¬a b ¬c = {!!} -- x = max so ¬ A ∋ max
|
|
|
339 ... | tri> ¬a ¬b c = {!!} -- can't happen
|
|
503
|
340 ... | yes ax = zc4 where -- we have previous ordinal and A ∋ x
|
|
472
|
341 px = Oprev.oprev op
|
|
503
|
342 zc1 : OSup> A (subst (OD.def (od A)) (sym &iso) ax) → ZChain A x ∨ Maximal A
|
|
|
343 zc1 os with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc)
|
|
498
|
344 ... | case2 x = case2 x
|
|
507
|
345 ... | case1 x = {!!}
|
|
503
|
346 zc4 : ZChain A x ∨ Maximal A
|
|
|
347 zc4 with Zorn-lemma-3case 0<A PO (me ax)
|
|
|
348 ... | case1 y>x = zc1 y>x
|
|
|
349 ... | case2 (case1 x) = case2 x
|
|
|
350 ... | case2 (case2 x) = ⊥-elim (zc5 x) where
|
|
|
351 FC : HOD
|
|
|
352 FC = IChainSet {A} (me ax)
|
|
511
|
353 B : InFiniteIChain A ax → HOD
|
|
|
354 B ifc = InFCSet A ax ifc
|
|
|
355 zc6 : (ifc : InFiniteIChain A ax ) → ¬ SUP A (B ifc)
|
|
503
|
356 zc6 = {!!}
|
|
511
|
357 FC-is-total : (ifc : InFiniteIChain A ax) → IsTotalOrderSet (B ifc)
|
|
|
358 FC-is-total ifc = ChainClosure-is-total A ax PO ifc
|
|
|
359 B⊆A : (ifc : InFiniteIChain A ax) → B ifc ⊆ A
|
|
|
360 B⊆A = {!!}
|
|
|
361 ifc : InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax) → InFiniteIChain A ax
|
|
|
362 ifc record { chain<x = chain<x ; c-infinite = c-infinite } = record { chain<x = ? ; c-infinite = ? }
|
|
503
|
363 zc5 : InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax) → ⊥
|
|
511
|
364 zc5 x = zc6 (ifc x) ( supP (B (ifc x)) (B⊆A (ifc x)) (FC-is-total (ifc x) ))
|
|
497
|
365 ind x prev | no ¬ox with trio< (& A) x --- limit ordinal case
|
|
483
|
366 ... | tri< a ¬b ¬c = {!!} where
|
|
497
|
367 zc1 : ZChain A (& A)
|
|
|
368 zc1 with prev (& A) a
|
|
|
369 ... | t = {!!}
|
|
483
|
370 ... | tri≈ ¬a b ¬c = {!!} where
|
|
478
|
371 ... | tri> ¬a ¬b c with ODC.∋-p O A (* x)
|
|
|
372 ... | no ¬Ax = {!!} where
|
|
507
|
373 ... | yes ax = {!!}
|
|
478
|
374 ... | no not = {!!} where
|
|
497
|
375 zorn03 : (x : Ordinal) → ZChain A x ∨ Maximal A
|
|
507
|
376 zorn03 x = TransFinite ind x
|
|
497
|
377 zorn04 : Maximal A
|
|
|
378 zorn04 with zorn03 (& A)
|
|
507
|
379 ... | case1 chain = ⊥-elim ( o<> (c<→o< {ZChain.max chain} {A} (ZChain.A∋max chain)) (ZChain.y<max chain) )
|
|
497
|
380 ... | case2 m = m
|
|
464
|
381
|
|
497
|
382 -- _⊆'_ : ( A B : HOD ) → Set n
|
|
|
383 -- _⊆'_ A B = (x : Ordinal ) → odef A x → odef B x
|
|
482
|
384
|
|
497
|
385 -- MaximumSubset : {L P : HOD}
|
|
|
386 -- → o∅ o< & L → o∅ o< & P → P ⊆ L
|
|
|
387 -- → IsPartialOrderSet P _⊆'_
|
|
|
388 -- → ( (B : HOD) → B ⊆ P → IsTotalOrderSet B _⊆'_ → SUP P B _⊆'_ )
|
|
|
389 -- → Maximal P (_⊆'_)
|
|
|
390 -- MaximumSubset {L} {P} 0<L 0<P P⊆L PO SP = Zorn-lemma {P} {_⊆'_} 0<P PO SP
|
