File: Mathlib/Order/CompleteLattice.lean

full_name: iSup_ulift
code: @[simp] lemma iSup_ulift {ι : Type*} [SupSet α] (f : ULift ι → α) :
    ⨆ i : ULift ι, f i = ⨆ i, f (.up i) 
goal: ⨆ i, f i = ⨆ i, f { down := i }

full_name: iInf_ulift
code: @[simp] lemma iInf_ulift {ι : Type*} [InfSet α] (f : ULift ι → α) :
    ⨅ i : ULift ι, f i = ⨅ i, f (.up i) 
goal: ⨅ i, f i = ⨅ i, f { down := i }

full_name: OrderDual.supSet
code: instance OrderDual.supSet (α) [InfSet α] : SupSet αᵒᵈ 
goal: SupSet αᵒᵈ

full_name: OrderDual.infSet
code: instance OrderDual.infSet (α) [SupSet α] : InfSet αᵒᵈ 
goal: InfSet αᵒᵈ

full_name: CompleteSemilatticeSup
code: /-- Note that we rarely use `CompleteSemilatticeSup`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
  /-- Any element of a set is less than the set supremum. -/
  le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
  /-- Any upper bound is more than the set supremum. -/
  sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a
goal: Type u_9

full_name: CompleteSemilatticeSup.le_sSup
code: /-- Note that we rarely use `CompleteSemilatticeSup`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
  /-- Any element of a set is less than the set supremum. -/
  le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
  /-- Any upper bound is more than the set supremum. -/
  sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a
goal: a ∈ s → a ≤ sSup s

full_name: CompleteSemilatticeSup.sSup_le
code: /-- Note that we rarely use `CompleteSemilatticeSup`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
  /-- Any element of a set is less than the set supremum. -/
  le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
  /-- Any upper bound is more than the set supremum. -/
  sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a
goal: (∀ b ∈ s, b ≤ a) → sSup s ≤ a

full_name: le_sSup
code: theorem le_sSup : a ∈ s → a ≤ sSup s 
goal: a ∈ s → a ≤ sSup s

full_name: sSup_le
code: theorem sSup_le : (∀ b ∈ s, b ≤ a) → sSup s ≤ a 
goal: (∀ b ∈ s, b ≤ a) → sSup s ≤ a

full_name: isLUB_sSup
code: theorem isLUB_sSup (s : Set α) : IsLUB s (sSup s) 
goal: IsLUB s (sSup s)

full_name: isLUB_iff_sSup_eq
code: lemma isLUB_iff_sSup_eq : IsLUB s a ↔ sSup s = a 
goal: IsLUB s a ↔ sSup s = a

full_name: le_sSup_of_le
code: theorem le_sSup_of_le (hb : b ∈ s) (h : a ≤ b) : a ≤ sSup s 
goal: a ≤ sSup s

full_name: sSup_le_sSup
code: @[gcongr]
theorem sSup_le_sSup (h : s ⊆ t) : sSup s ≤ sSup t 
goal: sSup s ≤ sSup t

full_name: sSup_le_iff
code: @[simp]
theorem sSup_le_iff : sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a 
goal: sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a

full_name: le_sSup_iff
code: theorem le_sSup_iff : a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b 
goal: a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b

full_name: le_iSup_iff
code: theorem le_iSup_iff {s : ι → α} : a ≤ iSup s ↔ ∀ b, (∀ i, s i ≤ b) → a ≤ b 
goal: a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b

full_name: sSup_le_sSup_of_forall_exists_le
code: theorem sSup_le_sSup_of_forall_exists_le (h : ∀ x ∈ s, ∃ y ∈ t, x ≤ y) : sSup s ≤ sSup t 
goal: sSup s ≤ sSup t

full_name: sSup_singleton
code: theorem sSup_singleton {a : α} : sSup {a} = a 
goal: sSup {a} = a

full_name: CompleteSemilatticeInf
code: /-- Note that we rarely use `CompleteSemilatticeInf`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeInf (α : Type*) extends PartialOrder α, InfSet α where
  /-- Any element of a set is more than the set infimum. -/
  sInf_le : ∀ s, ∀ a ∈ s, sInf s ≤ a
  /-- Any lower bound is less than the set infimum. -/
  le_sInf : ∀ s a, (∀ b ∈ s, a ≤ b) → a ≤ sInf s
goal: Type u_9

full_name: CompleteSemilatticeInf.le_sInf
code: /-- Note that we rarely use `CompleteSemilatticeInf`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeInf (α : Type*) extends PartialOrder α, InfSet α where
  /-- Any element of a set is more than the set infimum. -/
  sInf_le : ∀ s, ∀ a ∈ s, sInf s ≤ a
  /-- Any lower bound is less than the set infimum. -/
  le_sInf : ∀ s a, (∀ b ∈ s, a ≤ b) → a ≤ sInf s
goal: (∀ b ∈ s, a ≤ b) → a ≤ sInf s

full_name: CompleteSemilatticeInf.sInf_le
code: /-- Note that we rarely use `CompleteSemilatticeInf`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeInf (α : Type*) extends PartialOrder α, InfSet α where
  /-- Any element of a set is more than the set infimum. -/
  sInf_le : ∀ s, ∀ a ∈ s, sInf s ≤ a
  /-- Any lower bound is less than the set infimum. -/
  le_sInf : ∀ s a, (∀ b ∈ s, a ≤ b) → a ≤ sInf s
goal: a ∈ s → sInf s ≤ a

full_name: sInf_le
code: theorem sInf_le : a ∈ s → sInf s ≤ a 
goal: a ∈ s → sInf s ≤ a

full_name: le_sInf
code: theorem le_sInf : (∀ b ∈ s, a ≤ b) → a ≤ sInf s 
goal: (∀ b ∈ s, a ≤ b) → a ≤ sInf s

full_name: isGLB_sInf
code: theorem isGLB_sInf (s : Set α) : IsGLB s (sInf s) 
goal: IsGLB s (sInf s)

full_name: isGLB_iff_sInf_eq
code: lemma isGLB_iff_sInf_eq : IsGLB s a ↔ sInf s = a 
goal: IsGLB s a ↔ sInf s = a

full_name: sInf_le_of_le
code: theorem sInf_le_of_le (hb : b ∈ s) (h : b ≤ a) : sInf s ≤ a 
goal: sInf s ≤ a

full_name: sInf_le_sInf
code: @[gcongr]
theorem sInf_le_sInf (h : s ⊆ t) : sInf t ≤ sInf s 
goal: sInf t ≤ sInf s

full_name: le_sInf_iff
code: @[simp]
theorem le_sInf_iff : a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b 
goal: a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b

full_name: sInf_le_iff
code: theorem sInf_le_iff : sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a 
goal: sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a

full_name: iInf_le_iff
code: theorem iInf_le_iff {s : ι → α} : iInf s ≤ a ↔ ∀ b, (∀ i, b ≤ s i) → b ≤ a 
goal: iInf s ≤ a ↔ ∀ (b : α), (∀ (i : ι), b ≤ s i) → b ≤ a

full_name: sInf_le_sInf_of_forall_exists_le
code: theorem sInf_le_sInf_of_forall_exists_le (h : ∀ x ∈ s, ∃ y ∈ t, y ≤ x) : sInf t ≤ sInf s 
goal: sInf t ≤ sInf s

full_name: sInf_singleton
code: theorem sInf_singleton {a : α} : sInf {a} = a 
goal: sInf {a} = a

full_name: CompleteLattice.le_top
code: /-- A complete lattice is a bounded lattice which has suprema and infima for every subset. -/
class CompleteLattice (α : Type*) extends Lattice α, CompleteSemilatticeSup α,
  CompleteSemilatticeInf α, Top α, Bot α where
  /-- Any element is less than the top one. -/
  protected le_top : ∀ x : α, x ≤ ⊤
  /-- Any element is more than the bottom one. -/
  protected bot_le : ∀ x : α, ⊥ ≤ x
goal: x ≤ ⊤

full_name: CompleteLattice
code: /-- A complete lattice is a bounded lattice which has suprema and infima for every subset. -/
class CompleteLattice (α : Type*) extends Lattice α, CompleteSemilatticeSup α,
  CompleteSemilatticeInf α, Top α, Bot α where
  /-- Any element is less than the top one. -/
  protected le_top : ∀ x : α, x ≤ ⊤
  /-- Any element is more than the bottom one. -/
  protected bot_le : ∀ x : α, ⊥ ≤ x
goal: Type u_9

full_name: CompleteLattice.bot_le
code: /-- A complete lattice is a bounded lattice which has suprema and infima for every subset. -/
class CompleteLattice (α : Type*) extends Lattice α, CompleteSemilatticeSup α,
  CompleteSemilatticeInf α, Top α, Bot α where
  /-- Any element is less than the top one. -/
  protected le_top : ∀ x : α, x ≤ ⊤
  /-- Any element is more than the bottom one. -/
  protected bot_le : ∀ x : α, ⊥ ≤ x
goal: ⊥ ≤ x

full_name: CompleteLattice.toBoundedOrder
code: instance (priority := 100) CompleteLattice.toBoundedOrder [h : CompleteLattice α] :
    BoundedOrder α 
goal: BoundedOrder α

full_name: completeLatticeOfInf
code: /-- Create a `CompleteLattice` from a `PartialOrder` and `InfSet`
that returns the greatest lower bound of a set. Usually this constructor provides
poor definitional equalities.  If other fields are known explicitly, they should be
provided; for example, if `inf` is known explicitly, construct the `CompleteLattice`
instance as
```
instance : CompleteLattice my_T where
  inf := better_inf
  le_inf := ...
  inf_le_right := ...
  inf_le_left := ...
  -- don't care to fix sup, sSup, bot, top
  __ := completeLatticeOfInf my_T _
```
-/
def completeLatticeOfInf (α : Type*) [H1 : PartialOrder α] [H2 : InfSet α]
    (isGLB_sInf : ∀ s : Set α, IsGLB s (sInf s)) : CompleteLattice α 
goal: CompleteLattice α

full_name: completeLatticeOfCompleteSemilatticeInf
code: /-- Any `CompleteSemilatticeInf` is in fact a `CompleteLattice`.

Note that this construction has bad definitional properties:
see the doc-string on `completeLatticeOfInf`.
-/
def completeLatticeOfCompleteSemilatticeInf (α : Type*) [CompleteSemilatticeInf α] :
    CompleteLattice α 
goal: CompleteLattice α

full_name: completeLatticeOfSup
code: /-- Create a `CompleteLattice` from a `PartialOrder` and `SupSet`
that returns the least upper bound of a set. Usually this constructor provides
poor definitional equalities.  If other fields are known explicitly, they should be
provided; for example, if `inf` is known explicitly, construct the `CompleteLattice`
instance as
```
instance : CompleteLattice my_T where
  inf := better_inf
  le_inf := ...
  inf_le_right := ...
  inf_le_left := ...
  -- don't care to fix sup, sInf, bot, top
  __ := completeLatticeOfSup my_T _
```
-/
def completeLatticeOfSup (α : Type*) [H1 : PartialOrder α] [H2 : SupSet α]
    (isLUB_sSup : ∀ s : Set α, IsLUB s (sSup s)) : CompleteLattice α 
goal: CompleteLattice α

full_name: completeLatticeOfCompleteSemilatticeSup
code: /-- Any `CompleteSemilatticeSup` is in fact a `CompleteLattice`.

Note that this construction has bad definitional properties:
see the doc-string on `completeLatticeOfSup`.
-/
def completeLatticeOfCompleteSemilatticeSup (α : Type*) [CompleteSemilatticeSup α] :
    CompleteLattice α 
goal: CompleteLattice α

full_name: CompleteLinearOrder.decidableLT
code: /-- A complete linear order is a linear order whose lattice structure is complete. -/
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
  /-- A linear order is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
goal: DecidableRel fun x x_1 => x < x_1

full_name: CompleteLinearOrder.decidableLE
code: /-- A complete linear order is a linear order whose lattice structure is complete. -/
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
  /-- A linear order is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
goal: DecidableRel fun x x_1 => x ≤ x_1

full_name: CompleteLinearOrder.decidableEq
code: /-- A complete linear order is a linear order whose lattice structure is complete. -/
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
  /-- A linear order is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
goal: DecidableEq α

full_name: CompleteLinearOrder
code: /-- A complete linear order is a linear order whose lattice structure is complete. -/
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
  /-- A linear order is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
goal: Type u_9

full_name: CompleteLinearOrder.le_total
code: /-- A complete linear order is a linear order whose lattice structure is complete. -/
class CompleteLinearOrder (α : Type*) extends CompleteLattice α, BiheytingAlgebra α where
  /-- A linear order is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a linearly ordered type, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
goal: a ≤ b ∨ b ≤ a

full_name: CompleteLinearOrder.toLinearOrder
code: instance CompleteLinearOrder.toLinearOrder [i : CompleteLinearOrder α] : LinearOrder α 
goal: LinearOrder α

full_name: OrderDual.instCompleteLattice
code: instance instCompleteLattice [CompleteLattice α] : CompleteLattice αᵒᵈ 
goal: CompleteLattice αᵒᵈ

full_name: OrderDual.instCompleteLinearOrder
code: instance instCompleteLinearOrder [CompleteLinearOrder α] : CompleteLinearOrder αᵒᵈ 
goal: CompleteLinearOrder αᵒᵈ

full_name: toDual_sSup
code: @[simp]
theorem toDual_sSup (s : Set α) : toDual (sSup s) = sInf (ofDual ⁻¹' s) 
goal: OrderDual.toDual (sSup s) = sInf (⇑OrderDual.ofDual ⁻¹' s)

full_name: toDual_sInf
code: @[simp]
theorem toDual_sInf (s : Set α) : toDual (sInf s) = sSup (ofDual ⁻¹' s) 
goal: OrderDual.toDual (sInf s) = sSup (⇑OrderDual.ofDual ⁻¹' s)

full_name: ofDual_sSup
code: @[simp]
theorem ofDual_sSup (s : Set αᵒᵈ) : ofDual (sSup s) = sInf (toDual ⁻¹' s) 
goal: OrderDual.ofDual (sSup s) = sInf (⇑OrderDual.toDual ⁻¹' s)

full_name: ofDual_sInf
code: @[simp]
theorem ofDual_sInf (s : Set αᵒᵈ) : ofDual (sInf s) = sSup (toDual ⁻¹' s) 
goal: OrderDual.ofDual (sInf s) = sSup (⇑OrderDual.toDual ⁻¹' s)

full_name: toDual_iSup
code: @[simp]
theorem toDual_iSup (f : ι → α) : toDual (⨆ i, f i) = ⨅ i, toDual (f i) 
goal: OrderDual.toDual (⨆ i, f i) = ⨅ i, OrderDual.toDual (f i)

full_name: toDual_iInf
code: @[simp]
theorem toDual_iInf (f : ι → α) : toDual (⨅ i, f i) = ⨆ i, toDual (f i) 
goal: OrderDual.toDual (⨅ i, f i) = ⨆ i, OrderDual.toDual (f i)

full_name: ofDual_iSup
code: @[simp]
theorem ofDual_iSup (f : ι → αᵒᵈ) : ofDual (⨆ i, f i) = ⨅ i, ofDual (f i) 
goal: OrderDual.ofDual (⨆ i, f i) = ⨅ i, OrderDual.ofDual (f i)

full_name: ofDual_iInf
code: @[simp]
theorem ofDual_iInf (f : ι → αᵒᵈ) : ofDual (⨅ i, f i) = ⨆ i, ofDual (f i) 
goal: OrderDual.ofDual (⨅ i, f i) = ⨆ i, OrderDual.ofDual (f i)

full_name: sInf_le_sSup
code: theorem sInf_le_sSup (hs : s.Nonempty) : sInf s ≤ sSup s 
goal: sInf s ≤ sSup s

full_name: sSup_union
code: theorem sSup_union {s t : Set α} : sSup (s ∪ t) = sSup s ⊔ sSup t 
goal: sSup (s ∪ t) = sSup s ⊔ sSup t

full_name: sInf_union
code: theorem sInf_union {s t : Set α} : sInf (s ∪ t) = sInf s ⊓ sInf t 
goal: sInf (s ∪ t) = sInf s ⊓ sInf t

full_name: sSup_inter_le
code: theorem sSup_inter_le {s t : Set α} : sSup (s ∩ t) ≤ sSup s ⊓ sSup t 
goal: sSup (s ∩ t) ≤ sSup s ⊓ sSup t

full_name: le_sInf_inter
code: theorem le_sInf_inter {s t : Set α} : sInf s ⊔ sInf t ≤ sInf (s ∩ t) 
goal: sInf s ⊔ sInf t ≤ sInf (s ∩ t)

full_name: sSup_empty
code: @[simp]
theorem sSup_empty : sSup ∅ = (⊥ : α) 
goal: sSup ∅ = ⊥

full_name: sInf_empty
code: @[simp]
theorem sInf_empty : sInf ∅ = (⊤ : α) 
goal: sInf ∅ = ⊤

full_name: sSup_univ
code: @[simp]
theorem sSup_univ : sSup univ = (⊤ : α) 
goal: sSup Set.univ = ⊤

full_name: sInf_univ
code: @[simp]
theorem sInf_univ : sInf univ = (⊥ : α) 
goal: sInf Set.univ = ⊥

full_name: sSup_insert
code: @[simp]
theorem sSup_insert {a : α} {s : Set α} : sSup (insert a s) = a ⊔ sSup s 
goal: sSup (insert a s) = a ⊔ sSup s

full_name: sInf_insert
code: @[simp]
theorem sInf_insert {a : α} {s : Set α} : sInf (insert a s) = a ⊓ sInf s 
goal: sInf (insert a s) = a ⊓ sInf s

full_name: sSup_le_sSup_of_subset_insert_bot
code: theorem sSup_le_sSup_of_subset_insert_bot (h : s ⊆ insert ⊥ t) : sSup s ≤ sSup t 
goal: sSup s ≤ sSup t

full_name: sInf_le_sInf_of_subset_insert_top
code: theorem sInf_le_sInf_of_subset_insert_top (h : s ⊆ insert ⊤ t) : sInf t ≤ sInf s 
goal: sInf t ≤ sInf s

full_name: sSup_diff_singleton_bot
code: @[simp]
theorem sSup_diff_singleton_bot (s : Set α) : sSup (s \ {⊥}) = sSup s 
goal: sSup (s \ {⊥}) = sSup s

full_name: sInf_diff_singleton_top
code: @[simp]
theorem sInf_diff_singleton_top (s : Set α) : sInf (s \ {⊤}) = sInf s 
goal: sInf (s \ {⊤}) = sInf s

full_name: sSup_pair
code: theorem sSup_pair {a b : α} : sSup {a, b} = a ⊔ b 
goal: sSup {a, b} = a ⊔ b

full_name: sInf_pair
code: theorem sInf_pair {a b : α} : sInf {a, b} = a ⊓ b 
goal: sInf {a, b} = a ⊓ b

full_name: sSup_eq_bot
code: @[simp]
theorem sSup_eq_bot : sSup s = ⊥ ↔ ∀ a ∈ s, a = ⊥ 
goal: sSup s = ⊥ ↔ ∀ a ∈ s, a = ⊥

full_name: sInf_eq_top
code: @[simp]
theorem sInf_eq_top : sInf s = ⊤ ↔ ∀ a ∈ s, a = ⊤ 
goal: sInf s = ⊤ ↔ ∀ a ∈ s, a = ⊤

full_name: sSup_eq_bot'
code: lemma sSup_eq_bot' {s : Set α} : sSup s = ⊥ ↔ s = ∅ ∨ s = {⊥} 
goal: sSup s = ⊥ ↔ s = ∅ ∨ s = {⊥}

full_name: eq_singleton_bot_of_sSup_eq_bot_of_nonempty
code: theorem eq_singleton_bot_of_sSup_eq_bot_of_nonempty {s : Set α} (h_sup : sSup s = ⊥)
    (hne : s.Nonempty) : s = {⊥} 
goal: s = {⊥}

full_name: eq_singleton_top_of_sInf_eq_top_of_nonempty
code: theorem eq_singleton_top_of_sInf_eq_top_of_nonempty : sInf s = ⊤ → s.Nonempty → s = {⊤} 
goal: sInf s = ⊤ → s.Nonempty → s = {⊤}

full_name: sSup_eq_of_forall_le_of_forall_lt_exists_gt
code: /-- Introduction rule to prove that `b` is the supremum of `s`: it suffices to check that `b`
is larger than all elements of `s`, and that this is not the case of any `w < b`.
See `csSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in conditionally complete
lattices. -/
theorem sSup_eq_of_forall_le_of_forall_lt_exists_gt (h₁ : ∀ a ∈ s, a ≤ b)
    (h₂ : ∀ w, w < b → ∃ a ∈ s, w < a) : sSup s = b 
goal: sSup s = b

full_name: sInf_eq_of_forall_ge_of_forall_gt_exists_lt
code: /-- Introduction rule to prove that `b` is the infimum of `s`: it suffices to check that `b`
is smaller than all elements of `s`, and that this is not the case of any `w > b`.
See `csInf_eq_of_forall_ge_of_forall_gt_exists_lt` for a version in conditionally complete
lattices. -/
theorem sInf_eq_of_forall_ge_of_forall_gt_exists_lt :
    (∀ a ∈ s, b ≤ a) → (∀ w, b < w → ∃ a ∈ s, a < w) → sInf s = b 
goal: (∀ a ∈ s, b ≤ a) → (∀ (w : α), b < w → ∃ a ∈ s, a < w) → sInf s = b

full_name: lt_sSup_iff
code: theorem lt_sSup_iff : b < sSup s ↔ ∃ a ∈ s, b < a 
goal: b < sSup s ↔ ∃ a ∈ s, b < a

full_name: sInf_lt_iff
code: theorem sInf_lt_iff : sInf s < b ↔ ∃ a ∈ s, a < b 
goal: sInf s < b ↔ ∃ a ∈ s, a < b

full_name: sSup_eq_top
code: theorem sSup_eq_top : sSup s = ⊤ ↔ ∀ b < ⊤, ∃ a ∈ s, b < a 
goal: sSup s = ⊤ ↔ ∀ b < ⊤, ∃ a ∈ s, b < a

full_name: sInf_eq_bot
code: theorem sInf_eq_bot : sInf s = ⊥ ↔ ∀ b > ⊥, ∃ a ∈ s, a < b 
goal: sInf s = ⊥ ↔ ∀ b > ⊥, ∃ a ∈ s, a < b

full_name: lt_iSup_iff
code: theorem lt_iSup_iff {f : ι → α} : a < iSup f ↔ ∃ i, a < f i 
goal: a < iSup f ↔ ∃ i, a < f i

full_name: iInf_lt_iff
code: theorem iInf_lt_iff {f : ι → α} : iInf f < a ↔ ∃ i, f i < a 
goal: iInf f < a ↔ ∃ i, f i < a

full_name: sSup_range
code: theorem sSup_range : sSup (range f) = iSup f 
goal: sSup (Set.range f) = iSup f

full_name: sSup_eq_iSup'
code: theorem sSup_eq_iSup' (s : Set α) : sSup s = ⨆ a : s, (a : α) 
goal: sSup s = ⨆ a, ↑a

full_name: iSup_congr
code: theorem iSup_congr (h : ∀ i, f i = g i) : ⨆ i, f i = ⨆ i, g i 
goal: ⨆ i, f i = ⨆ i, g i

full_name: biSup_congr
code: theorem biSup_congr {p : ι → Prop} (h : ∀ i, p i → f i = g i) :
    ⨆ (i) (_ : p i), f i = ⨆ (i) (_ : p i), g i 
goal: ⨆ i, ⨆ (_ : p i), f i = ⨆ i, ⨆ (_ : p i), g i

full_name: biSup_congr'
code: theorem biSup_congr' {p : ι → Prop} {f g : (i : ι) → p i → α}
    (h : ∀ i (hi : p i), f i hi = g i hi) :
    ⨆ i, ⨆ (hi : p i), f i hi = ⨆ i, ⨆ (hi : p i), g i hi 
goal: ⨆ i, ⨆ (hi : p i), f i hi = ⨆ i, ⨆ (hi : p i), g i hi

full_name: Function.Surjective.iSup_comp
code: theorem Function.Surjective.iSup_comp {f : ι → ι'} (hf : Surjective f) (g : ι' → α) :
    ⨆ x, g (f x) = ⨆ y, g y 
goal: ⨆ x, g (f x) = ⨆ y, g y

full_name: Equiv.iSup_comp
code: theorem Equiv.iSup_comp {g : ι' → α} (e : ι ≃ ι') : ⨆ x, g (e x) = ⨆ y, g y 
goal: ⨆ x, g (e x) = ⨆ y, g y

full_name: Function.Surjective.iSup_congr
code: protected theorem Function.Surjective.iSup_congr {g : ι' → α} (h : ι → ι') (h1 : Surjective h)
    (h2 : ∀ x, g (h x) = f x) : ⨆ x, f x = ⨆ y, g y 
goal: ⨆ x, f x = ⨆ y, g y

full_name: Equiv.iSup_congr
code: protected theorem Equiv.iSup_congr {g : ι' → α} (e : ι ≃ ι') (h : ∀ x, g (e x) = f x) :
    ⨆ x, f x = ⨆ y, g y 
goal: ⨆ x, f x = ⨆ y, g y

full_name: iSup_congr_Prop
code: @[congr]
theorem iSup_congr_Prop {p q : Prop} {f₁ : p → α} {f₂ : q → α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iSup f₁ = iSup f₂ 
goal: iSup f₁ = iSup f₂

full_name: iSup_plift_up
code: theorem iSup_plift_up (f : PLift ι → α) : ⨆ i, f (PLift.up i) = ⨆ i, f i 
goal: ⨆ i, f { down := i } = ⨆ i, f i

full_name: iSup_plift_down
code: theorem iSup_plift_down (f : ι → α) : ⨆ i, f (PLift.down i) = ⨆ i, f i 
goal: ⨆ i, f i.down = ⨆ i, f i

full_name: iSup_range'
code: theorem iSup_range' (g : β → α) (f : ι → β) : ⨆ b : range f, g b = ⨆ i, g (f i) 
goal: ⨆ b, g ↑b = ⨆ i, g (f i)

full_name: sSup_image'
code: theorem sSup_image' {s : Set β} {f : β → α} : sSup (f '' s) = ⨆ a : s, f a 
goal: sSup (f '' s) = ⨆ a, f ↑a

full_name: sInf_range
code: theorem sInf_range : sInf (range f) = iInf f 
goal: sInf (Set.range f) = iInf f

full_name: sInf_eq_iInf'
code: theorem sInf_eq_iInf' (s : Set α) : sInf s = ⨅ a : s, (a : α) 
goal: sInf s = ⨅ a, ↑a

full_name: iInf_congr
code: theorem iInf_congr (h : ∀ i, f i = g i) : ⨅ i, f i = ⨅ i, g i 
goal: ⨅ i, f i = ⨅ i, g i

full_name: biInf_congr
code: theorem biInf_congr {p : ι → Prop} (h : ∀ i, p i → f i = g i) :
    ⨅ (i) (_ : p i), f i = ⨅ (i) (_ : p i), g i 
goal: ⨅ i, ⨅ (_ : p i), f i = ⨅ i, ⨅ (_ : p i), g i

full_name: biInf_congr'
code: theorem biInf_congr' {p : ι → Prop} {f g : (i : ι) → p i → α}
    (h : ∀ i (hi : p i), f i hi = g i hi) :
    ⨅ i, ⨅ (hi : p i), f i hi = ⨅ i, ⨅ (hi : p i), g i hi 
goal: ⨅ i, ⨅ (hi : p i), f i hi = ⨅ i, ⨅ (hi : p i), g i hi

full_name: Function.Surjective.iInf_comp
code: theorem Function.Surjective.iInf_comp {f : ι → ι'} (hf : Surjective f) (g : ι' → α) :
    ⨅ x, g (f x) = ⨅ y, g y 
goal: ⨅ x, g (f x) = ⨅ y, g y

full_name: Equiv.iInf_comp
code: theorem Equiv.iInf_comp {g : ι' → α} (e : ι ≃ ι') : ⨅ x, g (e x) = ⨅ y, g y 
goal: ⨅ x, g (e x) = ⨅ y, g y

full_name: Function.Surjective.iInf_congr
code: protected theorem Function.Surjective.iInf_congr {g : ι' → α} (h : ι → ι') (h1 : Surjective h)
    (h2 : ∀ x, g (h x) = f x) : ⨅ x, f x = ⨅ y, g y 
goal: ⨅ x, f x = ⨅ y, g y

full_name: Equiv.iInf_congr
code: protected theorem Equiv.iInf_congr {g : ι' → α} (e : ι ≃ ι') (h : ∀ x, g (e x) = f x) :
    ⨅ x, f x = ⨅ y, g y 
goal: ⨅ x, f x = ⨅ y, g y

full_name: iInf_congr_Prop
code: @[congr]
theorem iInf_congr_Prop {p q : Prop} {f₁ : p → α} {f₂ : q → α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iInf f₁ = iInf f₂ 
goal: iInf f₁ = iInf f₂

full_name: iInf_plift_up
code: theorem iInf_plift_up (f : PLift ι → α) : ⨅ i, f (PLift.up i) = ⨅ i, f i 
goal: ⨅ i, f { down := i } = ⨅ i, f i

full_name: iInf_plift_down
code: theorem iInf_plift_down (f : ι → α) : ⨅ i, f (PLift.down i) = ⨅ i, f i 
goal: ⨅ i, f i.down = ⨅ i, f i

full_name: iInf_range'
code: theorem iInf_range' (g : β → α) (f : ι → β) : ⨅ b : range f, g b = ⨅ i, g (f i) 
goal: ⨅ b, g ↑b = ⨅ i, g (f i)

full_name: sInf_image'
code: theorem sInf_image' {s : Set β} {f : β → α} : sInf (f '' s) = ⨅ a : s, f a 
goal: sInf (f '' s) = ⨅ a, f ↑a

full_name: le_iSup
code: theorem le_iSup (f : ι → α) (i : ι) : f i ≤ iSup f 
goal: f i ≤ iSup f

full_name: iInf_le
code: theorem iInf_le (f : ι → α) (i : ι) : iInf f ≤ f i 
goal: iInf f ≤ f i

full_name: le_iSup'
code: theorem le_iSup' (f : ι → α) (i : ι) : f i ≤ iSup f 
goal: f i ≤ iSup f

full_name: iInf_le'
code: theorem iInf_le' (f : ι → α) (i : ι) : iInf f ≤ f i 
goal: iInf f ≤ f i

full_name: isLUB_iSup
code: theorem isLUB_iSup : IsLUB (range f) (⨆ j, f j) 
goal: IsLUB (Set.range f) (⨆ j, f j)

full_name: isGLB_iInf
code: theorem isGLB_iInf : IsGLB (range f) (⨅ j, f j) 
goal: IsGLB (Set.range f) (⨅ j, f j)

full_name: IsLUB.iSup_eq
code: theorem IsLUB.iSup_eq (h : IsLUB (range f) a) : ⨆ j, f j = a 
goal: ⨆ j, f j = a

full_name: IsGLB.iInf_eq
code: theorem IsGLB.iInf_eq (h : IsGLB (range f) a) : ⨅ j, f j = a 
goal: ⨅ j, f j = a

full_name: le_iSup_of_le
code: theorem le_iSup_of_le (i : ι) (h : a ≤ f i) : a ≤ iSup f 
goal: a ≤ iSup f

full_name: iInf_le_of_le
code: theorem iInf_le_of_le (i : ι) (h : f i ≤ a) : iInf f ≤ a 
goal: iInf f ≤ a

full_name: le_iSup₂
code: theorem le_iSup₂ {f : ∀ i, κ i → α} (i : ι) (j : κ i) : f i j ≤ ⨆ (i) (j), f i j 
goal: f i j ≤ ⨆ i, ⨆ j, f i j

full_name: iInf₂_le
code: theorem iInf₂_le {f : ∀ i, κ i → α} (i : ι) (j : κ i) : ⨅ (i) (j), f i j ≤ f i j 
goal: ⨅ i, ⨅ j, f i j ≤ f i j

full_name: le_iSup₂_of_le
code: theorem le_iSup₂_of_le {f : ∀ i, κ i → α} (i : ι) (j : κ i) (h : a ≤ f i j) :
    a ≤ ⨆ (i) (j), f i j 
goal: a ≤ ⨆ i, ⨆ j, f i j

full_name: iInf₂_le_of_le
code: theorem iInf₂_le_of_le {f : ∀ i, κ i → α} (i : ι) (j : κ i) (h : f i j ≤ a) :
    ⨅ (i) (j), f i j ≤ a 
goal: ⨅ i, ⨅ j, f i j ≤ a

full_name: iSup_le
code: theorem iSup_le (h : ∀ i, f i ≤ a) : iSup f ≤ a 
goal: iSup f ≤ a

full_name: le_iInf
code: theorem le_iInf (h : ∀ i, a ≤ f i) : a ≤ iInf f 
goal: a ≤ iInf f

full_name: iSup₂_le
code: theorem iSup₂_le {f : ∀ i, κ i → α} (h : ∀ i j, f i j ≤ a) : ⨆ (i) (j), f i j ≤ a 
goal: ⨆ i, ⨆ j, f i j ≤ a

full_name: le_iInf₂
code: theorem le_iInf₂ {f : ∀ i, κ i → α} (h : ∀ i j, a ≤ f i j) : a ≤ ⨅ (i) (j), f i j 
goal: a ≤ ⨅ i, ⨅ j, f i j

full_name: iSup₂_le_iSup
code: theorem iSup₂_le_iSup (κ : ι → Sort*) (f : ι → α) : ⨆ (i) (_ : κ i), f i ≤ ⨆ i, f i 
goal: ⨆ i, ⨆ x, f i ≤ ⨆ i, f i

full_name: iInf_le_iInf₂
code: theorem iInf_le_iInf₂ (κ : ι → Sort*) (f : ι → α) : ⨅ i, f i ≤ ⨅ (i) (_ : κ i), f i 
goal: ⨅ i, f i ≤ ⨅ i, ⨅ x, f i

full_name: iSup_mono
code: @[gcongr]
theorem iSup_mono (h : ∀ i, f i ≤ g i) : iSup f ≤ iSup g 
goal: iSup f ≤ iSup g

full_name: iInf_mono
code: @[gcongr]
theorem iInf_mono (h : ∀ i, f i ≤ g i) : iInf f ≤ iInf g 
goal: iInf f ≤ iInf g

full_name: iSup₂_mono
code: theorem iSup₂_mono {f g : ∀ i, κ i → α} (h : ∀ i j, f i j ≤ g i j) :
    ⨆ (i) (j), f i j ≤ ⨆ (i) (j), g i j 
goal: ⨆ i, ⨆ j, f i j ≤ ⨆ i, ⨆ j, g i j

full_name: iInf₂_mono
code: theorem iInf₂_mono {f g : ∀ i, κ i → α} (h : ∀ i j, f i j ≤ g i j) :
    ⨅ (i) (j), f i j ≤ ⨅ (i) (j), g i j 
goal: ⨅ i, ⨅ j, f i j ≤ ⨅ i, ⨅ j, g i j

full_name: iSup_mono'
code: theorem iSup_mono' {g : ι' → α} (h : ∀ i, ∃ i', f i ≤ g i') : iSup f ≤ iSup g 
goal: iSup f ≤ iSup g

full_name: iInf_mono'
code: theorem iInf_mono' {g : ι' → α} (h : ∀ i', ∃ i, f i ≤ g i') : iInf f ≤ iInf g 
goal: iInf f ≤ iInf g

full_name: iSup₂_mono'
code: theorem iSup₂_mono' {f : ∀ i, κ i → α} {g : ∀ i', κ' i' → α} (h : ∀ i j, ∃ i' j', f i j ≤ g i' j') :
    ⨆ (i) (j), f i j ≤ ⨆ (i) (j), g i j 
goal: ⨆ i, ⨆ j, f i j ≤ ⨆ i, ⨆ j, g i j

full_name: iInf₂_mono'
code: theorem iInf₂_mono' {f : ∀ i, κ i → α} {g : ∀ i', κ' i' → α} (h : ∀ i j, ∃ i' j', f i' j' ≤ g i j) :
    ⨅ (i) (j), f i j ≤ ⨅ (i) (j), g i j 
goal: ⨅ i, ⨅ j, f i j ≤ ⨅ i, ⨅ j, g i j

full_name: iSup_const_mono
code: theorem iSup_const_mono (h : ι → ι') : ⨆ _ : ι, a ≤ ⨆ _ : ι', a 
goal: ⨆ x, a ≤ ⨆ x, a

full_name: iInf_const_mono
code: theorem iInf_const_mono (h : ι' → ι) : ⨅ _ : ι, a ≤ ⨅ _ : ι', a 
goal: ⨅ x, a ≤ ⨅ x, a

full_name: iSup_iInf_le_iInf_iSup
code: theorem iSup_iInf_le_iInf_iSup (f : ι → ι' → α) : ⨆ i, ⨅ j, f i j ≤ ⨅ j, ⨆ i, f i j 
goal: ⨆ i, ⨅ j, f i j ≤ ⨅ j, ⨆ i, f i j

full_name: biSup_mono
code: theorem biSup_mono {p q : ι → Prop} (hpq : ∀ i, p i → q i) :
    ⨆ (i) (_ : p i), f i ≤ ⨆ (i) (_ : q i), f i 
goal: ⨆ i, ⨆ (_ : p i), f i ≤ ⨆ i, ⨆ (_ : q i), f i

full_name: biInf_mono
code: theorem biInf_mono {p q : ι → Prop} (hpq : ∀ i, p i → q i) :
    ⨅ (i) (_ : q i), f i ≤ ⨅ (i) (_ : p i), f i 
goal: ⨅ i, ⨅ (_ : q i), f i ≤ ⨅ i, ⨅ (_ : p i), f i

full_name: iSup_le_iff
code: @[simp]
theorem iSup_le_iff : iSup f ≤ a ↔ ∀ i, f i ≤ a 
goal: iSup f ≤ a ↔ ∀ (i : ι), f i ≤ a

full_name: le_iInf_iff
code: @[simp]
theorem le_iInf_iff : a ≤ iInf f ↔ ∀ i, a ≤ f i 
goal: a ≤ iInf f ↔ ∀ (i : ι), a ≤ f i

full_name: iSup₂_le_iff
code: theorem iSup₂_le_iff {f : ∀ i, κ i → α} : ⨆ (i) (j), f i j ≤ a ↔ ∀ i j, f i j ≤ a 
goal: ⨆ i, ⨆ j, f i j ≤ a ↔ ∀ (i : ι) (j : κ i), f i j ≤ a

full_name: le_iInf₂_iff
code: theorem le_iInf₂_iff {f : ∀ i, κ i → α} : (a ≤ ⨅ (i) (j), f i j) ↔ ∀ i j, a ≤ f i j 
goal: a ≤ ⨅ i, ⨅ j, f i j ↔ ∀ (i : ι) (j : κ i), a ≤ f i j

full_name: iSup_lt_iff
code: theorem iSup_lt_iff : iSup f < a ↔ ∃ b, b < a ∧ ∀ i, f i ≤ b 
goal: iSup f < a ↔ ∃ b < a, ∀ (i : ι), f i ≤ b

full_name: lt_iInf_iff
code: theorem lt_iInf_iff : a < iInf f ↔ ∃ b, a < b ∧ ∀ i, b ≤ f i 
goal: a < iInf f ↔ ∃ b, a < b ∧ ∀ (i : ι), b ≤ f i

full_name: sSup_eq_iSup
code: theorem sSup_eq_iSup {s : Set α} : sSup s = ⨆ a ∈ s, a 
goal: sSup s = ⨆ a ∈ s, a

full_name: sInf_eq_iInf
code: theorem sInf_eq_iInf {s : Set α} : sInf s = ⨅ a ∈ s, a 
goal: sInf s = ⨅ a ∈ s, a

full_name: Monotone.le_map_iSup
code: theorem Monotone.le_map_iSup [CompleteLattice β] {f : α → β} (hf : Monotone f) :
    ⨆ i, f (s i) ≤ f (iSup s) 
goal: ⨆ i, f (s i) ≤ f (iSup s)

full_name: Antitone.le_map_iInf
code: theorem Antitone.le_map_iInf [CompleteLattice β] {f : α → β} (hf : Antitone f) :
    ⨆ i, f (s i) ≤ f (iInf s) 
goal: ⨆ i, f (s i) ≤ f (iInf s)

full_name: Monotone.le_map_iSup₂
code: theorem Monotone.le_map_iSup₂ [CompleteLattice β] {f : α → β} (hf : Monotone f) (s : ∀ i, κ i → α) :
    ⨆ (i) (j), f (s i j) ≤ f (⨆ (i) (j), s i j) 
goal: ⨆ i, ⨆ j, f (s i j) ≤ f (⨆ i, ⨆ j, s i j)

full_name: Antitone.le_map_iInf₂
code: theorem Antitone.le_map_iInf₂ [CompleteLattice β] {f : α → β} (hf : Antitone f) (s : ∀ i, κ i → α) :
    ⨆ (i) (j), f (s i j) ≤ f (⨅ (i) (j), s i j) 
goal: ⨆ i, ⨆ j, f (s i j) ≤ f (⨅ i, ⨅ j, s i j)

full_name: Monotone.le_map_sSup
code: theorem Monotone.le_map_sSup [CompleteLattice β] {s : Set α} {f : α → β} (hf : Monotone f) :
    ⨆ a ∈ s, f a ≤ f (sSup s) 
goal: ⨆ a ∈ s, f a ≤ f (sSup s)

full_name: Antitone.le_map_sInf
code: theorem Antitone.le_map_sInf [CompleteLattice β] {s : Set α} {f : α → β} (hf : Antitone f) :
    ⨆ a ∈ s, f a ≤ f (sInf s) 
goal: ⨆ a ∈ s, f a ≤ f (sInf s)

full_name: OrderIso.map_iSup
code: theorem OrderIso.map_iSup [CompleteLattice β] (f : α ≃o β) (x : ι → α) :
    f (⨆ i, x i) = ⨆ i, f (x i) 
goal: f (⨆ i, x i) = ⨆ i, f (x i)

full_name: OrderIso.map_iInf
code: theorem OrderIso.map_iInf [CompleteLattice β] (f : α ≃o β) (x : ι → α) :
    f (⨅ i, x i) = ⨅ i, f (x i) 
goal: f (⨅ i, x i) = ⨅ i, f (x i)

full_name: OrderIso.map_sSup
code: theorem OrderIso.map_sSup [CompleteLattice β] (f : α ≃o β) (s : Set α) :
    f (sSup s) = ⨆ a ∈ s, f a 
goal: f (sSup s) = ⨆ a ∈ s, f a

full_name: OrderIso.map_sInf
code: theorem OrderIso.map_sInf [CompleteLattice β] (f : α ≃o β) (s : Set α) :
    f (sInf s) = ⨅ a ∈ s, f a 
goal: f (sInf s) = ⨅ a ∈ s, f a

full_name: iSup_comp_le
code: theorem iSup_comp_le {ι' : Sort*} (f : ι' → α) (g : ι → ι') : ⨆ x, f (g x) ≤ ⨆ y, f y 
goal: ⨆ x, f (g x) ≤ ⨆ y, f y

full_name: le_iInf_comp
code: theorem le_iInf_comp {ι' : Sort*} (f : ι' → α) (g : ι → ι') : ⨅ y, f y ≤ ⨅ x, f (g x) 
goal: ⨅ y, f y ≤ ⨅ x, f (g x)

full_name: Monotone.iSup_comp_eq
code: theorem Monotone.iSup_comp_eq [Preorder β] {f : β → α} (hf : Monotone f) {s : ι → β}
    (hs : ∀ x, ∃ i, x ≤ s i) : ⨆ x, f (s x) = ⨆ y, f y 
goal: ⨆ x, f (s x) = ⨆ y, f y

full_name: Monotone.iInf_comp_eq
code: theorem Monotone.iInf_comp_eq [Preorder β] {f : β → α} (hf : Monotone f) {s : ι → β}
    (hs : ∀ x, ∃ i, s i ≤ x) : ⨅ x, f (s x) = ⨅ y, f y 
goal: ⨅ x, f (s x) = ⨅ y, f y

full_name: Antitone.map_iSup_le
code: theorem Antitone.map_iSup_le [CompleteLattice β] {f : α → β} (hf : Antitone f) :
    f (iSup s) ≤ ⨅ i, f (s i) 
goal: f (iSup s) ≤ ⨅ i, f (s i)

full_name: Monotone.map_iInf_le
code: theorem Monotone.map_iInf_le [CompleteLattice β] {f : α → β} (hf : Monotone f) :
    f (iInf s) ≤ ⨅ i, f (s i) 
goal: f (iInf s) ≤ ⨅ i, f (s i)

full_name: Antitone.map_iSup₂_le
code: theorem Antitone.map_iSup₂_le [CompleteLattice β] {f : α → β} (hf : Antitone f) (s : ∀ i, κ i → α) :
    f (⨆ (i) (j), s i j) ≤ ⨅ (i) (j), f (s i j) 
goal: f (⨆ i, ⨆ j, s i j) ≤ ⨅ i, ⨅ j, f (s i j)

full_name: Monotone.map_iInf₂_le
code: theorem Monotone.map_iInf₂_le [CompleteLattice β] {f : α → β} (hf : Monotone f) (s : ∀ i, κ i → α) :
    f (⨅ (i) (j), s i j) ≤ ⨅ (i) (j), f (s i j) 
goal: f (⨅ i, ⨅ j, s i j) ≤ ⨅ i, ⨅ j, f (s i j)

full_name: Antitone.map_sSup_le
code: theorem Antitone.map_sSup_le [CompleteLattice β] {s : Set α} {f : α → β} (hf : Antitone f) :
    f (sSup s) ≤ ⨅ a ∈ s, f a 
goal: f (sSup s) ≤ ⨅ a ∈ s, f a

full_name: Monotone.map_sInf_le
code: theorem Monotone.map_sInf_le [CompleteLattice β] {s : Set α} {f : α → β} (hf : Monotone f) :
    f (sInf s) ≤ ⨅ a ∈ s, f a 
goal: f (sInf s) ≤ ⨅ a ∈ s, f a

full_name: iSup_const_le
code: theorem iSup_const_le : ⨆ _ : ι, a ≤ a 
goal: ⨆ x, a ≤ a

full_name: le_iInf_const
code: theorem le_iInf_const : a ≤ ⨅ _ : ι, a 
goal: a ≤ ⨅ x, a

full_name: iSup_const
code: theorem iSup_const [Nonempty ι] : ⨆ _ : ι, a = a 
goal: ⨆ x, a = a

full_name: iInf_const
code: theorem iInf_const [Nonempty ι] : ⨅ _ : ι, a = a 
goal: ⨅ x, a = a

full_name: iSup_unique
code: lemma iSup_unique [Unique ι] (f : ι → α) : ⨆ i, f i = f default 
goal: ⨆ i, f i = f default

full_name: iInf_unique
code: lemma iInf_unique [Unique ι] (f : ι → α) : ⨅ i, f i = f default 
goal: ⨅ i, f i = f default

full_name: iSup_bot
code: @[simp]
theorem iSup_bot : (⨆ _ : ι, ⊥ : α) = ⊥ 
goal: ⨆ x, ⊥ = ⊥

full_name: iInf_top
code: @[simp]
theorem iInf_top : (⨅ _ : ι, ⊤ : α) = ⊤ 
goal: ⨅ x, ⊤ = ⊤

full_name: iSup_eq_bot
code: @[simp]
theorem iSup_eq_bot : iSup s = ⊥ ↔ ∀ i, s i = ⊥ 
goal: iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥

full_name: iInf_eq_top
code: @[simp]
theorem iInf_eq_top : iInf s = ⊤ ↔ ∀ i, s i = ⊤ 
goal: iInf s = ⊤ ↔ ∀ (i : ι), s i = ⊤

full_name: iSup₂_eq_bot
code: theorem iSup₂_eq_bot {f : ∀ i, κ i → α} : ⨆ (i) (j), f i j = ⊥ ↔ ∀ i j, f i j = ⊥ 
goal: ⨆ i, ⨆ j, f i j = ⊥ ↔ ∀ (i : ι) (j : κ i), f i j = ⊥

full_name: iInf₂_eq_top
code: theorem iInf₂_eq_top {f : ∀ i, κ i → α} : ⨅ (i) (j), f i j = ⊤ ↔ ∀ i j, f i j = ⊤ 
goal: ⨅ i, ⨅ j, f i j = ⊤ ↔ ∀ (i : ι) (j : κ i), f i j = ⊤

full_name: iSup_pos
code: @[simp]
theorem iSup_pos {p : Prop} {f : p → α} (hp : p) : ⨆ h : p, f h = f hp 
goal: ⨆ (h : p), f h = f hp

full_name: iInf_pos
code: @[simp]
theorem iInf_pos {p : Prop} {f : p → α} (hp : p) : ⨅ h : p, f h = f hp 
goal: ⨅ (h : p), f h = f hp

full_name: iSup_neg
code: @[simp]
theorem iSup_neg {p : Prop} {f : p → α} (hp : ¬p) : ⨆ h : p, f h = ⊥ 
goal: ⨆ (h : p), f h = ⊥

full_name: iInf_neg
code: @[simp]
theorem iInf_neg {p : Prop} {f : p → α} (hp : ¬p) : ⨅ h : p, f h = ⊤ 
goal: ⨅ (h : p), f h = ⊤

full_name: iSup_eq_of_forall_le_of_forall_lt_exists_gt
code: /-- Introduction rule to prove that `b` is the supremum of `f`: it suffices to check that `b`
is larger than `f i` for all `i`, and that this is not the case of any `w<b`.
See `ciSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in conditionally complete
lattices. -/
theorem iSup_eq_of_forall_le_of_forall_lt_exists_gt {f : ι → α} (h₁ : ∀ i, f i ≤ b)
    (h₂ : ∀ w, w < b → ∃ i, w < f i) : ⨆ i : ι, f i = b 
goal: ⨆ i, f i = b

full_name: iInf_eq_of_forall_ge_of_forall_gt_exists_lt
code: /-- Introduction rule to prove that `b` is the infimum of `f`: it suffices to check that `b`
is smaller than `f i` for all `i`, and that this is not the case of any `w>b`.
See `ciInf_eq_of_forall_ge_of_forall_gt_exists_lt` for a version in conditionally complete
lattices. -/
theorem iInf_eq_of_forall_ge_of_forall_gt_exists_lt :
    (∀ i, b ≤ f i) → (∀ w, b < w → ∃ i, f i < w) → ⨅ i, f i = b 
goal: (∀ (i : ι), b ≤ f i) → (∀ (w : α), b < w → ∃ i, f i < w) → ⨅ i, f i = b

full_name: iSup_eq_dif
code: theorem iSup_eq_dif {p : Prop} [Decidable p] (a : p → α) :
    ⨆ h : p, a h = if h : p then a h else ⊥ 
goal: ⨆ (h : p), a h = if h : p then a h else ⊥

full_name: iSup_eq_if
code: theorem iSup_eq_if {p : Prop} [Decidable p] (a : α) : ⨆ _ : p, a = if p then a else ⊥ 
goal: ⨆ (_ : p), a = if p then a else ⊥

full_name: iInf_eq_dif
code: theorem iInf_eq_dif {p : Prop} [Decidable p] (a : p → α) :
    ⨅ h : p, a h = if h : p then a h else ⊤ 
goal: ⨅ (h : p), a h = if h : p then a h else ⊤

full_name: iInf_eq_if
code: theorem iInf_eq_if {p : Prop} [Decidable p] (a : α) : ⨅ _ : p, a = if p then a else ⊤ 
goal: ⨅ (_ : p), a = if p then a else ⊤

full_name: iSup_comm
code: theorem iSup_comm {f : ι → ι' → α} : ⨆ (i) (j), f i j = ⨆ (j) (i), f i j 
goal: ⨆ i, ⨆ j, f i j = ⨆ j, ⨆ i, f i j

full_name: iInf_comm
code: theorem iInf_comm {f : ι → ι' → α} : ⨅ (i) (j), f i j = ⨅ (j) (i), f i j 
goal: ⨅ i, ⨅ j, f i j = ⨅ j, ⨅ i, f i j

full_name: iSup₂_comm
code: theorem iSup₂_comm {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*}
    (f : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → α) :
    ⨆ (i₁) (j₁) (i₂) (j₂), f i₁ j₁ i₂ j₂ = ⨆ (i₂) (j₂) (i₁) (j₁), f i₁ j₁ i₂ j₂ 
goal: ⨆ i₁, ⨆ j₁, ⨆ i₂, ⨆ j₂, f i₁ j₁ i₂ j₂ = ⨆ i₂, ⨆ j₂, ⨆ i₁, ⨆ j₁, f i₁ j₁ i₂ j₂

full_name: iInf₂_comm
code: theorem iInf₂_comm {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*}
    (f : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → α) :
    ⨅ (i₁) (j₁) (i₂) (j₂), f i₁ j₁ i₂ j₂ = ⨅ (i₂) (j₂) (i₁) (j₁), f i₁ j₁ i₂ j₂ 
goal: ⨅ i₁, ⨅ j₁, ⨅ i₂, ⨅ j₂, f i₁ j₁ i₂ j₂ = ⨅ i₂, ⨅ j₂, ⨅ i₁, ⨅ j₁, f i₁ j₁ i₂ j₂

full_name: iSup_iSup_eq_left
code: @[simp]
theorem iSup_iSup_eq_left {b : β} {f : ∀ x : β, x = b → α} : ⨆ x, ⨆ h : x = b, f x h = f b rfl 
goal: ⨆ x, ⨆ (h : x = b), f x h = f b ⋯

full_name: iInf_iInf_eq_left
code: @[simp]
theorem iInf_iInf_eq_left {b : β} {f : ∀ x : β, x = b → α} : ⨅ x, ⨅ h : x = b, f x h = f b rfl 
goal: ⨅ x, ⨅ (h : x = b), f x h = f b ⋯

full_name: iSup_iSup_eq_right
code: @[simp]
theorem iSup_iSup_eq_right {b : β} {f : ∀ x : β, b = x → α} : ⨆ x, ⨆ h : b = x, f x h = f b rfl 
goal: ⨆ x, ⨆ (h : b = x), f x h = f b ⋯

full_name: iInf_iInf_eq_right
code: @[simp]
theorem iInf_iInf_eq_right {b : β} {f : ∀ x : β, b = x → α} : ⨅ x, ⨅ h : b = x, f x h = f b rfl 
goal: ⨅ x, ⨅ (h : b = x), f x h = f b ⋯

full_name: iSup_subtype
code: theorem iSup_subtype {p : ι → Prop} {f : Subtype p → α} : iSup f = ⨆ (i) (h : p i), f ⟨i, h⟩ 
goal: iSup f = ⨆ i, ⨆ (h : p i), f ⟨i, h⟩

full_name: iInf_subtype
code: theorem iInf_subtype : ∀ {p : ι → Prop} {f : Subtype p → α}, iInf f = ⨅ (i) (h : p i), f ⟨i, h⟩ 
goal: iInf f = ⨅ i, ⨅ (h : p i), f ⟨i, h⟩

full_name: iSup_subtype'
code: theorem iSup_subtype' {p : ι → Prop} {f : ∀ i, p i → α} :
    ⨆ (i) (h), f i h = ⨆ x : Subtype p, f x x.property 
goal: ⨆ i, ⨆ (h : p i), f i h = ⨆ x, f ↑x ⋯

full_name: iInf_subtype'
code: theorem iInf_subtype' {p : ι → Prop} {f : ∀ i, p i → α} :
    ⨅ (i) (h : p i), f i h = ⨅ x : Subtype p, f x x.property 
goal: ⨅ i, ⨅ (h : p i), f i h = ⨅ x, f ↑x ⋯

full_name: iSup_subtype''
code: theorem iSup_subtype'' {ι} (s : Set ι) (f : ι → α) : ⨆ i : s, f i = ⨆ (t : ι) (_ : t ∈ s), f t 
goal: ⨆ i, f ↑i = ⨆ t ∈ s, f t

full_name: iInf_subtype''
code: theorem iInf_subtype'' {ι} (s : Set ι) (f : ι → α) : ⨅ i : s, f i = ⨅ (t : ι) (_ : t ∈ s), f t 
goal: ⨅ i, f ↑i = ⨅ t ∈ s, f t

full_name: biSup_const
code: theorem biSup_const {ι : Sort _} {a : α} {s : Set ι} (hs : s.Nonempty) : ⨆ i ∈ s, a = a 
goal: ⨆ i ∈ s, a = a

full_name: biInf_const
code: theorem biInf_const {ι : Sort _} {a : α} {s : Set ι} (hs : s.Nonempty) : ⨅ i ∈ s, a = a 
goal: ⨅ i ∈ s, a = a

full_name: iSup_sup_eq
code: theorem iSup_sup_eq : ⨆ x, f x ⊔ g x = (⨆ x, f x) ⊔ ⨆ x, g x 
goal: ⨆ x, f x ⊔ g x = (⨆ x, f x) ⊔ ⨆ x, g x

full_name: iInf_inf_eq
code: theorem iInf_inf_eq : ⨅ x, f x ⊓ g x = (⨅ x, f x) ⊓ ⨅ x, g x 
goal: ⨅ x, f x ⊓ g x = (⨅ x, f x) ⊓ ⨅ x, g x

full_name: Equiv.biSup_comp
code: lemma Equiv.biSup_comp {ι ι' : Type*} {g : ι' → α} (e : ι ≃ ι') (s : Set ι') :
    ⨆ i ∈ e.symm '' s, g (e i) = ⨆ i ∈ s, g i 
goal: ⨆ i ∈ ⇑e.symm '' s, g (e i) = ⨆ i ∈ s, g i

full_name: Equiv.biInf_comp
code: lemma Equiv.biInf_comp {ι ι' : Type*} {g : ι' → α} (e : ι ≃ ι') (s : Set ι') :
    ⨅ i ∈ e.symm '' s, g (e i) = ⨅ i ∈ s, g i 
goal: ⨅ i ∈ ⇑e.symm '' s, g (e i) = ⨅ i ∈ s, g i

full_name: biInf_le
code: lemma biInf_le {ι : Type*} {s : Set ι} (f : ι → α) {i : ι} (hi : i ∈ s) :
    ⨅ i ∈ s, f i ≤ f i 
goal: ⨅ i ∈ s, f i ≤ f i

full_name: le_biSup
code: lemma le_biSup {ι : Type*} {s : Set ι} (f : ι → α) {i : ι} (hi : i ∈ s) :
    f i ≤ ⨆ i ∈ s, f i 
goal: f i ≤ ⨆ i ∈ s, f i

full_name: iSup_sup
code: theorem iSup_sup [Nonempty ι] {f : ι → α} {a : α} : (⨆ x, f x) ⊔ a = ⨆ x, f x ⊔ a 
goal: (⨆ x, f x) ⊔ a = ⨆ x, f x ⊔ a

full_name: iInf_inf
code: theorem iInf_inf [Nonempty ι] {f : ι → α} {a : α} : (⨅ x, f x) ⊓ a = ⨅ x, f x ⊓ a 
goal: (⨅ x, f x) ⊓ a = ⨅ x, f x ⊓ a

full_name: sup_iSup
code: theorem sup_iSup [Nonempty ι] {f : ι → α} {a : α} : (a ⊔ ⨆ x, f x) = ⨆ x, a ⊔ f x 
goal: a ⊔ ⨆ x, f x = ⨆ x, a ⊔ f x

full_name: inf_iInf
code: theorem inf_iInf [Nonempty ι] {f : ι → α} {a : α} : (a ⊓ ⨅ x, f x) = ⨅ x, a ⊓ f x 
goal: a ⊓ ⨅ x, f x = ⨅ x, a ⊓ f x

full_name: biSup_sup
code: theorem biSup_sup {p : ι → Prop} {f : ∀ i, p i → α} {a : α} (h : ∃ i, p i) :
    (⨆ (i) (h : p i), f i h) ⊔ a = ⨆ (i) (h : p i), f i h ⊔ a 
goal: (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a

full_name: sup_biSup
code: theorem sup_biSup {p : ι → Prop} {f : ∀ i, p i → α} {a : α} (h : ∃ i, p i) :
    (a ⊔ ⨆ (i) (h : p i), f i h) = ⨆ (i) (h : p i), a ⊔ f i h 
goal: a ⊔ ⨆ i, ⨆ (h : p i), f i h = ⨆ i, ⨆ (h : p i), a ⊔ f i h

full_name: biInf_inf
code: theorem biInf_inf {p : ι → Prop} {f : ∀ i, p i → α} {a : α} (h : ∃ i, p i) :
    (⨅ (i) (h : p i), f i h) ⊓ a = ⨅ (i) (h : p i), f i h ⊓ a 
goal: (⨅ i, ⨅ (h : p i), f i h) ⊓ a = ⨅ i, ⨅ (h : p i), f i h ⊓ a

full_name: inf_biInf
code: theorem inf_biInf {p : ι → Prop} {f : ∀ i, p i → α} {a : α} (h : ∃ i, p i) :
    (a ⊓ ⨅ (i) (h : p i), f i h) = ⨅ (i) (h : p i), a ⊓ f i h 
goal: a ⊓ ⨅ i, ⨅ (h : p i), f i h = ⨅ i, ⨅ (h : p i), a ⊓ f i h

full_name: iSup_false
code: theorem iSup_false {s : False → α} : iSup s = ⊥ 
goal: iSup s = ⊥

full_name: iInf_false
code: theorem iInf_false {s : False → α} : iInf s = ⊤ 
goal: iInf s = ⊤

full_name: iSup_true
code: theorem iSup_true {s : True → α} : iSup s = s trivial 
goal: iSup s = s trivial

full_name: iInf_true
code: theorem iInf_true {s : True → α} : iInf s = s trivial 
goal: iInf s = s trivial

full_name: iSup_exists
code: @[simp]
theorem iSup_exists {p : ι → Prop} {f : Exists p → α} : ⨆ x, f x = ⨆ (i) (h), f ⟨i, h⟩ 
goal: ⨆ (x : Exists p), f x = ⨆ i, ⨆ (h : p i), f ⋯

full_name: iInf_exists
code: @[simp]
theorem iInf_exists {p : ι → Prop} {f : Exists p → α} : ⨅ x, f x = ⨅ (i) (h), f ⟨i, h⟩ 
goal: ⨅ (x : Exists p), f x = ⨅ i, ⨅ (h : p i), f ⋯

full_name: iSup_and
code: theorem iSup_and {p q : Prop} {s : p ∧ q → α} : iSup s = ⨆ (h₁) (h₂), s ⟨h₁, h₂⟩ 
goal: iSup s = ⨆ (h₁ : p), ⨆ (h₂ : q), s ⋯

full_name: iInf_and
code: theorem iInf_and {p q : Prop} {s : p ∧ q → α} : iInf s = ⨅ (h₁) (h₂), s ⟨h₁, h₂⟩ 
goal: iInf s = ⨅ (h₁ : p), ⨅ (h₂ : q), s ⋯

full_name: iSup_and'
code: /-- The symmetric case of `iSup_and`, useful for rewriting into a supremum over a conjunction -/
theorem iSup_and' {p q : Prop} {s : p → q → α} :
    ⨆ (h₁ : p) (h₂ : q), s h₁ h₂ = ⨆ h : p ∧ q, s h.1 h.2 
goal: ⨆ (h₁ : p), ⨆ (h₂ : q), s h₁ h₂ = ⨆ (h : p ∧ q), s ⋯ ⋯

full_name: iInf_and'
code: /-- The symmetric case of `iInf_and`, useful for rewriting into an infimum over a conjunction -/
theorem iInf_and' {p q : Prop} {s : p → q → α} :
    ⨅ (h₁ : p) (h₂ : q), s h₁ h₂ = ⨅ h : p ∧ q, s h.1 h.2 
goal: ⨅ (h₁ : p), ⨅ (h₂ : q), s h₁ h₂ = ⨅ (h : p ∧ q), s ⋯ ⋯

full_name: iSup_or
code: theorem iSup_or {p q : Prop} {s : p ∨ q → α} :
    ⨆ x, s x = (⨆ i, s (Or.inl i)) ⊔ ⨆ j, s (Or.inr j) 
goal: ⨆ (x : p ∨ q), s x = (⨆ (i : p), s ⋯) ⊔ ⨆ (j : q), s ⋯

full_name: iInf_or
code: theorem iInf_or {p q : Prop} {s : p ∨ q → α} :
    ⨅ x, s x = (⨅ i, s (Or.inl i)) ⊓ ⨅ j, s (Or.inr j) 
goal: ⨅ (x : p ∨ q), s x = (⨅ (i : p), s ⋯) ⊓ ⨅ (j : q), s ⋯

full_name: iSup_dite
code: theorem iSup_dite (f : ∀ i, p i → α) (g : ∀ i, ¬p i → α) :
    ⨆ i, (if h : p i then f i h else g i h) = (⨆ (i) (h : p i), f i h) ⊔ ⨆ (i) (h : ¬p i),
    g i h 
goal: (⨆ i, if h : p i then f i h else g i h) = (⨆ i, ⨆ (h : p i), f i h) ⊔ ⨆ i, ⨆ (h : ¬p i), g i h

full_name: iInf_dite
code: theorem iInf_dite (f : ∀ i, p i → α) (g : ∀ i, ¬p i → α) :
    ⨅ i, (if h : p i then f i h else g i h) = (⨅ (i) (h : p i), f i h) ⊓ ⨅ (i) (h : ¬p i), g i h 
goal: (⨅ i, if h : p i then f i h else g i h) = (⨅ i, ⨅ (h : p i), f i h) ⊓ ⨅ i, ⨅ (h : ¬p i), g i h

full_name: iSup_ite
code: theorem iSup_ite (f g : ι → α) :
    ⨆ i, (if p i then f i else g i) = (⨆ (i) (_ : p i), f i) ⊔ ⨆ (i) (_ : ¬p i), g i 
goal: (⨆ i, if p i then f i else g i) = (⨆ i, ⨆ (_ : p i), f i) ⊔ ⨆ i, ⨆ (_ : ¬p i), g i

full_name: iInf_ite
code: theorem iInf_ite (f g : ι → α) :
    ⨅ i, (if p i then f i else g i) = (⨅ (i) (_ : p i), f i) ⊓ ⨅ (i) (_ : ¬p i), g i 
goal: (⨅ i, if p i then f i else g i) = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), g i

full_name: iSup_range
code: theorem iSup_range {g : β → α} {f : ι → β} : ⨆ b ∈ range f, g b = ⨆ i, g (f i) 
goal: ⨆ b ∈ Set.range f, g b = ⨆ i, g (f i)

full_name: iInf_range
code: theorem iInf_range : ∀ {g : β → α} {f : ι → β}, ⨅ b ∈ range f, g b = ⨅ i, g (f i) 
goal: ⨅ b ∈ Set.range f, g b = ⨅ i, g (f i)

full_name: sSup_image
code: theorem sSup_image {s : Set β} {f : β → α} : sSup (f '' s) = ⨆ a ∈ s, f a 
goal: sSup (f '' s) = ⨆ a ∈ s, f a

full_name: sInf_image
code: theorem sInf_image {s : Set β} {f : β → α} : sInf (f '' s) = ⨅ a ∈ s, f a 
goal: sInf (f '' s) = ⨅ a ∈ s, f a

full_name: OrderIso.map_sSup_eq_sSup_symm_preimage
code: theorem OrderIso.map_sSup_eq_sSup_symm_preimage [CompleteLattice β] (f : α ≃o β) (s : Set α) :
    f (sSup s) = sSup (f.symm ⁻¹' s) 
goal: f (sSup s) = sSup (⇑f.symm ⁻¹' s)

full_name: OrderIso.map_sInf_eq_sInf_symm_preimage
code: theorem OrderIso.map_sInf_eq_sInf_symm_preimage [CompleteLattice β] (f : α ≃o β) (s : Set α) :
    f (sInf s) = sInf (f.symm ⁻¹' s) 
goal: f (sInf s) = sInf (⇑f.symm ⁻¹' s)

full_name: iSup_emptyset
code: theorem iSup_emptyset {f : β → α} : ⨆ x ∈ (∅ : Set β), f x = ⊥ 
goal: ⨆ x ∈ ∅, f x = ⊥

full_name: iInf_emptyset
code: theorem iInf_emptyset {f : β → α} : ⨅ x ∈ (∅ : Set β), f x = ⊤ 
goal: ⨅ x ∈ ∅, f x = ⊤

full_name: iSup_univ
code: theorem iSup_univ {f : β → α} : ⨆ x ∈ (univ : Set β), f x = ⨆ x, f x 
goal: ⨆ x ∈ Set.univ, f x = ⨆ x, f x

full_name: iInf_univ
code: theorem iInf_univ {f : β → α} : ⨅ x ∈ (univ : Set β), f x = ⨅ x, f x 
goal: ⨅ x ∈ Set.univ, f x = ⨅ x, f x

full_name: iSup_union
code: theorem iSup_union {f : β → α} {s t : Set β} :
    ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x 
goal: ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x

full_name: iInf_union
code: theorem iInf_union {f : β → α} {s t : Set β} : ⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x 
goal: ⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x

full_name: iSup_split
code: theorem iSup_split (f : β → α) (p : β → Prop) :
    ⨆ i, f i = (⨆ (i) (_ : p i), f i) ⊔ ⨆ (i) (_ : ¬p i), f i 
goal: ⨆ i, f i = (⨆ i, ⨆ (_ : p i), f i) ⊔ ⨆ i, ⨆ (_ : ¬p i), f i

full_name: iInf_split
code: theorem iInf_split :
    ∀ (f : β → α) (p : β → Prop), ⨅ i, f i = (⨅ (i) (_ : p i), f i) ⊓ ⨅ (i) (_ : ¬p i), f i 
goal: ⨅ i, f i = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), f i

full_name: iSup_split_single
code: theorem iSup_split_single (f : β → α) (i₀ : β) : ⨆ i, f i = f i₀ ⊔ ⨆ (i) (_ : i ≠ i₀), f i 
goal: ⨆ i, f i = f i₀ ⊔ ⨆ i, ⨆ (_ : i ≠ i₀), f i

full_name: iInf_split_single
code: theorem iInf_split_single (f : β → α) (i₀ : β) : ⨅ i, f i = f i₀ ⊓ ⨅ (i) (_ : i ≠ i₀), f i 
goal: ⨅ i, f i = f i₀ ⊓ ⨅ i, ⨅ (_ : i ≠ i₀), f i

full_name: iSup_le_iSup_of_subset
code: theorem iSup_le_iSup_of_subset {f : β → α} {s t : Set β} : s ⊆ t → ⨆ x ∈ s, f x ≤ ⨆ x ∈ t, f x 
goal: s ⊆ t → ⨆ x ∈ s, f x ≤ ⨆ x ∈ t, f x

full_name: iInf_le_iInf_of_subset
code: theorem iInf_le_iInf_of_subset {f : β → α} {s t : Set β} : s ⊆ t → ⨅ x ∈ t, f x ≤ ⨅ x ∈ s, f x 
goal: s ⊆ t → ⨅ x ∈ t, f x ≤ ⨅ x ∈ s, f x

full_name: iSup_insert
code: theorem iSup_insert {f : β → α} {s : Set β} {b : β} :
    ⨆ x ∈ insert b s, f x = f b ⊔ ⨆ x ∈ s, f x 
goal: ⨆ x ∈ insert b s, f x = f b ⊔ ⨆ x ∈ s, f x

full_name: iInf_insert
code: theorem iInf_insert {f : β → α} {s : Set β} {b : β} :
    ⨅ x ∈ insert b s, f x = f b ⊓ ⨅ x ∈ s, f x 
goal: ⨅ x ∈ insert b s, f x = f b ⊓ ⨅ x ∈ s, f x

full_name: iSup_singleton
code: theorem iSup_singleton {f : β → α} {b : β} : ⨆ x ∈ (singleton b : Set β), f x = f b 
goal: ⨆ x ∈ {b}, f x = f b

full_name: iInf_singleton
code: theorem iInf_singleton {f : β → α} {b : β} : ⨅ x ∈ (singleton b : Set β), f x = f b 
goal: ⨅ x ∈ {b}, f x = f b

full_name: iSup_pair
code: theorem iSup_pair {f : β → α} {a b : β} : ⨆ x ∈ ({a, b} : Set β), f x = f a ⊔ f b 
goal: ⨆ x ∈ {a, b}, f x = f a ⊔ f b

full_name: iInf_pair
code: theorem iInf_pair {f : β → α} {a b : β} : ⨅ x ∈ ({a, b} : Set β), f x = f a ⊓ f b 
goal: ⨅ x ∈ {a, b}, f x = f a ⊓ f b

full_name: iSup_image
code: theorem iSup_image {γ} {f : β → γ} {g : γ → α} {t : Set β} :
    ⨆ c ∈ f '' t, g c = ⨆ b ∈ t, g (f b) 
goal: ⨆ c ∈ f '' t, g c = ⨆ b ∈ t, g (f b)

full_name: iInf_image
code: theorem iInf_image :
    ∀ {γ} {f : β → γ} {g : γ → α} {t : Set β}, ⨅ c ∈ f '' t, g c = ⨅ b ∈ t, g (f b) 
goal: ⨅ c ∈ f '' t, g c = ⨅ b ∈ t, g (f b)

full_name: iSup_extend_bot
code: theorem iSup_extend_bot {e : ι → β} (he : Injective e) (f : ι → α) :
    ⨆ j, extend e f ⊥ j = ⨆ i, f i 
goal: ⨆ j, Function.extend e f ⊥ j = ⨆ i, f i

full_name: iInf_extend_top
code: theorem iInf_extend_top {e : ι → β} (he : Injective e) (f : ι → α) :
    ⨅ j, extend e f ⊤ j = iInf f 
goal: ⨅ j, Function.extend e f ⊤ j = iInf f

full_name: iSup_of_empty'
code: theorem iSup_of_empty' {α ι} [SupSet α] [IsEmpty ι] (f : ι → α) : iSup f = sSup (∅ : Set α) 
goal: iSup f = sSup ∅

full_name: iInf_of_isEmpty
code: theorem iInf_of_isEmpty {α ι} [InfSet α] [IsEmpty ι] (f : ι → α) : iInf f = sInf (∅ : Set α) 
goal: iInf f = sInf ∅

full_name: iSup_of_empty
code: theorem iSup_of_empty [IsEmpty ι] (f : ι → α) : iSup f = ⊥ 
goal: iSup f = ⊥

full_name: iInf_of_empty
code: theorem iInf_of_empty [IsEmpty ι] (f : ι → α) : iInf f = ⊤ 
goal: iInf f = ⊤

full_name: iSup_bool_eq
code: theorem iSup_bool_eq {f : Bool → α} : ⨆ b : Bool, f b = f true ⊔ f false 
goal: ⨆ b, f b = f true ⊔ f false

full_name: iInf_bool_eq
code: theorem iInf_bool_eq {f : Bool → α} : ⨅ b : Bool, f b = f true ⊓ f false 
goal: ⨅ b, f b = f true ⊓ f false

full_name: sup_eq_iSup
code: theorem sup_eq_iSup (x y : α) : x ⊔ y = ⨆ b : Bool, cond b x y 
goal: x ⊔ y = ⨆ b, bif b then x else y

full_name: inf_eq_iInf
code: theorem inf_eq_iInf (x y : α) : x ⊓ y = ⨅ b : Bool, cond b x y 
goal: x ⊓ y = ⨅ b, bif b then x else y

full_name: isGLB_biInf
code: theorem isGLB_biInf {s : Set β} {f : β → α} : IsGLB (f '' s) (⨅ x ∈ s, f x) 
goal: IsGLB (f '' s) (⨅ x ∈ s, f x)

full_name: isLUB_biSup
code: theorem isLUB_biSup {s : Set β} {f : β → α} : IsLUB (f '' s) (⨆ x ∈ s, f x) 
goal: IsLUB (f '' s) (⨆ x ∈ s, f x)

full_name: iSup_sigma
code: theorem iSup_sigma {p : β → Type*} {f : Sigma p → α} : ⨆ x, f x = ⨆ (i) (j), f ⟨i, j⟩ 
goal: ⨆ x, f x = ⨆ i, ⨆ j, f ⟨i, j⟩

full_name: iInf_sigma
code: theorem iInf_sigma {p : β → Type*} {f : Sigma p → α} : ⨅ x, f x = ⨅ (i) (j), f ⟨i, j⟩ 
goal: ⨅ x, f x = ⨅ i, ⨅ j, f ⟨i, j⟩

full_name: iSup_sigma'
code: lemma iSup_sigma' {κ : β → Type*} (f : ∀ i, κ i → α) :
    (⨆ i, ⨆ j, f i j) = ⨆ x : Σ i, κ i, f x.1 x.2 
goal: ⨆ i, ⨆ j, f i j = ⨆ x, f x.fst x.snd

full_name: iInf_sigma'
code: lemma iInf_sigma' {κ : β → Type*} (f : ∀ i, κ i → α) :
    (⨅ i, ⨅ j, f i j) = ⨅ x : Σ i, κ i, f x.1 x.2 
goal: ⨅ i, ⨅ j, f i j = ⨅ x, f x.fst x.snd

full_name: iSup_prod
code: theorem iSup_prod {f : β × γ → α} : ⨆ x, f x = ⨆ (i) (j), f (i, j) 
goal: ⨆ x, f x = ⨆ i, ⨆ j, f (i, j)

full_name: iInf_prod
code: theorem iInf_prod {f : β × γ → α} : ⨅ x, f x = ⨅ (i) (j), f (i, j) 
goal: ⨅ x, f x = ⨅ i, ⨅ j, f (i, j)

full_name: iSup_prod'
code: lemma iSup_prod' (f : β → γ → α) : (⨆ i, ⨆ j, f i j) = ⨆ x : β × γ, f x.1 x.2 
goal: ⨆ i, ⨆ j, f i j = ⨆ x, f x.1 x.2

full_name: iInf_prod'
code: lemma iInf_prod' (f : β → γ → α) : (⨅ i, ⨅ j, f i j) = ⨅ x : β × γ, f x.1 x.2 
goal: ⨅ i, ⨅ j, f i j = ⨅ x, f x.1 x.2

full_name: biSup_prod
code: theorem biSup_prod {f : β × γ → α} {s : Set β} {t : Set γ} :
    ⨆ x ∈ s ×ˢ t, f x = ⨆ (a ∈ s) (b ∈ t), f (a, b) 
goal: ⨆ x ∈ s ×ˢ t, f x = ⨆ a ∈ s, ⨆ b ∈ t, f (a, b)

full_name: biInf_prod
code: theorem biInf_prod {f : β × γ → α} {s : Set β} {t : Set γ} :
    ⨅ x ∈ s ×ˢ t, f x = ⨅ (a ∈ s) (b ∈ t), f (a, b) 
goal: ⨅ x ∈ s ×ˢ t, f x = ⨅ a ∈ s, ⨅ b ∈ t, f (a, b)

full_name: iSup_sum
code: theorem iSup_sum {f : β ⊕ γ → α} : ⨆ x, f x = (⨆ i, f (Sum.inl i)) ⊔ ⨆ j, f (Sum.inr j) 
goal: ⨆ x, f x = (⨆ i, f (Sum.inl i)) ⊔ ⨆ j, f (Sum.inr j)

full_name: iInf_sum
code: theorem iInf_sum {f : β ⊕ γ → α} : ⨅ x, f x = (⨅ i, f (Sum.inl i)) ⊓ ⨅ j, f (Sum.inr j) 
goal: ⨅ x, f x = (⨅ i, f (Sum.inl i)) ⊓ ⨅ j, f (Sum.inr j)

full_name: iSup_option
code: theorem iSup_option (f : Option β → α) : ⨆ o, f o = f none ⊔ ⨆ b, f (Option.some b) 
goal: ⨆ o, f o = f none ⊔ ⨆ b, f (some b)

full_name: iInf_option
code: theorem iInf_option (f : Option β → α) : ⨅ o, f o = f none ⊓ ⨅ b, f (Option.some b) 
goal: ⨅ o, f o = f none ⊓ ⨅ b, f (some b)

full_name: iSup_option_elim
code: /-- A version of `iSup_option` useful for rewriting right-to-left. -/
theorem iSup_option_elim (a : α) (f : β → α) : ⨆ o : Option β, o.elim a f = a ⊔ ⨆ b, f b 
goal: ⨆ o, o.elim a f = a ⊔ ⨆ b, f b

full_name: iInf_option_elim
code: /-- A version of `iInf_option` useful for rewriting right-to-left. -/
theorem iInf_option_elim (a : α) (f : β → α) : ⨅ o : Option β, o.elim a f = a ⊓ ⨅ b, f b 
goal: ⨅ o, o.elim a f = a ⊓ ⨅ b, f b

full_name: iSup_ne_bot_subtype
code: /-- When taking the supremum of `f : ι → α`, the elements of `ι` on which `f` gives `⊥` can be
dropped, without changing the result. -/
@[simp]
theorem iSup_ne_bot_subtype (f : ι → α) : ⨆ i : { i // f i ≠ ⊥ }, f i = ⨆ i, f i 
goal: ⨆ i, f ↑i = ⨆ i, f i

full_name: iInf_ne_top_subtype
code: /-- When taking the infimum of `f : ι → α`, the elements of `ι` on which `f` gives `⊤` can be
dropped, without changing the result. -/
theorem iInf_ne_top_subtype (f : ι → α) : ⨅ i : { i // f i ≠ ⊤ }, f i = ⨅ i, f i 
goal: ⨅ i, f ↑i = ⨅ i, f i

full_name: sSup_image2
code: theorem sSup_image2 {f : β → γ → α} {s : Set β} {t : Set γ} :
    sSup (image2 f s t) = ⨆ (a ∈ s) (b ∈ t), f a b 
goal: sSup (Set.image2 f s t) = ⨆ a ∈ s, ⨆ b ∈ t, f a b

full_name: sInf_image2
code: theorem sInf_image2 {f : β → γ → α} {s : Set β} {t : Set γ} :
    sInf (image2 f s t) = ⨅ (a ∈ s) (b ∈ t), f a b 
goal: sInf (Set.image2 f s t) = ⨅ a ∈ s, ⨅ b ∈ t, f a b

full_name: iSup_ge_eq_iSup_nat_add
code: theorem iSup_ge_eq_iSup_nat_add (u : ℕ → α) (n : ℕ) : ⨆ i ≥ n, u i = ⨆ i, u (i + n) 
goal: ⨆ i, ⨆ (_ : i ≥ n), u i = ⨆ i, u (i + n)

full_name: iInf_ge_eq_iInf_nat_add
code: theorem iInf_ge_eq_iInf_nat_add (u : ℕ → α) (n : ℕ) : ⨅ i ≥ n, u i = ⨅ i, u (i + n) 
goal: ⨅ i, ⨅ (_ : i ≥ n), u i = ⨅ i, u (i + n)

full_name: Monotone.iSup_nat_add
code: theorem Monotone.iSup_nat_add {f : ℕ → α} (hf : Monotone f) (k : ℕ) : ⨆ n, f (n + k) = ⨆ n, f n 
goal: ⨆ n, f (n + k) = ⨆ n, f n

full_name: Antitone.iInf_nat_add
code: theorem Antitone.iInf_nat_add {f : ℕ → α} (hf : Antitone f) (k : ℕ) : ⨅ n, f (n + k) = ⨅ n, f n 
goal: ⨅ n, f (n + k) = ⨅ n, f n

full_name: iSup_iInf_ge_nat_add
code: theorem iSup_iInf_ge_nat_add (f : ℕ → α) (k : ℕ) :
    ⨆ n, ⨅ i ≥ n, f (i + k) = ⨆ n, ⨅ i ≥ n, f i 
goal: ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i

full_name: iInf_iSup_ge_nat_add
code: theorem iInf_iSup_ge_nat_add :
    ∀ (f : ℕ → α) (k : ℕ), ⨅ n, ⨆ i ≥ n, f (i + k) = ⨅ n, ⨆ i ≥ n, f i 
goal: ⨅ n, ⨆ i, ⨆ (_ : i ≥ n), f (i + k) = ⨅ n, ⨆ i, ⨆ (_ : i ≥ n), f i

full_name: sup_iSup_nat_succ
code: theorem sup_iSup_nat_succ (u : ℕ → α) : (u 0 ⊔ ⨆ i, u (i + 1)) = ⨆ i, u i 
goal: u 0 ⊔ ⨆ i, u (i + 1) = ⨆ i, u i

full_name: inf_iInf_nat_succ
code: theorem inf_iInf_nat_succ (u : ℕ → α) : (u 0 ⊓ ⨅ i, u (i + 1)) = ⨅ i, u i 
goal: u 0 ⊓ ⨅ i, u (i + 1) = ⨅ i, u i

full_name: iInf_nat_gt_zero_eq
code: theorem iInf_nat_gt_zero_eq (f : ℕ → α) : ⨅ i > 0, f i = ⨅ i, f (i + 1) 
goal: ⨅ i, ⨅ (_ : i > 0), f i = ⨅ i, f (i + 1)

full_name: iSup_nat_gt_zero_eq
code: theorem iSup_nat_gt_zero_eq (f : ℕ → α) : ⨆ i > 0, f i = ⨆ i, f (i + 1) 
goal: ⨆ i, ⨆ (_ : i > 0), f i = ⨆ i, f (i + 1)

full_name: iSup_eq_top
code: theorem iSup_eq_top (f : ι → α) : iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i 
goal: iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i

full_name: iInf_eq_bot
code: theorem iInf_eq_bot (f : ι → α) : iInf f = ⊥ ↔ ∀ b > ⊥, ∃ i, f i < b 
goal: iInf f = ⊥ ↔ ∀ b > ⊥, ∃ i, f i < b

full_name: Prop.instCompleteLattice
code: instance Prop.instCompleteLattice : CompleteLattice Prop 
goal: CompleteLattice Prop

full_name: Prop.instCompleteLinearOrder
code: noncomputable instance Prop.instCompleteLinearOrder : CompleteLinearOrder Prop 
goal: CompleteLinearOrder Prop

full_name: sSup_Prop_eq
code: @[simp]
theorem sSup_Prop_eq {s : Set Prop} : sSup s = ∃ p ∈ s, p 
goal: sSup s = ∃ p ∈ s, p

full_name: sInf_Prop_eq
code: @[simp]
theorem sInf_Prop_eq {s : Set Prop} : sInf s = ∀ p ∈ s, p 
goal: sInf s = ∀ p ∈ s, p

full_name: iSup_Prop_eq
code: @[simp]
theorem iSup_Prop_eq {p : ι → Prop} : ⨆ i, p i = ∃ i, p i 
goal: ⨆ i, p i = ∃ i, p i

full_name: iInf_Prop_eq
code: @[simp]
theorem iInf_Prop_eq {p : ι → Prop} : ⨅ i, p i = ∀ i, p i 
goal: ⨅ i, p i = ∀ (i : ι), p i

full_name: Pi.supSet
code: instance Pi.supSet {α : Type*} {β : α → Type*} [∀ i, SupSet (β i)] : SupSet (∀ i, β i) 
goal: SupSet ((i : α) → β i)

full_name: Pi.infSet
code: instance Pi.infSet {α : Type*} {β : α → Type*} [∀ i, InfSet (β i)] : InfSet (∀ i, β i) 
goal: InfSet ((i : α) → β i)

full_name: Pi.instCompleteLattice
code: instance Pi.instCompleteLattice {α : Type*} {β : α → Type*} [∀ i, CompleteLattice (β i)] :
    CompleteLattice (∀ i, β i) 
goal: CompleteLattice ((i : α) → β i)

full_name: sSup_apply
code: @[simp]
theorem sSup_apply {α : Type*} {β : α → Type*} [∀ i, SupSet (β i)] {s : Set (∀ a, β a)} {a : α} :
    (sSup s) a = ⨆ f : s, (f : ∀ a, β a) a 
goal: sSup s a = ⨆ f, ↑f a

full_name: sInf_apply
code: @[simp]
theorem sInf_apply {α : Type*} {β : α → Type*} [∀ i, InfSet (β i)] {s : Set (∀ a, β a)} {a : α} :
    sInf s a = ⨅ f : s, (f : ∀ a, β a) a 
goal: sInf s a = ⨅ f, ↑f a

full_name: iSup_apply
code: @[simp]
theorem iSup_apply {α : Type*} {β : α → Type*} {ι : Sort*} [∀ i, SupSet (β i)] {f : ι → ∀ a, β a}
    {a : α} : (⨆ i, f i) a = ⨆ i, f i a 
goal: (⨆ i, f i) a = ⨆ i, f i a

full_name: iInf_apply
code: @[simp]
theorem iInf_apply {α : Type*} {β : α → Type*} {ι : Sort*} [∀ i, InfSet (β i)] {f : ι → ∀ a, β a}
    {a : α} : (⨅ i, f i) a = ⨅ i, f i a 
goal: (⨅ i, f i) a = ⨅ i, f i a

full_name: unary_relation_sSup_iff
code: theorem unary_relation_sSup_iff {α : Type*} (s : Set (α → Prop)) {a : α} :
    sSup s a ↔ ∃ r : α → Prop, r ∈ s ∧ r a 
goal: sSup s a ↔ ∃ r ∈ s, r a

full_name: unary_relation_sInf_iff
code: theorem unary_relation_sInf_iff {α : Type*} (s : Set (α → Prop)) {a : α} :
    sInf s a ↔ ∀ r : α → Prop, r ∈ s → r a 
goal: sInf s a ↔ ∀ r ∈ s, r a

full_name: binary_relation_sSup_iff
code: theorem binary_relation_sSup_iff {α β : Type*} (s : Set (α → β → Prop)) {a : α} {b : β} :
    sSup s a b ↔ ∃ r : α → β → Prop, r ∈ s ∧ r a b 
goal: sSup s a b ↔ ∃ r ∈ s, r a b

full_name: binary_relation_sInf_iff
code: theorem binary_relation_sInf_iff {α β : Type*} (s : Set (α → β → Prop)) {a : α} {b : β} :
    sInf s a b ↔ ∀ r : α → β → Prop, r ∈ s → r a b 
goal: sInf s a b ↔ ∀ r ∈ s, r a b

full_name: Monotone.sSup
code: protected lemma Monotone.sSup (hs : ∀ f ∈ s, Monotone f) : Monotone (sSup s) 
goal: Monotone (sSup s)

full_name: Monotone.sInf
code: protected lemma Monotone.sInf (hs : ∀ f ∈ s, Monotone f) : Monotone (sInf s) 
goal: Monotone (sInf s)

full_name: Antitone.sSup
code: protected lemma Antitone.sSup (hs : ∀ f ∈ s, Antitone f) : Antitone (sSup s) 
goal: Antitone (sSup s)

full_name: Antitone.sInf
code: protected lemma Antitone.sInf (hs : ∀ f ∈ s, Antitone f) : Antitone (sInf s) 
goal: Antitone (sInf s)

full_name: Monotone.iSup
code: protected lemma Monotone.iSup (hf : ∀ i, Monotone (f i)) : Monotone (⨆ i, f i) 
goal: Monotone (⨆ i, f i)

full_name: Monotone.iInf
code: protected lemma Monotone.iInf (hf : ∀ i, Monotone (f i)) : Monotone (⨅ i, f i) 
goal: Monotone (⨅ i, f i)

full_name: Antitone.iSup
code: protected lemma Antitone.iSup (hf : ∀ i, Antitone (f i)) : Antitone (⨆ i, f i) 
goal: Antitone (⨆ i, f i)

full_name: Antitone.iInf
code: protected lemma Antitone.iInf (hf : ∀ i, Antitone (f i)) : Antitone (⨅ i, f i) 
goal: Antitone (⨅ i, f i)

full_name: Prod.supSet
code: instance supSet [SupSet α] [SupSet β] : SupSet (α × β) 
goal: SupSet (α × β)

full_name: Prod.infSet
code: instance infSet [InfSet α] [InfSet β] : InfSet (α × β) 
goal: InfSet (α × β)

full_name: Prod.fst_sInf
code: theorem fst_sInf [InfSet α] [InfSet β] (s : Set (α × β)) : (sInf s).fst = sInf (Prod.fst '' s) 
goal: (sInf s).1 = sInf (Prod.fst '' s)

full_name: Prod.snd_sInf
code: theorem snd_sInf [InfSet α] [InfSet β] (s : Set (α × β)) : (sInf s).snd = sInf (Prod.snd '' s) 
goal: (sInf s).2 = sInf (Prod.snd '' s)

full_name: Prod.swap_sInf
code: theorem swap_sInf [InfSet α] [InfSet β] (s : Set (α × β)) : (sInf s).swap = sInf (Prod.swap '' s) 
goal: (sInf s).swap = sInf (Prod.swap '' s)

full_name: Prod.fst_sSup
code: theorem fst_sSup [SupSet α] [SupSet β] (s : Set (α × β)) : (sSup s).fst = sSup (Prod.fst '' s) 
goal: (sSup s).1 = sSup (Prod.fst '' s)

full_name: Prod.snd_sSup
code: theorem snd_sSup [SupSet α] [SupSet β] (s : Set (α × β)) : (sSup s).snd = sSup (Prod.snd '' s) 
goal: (sSup s).2 = sSup (Prod.snd '' s)

full_name: Prod.swap_sSup
code: theorem swap_sSup [SupSet α] [SupSet β] (s : Set (α × β)) : (sSup s).swap = sSup (Prod.swap '' s) 
goal: (sSup s).swap = sSup (Prod.swap '' s)

full_name: Prod.fst_iInf
code: theorem fst_iInf [InfSet α] [InfSet β] (f : ι → α × β) : (iInf f).fst = ⨅ i, (f i).fst 
goal: (iInf f).1 = ⨅ i, (f i).1

full_name: Prod.snd_iInf
code: theorem snd_iInf [InfSet α] [InfSet β] (f : ι → α × β) : (iInf f).snd = ⨅ i, (f i).snd 
goal: (iInf f).2 = ⨅ i, (f i).2

full_name: Prod.swap_iInf
code: theorem swap_iInf [InfSet α] [InfSet β] (f : ι → α × β) : (iInf f).swap = ⨅ i, (f i).swap 
goal: (iInf f).swap = ⨅ i, (f i).swap

full_name: Prod.iInf_mk
code: theorem iInf_mk [InfSet α] [InfSet β] (f : ι → α) (g : ι → β) :
    ⨅ i, (f i, g i) = (⨅ i, f i, ⨅ i, g i) 
goal: ⨅ i, (f i, g i) = (⨅ i, f i, ⨅ i, g i)

full_name: Prod.fst_iSup
code: theorem fst_iSup [SupSet α] [SupSet β] (f : ι → α × β) : (iSup f).fst = ⨆ i, (f i).fst 
goal: (iSup f).1 = ⨆ i, (f i).1

full_name: Prod.snd_iSup
code: theorem snd_iSup [SupSet α] [SupSet β] (f : ι → α × β) : (iSup f).snd = ⨆ i, (f i).snd 
goal: (iSup f).2 = ⨆ i, (f i).2

full_name: Prod.swap_iSup
code: theorem swap_iSup [SupSet α] [SupSet β] (f : ι → α × β) : (iSup f).swap = ⨆ i, (f i).swap 
goal: (iSup f).swap = ⨆ i, (f i).swap

full_name: Prod.iSup_mk
code: theorem iSup_mk [SupSet α] [SupSet β] (f : ι → α) (g : ι → β) :
    ⨆ i, (f i, g i) = (⨆ i, f i, ⨆ i, g i) 
goal: ⨆ i, (f i, g i) = (⨆ i, f i, ⨆ i, g i)

full_name: Prod.instCompleteLattice
code: instance instCompleteLattice [CompleteLattice α] [CompleteLattice β] : CompleteLattice (α × β) 
goal: CompleteLattice (α × β)

full_name: sInf_prod
code: lemma sInf_prod [InfSet α] [InfSet β] {s : Set α} {t : Set β} (hs : s.Nonempty) (ht : t.Nonempty) :
    sInf (s ×ˢ t) = (sInf s, sInf t) 
goal: sInf (s ×ˢ t) = (sInf s, sInf t)

full_name: sSup_prod
code: lemma sSup_prod [SupSet α] [SupSet β] {s : Set α} {t : Set β} (hs : s.Nonempty) (ht : t.Nonempty) :
    sSup (s ×ˢ t) = (sSup s, sSup t) 
goal: sSup (s ×ˢ t) = (sSup s, sSup t)

full_name: sup_sInf_le_iInf_sup
code: /-- This is a weaker version of `sup_sInf_eq` -/
theorem sup_sInf_le_iInf_sup : a ⊔ sInf s ≤ ⨅ b ∈ s, a ⊔ b 
goal: a ⊔ sInf s ≤ ⨅ b ∈ s, a ⊔ b

full_name: iSup_inf_le_inf_sSup
code: /-- This is a weaker version of `inf_sSup_eq` -/
theorem iSup_inf_le_inf_sSup : ⨆ b ∈ s, a ⊓ b ≤ a ⊓ sSup s 
goal: ⨆ b ∈ s, a ⊓ b ≤ a ⊓ sSup s

full_name: sInf_sup_le_iInf_sup
code: /-- This is a weaker version of `sInf_sup_eq` -/
theorem sInf_sup_le_iInf_sup : sInf s ⊔ a ≤ ⨅ b ∈ s, b ⊔ a 
goal: sInf s ⊔ a ≤ ⨅ b ∈ s, b ⊔ a

full_name: iSup_inf_le_sSup_inf
code: /-- This is a weaker version of `sSup_inf_eq` -/
theorem iSup_inf_le_sSup_inf : ⨆ b ∈ s, b ⊓ a ≤ sSup s ⊓ a 
goal: ⨆ b ∈ s, b ⊓ a ≤ sSup s ⊓ a

full_name: le_iSup_inf_iSup
code: theorem le_iSup_inf_iSup (f g : ι → α) : ⨆ i, f i ⊓ g i ≤ (⨆ i, f i) ⊓ ⨆ i, g i 
goal: ⨆ i, f i ⊓ g i ≤ (⨆ i, f i) ⊓ ⨆ i, g i

full_name: iInf_sup_iInf_le
code: theorem iInf_sup_iInf_le (f g : ι → α) : (⨅ i, f i) ⊔ ⨅ i, g i ≤ ⨅ i, f i ⊔ g i 
goal: (⨅ i, f i) ⊔ ⨅ i, g i ≤ ⨅ i, f i ⊔ g i

full_name: disjoint_sSup_left
code: theorem disjoint_sSup_left {a : Set α} {b : α} (d : Disjoint (sSup a) b) {i} (hi : i ∈ a) :
    Disjoint i b 
goal: Disjoint i b

full_name: disjoint_sSup_right
code: theorem disjoint_sSup_right {a : Set α} {b : α} (d : Disjoint b (sSup a)) {i} (hi : i ∈ a) :
    Disjoint b i 
goal: Disjoint b i

full_name: Function.Injective.completeLattice
code: /-- Pullback a `CompleteLattice` along an injection. -/
protected abbrev Function.Injective.completeLattice [Sup α] [Inf α] [SupSet α] [InfSet α] [Top α]
    [Bot α] [CompleteLattice β] (f : α → β) (hf : Function.Injective f)
    (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b)
    (map_sSup : ∀ s, f (sSup s) = ⨆ a ∈ s, f a) (map_sInf : ∀ s, f (sInf s) = ⨅ a ∈ s, f a)
    (map_top : f ⊤ = ⊤) (map_bot : f ⊥ = ⊥) : CompleteLattice α 
goal: CompleteLattice α

full_name: ULift.supSet
code: instance supSet [SupSet α] : SupSet (ULift.{v} α) 
goal: SupSet (ULift.{v, u_1} α)

full_name: ULift.down_sSup
code: theorem down_sSup [SupSet α] (s : Set (ULift.{v} α)) : (sSup s).down = sSup (ULift.up ⁻¹' s) 
goal: (sSup s).down = sSup (ULift.up ⁻¹' s)

full_name: ULift.up_sSup
code: theorem up_sSup [SupSet α] (s : Set α) : up (sSup s) = sSup (ULift.down ⁻¹' s) 
goal: { down := sSup s } = sSup (ULift.down ⁻¹' s)

full_name: ULift.infSet
code: instance infSet [InfSet α] : InfSet (ULift.{v} α) 
goal: InfSet (ULift.{v, u_1} α)

full_name: ULift.down_sInf
code: theorem down_sInf [InfSet α] (s : Set (ULift.{v} α)) : (sInf s).down = sInf (ULift.up ⁻¹' s) 
goal: (sInf s).down = sInf (ULift.up ⁻¹' s)

full_name: ULift.up_sInf
code: theorem up_sInf [InfSet α] (s : Set α) : up (sInf s) = sInf (ULift.down ⁻¹' s) 
goal: { down := sInf s } = sInf (ULift.down ⁻¹' s)

full_name: ULift.down_iSup
code: theorem down_iSup [SupSet α] (f : ι → ULift.{v} α) : (⨆ i, f i).down = ⨆ i, (f i).down 
goal: (⨆ i, f i).down = ⨆ i, (f i).down

full_name: ULift.up_iSup
code: theorem up_iSup [SupSet α] (f : ι → α) : up (⨆ i, f i) = ⨆ i, up (f i) 
goal: { down := ⨆ i, f i } = ⨆ i, { down := f i }

full_name: ULift.down_iInf
code: theorem down_iInf [InfSet α] (f : ι → ULift.{v} α) : (⨅ i, f i).down = ⨅ i, (f i).down 
goal: (⨅ i, f i).down = ⨅ i, (f i).down

full_name: ULift.up_iInf
code: theorem up_iInf [InfSet α] (f : ι → α) : up (⨅ i, f i) = ⨅ i, up (f i) 
goal: { down := ⨅ i, f i } = ⨅ i, { down := f i }

full_name: ULift.instCompleteLattice
code: instance instCompleteLattice [CompleteLattice α] : CompleteLattice (ULift.{v} α) 
goal: CompleteLattice (ULift.{v, u_1} α)

full_name: PUnit.instCompleteLinearOrder
code: instance instCompleteLinearOrder : CompleteLinearOrder PUnit 
goal: CompleteLinearOrder PUnit.{u_9 + 1}