{-# 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

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 (_≅_ ) 

postulate
   ∋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 ZChain ( A : HOD ) (y : Ordinal)   : Set (Level.suc n) where
   field
      max : HOD
      A∋max : A ∋ max
      y<max : y o< & max
      chain : HOD
      chain⊆A : chain ⊆ A  
      total : IsTotalOrderSet chain 
      chain-max : (x : HOD) → chain ∋ x → (x ≡ max ) ∨ ( x < max )

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 

IChainSet : {A : HOD} → Element A → HOD
IChainSet {A} ax = record { od = record { def = λ y → odef A y ∧ IChained A (& (elm ax)) y }
    ; odmax = & A ; <odmax = λ {y} lt → subst (λ k → k o< & A) &iso (c<→o< (subst (λ k → odef A k) (sym &iso) (proj1 lt))) } 

-- 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} (me 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

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

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

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

ChainClosure : (A : HOD) →  (next : (x : Ordinal ) → odef A x → Ordinal ) → HOD
ChainClosure A  next = record { od = record { def = λ x → Chain A next x } ; odmax = {!!} ; <odmax = {!!} }

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

InFCSet : (A : HOD) → {x : Ordinal}  (ax : A ∋ * x)
     → (ifc : InFiniteIChain A ax ) → HOD
InFCSet A ax ifc =  ChainClosure (IChainSet {A} (me ax)) (λ y ay → IChainSup>.y ( InFiniteIChain.c-infinite ifc y ay ) ) 

ChainClosure-is-total : (A : HOD) → {x : Ordinal}  (ax : A ∋ * x)
     → IsPartialOrderSet A 
     → (ifc : InFiniteIChain A ax )
     → IsTotalOrderSet ( InFCSet A ax ifc )
ChainClosure-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 = λ {x} lt → {!!} } PO
    cnext :  (y : Ordinal ) → odef (IChainSet {A} (me ax)) y → Ordinal
    cnext y ay = IChainSup>.y ( InFiniteIChain.c-infinite ifc y ay  )
    cmp : Trichotomous _ _ 
    cmp x y with NP.<-cmp (cton (IChainSet {A} (me ax)) cnext x) (cton (IChainSet {A} (me ax)) cnext y)
    ... | tri< a ¬b ¬c = {!!}
    ... | tri≈ ¬a b ¬c = {!!}
    ... | tri> ¬a ¬b c = {!!}

      
record IsFC (A : HOD) {x : Ordinal}  (ax : A ∋ * x) (y : Ordinal) : Set n where
   field
      icy : odef (IChainSet {A} (me ax)) y  
      c-finite : ¬ IChainSup> A ax
      
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                       (will contradic in the transfinite induction )
-- case 2) no > x in some chain ( maximal )
-- case 3) countably infinite chain below x (will be prohibited by sup condtion )
--
Zorn-lemma-3case : { A : HOD } 
    → o∅ o< & A 
    → IsPartialOrderSet A 
    → (x : Element A) → OSup> A (d→∋ A (is-elm x)) ∨ Maximal A ∨ InFiniteIChain A (d→∋ A (is-elm x))
Zorn-lemma-3case {A}  0<A PO x = zc2 where
    Gtx : HOD
    Gtx = record { od = record { def = λ y → odef ( IChainSet x ) y ∧  ( & (elm 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 (is-elm x) ) y } ; odmax = & A
        ; <odmax = λ lt → subst (λ k → k o< & A) &iso (c<→o< (d→∋  A  (proj1 lt) ))  }
    zc2 :  OSup> A (d→∋ A (is-elm x))  ∨ Maximal A ∨ InFiniteIChain A  (d→∋ A (is-elm x))
    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 x ) (& y) ∧  ( & (elm x) o< (& y ))
        zc3  = ODC.x∋minimal O Gtx  (λ eq → not (=od∅→≡o∅ eq))
        zc4 : odef (IChainSet (me (subst (OD.def (od A)) (sym &iso) (is-elm x)))) (& 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 (is-elm x) ) (& y)
        zc3  = ODC.x∋minimal O HG  (λ eq → finite-chain (=od∅→≡o∅ eq))
        zc5 : odef (IChainSet {A} (me (d→∋ A (is-elm x) ))) (& y)
        zc5 = IsFC.icy (proj2 zc3)
        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) zc6 } where
            zc8 : ic-connect (& (* (& (elm x)))) (IChained.iy (proj2 zc5)) 
            zc8 = IChained.ic (proj2 zc5)
            zc7 : elm x < y
            zc7 = subst₂ (λ j k → j < k ) *iso *iso ( ic→< {A} PO (& (elm x)) (is-elm x) (IChained.iy (proj2 zc5))
                (subst (λ k → ic-connect (& k) (IChained.iy (proj2 zc5)) ) (me-elm-refl A x) (IChained.ic (proj2 zc5)) )  )
            zc6 : elm x < z
            zc6 = IsStrictPartialOrder.trans PO {x} {me (proj1 zc3)} {me az} zc7 y<z
    ... | yes inifite = case2 (case2 record {  chain<x = {!!} ;  c-infinite = {!!}  } )


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

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 = zorn04 where
     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)
     z02 : {x : Ordinal } → (ax : A ∋ * x ) → InFiniteIChain A  ax  → ⊥
     z02 {x} ax ic = zc5 ic where
              FC : HOD
              FC = IChainSet {A} (me ax)
              zc6 :  InFiniteIChain A ax  → ¬ SUP A FC 
              zc6 inf = {!!}
              FC-is-total : IsTotalOrderSet FC
              FC-is-total = {!!}
              FC⊆A :  FC ⊆ A
              FC⊆A = record { incl = λ {x} lt → proj1 lt }
              zc5 : InFiniteIChain A ax → ⊥
              zc5 x = zc6 x ( supP FC FC⊆A FC-is-total )
     -- ZChain is not compatible with the SUP condition
     ind : (x : Ordinal) → ((y : Ordinal) → y o< x →  ZChain A y ∨ Maximal A )
         →  ZChain A x ∨ Maximal A 
     --     has previous ordinal
     --        has maximal          use this
     --        else has chain
     --        & A < y              A is a counter example of assumption
     --          chack y is maximal 
     --          y < max              use previous chain
     --          y = max  (  y > max  cannot happen )
     --              ¬ A ∋ y           use previous chain
     --              A ∋ y is use oridinaly min of y or previous
     --     y is limit ordinal    
     --        has maximal in some lower   use this
     --        no maximal in all lower
     --          & A < y              A is a counter example of assumption
     --          A ∋ y is maximal      use this            
     --          ¬ A ∋ y           use previous chain
     --          check some y ≤ max 
     --              if none A < y is the counter example
     --              else use the ordinaly smallest max as next chain
     ind 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
          zc1 : ZChain A x ∨ Maximal A
          zc1 with prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) 
          ... | case2 x = case2 x  -- we have the Maximal
          ... | case1 z with trio< x (& (ZChain.max z))
          ... | tri< a ¬b ¬c = case1 record { max = ZChain.max z ; y<max = a }
          ... | tri≈ ¬a b ¬c = {!!} -- x = max so ¬ A ∋ max 
          ... | tri> ¬a ¬b c = {!!} -- can't happen
     ... | yes ax = zc4 where -- we have previous ordinal and A ∋ x
          px = Oprev.oprev op
          zc1 : OSup> A (subst (OD.def (od A)) (sym &iso) ax) → ZChain A x ∨ Maximal A
          zc1 os with  prev px (subst (λ k → px o< k) (Oprev.oprev=x op) <-osuc) 
          ... | case2 x = case2 x
          ... | case1 x = {!!}
          zc4 : ZChain A x ∨ Maximal A
          zc4 with Zorn-lemma-3case 0<A PO (me ax)
          ... | case1 y>x = zc1 y>x
          ... | case2 (case1 x) = case2 x
          ... | case2 (case2 x) = ⊥-elim (zc5 x) where
              FC : HOD
              FC = IChainSet {A} (me ax)
              zc6 :  InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax)  → ¬ SUP A FC 
              zc6 = {!!}
              FC-is-total : IsTotalOrderSet FC
              FC-is-total = {!!}
              FC⊆A :  FC ⊆ A
              FC⊆A = {!!}
              zc5 : InFiniteIChain A (subst (OD.def (od A)) (sym &iso) ax) → ⊥
              zc5 x = zc6 x ( supP FC FC⊆A FC-is-total )
     ind x prev | no ¬ox with trio< (& A) x   --- limit ordinal case
     ... | tri< a ¬b ¬c = {!!} where
          zc1 : ZChain A (& A) 
          zc1 with prev (& A) a 
          ... | t = {!!}
     ... | tri≈ ¬a b ¬c = {!!} where
     ... | tri> ¬a ¬b c with ODC.∋-p O A (* x)
     ... | no ¬Ax = {!!} where
     ... | yes ax = {!!}
     ... | no not = {!!} where
     zorn03 : (x : Ordinal) → ZChain A x  ∨ Maximal A 
     zorn03 x = TransFinite ind  x
     zorn04 : Maximal A 
     zorn04 with zorn03 (& A)
     ... | case1 chain = ⊥-elim ( o<> (c<→o< {ZChain.max chain} {A} (ZChain.A∋max chain))  (ZChain.y<max chain) )
     ... | case2 m = m

-- _⊆'_ : ( 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