{-# OPTIONS --allow-unsolved-metas #-}
open import Level hiding ( suc ; zero )
open import Ordinals
import OD 
module zorn {n : Level } (O : Ordinals {n}) (_<_ : (x y : OD.HOD O ) → Set n ) where

open import zf
open import logic
-- open import partfunc {n} O

open import Relation.Nullary 
open import Relation.Binary 
open import Data.Empty 
open import Relation.Binary
open import Relation.Binary.Core
open import Relation.Binary.PropositionalEquality
import BAlgbra 


open inOrdinal O
open OD O
open OD.OD
open ODAxiom odAxiom
import OrdUtil
import ODUtil
open Ordinals.Ordinals  O
open Ordinals.IsOrdinals isOrdinal
open Ordinals.IsNext isNext
open OrdUtil O
open ODUtil O


import ODC


open _∧_
open _∨_
open Bool


open HOD

_≤_ : (x y : HOD) → Set (Level.suc n)
x ≤ y = ( x ≡ y ) ∨ ( x < y )

record Element (A : HOD) : Set (Level.suc n) where
    field
       elm : HOD
       is-elm : A ∋ elm

open Element

_<A_ : {A : HOD} → (x y : Element A ) → Set n
x <A y = elm x < elm y
_≡A_ : {A : HOD} → (x y : Element A ) → Set (Level.suc n)
x ≡A y = elm x ≡ elm y

IsPartialOrderSet : ( A : HOD ) → Set (Level.suc n)
IsPartialOrderSet A = IsStrictPartialOrder (_≡A_ {A}) _<A_  

open _==_
open _⊆_

isA : { A B  : HOD } → B ⊆ A → (x : Element B) → Element A
isA B⊆A x = record { elm = elm x ; is-elm = incl B⊆A (is-elm x) }

⊆-IsPartialOrderSet : { A B  : HOD } → B ⊆ A → IsPartialOrderSet A → IsPartialOrderSet B 
⊆-IsPartialOrderSet {A} {B} B⊆A  PA = record {
       isEquivalence = record { refl = refl ; sym = sym ; trans = trans } ;  trans = λ {x} {y} {z} → trans1 {x} {y} {z} 
     ; irrefl = λ {x} {y} → irrefl1 {x} {y} ; <-resp-≈ = resp0 
   } where
   _<B_ : (x y : Element B ) → Set n
   x <B y = elm x < elm y
   trans1 : {x y z : Element B} → x <B y → y <B z → x <B z 
   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 
   irrefl1 : {x y : Element B} → elm x ≡ elm y → ¬ ( x <B y  )
   irrefl1 {x} {y} x=y x<y = IsStrictPartialOrder.irrefl PA {isA B⊆A x} {isA B⊆A y} x=y x<y 
   open import Data.Product
   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) 
   resp0 = Data.Product._,_  (λ {x} {y} {z} → proj₁ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z }) 
                             (λ {x} {y} {z} → proj₂ (IsStrictPartialOrder.<-resp-≈ PA) {isA B⊆A x } {isA B⊆A y }{isA B⊆A z })

-- open import Relation.Binary.Properties.Poset as Poset

IsTotalOrderSet : ( A : HOD ) →  Set (Level.suc n)
IsTotalOrderSet A = IsStrictTotalOrder  (_≡A_ {A}) _<A_ 

me : { A a : HOD } → A ∋ a → Element A
me {A} {a} lt = record { elm = a ; is-elm = lt }

A∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (A ∋ x) ≡ (A ∋ y )
A∋x-irr A {x} {y} refl = refl

me-elm-refl : (A : HOD) → (x : Element A) → elm (me {A} (d→∋ A (is-elm x))) ≡ elm x
me-elm-refl A record { elm = ex ; is-elm = ax } = *iso 

open import Relation.Binary.HeterogeneousEquality as HE using (_≅_ ) 

-- Don't use Element other than Order, you'll be in a trouble
-- postulate   -- may be proved by transfinite induction and functional extentionality
--   ∋x-irr : (A : HOD) {x y : HOD} → x ≡ y → (ax : A ∋ x) (ay : A ∋ y ) → ax ≅ ay 
--   odef-irr : (A : OD) {x y : Ordinal} → x ≡ y → (ax : def A x) (ay : def A y ) → ax ≅ ay 

-- is-elm-irr : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y 
-- is-elm-irr A {x} {y} eq = ∋x-irr A eq (is-elm x) (is-elm y )

El-irr2 : (A : HOD) → {x y : Element A } → elm x ≡ elm y → is-elm x ≅ is-elm y → x ≡ y
El-irr2  A {x} {y} refl HE.refl = refl

-- El-irr : {A : HOD} → {x y : Element A } → elm x ≡ elm y → x ≡ y
-- El-irr {A} {x} {y} eq = El-irr2 A eq ( is-elm-irr A eq ) 

record _Set≈_ (A B : Ordinal ) : Set n where
   field
       fun←  : {x : Ordinal } → odef (* A)  x → Ordinal
       fun→  : {x : Ordinal } → odef (* B)  x → Ordinal
       funB  : {x : Ordinal } → ( lt : odef (* A)  x ) → odef (* B) ( fun← lt )
       funA  : {x : Ordinal } → ( lt : odef (* B)  x ) → odef (* A) ( fun→ lt )
       fiso← : {x : Ordinal } → ( lt : odef (* B)  x ) → fun←  ( funA lt ) ≡ x
       fiso→ : {x : Ordinal } → ( lt : odef (* A)  x ) → fun→  ( funB lt ) ≡ x

open _Set≈_
record _OS≈_ {A B : HOD} (TA : IsTotalOrderSet A ) (TB : IsTotalOrderSet B ) : Set (Level.suc n) where
   field
      iso : (& A ) Set≈  (& B)
      fmap : {x y : Ordinal} → (ax : odef A x) → (ay : odef A y) → * x < * y
          → * (fun← iso (subst (λ k → odef k x) (sym *iso) ax)) < * (fun← iso (subst (λ k → odef k y) (sym *iso) ay))

Cut< : ( A x : HOD )  → HOD
Cut<  A x = record { od = record { def = λ y → ( odef A y ) ∧ ( x < * y ) } ; odmax = & A
    ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k ) (sym &iso) (proj1 lt))) }

Cut<T : {A : HOD}   → (TA : IsTotalOrderSet A ) ( x : HOD )→  IsTotalOrderSet ( Cut< A x )
Cut<T {A} TA x =  record { isEquivalence = record { refl = refl ; trans = trans ; sym = sym }
   ; trans = λ {x} {y} {z} → IsStrictTotalOrder.trans TA {me (proj1 (is-elm x))} {me (proj1 (is-elm y))} {me (proj1 (is-elm z))} ;
         compare = λ x y → IsStrictTotalOrder.compare TA (me (proj1 (is-elm x))) (me (proj1 (is-elm y)))  }

record _OS<_ {A B : HOD} (TA : IsTotalOrderSet A ) (TB : IsTotalOrderSet B ) : Set (Level.suc n) where
   field
      x : HOD
      iso : TA OS≈ (Cut<T TA x) 

-- OS<-cmp : {x : HOD} → Trichotomous {_} {IsTotalOrderSet x} _OS≈_ _OS<_ 
-- OS<-cmp A B = {!!}

-- tree structure
data IChain  (A : HOD) : Ordinal → Set n where
    ifirst : {ox : Ordinal} → odef A ox → IChain A ox
    inext  : {ox oy : Ordinal} → odef A oy → * ox < * oy → IChain A ox → IChain A oy

--   * ox < .. < * oy
ic-connect :  {A : HOD} {oy : Ordinal} → (ox : Ordinal) →  (iy : IChain A oy) → Set n 
ic-connect {A} ox (ifirst {oy} ay) = Lift n ⊥
ic-connect {A} ox (inext {oy} {oz} ay y<z iz) = (ox ≡ oy) ∨ ic-connect ox iz 

ic→odef : {A : HOD} {ox : Ordinal} → IChain A ox → odef A ox
ic→odef {A} {ox} (ifirst ax) = ax
ic→odef {A} {ox} (inext ax x<y ic) = ax

ic→< :  {A : HOD} → IsPartialOrderSet A → (x : Ordinal) → odef A x → {y : Ordinal} → (iy : IChain A y) → ic-connect {A} {y} x iy → * x < * y
ic→< {A} PO x ax {y} (ifirst ay) ()
ic→< {A} PO x ax {y} (inext ay x<y iy) (case1 refl) = x<y
ic→< {A} PO x ax {y} (inext {oy} ay x<y iy) (case2 ic) = IsStrictPartialOrder.trans PO 
     {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) }
    (ic→< {A} PO x ax iy ic ) x<y

record IChained (A : HOD) (x y : Ordinal) : Set n where
   field
      iy : IChain A y
      ic : ic-connect x iy 

--
-- all tree from x
--
IChainSet : (A : HOD) {x : Ordinal} → odef A  x → HOD
IChainSet A {x} ax = record { od = record { def = λ y → odef A y ∧ IChained A x y }
    ; odmax = & A ; <odmax = λ {y} lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k) (sym &iso) (proj1 lt))) } 

IChainSet⊆A :  {A : HOD} → {x : Ordinal } → (ax : odef A x ) → IChainSet A ax ⊆ A
IChainSet⊆A {A} x = record { incl = λ {oy} y → proj1 y }

¬IChained-refl : (A : HOD) {x : Ordinal} → IsPartialOrderSet A → ¬ IChained A x x
¬IChained-refl A {x} PO record { iy = iy ; ic = ic } = IsStrictPartialOrder.irrefl PO
        {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
     ic0 : odef A x
     ic0 = ic→odef {A} iy

-- there is a y, & y > & x

record OSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
   field
      y : Ordinal
      icy : odef (IChainSet A ax ) y 
      y>x : x o< y

record IChainSup> (A : HOD) {x : Ordinal} (ax : A ∋ * x) : Set n where
   field
      y : Ordinal
      A∋y : odef A y
      y>x  : * x < * y

-- finite IChain
--
--    tree structured

ic→A∋y : (A : HOD) {x y : Ordinal}  (ax : A ∋ * x) → odef (IChainSet A ax) y → A ∋ * y
ic→A∋y A {x} {y} ax ⟪ ay , _ ⟫ = subst (λ k → odef A k) (sym &iso) ay

record InfiniteChain (A : HOD) (max : Ordinal) {x : Ordinal}  (ax : A ∋ * x) : Set n where
   field
      chain<x : (y : Ordinal ) → odef (IChainSet A ax) y →  y o< max
      c-infinite : (y : Ordinal ) → (cy : odef (IChainSet A ax) y  )
          → IChainSup> A (ic→A∋y A ax cy)

open import Data.Nat hiding (_<_ ; _≤_ ) 
import Data.Nat.Properties as NP
open import nat

data Chain (A : HOD) (s : Ordinal) (next : Ordinal  → Ordinal ) : ( x : Ordinal  ) → Set n where
     cfirst : odef A s → Chain A s next s
     csuc : (x : Ordinal ) → (ax : odef A x ) → Chain A s next x → odef A (next x) → Chain A s next (next x )

ct∈A : (A : HOD ) (s : Ordinal)  → (next : Ordinal  → Ordinal ) → {x : Ordinal} → Chain A s next x → odef A x
ct∈A A s next {x} (cfirst x₁) = x₁ 
ct∈A A s next {.(next x )} (csuc x ax t anx) = anx

--
-- extract single chain from countable infinite chains
--
TransitiveClosure : (A : HOD) (s : Ordinal) →  (next : Ordinal → Ordinal ) → HOD
TransitiveClosure A s next = record { od = record { def = λ x → Chain A s next x } ; odmax = & A ; <odmax = cc01 } where
    cc01 : {y : Ordinal} → Chain A s next y → y o< & A
    cc01 {y} cy = subst (λ k → k o< & A ) &iso ( c<→o< (subst (λ k → odef A k ) (sym &iso) ( ct∈A A s next cy ) ) )

cton0 : (A : HOD ) (s : Ordinal) → (next : Ordinal  → Ordinal )  {y : Ordinal } → Chain A s next y → ℕ
cton0 A s next (cfirst _)  = zero
cton0 A s next (csuc x ax z _) = suc (cton0 A s next z) 
cton : (A : HOD ) (s : Ordinal)   → (next : Ordinal → Ordinal ) → Element (TransitiveClosure A s next) → ℕ
cton A s next y = cton0 A s next (is-elm y)

cinext :  (A : HOD) {x max : Ordinal } → (ax : A ∋ * x ) → (ifc : InfiniteChain A max ax ) → Ordinal  →  Ordinal
cinext A ax ifc y with ODC.∋-p O (IChainSet A ax) (* y)
... | yes ics-y = IChainSup>.y ( InfiniteChain.c-infinite ifc y (subst (λ k → odef (IChainSet A ax) k) &iso ics-y ))
... | no _ = o∅

InFCSet : (A : HOD) → {x max : Ordinal}  (ax : A ∋ * x)
     → (ifc : InfiniteChain A max ax ) → HOD
InFCSet A {x} ax ifc =  TransitiveClosure (IChainSet A ax) x (cinext A ax ifc ) 

InFCSet⊆A : (A : HOD) → {x max : Ordinal}  (ax : A ∋ * x) →  (ifc : InfiniteChain A max ax ) → InFCSet A ax ifc ⊆ A
InFCSet⊆A A {x} ax ifc = record { incl = λ {y} lt → incl (IChainSet⊆A ax) (
     ct∈A (IChainSet A ax) x (cinext A ax ifc) lt ) }

cinext→IChainSup :  (A : HOD) {x max : Ordinal } → (ax : A ∋ * x ) → (ifc : InfiniteChain A max ax ) → (y : Ordinal )
    → (ay1 : IChainSet A ax ∋ * y ) → IChainSup> A (subst (odef A) (sym &iso) (proj1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1)))
cinext→IChainSup A {x} ax ifc y ay with ODC.∋-p O (IChainSet A ax) (* y)
... | no not = ⊥-elim ( not ay )
... | yes ay1 = InfiniteChain.c-infinite ifc y (subst (λ k → odef (IChainSet A ax) k) &iso ay )

TransitiveClosure-is-total : (A : HOD) → {x max : Ordinal}  (ax : A ∋ * x)
     → IsPartialOrderSet A 
     → (ifc : InfiniteChain A max ax )
     → IsTotalOrderSet ( InFCSet A ax ifc )
TransitiveClosure-is-total A {x} ax PO ifc = record { isEquivalence = IsStrictPartialOrder.isEquivalence IPO
   ; trans = λ {x} {y} {z} → IsStrictPartialOrder.trans IPO {x} {y} {z}  ; compare = cmp } where
    IPO : IsPartialOrderSet (InFCSet A ax ifc )
    IPO = ⊆-IsPartialOrderSet record { incl = λ {y} lt → incl (InFCSet⊆A A {x} ax ifc) lt} PO
    B = IChainSet A ax
    cnext = cinext A ax ifc
    ct02 : {oy : Ordinal} → (y : Chain B x cnext oy ) → A ∋ * oy 
    ct02 y = incl (IChainSet⊆A {A} ax) (subst (λ k → odef (IChainSet A ax) k) (sym &iso) (ct∈A B x cnext y) ) 
    ct-inject : {ox oy : Ordinal} → (x1 : Chain B x cnext ox ) → (y : Chain B x cnext oy )
       → (cton0 B x cnext x1) ≡ (cton0 B x cnext y) → ox ≡ oy
    ct-inject {ox} {ox} (cfirst x) (cfirst x₁) refl = refl
    ct-inject {.(cnext x₀ )} {.(cnext x₃ )} (csuc x₀ ax x₁ x₂) (csuc x₃ ax₁ y x₄) eq = cong cnext ct05 where
        ct06 : {x y : ℕ} → suc x ≡ suc y → x ≡ y
        ct06 refl = refl 
        ct05 : x₀ ≡ x₃
        ct05 = ct-inject x₁ y (ct06 eq)
    ct-monotonic : {ox oy : Ordinal} → (x1 : Chain B x cnext ox ) → (y : Chain B x cnext oy )
       → (cton0 B x cnext x1) Data.Nat.< (cton0 B x cnext y) → * ox < * oy
    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 )
    ... | tri< a ¬b ¬c = ct07 where
        ct07 :  * ox < * (cnext oy1)
        ct07 with ODC.∋-p O (IChainSet A ax) (* oy1)
        ... | no not  = ⊥-elim ( not (subst (λ k → odef (IChainSet A ax) k ) (sym &iso) ay ) )
        ... | yes ay1 = IsStrictPartialOrder.trans PO {me (ct02 x1) } {me (ct02 y)} {me ct031 } (ct-monotonic x1 y a ) ct011 where
           ct031 :  A ∋ * (IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 ) )) 
           ct031 = subst (λ k → odef A k ) (sym &iso) (
              IChainSup>.A∋y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) )
           ct011 :  * oy1 < * ( IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) )
           ct011 = IChainSup>.y>x (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) 
    ... | tri≈ ¬a b ¬c = ct11 where
           ct11 : * ox < * (cnext oy1)
           ct11 with ODC.∋-p O (IChainSet A ax) (* oy1)
           ... | no not  = ⊥-elim ( not (subst (λ k → odef (IChainSet A ax) k ) (sym &iso) ay ) )
           ... | yes ay1 = subst (λ k → * k < _) (sym (ct-inject _ _ b)) ct011  where
              ct011 :  * oy1 < * ( IChainSup>.y (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) )
              ct011 = IChainSup>.y>x (InfiniteChain.c-infinite ifc oy1 (subst (λ k → odef (IChainSet A ax) k) &iso ay1 )) 
    ... | tri> ¬a ¬b c = ⊥-elim ( nat-≤> lt c ) 
    ct12 : {y z : Element (TransitiveClosure B x cnext) } → elm y ≡ elm z → elm y < elm z → ⊥ 
    ct12 {y} {z} y=z y<z = IsStrictPartialOrder.irrefl IPO {y} {z} y=z y<z
    ct13 : {y z : Element (TransitiveClosure B x cnext) } → elm y < elm z → elm z < elm y → ⊥ 
    ct13 {y} {z} y<z y>z = IsStrictPartialOrder.irrefl IPO {y} {y} refl ( IsStrictPartialOrder.trans IPO {y} {z} {y} y<z y>z )
    ct17 : (x1 : Element (TransitiveClosure B x cnext)) → Chain B x cnext (& (elm x1))
    ct17 x1 = is-elm x1
    cmp : Trichotomous _ _ 
    cmp x1 y with NP.<-cmp (cton B x cnext x1) (cton B x cnext y)
    ... | tri< a ¬b ¬c = tri< ct04 ct14 ct15 where
        ct04 : elm x1 < elm y
        ct04 = subst₂ (λ j k → j < k  ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a)
        ct14 : ¬ elm x1 ≡  elm y
        ct14 eq = ct12 {x1} {y} eq (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a )  )
        ct15 : ¬ (elm y <  elm x1)
        ct15 lt = ct13 {y} {x1} lt (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm x1) (is-elm y) a )  )
    ... | tri≈ ¬a b ¬c = tri≈ (ct12 {x1} {y} ct16)  ct16 (ct12 {y} {x1} (sym ct16)) where
        ct16 :  elm x1 ≡ elm y
        ct16 = subst₂ (λ j k → j ≡ k ) *iso *iso (cong (*) (ct-inject {& (elm x1)} {& (elm y)} (is-elm x1) (is-elm y) b ))
    ... | tri> ¬a ¬b c = tri> ct15 ct14 ct04 where
        ct04 : elm y < elm x1
        ct04 = subst₂ (λ j k → j < k  ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c)
        ct14 : ¬ elm x1 ≡  elm y
        ct14 eq = ct12 {y} {x1} (sym eq) (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c )  )
        ct15 : ¬ (elm x1 <  elm y)
        ct15 lt = ct13 {x1} {y} lt (subst₂ (λ j k → j < k ) *iso *iso (ct-monotonic (is-elm y) (is-elm x1) c )  )

record IsFC (A : HOD) {x : Ordinal}  (ax : A ∋ * x) (y : Ordinal) : Set n where
   field
      icy : odef (IChainSet A ax) y  
      c-finite : ¬ IChainSup> A (subst (λ k → odef A k ) (sym &iso) (proj1 icy) )
      
record Maximal ( A : HOD )  : Set (Level.suc n) where
   field
      maximal : HOD
      A∋maximal : A ∋ maximal
      ¬maximal<x : {x : HOD} → A ∋ x  → ¬ maximal < x       -- A is Partial, use negative

--
-- possible three cases in a limit ordinal step
-- 
-- case 1) < goes x o<
-- case 2) no > x in some chain ( maximal )
-- case 3) countably infinite chain below x 
--
Zorn-lemma-3case : { A : HOD } 
    → o∅ o< & A 
    → IsPartialOrderSet A 
    → (x : Ordinal ) → (ax : odef A x)  → OSup> A (d→∋ A ax) ∨ Maximal A ∨ InfiniteChain A x  (d→∋ A ax)
Zorn-lemma-3case {A}  0<A PO x ax = zc2 where
    Gtx : HOD
    Gtx = record { od = record { def = λ y → odef ( IChainSet A ax ) y ∧  ( x o< y ) } ; odmax = & A
        ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋  A (proj1 (proj1 lt))))  }
    HG : HOD
    HG = record { od = record { def = λ y → odef A y ∧ IsFC A (d→∋ A ax ) y } ; odmax = & A
        ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋  A  (proj1 lt) ))  }
    zc2 :  OSup> A (d→∋ A ax)  ∨ Maximal A ∨ InfiniteChain A x  (d→∋ A ax )
    zc2 with  is-o∅ (& Gtx)
    ... | no not = case1 record { y = & y ; icy = zc4 ; y>x = proj2 zc3 } where
        y : HOD
        y =  ODC.minimal O Gtx  (λ eq → not (=od∅→≡o∅ eq))
        zc3 :  odef ( IChainSet A ax ) (& y) ∧  ( x o< (& y ))
        zc3  = ODC.x∋minimal O Gtx  (λ eq → not (=od∅→≡o∅ eq))
        zc4 : odef (IChainSet A (subst (OD.def (od A)) (sym &iso) ax)) (& y)
        zc4 = ⟪ proj1 (proj1 zc3) , (subst (λ k → IChained A k (& y)) (sym &iso) (proj2 (proj1 zc3))) ⟫ 
    ... | yes nogt with is-o∅ (& HG)
    ... | no  finite-chain = case2 (case1 record { maximal = y ; A∋maximal = proj1 zc3 ; ¬maximal<x = zc4 } ) where
        y : HOD
        y =  ODC.minimal O HG (λ eq → finite-chain (=od∅→≡o∅ eq))
        zc3 :  odef A (& y) ∧ IsFC A (d→∋ A ax ) (& y)
        zc3  = ODC.x∋minimal O HG  (λ eq → finite-chain (=od∅→≡o∅ eq))
        zc4 : {z : HOD} → A ∋ z → ¬ (y < z)
        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 } 
    ... | yes inifite = case2 (case2 record {    c-infinite = zc91 ; chain<x = zc10 } ) where
        B : HOD
        B = IChainSet A ax -- (me (subst (OD.def (od A)) (sym &iso) (is-elm x)))
        B1 : HOD
        B1 = IChainSet A (subst (OD.def (od A)) (sym &iso) ax)
        Nx : (y : Ordinal) → odef A y → HOD
        Nx y ay = record { od = record { def = λ x → odef A x ∧ ( * y < * x ) } ; odmax = & A
              ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋  A (proj1 lt)))  }
        zc10 : (y : Ordinal) → odef (IChainSet A (subst (OD.def (od A)) (sym &iso) ax)) y → y o< x
        zc10 oy icsy = zc21 where
             zc20 : (y : HOD) → (IChainSet A ax) ∋ y  → x o< & y → ⊥
             zc20 y icsy lt = ¬A∋x→A≡od∅ Gtx ⟪ icsy , lt ⟫ nogt
             zc22 : IChainSet A ax ∋ * oy
             zc22 = ⟪ subst (λ k → odef A k) (sym &iso) (proj1 icsy) , subst₂ (λ j k → IChained A j k ) &iso (sym &iso) (proj2 icsy) ⟫
             zc21 : oy o< x
             zc21 with trio< oy  x
             ... | tri< a ¬b ¬c = a
             ... | tri≈ ¬a b ¬c = ⊥-elim (¬IChained-refl A PO (subst₂ (λ j k → IChained A j k ) &iso b (proj2 icsy)) ) 
             ... | tri> ¬a ¬b c = ⊥-elim ( zc20 (* oy) zc22 (subst (λ k → x o< k) (sym &iso) c ))
        zc91 : (y : Ordinal) (cy : odef B1 y) → IChainSup> A (ic→A∋y A (subst (OD.def (od A)) (sym &iso) ax) cy)
        zc91 y cy with is-o∅ (& (Nx y (proj1 cy) ))
        ... | yes no-next = ⊥-elim zc16 where
             zc18 :   ¬ IChainSup> A (subst (odef A) (sym &iso) (proj1 (subst (λ k → odef (IChainSet A (d→∋ A ax)) k) (sym &iso) cy)))
             zc18 ics = ¬A∋x→A≡od∅ (Nx y (proj1 cy) ) ⟪ subst (λ k → odef A k ) (sym &iso) (IChainSup>.A∋y ics)
                  ,  subst₂ (λ j k → j < k ) *iso (cong (*) (sym &iso))( IChainSup>.y>x ics) ⟫ no-next  
             zc17 : IsFC A {x} (d→∋ A ax) (& (* y))
             zc17 = record { icy = subst (λ k → odef (IChainSet A (d→∋ A ax)) k) (sym &iso) cy ; c-finite = zc18 }
             zc16 : ⊥
             zc16 = ¬A∋x→A≡od∅ HG ⟪ subst (λ k → odef A k ) (sym &iso) (proj1 cy ) , zc17 ⟫ inifite 
        ... | no not = record { y = & zc13 ; A∋y = proj1 zc12  ; y>x = proj2 zc12 }  where
             zc13 = ODC.minimal O (Nx y (proj1 cy)) (λ eq → not (=od∅→≡o∅ eq ))
             zc12 : odef A (& zc13 ) ∧ ( * y < * ( & zc13 ))
             zc12 = ODC.x∋minimal O (Nx y (proj1 cy)) (λ eq → not (=od∅→≡o∅ eq ))

all-climb-case : { A : HOD } → (0<A : o∅ o< & A) → IsPartialOrderSet A
     → (( x : Ordinal ) → (ax : odef A (& (* x))) → OSup> A ax )
     → (x : HOD) ( ax : A ∋ x )
     → InfiniteChain A (& A) (d→∋ A ax)
all-climb-case {A} 0<A PO climb x ax = record {    c-infinite = ac00 ; chain<x = ac01 }  where
        B = IChainSet A ax
        ac01 : (y : Ordinal) → odef (IChainSet A (d→∋ A ax)) y → y o< & A 
        ac01 y ⟪ ay , _ ⟫ = subst (λ k → k o< & A ) &iso (c<→o< (subst (λ k → odef A k ) (sym &iso) ay) )
        ac00 : (y : Ordinal) (cy : odef (IChainSet A (d→∋ A ax)) y) → IChainSup> A (ic→A∋y A (d→∋ A ax) cy)
        ac00 y cy = record { y = z ; A∋y = az ; y>x = y<z} where
             ay : odef A (& (* y))
             ay = subst (λ k → odef A k) (sym &iso) (proj1 cy)
             z : Ordinal
             z = OSup>.y ( climb y  ay)
             az : odef A z
             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))))
             icy :  odef (IChainSet A ay ) z
             icy  = OSup>.icy ( climb y ay )
             y<z  : * y < * z
             y<z  = ic→< {A} PO y (subst (λ k → odef A k) &iso ay) (IChained.iy (proj2 icy))
               (subst (λ k → ic-connect k (IChained.iy (proj2 icy))) &iso (IChained.ic (proj2 icy)))

-- <-TransFinite : ( A : HOD ) → IsTotalOrderSet A 
--          → ( (x : Ordinal) → ((y : Ordinal) → y o< x → ZChain A y) → ZChain A x ) → (x : Ordinal ) → ZChain A x
-- <-TransFinite A TA ind x = TransFinite {ZChain A} ind x 

--
-- inductive maxmum tree from x
-- tree structure
--

≤-monotonic-f : (A : HOD) → ( Ordinal → Ordinal ) → Set (Level.suc n)
≤-monotonic-f A f = (x : Ordinal ) → odef A x → ( * x ≤ * (f x) ) ∧  odef A (f x )

record Indirect< (A : HOD) {x y : Ordinal } (xa : odef A x) (ya : odef A y) (z : Ordinal)  : Set n where
   field
      az : odef A z
      x<z : * x < * z 
      z<y : * z < * y 

record Prev< (A : HOD) {x : Ordinal } (xa : odef A x)  ( f : Ordinal → Ordinal )  : Set n where
   field
      y : Ordinal
      ay : odef A y
      x=fy :  x ≡ f y 

record SUP ( A B : HOD )  : Set (Level.suc n) where
   field
      sup : HOD
      A∋maximal : A ∋ sup
      x<sup : {x : HOD} → B ∋ x → (x ≡ sup ) ∨ (x < sup )   -- B is Total, use positive

SupCond : ( A B : HOD) → (B⊆A : B ⊆ A) → IsTotalOrderSet B → Set (Level.suc n)
SupCond A B _ _ = SUP A B  

record ZChain ( A : HOD ) {x : Ordinal} (ax : A ∋ * x) ( f : Ordinal → Ordinal ) (mf : ≤-monotonic-f A f )
         (sup : (C : Ordinal ) → (* C ⊆ A) → IsTotalOrderSet (* C) → Ordinal) (z : Ordinal)  : Set (Level.suc n) where
   field
      chain : HOD
      chain⊆A : chain ⊆ A
      f-total : IsTotalOrderSet chain 
      f-next : {a : Ordinal } → odef chain a → odef chain (f a)
      is-max :  {a b : Ordinal } → (ca : odef chain a ) → odef A b → a o< z
          → ( Prev< A (incl chain⊆A (subst (λ k → odef chain k ) (sym &iso) ca)) f
               ∨ (sup (& chain) (subst (λ k → k  ⊆ A) (sym *iso) chain⊆A)  (subst (λ k → IsTotalOrderSet k) (sym *iso) f-total) ≡ b ))
          → * a < * b  → odef chain b

Zorn-lemma : { A : HOD } 
    → o∅ o< & A 
    → IsPartialOrderSet A 
    → ( ( B : HOD) → (B⊆A : B ⊆ A) → IsTotalOrderSet B → SUP A B   ) -- SUP condition
    → Maximal A 
Zorn-lemma {A}  0<A PO supP = zorn00 where
     supO : (C : Ordinal ) → (* C) ⊆ A → IsTotalOrderSet (* C) → Ordinal
     supO C C⊆A TC = & ( SUP.sup ( supP (* C)  C⊆A TC ))
     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 = IsStrictPartialOrder.irrefl PO {me A∋b} {me A∋a} (sym a=b) b<a
     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)
     s : HOD
     s = ODC.minimal O A (λ eq → ¬x<0 ( subst (λ k → o∅ o< k ) (=od∅→≡o∅ eq) 0<A )) 
     sa : A ∋ * ( & s  )
     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 ))  )
     HasMaximal : HOD
     HasMaximal = record { od = record { def = λ x → odef A x ∧ ( (m : Ordinal) →  odef A m → ¬ (* x < * m)) }  ; odmax = & A ; <odmax = z07 } where
         z07 :   {y : Ordinal} → odef A y ∧ ((m : Ordinal) → 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 )))
     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} {!!} ) 
     Gtx : { x : HOD} → A ∋ x → HOD
     Gtx {x} ax = record { od = record { def = λ y → odef A y ∧ (x < (* y)) } ; odmax = & A ; <odmax = {!!} } 
     cf : ¬ Maximal A → Ordinal → Ordinal
     cf  nmx x with ODC.∋-p O A (* x)
     ... | no _ = o∅
     ... | yes ax with is-o∅ (& ( Gtx ax ))
     ... | yes nogt = ⊥-elim (no-maximum (≡o∅→=od∅ {!!} ) 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
              ¬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 =  & (ODC.minimal O (Gtx ax) (λ eq → not (=od∅→≡o∅ eq)))
     cf-is-<-monotonic : (nmx : ¬ Maximal A ) → (x : Ordinal) →  odef A x → ( * x < * (cf nmx x) ) ∧  odef A (cf nmx x )
     cf-is-<-monotonic nmx x ax = ⟪ {!!} , {!!} ⟫
     cf-is-≤-monotonic : (nmx : ¬ Maximal A ) →  ≤-monotonic-f A ( cf nmx )
     cf-is-≤-monotonic nmx x ax = ⟪ case2 (proj1 ( cf-is-<-monotonic nmx x ax  ))  , proj2 ( cf-is-<-monotonic nmx x ax  ) ⟫
     zsup :  ( f : Ordinal → Ordinal ) → (mf : ≤-monotonic-f A f) →  (zc : ZChain A sa f mf supO (& A)) → SUP A  (ZChain.chain zc) 
     zsup f mf zc = supP (ZChain.chain zc) (ZChain.chain⊆A zc) ( ZChain.f-total zc  )   
     -- zsup zc f mf = & ( SUP.sup (supP (ZChain.chain zc) (ZChain.chain⊆A zc) ( ZChain.f-total zc f mf )  ) )
     A∋zsup :  (nmx : ¬ Maximal A ) (zc : ZChain A sa (cf nmx) (cf-is-≤-monotonic nmx) supO (& A)) 
        →  A ∋ * ( & ( SUP.sup (zsup (cf nmx) (cf-is-≤-monotonic nmx) zc ) ))
     A∋zsup nmx zc = subst (λ k → odef A (& k )) (sym *iso) ( SUP.A∋maximal  (zsup (cf nmx) (cf-is-≤-monotonic nmx) zc ) )
     z03 :  ( f : Ordinal → Ordinal ) → (mf : ≤-monotonic-f A f ) (zc : ZChain A sa f mf supO (& A)) → f (& ( SUP.sup (zsup f mf zc ))) ≡ & (SUP.sup (zsup f mf zc ))
     z03 = {!!}
     z04 :  (nmx : ¬ Maximal A ) → (zc : ZChain A sa (cf nmx) (cf-is-≤-monotonic nmx) supO (& A)) → ⊥
     z04 nmx zc = z01  {* (cf nmx c)} {* c} {!!} (A∋zsup nmx zc ) (case1 ( cong (*)( z03 (cf nmx) (cf-is-≤-monotonic nmx ) zc )))
           (proj1 (cf-is-<-monotonic nmx c ((subst λ k → odef A k ) &iso (A∋zsup nmx zc )))) where
          c = & (SUP.sup (zsup (cf nmx) (cf-is-≤-monotonic nmx) zc ))
     -- ZChain is not compatible with the SUP condition
     ind : ( f : Ordinal → Ordinal ) → (mf : ≤-monotonic-f A f ) → (x : Ordinal) → ((y : Ordinal) → y o< x →  ZChain A sa f mf supO y )
         →  ZChain A sa f mf supO x 
     ind f mf x prev with Oprev-p x
     ... | yes op with ODC.∋-p O A (* x)
     ... | no ¬Ax = zc1 where
          -- we have previous ordinal and ¬ A ∋ x, use previous Zchain
          px = Oprev.oprev op
          zc0 : ZChain A sa f mf supO (Oprev.oprev op) 
          zc0 = prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) 
          zc1 : ZChain A sa f mf supO x 
          zc1 = record { chain = ZChain.chain zc0 ; chain⊆A = ZChain.chain⊆A zc0 ; f-total = ZChain.f-total zc0 ; f-next = ZChain.f-next zc0 ; is-max = {!!} }
     ... | yes ax = zc4 where -- we have previous ordinal and A ∋ x
          px = Oprev.oprev op
          zc0 : ZChain A sa f mf supO (Oprev.oprev op) 
          zc0 = prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) 
          --   x is in the previous chain, use the same
          --   x has some y which y < x ∧ f y ≡ x
          --   x has no y which y < x 
          zc4 : ZChain A sa f mf supO x
          zc4 = record { chain = {!!} ; chain⊆A = {!!} ; f-total = {!!} ; f-next = {!!} ; is-max = {!!} }
     ind f mf x prev | no ¬ox with trio< (& A) x   --- limit ordinal case
     ... | tri< a ¬b ¬c = record { chain = ZChain.chain zc0 ; chain⊆A = ZChain.chain⊆A zc0 ; f-total = ZChain.f-total zc0 ; f-next =  ZChain.f-next zc0
              ; is-max = {!!} } where
          zc0 = prev (& A) a
     ... | tri≈ ¬a b ¬c = {!!}
     ... | tri> ¬a ¬b c = {!!}
     zorn00 : Maximal A 
     zorn00 with is-o∅ ( & HasMaximal )  -- we have no Level (suc n) LEM 
     ... | no not = record { maximal = ODC.minimal O HasMaximal  (λ eq → not (=od∅→≡o∅ eq)) ; A∋maximal = zorn01 ; ¬maximal<x  = zorn02 } where
         -- yes we have the maximal
         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  
         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 )
     ... | yes ¬Maximal = ⊥-elim ( z04 nmx  (zorn03 (cf nmx) (cf-is-≤-monotonic nmx))) where
         -- if we have no maximal, make ZChain, which contradict SUP condition
         nmx : ¬ Maximal A 
         nmx mx =  ∅< {HasMaximal} zc5 ( ≡o∅→=od∅  ¬Maximal ) where
              zc5 : odef A (& (Maximal.maximal mx)) ∧ (( y : Ordinal ) →  odef A y → ¬ (* (& (Maximal.maximal mx)) < * y)) 
              zc5 = ⟪  Maximal.A∋maximal mx , (λ y ay mx<y → Maximal.¬maximal<x mx (subst (λ k → odef A k ) (sym &iso) ay) (subst (λ k → k < * y) *iso mx<y) ) ⟫
         zorn03 : ( f : Ordinal → Ordinal ) → (mf : ≤-monotonic-f A f ) → ZChain A sa f mf supO (& A)
         zorn03 f mf = TransFinite (ind f mf)  (& A) 

-- usage (see filter.agda )
--
-- _⊆'_ : ( 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
--        → IsPartialOrderSet P _⊆'_
--        → ( (B : HOD) → B ⊆ P → IsTotalOrderSet B _⊆'_ → SUP P B _⊆'_ )
--        → Maximal P (_⊆'_)
-- MaximumSubset {L} {P} 0<L 0<P P⊆L PO SP  = Zorn-lemma {P} {_⊆'_} 0<P PO SP