open import Level
open import Ordinals
module filter {n : Level } (O : Ordinals {n})   where

open import zf
open import logic
import OD 

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
open import Data.Nat renaming ( zero to Zero ; suc to Suc ;  ℕ to Nat ; _⊔_ to _n⊔_ ) 

open inOrdinal O
open OD O
open OD.OD

open _∧_
open _∨_
open Bool

record Filter  ( L : OD  ) : Set (suc n) where
   field
       F1 : { p q : Ordinal } → def L p →  p o< osuc q  → def L q
       F2 : { p q : Ordinal } → def L p →  def L q  → def L (minα p q)

open Filter

proper-filter : {L : OD} → Filter L → Set n
proper-filter {L} P = ¬ ( def L o∅ )

prime-filter : {L : OD} → Filter L → {p q : Ordinal } → Set n
prime-filter {L} P {p} {q} =  def L ( maxα p q) → ( def L p ) ∨ ( def L q )

ultra-filter :  {L : OD} → Filter L → {p : Ordinal } → Set n 
ultra-filter {L} P {p} = ( def L p ) ∨ ( ¬ ( def L p ))

postulate
   dist-ord : {p q r : Ordinal } → minα p ( maxα q r ) ≡ maxα  ( minα p q ) ( minα p r )

filter-lemma1 :  {L : OD} → (P : Filter L)  → {p q : Ordinal } → ( (p : Ordinal ) → ultra-filter {L} P {p} ) → prime-filter {L} P {p} {q}
filter-lemma1 {L} P {p} {q} u lt with u p | u q
filter-lemma1 {L} P {p} {q} u lt | case1 x | case1 y = case1 x
filter-lemma1 {L} P {p} {q} u lt | case1 x | case2 y = case1 x
filter-lemma1 {L} P {p} {q} u lt | case2 x | case1 y = case2 y
filter-lemma1 {L} P {p} {q} u lt | case2 x | case2 y with trio< p q
filter-lemma1 {L} P {p} {q} u lt | case2 x | case2 y | tri< a ¬b ¬c =  ⊥-elim ( y lt )
filter-lemma1 {L} P {p} {q} u lt | case2 x | case2 y | tri≈ ¬a refl ¬c = ⊥-elim ( y lt )
filter-lemma1 {L} P {p} {q} u lt | case2 x | case2 y | tri> ¬a ¬b c = ⊥-elim ( x lt )

generated-filter : {L : OD} → Filter L → (p : Ordinal ) → Filter ( record { def = λ x → def L x ∨ (x ≡ p) } )
generated-filter {L} P p = record {
     F1 = {!!} ; F2 = {!!}
   }

-- H(ω,2) = Power ( Power ω ) = Def ( Def ω))

infinite = ZF.infinite OD→ZF

Hω2 : Filter (Power (Power infinite))
Hω2 = {!!}