File: Mathlib/Order/Concept.lean

full_name: intentClosure
code: /-- The intent closure of `s : Set α` along a relation `r : α → β → Prop` is the set of all elements
which `r` relates to all elements of `s`. -/
def intentClosure (s : Set α) : Set β 
goal: Set β

full_name: extentClosure
code: /-- The extent closure of `t : Set β` along a relation `r : α → β → Prop` is the set of all elements
which `r` relates to all elements of `t`. -/
def extentClosure (t : Set β) : Set α 
goal: Set α

full_name: subset_intentClosure_iff_subset_extentClosure
code: theorem subset_intentClosure_iff_subset_extentClosure :
    t ⊆ intentClosure r s ↔ s ⊆ extentClosure r t 
goal: t ⊆ intentClosure r s ↔ s ⊆ extentClosure r t

full_name: gc_intentClosure_extentClosure
code: theorem gc_intentClosure_extentClosure :
    GaloisConnection (toDual ∘ intentClosure r) (extentClosure r ∘ ofDual) 
goal: GaloisConnection (⇑OrderDual.toDual ∘ intentClosure r) (extentClosure r ∘ ⇑OrderDual.ofDual)

full_name: intentClosure_swap
code: theorem intentClosure_swap (t : Set β) : intentClosure (swap r) t = extentClosure r t 
goal: intentClosure (Function.swap r) t = extentClosure r t

full_name: extentClosure_swap
code: theorem extentClosure_swap (s : Set α) : extentClosure (swap r) s = intentClosure r s 
goal: extentClosure (Function.swap r) s = intentClosure r s

full_name: intentClosure_empty
code: @[simp]
theorem intentClosure_empty : intentClosure r ∅ = univ 
goal: intentClosure r ∅ = Set.univ

full_name: extentClosure_empty
code: @[simp]
theorem extentClosure_empty : extentClosure r ∅ = univ 
goal: extentClosure r ∅ = Set.univ

full_name: intentClosure_union
code: @[simp]
theorem intentClosure_union (s₁ s₂ : Set α) :
    intentClosure r (s₁ ∪ s₂) = intentClosure r s₁ ∩ intentClosure r s₂ 
goal: intentClosure r (s₁ ∪ s₂) = intentClosure r s₁ ∩ intentClosure r s₂

full_name: extentClosure_union
code: @[simp]
theorem extentClosure_union (t₁ t₂ : Set β) :
    extentClosure r (t₁ ∪ t₂) = extentClosure r t₁ ∩ extentClosure r t₂ 
goal: extentClosure r (t₁ ∪ t₂) = extentClosure r t₁ ∩ extentClosure r t₂

full_name: intentClosure_iUnion
code: @[simp]
theorem intentClosure_iUnion (f : ι → Set α) :
    intentClosure r (⋃ i, f i) = ⋂ i, intentClosure r (f i) 
goal: intentClosure r (⋃ i, f i) = ⋂ i, intentClosure r (f i)

full_name: extentClosure_iUnion
code: @[simp]
theorem extentClosure_iUnion (f : ι → Set β) :
    extentClosure r (⋃ i, f i) = ⋂ i, extentClosure r (f i) 
goal: extentClosure r (⋃ i, f i) = ⋂ i, extentClosure r (f i)

full_name: intentClosure_iUnion₂
code: theorem intentClosure_iUnion₂ (f : ∀ i, κ i → Set α) :
    intentClosure r (⋃ (i) (j), f i j) = ⋂ (i) (j), intentClosure r (f i j) 
goal: intentClosure r (⋃ i, ⋃ j, f i j) = ⋂ i, ⋂ j, intentClosure r (f i j)

full_name: extentClosure_iUnion₂
code: theorem extentClosure_iUnion₂ (f : ∀ i, κ i → Set β) :
    extentClosure r (⋃ (i) (j), f i j) = ⋂ (i) (j), extentClosure r (f i j) 
goal: extentClosure r (⋃ i, ⋃ j, f i j) = ⋂ i, ⋂ j, extentClosure r (f i j)

full_name: subset_extentClosure_intentClosure
code: theorem subset_extentClosure_intentClosure (s : Set α) :
    s ⊆ extentClosure r (intentClosure r s) 
goal: s ⊆ extentClosure r (intentClosure r s)

full_name: subset_intentClosure_extentClosure
code: theorem subset_intentClosure_extentClosure (t : Set β) :
    t ⊆ intentClosure r (extentClosure r t) 
goal: t ⊆ intentClosure r (extentClosure r t)

full_name: intentClosure_extentClosure_intentClosure
code: @[simp]
theorem intentClosure_extentClosure_intentClosure (s : Set α) :
    intentClosure r (extentClosure r <| intentClosure r s) = intentClosure r s 
goal: intentClosure r (extentClosure r (intentClosure r s)) = intentClosure r s

full_name: extentClosure_intentClosure_extentClosure
code: @[simp]
theorem extentClosure_intentClosure_extentClosure (t : Set β) :
    extentClosure r (intentClosure r <| extentClosure r t) = extentClosure r t 
goal: extentClosure r (intentClosure r (extentClosure r t)) = extentClosure r t

full_name: intentClosure_anti
code: theorem intentClosure_anti : Antitone (intentClosure r) 
goal: Antitone (intentClosure r)

full_name: extentClosure_anti
code: theorem extentClosure_anti : Antitone (extentClosure r) 
goal: Antitone (extentClosure r)

full_name: Concept
code: /-- The formal concepts of a relation. A concept of `r : α → β → Prop` is a pair of sets `s`, `t`
such that `s` is the set of all elements that are `r`-related to all of `t` and `t` is the set of
all elements that are `r`-related to all of `s`. -/
structure Concept extends Set α × Set β where
  /-- The axiom of a `Concept` stating that the closure of the first set is the second set. -/
  closure_fst : intentClosure r fst = snd
  /-- The axiom of a `Concept` stating that the closure of the second set is the first set. -/
  closure_snd : extentClosure r snd = fst
goal: Type (max u_2 u_3)

full_name: Concept.closure_fst
code: /-- The formal concepts of a relation. A concept of `r : α → β → Prop` is a pair of sets `s`, `t`
such that `s` is the set of all elements that are `r`-related to all of `t` and `t` is the set of
all elements that are `r`-related to all of `s`. -/
structure Concept extends Set α × Set β where
  /-- The axiom of a `Concept` stating that the closure of the first set is the second set. -/
  closure_fst : intentClosure r fst = snd
  /-- The axiom of a `Concept` stating that the closure of the second set is the first set. -/
  closure_snd : extentClosure r snd = fst
goal: intentClosure r self.toProd.1 = self.toProd.2

full_name: Concept.closure_snd
code: /-- The formal concepts of a relation. A concept of `r : α → β → Prop` is a pair of sets `s`, `t`
such that `s` is the set of all elements that are `r`-related to all of `t` and `t` is the set of
all elements that are `r`-related to all of `s`. -/
structure Concept extends Set α × Set β where
  /-- The axiom of a `Concept` stating that the closure of the first set is the second set. -/
  closure_fst : intentClosure r fst = snd
  /-- The axiom of a `Concept` stating that the closure of the second set is the first set. -/
  closure_snd : extentClosure r snd = fst
goal: extentClosure r self.toProd.2 = self.toProd.1

full_name: Concept.ext
code: @[ext]
theorem ext (h : c.fst = d.fst) : c = d 
goal: c = d

full_name: Concept.ext'
code: theorem ext' (h : c.snd = d.snd) : c = d 
goal: c = d

full_name: Concept.fst_injective
code: theorem fst_injective : Injective fun c : Concept α β r => c.fst 
goal: Function.Injective fun c => c.toProd.1

full_name: Concept.snd_injective
code: theorem snd_injective : Injective fun c : Concept α β r => c.snd 
goal: Function.Injective fun c => c.toProd.2

full_name: Concept.instSupConcept
code: instance instSupConcept : Sup (Concept α β r) 
goal: Sup (Concept α β r)

full_name: Concept.instInfConcept
code: instance instInfConcept : Inf (Concept α β r) 
goal: Inf (Concept α β r)

full_name: Concept.instSemilatticeInfConcept
code: instance instSemilatticeInfConcept : SemilatticeInf (Concept α β r) 
goal: SemilatticeInf (Concept α β r)

full_name: Concept.fst_subset_fst_iff
code: @[simp]
theorem fst_subset_fst_iff : c.fst ⊆ d.fst ↔ c ≤ d 
goal: c.toProd.1 ⊆ d.toProd.1 ↔ c ≤ d

full_name: Concept.fst_ssubset_fst_iff
code: @[simp]
theorem fst_ssubset_fst_iff : c.fst ⊂ d.fst ↔ c < d 
goal: c.toProd.1 ⊂ d.toProd.1 ↔ c < d

full_name: Concept.snd_subset_snd_iff
code: @[simp]
theorem snd_subset_snd_iff : c.snd ⊆ d.snd ↔ d ≤ c 
goal: c.toProd.2 ⊆ d.toProd.2 ↔ d ≤ c

full_name: Concept.snd_ssubset_snd_iff
code: @[simp]
theorem snd_ssubset_snd_iff : c.snd ⊂ d.snd ↔ d < c 
goal: c.toProd.2 ⊂ d.toProd.2 ↔ d < c

full_name: Concept.strictMono_fst
code: theorem strictMono_fst : StrictMono (Prod.fst ∘ toProd : Concept α β r → Set α) 
goal: StrictMono (Prod.fst ∘ Concept.toProd)

full_name: Concept.strictAnti_snd
code: theorem strictAnti_snd : StrictAnti (Prod.snd ∘ toProd : Concept α β r → Set β) 
goal: StrictAnti (Prod.snd ∘ Concept.toProd)

full_name: Concept.instLatticeConcept
code: instance instLatticeConcept : Lattice (Concept α β r) 
goal: Lattice (Concept α β r)

full_name: Concept.instBoundedOrderConcept
code: instance instBoundedOrderConcept : BoundedOrder (Concept α β r) 
goal: BoundedOrder (Concept α β r)

full_name: Concept.instSupSet
code: instance : SupSet (Concept α β r) 
goal: SupSet (Concept α β r)

full_name: Concept.instInfSet
code: instance : InfSet (Concept α β r) 
goal: InfSet (Concept α β r)

full_name: Concept.instCompleteLattice
code: instance : CompleteLattice (Concept α β r) 
goal: CompleteLattice (Concept α β r)

full_name: Concept.top_fst
code: @[simp]
theorem top_fst : (⊤ : Concept α β r).fst = univ 
goal: ⊤.toProd.1 = Set.univ

full_name: Concept.top_snd
code: @[simp]
theorem top_snd : (⊤ : Concept α β r).snd = intentClosure r univ 
goal: ⊤.toProd.2 = intentClosure r Set.univ

full_name: Concept.bot_fst
code: @[simp]
theorem bot_fst : (⊥ : Concept α β r).fst = extentClosure r univ 
goal: ⊥.toProd.1 = extentClosure r Set.univ

full_name: Concept.bot_snd
code: @[simp]
theorem bot_snd : (⊥ : Concept α β r).snd = univ 
goal: ⊥.toProd.2 = Set.univ

full_name: Concept.sup_fst
code: @[simp]
theorem sup_fst (c d : Concept α β r) : (c ⊔ d).fst = extentClosure r (c.snd ∩ d.snd) 
goal: (c ⊔ d).toProd.1 = extentClosure r (c.toProd.2 ∩ d.toProd.2)

full_name: Concept.sup_snd
code: @[simp]
theorem sup_snd (c d : Concept α β r) : (c ⊔ d).snd = c.snd ∩ d.snd 
goal: (c ⊔ d).toProd.2 = c.toProd.2 ∩ d.toProd.2

full_name: Concept.inf_fst
code: @[simp]
theorem inf_fst (c d : Concept α β r) : (c ⊓ d).fst = c.fst ∩ d.fst 
goal: (c ⊓ d).toProd.1 = c.toProd.1 ∩ d.toProd.1

full_name: Concept.inf_snd
code: @[simp]
theorem inf_snd (c d : Concept α β r) : (c ⊓ d).snd = intentClosure r (c.fst ∩ d.fst) 
goal: (c ⊓ d).toProd.2 = intentClosure r (c.toProd.1 ∩ d.toProd.1)

full_name: Concept.sSup_fst
code: @[simp]
theorem sSup_fst (S : Set (Concept α β r)) :
    (sSup S).fst = extentClosure r (⋂ c ∈ S, (c : Concept _ _ _).snd) 
goal: (sSup S).toProd.1 = extentClosure r (⋂ c ∈ S, c.toProd.2)

full_name: Concept.sSup_snd
code: @[simp]
theorem sSup_snd (S : Set (Concept α β r)) : (sSup S).snd = ⋂ c ∈ S, (c : Concept _ _ _).snd 
goal: (sSup S).toProd.2 = ⋂ c ∈ S, c.toProd.2

full_name: Concept.sInf_fst
code: @[simp]
theorem sInf_fst (S : Set (Concept α β r)) : (sInf S).fst = ⋂ c ∈ S, (c : Concept _ _ _).fst 
goal: (sInf S).toProd.1 = ⋂ c ∈ S, c.toProd.1

full_name: Concept.sInf_snd
code: @[simp]
theorem sInf_snd (S : Set (Concept α β r)) :
    (sInf S).snd = intentClosure r (⋂ c ∈ S, (c : Concept _ _ _).fst) 
goal: (sInf S).toProd.2 = intentClosure r (⋂ c ∈ S, c.toProd.1)

full_name: Concept.instInhabited
code: instance : Inhabited (Concept α β r) 
goal: Inhabited (Concept α β r)

full_name: Concept.swap
code: /-- Swap the sets of a concept to make it a concept of the dual context. -/
@[simps]
def swap (c : Concept α β r) : Concept β α (swap r) 
goal: Concept β α (Function.swap r)

full_name: Concept.swap_toProd
code: /-- Swap the sets of a concept to make it a concept of the dual context. -/
@[simps]
def swap (c : Concept α β r) : Concept β α (swap r) 
goal: c.swap.toProd = c.swap

full_name: Concept.swap_swap
code: @[simp]
theorem swap_swap (c : Concept α β r) : c.swap.swap = c 
goal: c.swap.swap = c

full_name: Concept.swap_le_swap_iff
code: @[simp]
theorem swap_le_swap_iff : c.swap ≤ d.swap ↔ d ≤ c 
goal: c.swap ≤ d.swap ↔ d ≤ c

full_name: Concept.swap_lt_swap_iff
code: @[simp]
theorem swap_lt_swap_iff : c.swap < d.swap ↔ d < c 
goal: c.swap < d.swap ↔ d < c

full_name: Concept.swapEquiv_symm_apply
code: /-- The dual of a concept lattice is isomorphic to the concept lattice of the dual context. -/
@[simps]
def swapEquiv : (Concept α β r)ᵒᵈ ≃o Concept β α (Function.swap r) 
goal: ∀ (a : Concept β α (Function.swap r)), (RelIso.symm Concept.swapEquiv) a = (⇑OrderDual.toDual ∘ Concept.swap) a

full_name: Concept.swapEquiv_apply
code: /-- The dual of a concept lattice is isomorphic to the concept lattice of the dual context. -/
@[simps]
def swapEquiv : (Concept α β r)ᵒᵈ ≃o Concept β α (Function.swap r) 
goal: ∀ (a : (Concept α β r)ᵒᵈ), Concept.swapEquiv a = (Concept.swap ∘ ⇑OrderDual.ofDual) a

full_name: Concept.swapEquiv
code: /-- The dual of a concept lattice is isomorphic to the concept lattice of the dual context. -/
@[simps]
def swapEquiv : (Concept α β r)ᵒᵈ ≃o Concept β α (Function.swap r) 
goal: (Concept α β r)ᵒᵈ ≃o Concept β α (Function.swap r)