File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

full_name: WithTop.instSupSet
code: noncomputable instance WithTop.instSupSet [SupSet α] :
    SupSet (WithTop α) 
goal: SupSet (WithTop α)

full_name: WithTop.instInfSet
code: noncomputable instance WithTop.instInfSet [InfSet α] : InfSet (WithTop α) 
goal: InfSet (WithTop α)

full_name: WithBot.instSupSet
code: noncomputable instance WithBot.instSupSet [SupSet α] : SupSet (WithBot α) 
goal: SupSet (WithBot α)

full_name: WithBot.instInfSet
code: noncomputable instance WithBot.instInfSet [InfSet α] :
    InfSet (WithBot α) 
goal: InfSet (WithBot α)

full_name: WithTop.sSup_eq
code: theorem WithTop.sSup_eq [SupSet α] {s : Set (WithTop α)} (hs : ⊤ ∉ s)
    (hs' : BddAbove ((↑) ⁻¹' s : Set α)) : sSup s = ↑(sSup ((↑) ⁻¹' s) : α) 
goal: sSup s = ↑(sSup (WithTop.some ⁻¹' s))

full_name: WithTop.sInf_eq
code: theorem WithTop.sInf_eq [InfSet α] {s : Set (WithTop α)} (hs : ¬s ⊆ {⊤}) (h's : BddBelow s) :
    sInf s = ↑(sInf ((↑) ⁻¹' s) : α) 
goal: sInf s = ↑(sInf (WithTop.some ⁻¹' s))

full_name: WithBot.sInf_eq
code: theorem WithBot.sInf_eq [InfSet α] {s : Set (WithBot α)} (hs : ⊥ ∉ s)
    (hs' : BddBelow ((↑) ⁻¹' s : Set α)) : sInf s = ↑(sInf ((↑) ⁻¹' s) : α) 
goal: sInf s = ↑(sInf (WithBot.some ⁻¹' s))

full_name: WithBot.sSup_eq
code: theorem WithBot.sSup_eq [SupSet α] {s : Set (WithBot α)} (hs : ¬s ⊆ {⊥}) (h's : BddAbove s) :
    sSup s = ↑(sSup ((↑) ⁻¹' s) : α) 
goal: sSup s = ↑(sSup (WithBot.some ⁻¹' s))

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

full_name: WithTop.iInf_empty
code: @[simp]
theorem WithTop.iInf_empty [IsEmpty ι] [InfSet α] (f : ι → WithTop α) :
    ⨅ i, f i = ⊤ 
goal: ⨅ i, f i = ⊤

full_name: WithTop.coe_sInf'
code: theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) (h's : BddBelow s) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) 
goal: ↑(sInf s) = sInf ((fun a => ↑a) '' s)

full_name: WithTop.coe_iInf
code: @[norm_cast]
theorem WithTop.coe_iInf [Nonempty ι] [InfSet α] {f : ι → α} (hf : BddBelow (range f)) :
    ↑(⨅ i, f i) = (⨅ i, f i : WithTop α) 
goal: ↑(⨅ i, f i) = ⨅ i, ↑(f i)

full_name: WithTop.coe_sSup'
code: theorem WithTop.coe_sSup' [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) 
goal: ↑(sSup s) = sSup ((fun a => ↑a) '' s)

full_name: WithTop.coe_iSup
code: @[norm_cast]
theorem WithTop.coe_iSup [SupSet α] (f : ι → α) (h : BddAbove (Set.range f)) :
    ↑(⨆ i, f i) = (⨆ i, f i : WithTop α) 
goal: ↑(⨆ i, f i) = ⨆ i, ↑(f i)

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

full_name: WithBot.ciSup_empty
code: @[simp]
theorem WithBot.ciSup_empty [IsEmpty ι] [SupSet α] (f : ι → WithBot α) :
    ⨆ i, f i = ⊥ 
goal: ⨆ i, f i = ⊥

full_name: WithBot.coe_sSup'
code: @[norm_cast]
theorem WithBot.coe_sSup' [SupSet α] {s : Set α} (hs : s.Nonempty) (h's : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithBot α) 
goal: ↑(sSup s) = sSup ((fun a => ↑a) '' s)

full_name: WithBot.coe_iSup
code: @[norm_cast]
theorem WithBot.coe_iSup [Nonempty ι] [SupSet α] {f : ι → α} (hf : BddAbove (range f)) :
    ↑(⨆ i, f i) = (⨆ i, f i : WithBot α) 
goal: ↑(⨆ i, f i) = ⨆ i, ↑(f i)

full_name: WithBot.coe_sInf'
code: @[norm_cast]
theorem WithBot.coe_sInf' [InfSet α] {s : Set α} (hs : BddBelow s) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithBot α) 
goal: ↑(sInf s) = sInf ((fun a => ↑a) '' s)

full_name: WithBot.coe_iInf
code: @[norm_cast]
theorem WithBot.coe_iInf [InfSet α] (f : ι → α) (h : BddBelow (Set.range f)) :
    ↑(⨅ i, f i) = (⨅ i, f i : WithBot α) 
goal: ↑(⨅ i, f i) = ⨅ i, ↑(f i)

full_name: ConditionallyCompleteLattice.csSup_le
code: /-- A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete lattices, we prefix sInf and subₛ by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLattice (α : Type*) extends Lattice α, SupSet α, InfSet α where
  /-- `a ≤ sSup s` for all `a ∈ s`. -/
  le_csSup : ∀ s a, BddAbove s → a ∈ s → a ≤ sSup s
  /-- `sSup s ≤ a` for all `a ∈ upperBounds s`. -/
  csSup_le : ∀ s a, Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a
  /-- `sInf s ≤ a` for all `a ∈ s`. -/
  csInf_le : ∀ s a, BddBelow s → a ∈ s → sInf s ≤ a
  /-- `a ≤ sInf s` for all `a ∈ lowerBounds s`. -/
  le_csInf : ∀ s a, Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s
goal: s.Nonempty → a ∈ upperBounds s → sSup s ≤ a

full_name: ConditionallyCompleteLattice
code: /-- A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete lattices, we prefix sInf and subₛ by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLattice (α : Type*) extends Lattice α, SupSet α, InfSet α where
  /-- `a ≤ sSup s` for all `a ∈ s`. -/
  le_csSup : ∀ s a, BddAbove s → a ∈ s → a ≤ sSup s
  /-- `sSup s ≤ a` for all `a ∈ upperBounds s`. -/
  csSup_le : ∀ s a, Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a
  /-- `sInf s ≤ a` for all `a ∈ s`. -/
  csInf_le : ∀ s a, BddBelow s → a ∈ s → sInf s ≤ a
  /-- `a ≤ sInf s` for all `a ∈ lowerBounds s`. -/
  le_csInf : ∀ s a, Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s
goal: Type u_5

full_name: ConditionallyCompleteLattice.le_csInf
code: /-- A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete lattices, we prefix sInf and subₛ by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLattice (α : Type*) extends Lattice α, SupSet α, InfSet α where
  /-- `a ≤ sSup s` for all `a ∈ s`. -/
  le_csSup : ∀ s a, BddAbove s → a ∈ s → a ≤ sSup s
  /-- `sSup s ≤ a` for all `a ∈ upperBounds s`. -/
  csSup_le : ∀ s a, Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a
  /-- `sInf s ≤ a` for all `a ∈ s`. -/
  csInf_le : ∀ s a, BddBelow s → a ∈ s → sInf s ≤ a
  /-- `a ≤ sInf s` for all `a ∈ lowerBounds s`. -/
  le_csInf : ∀ s a, Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s
goal: s.Nonempty → a ∈ lowerBounds s → a ≤ sInf s

full_name: ConditionallyCompleteLattice.csInf_le
code: /-- A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete lattices, we prefix sInf and subₛ by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLattice (α : Type*) extends Lattice α, SupSet α, InfSet α where
  /-- `a ≤ sSup s` for all `a ∈ s`. -/
  le_csSup : ∀ s a, BddAbove s → a ∈ s → a ≤ sSup s
  /-- `sSup s ≤ a` for all `a ∈ upperBounds s`. -/
  csSup_le : ∀ s a, Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a
  /-- `sInf s ≤ a` for all `a ∈ s`. -/
  csInf_le : ∀ s a, BddBelow s → a ∈ s → sInf s ≤ a
  /-- `a ≤ sInf s` for all `a ∈ lowerBounds s`. -/
  le_csInf : ∀ s a, Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s
goal: BddBelow s → a ∈ s → sInf s ≤ a

full_name: ConditionallyCompleteLattice.le_csSup
code: /-- A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete lattices, we prefix sInf and subₛ by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLattice (α : Type*) extends Lattice α, SupSet α, InfSet α where
  /-- `a ≤ sSup s` for all `a ∈ s`. -/
  le_csSup : ∀ s a, BddAbove s → a ∈ s → a ≤ sSup s
  /-- `sSup s ≤ a` for all `a ∈ upperBounds s`. -/
  csSup_le : ∀ s a, Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a
  /-- `sInf s ≤ a` for all `a ∈ s`. -/
  csInf_le : ∀ s a, BddBelow s → a ∈ s → sInf s ≤ a
  /-- `a ≤ sInf s` for all `a ∈ lowerBounds s`. -/
  le_csInf : ∀ s a, Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s
goal: BddAbove s → a ∈ s → a ≤ sSup s

full_name: ConditionallyCompleteLinearOrder.decidableLT
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: DecidableRel fun x x_1 => x < x_1

full_name: ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: ¬BddAbove s → sSup s = sSup ∅

full_name: ConditionallyCompleteLinearOrder.decidableLE
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: DecidableRel fun x x_1 => x ≤ x_1

full_name: ConditionallyCompleteLinearOrder
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: Type u_5

full_name: ConditionallyCompleteLinearOrder.csInf_of_not_bddBelow
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: ¬BddBelow s → sInf s = sInf ∅

full_name: ConditionallyCompleteLinearOrder.decidableEq
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: DecidableEq α

full_name: ConditionallyCompleteLinearOrder.le_total
code: /-- A conditionally complete linear order is a linear order in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix sInf and sSup by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrder (α : Type*) extends ConditionallyCompleteLattice α where
  /-- A `ConditionallyCompleteLinearOrder` is total. -/
  le_total (a b : α) : a ≤ b ∨ b ≤ a
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLE : DecidableRel (· ≤ · : α → α → Prop)
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableEq : DecidableEq α := @decidableEqOfDecidableLE _ _ decidableLE
  /-- In a `ConditionallyCompleteLinearOrder`, we assume the order relations are all decidable. -/
  decidableLT : DecidableRel (· < · : α → α → Prop) :=
    @decidableLTOfDecidableLE _ _ decidableLE
  /-- If a set is not bounded above, its supremum is by convention `sSup ∅`. -/
  csSup_of_not_bddAbove : ∀ s, ¬BddAbove s → sSup s = sSup (∅ : Set α)
  /-- If a set is not bounded below, its infimum is by convention `sInf ∅`. -/
  csInf_of_not_bddBelow : ∀ s, ¬BddBelow s → sInf s = sInf (∅ : Set α)
goal: a ≤ b ∨ b ≤ a

full_name: ConditionallyCompleteLinearOrder.toLinearOrder
code: instance ConditionallyCompleteLinearOrder.toLinearOrder [ConditionallyCompleteLinearOrder α] :
    LinearOrder α 
goal: LinearOrder α

full_name: ConditionallyCompleteLinearOrderBot.csSup_empty
code: /-- A conditionally complete linear order with `Bot` is a linear order with least element, in which
every nonempty subset which is bounded above has a supremum, and every nonempty subset (necessarily
bounded below) has an infimum.  A typical example is the natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix `sInf` and `sSup` by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrderBot (α : Type*) extends ConditionallyCompleteLinearOrder α,
  Bot α where
  /-- `⊥` is the least element -/
  bot_le : ∀ x : α, ⊥ ≤ x
  /-- The supremum of the empty set is `⊥` -/
  csSup_empty : sSup ∅ = ⊥
goal: sSup ∅ = ⊥

full_name: ConditionallyCompleteLinearOrderBot.bot_le
code: /-- A conditionally complete linear order with `Bot` is a linear order with least element, in which
every nonempty subset which is bounded above has a supremum, and every nonempty subset (necessarily
bounded below) has an infimum.  A typical example is the natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix `sInf` and `sSup` by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrderBot (α : Type*) extends ConditionallyCompleteLinearOrder α,
  Bot α where
  /-- `⊥` is the least element -/
  bot_le : ∀ x : α, ⊥ ≤ x
  /-- The supremum of the empty set is `⊥` -/
  csSup_empty : sSup ∅ = ⊥
goal: ⊥ ≤ x

full_name: ConditionallyCompleteLinearOrderBot
code: /-- A conditionally complete linear order with `Bot` is a linear order with least element, in which
every nonempty subset which is bounded above has a supremum, and every nonempty subset (necessarily
bounded below) has an infimum.  A typical example is the natural numbers.

To differentiate the statements from the corresponding statements in (unconditional)
complete linear orders, we prefix `sInf` and `sSup` by a c everywhere. The same statements should
hold in both worlds, sometimes with additional assumptions of nonemptiness or
boundedness. -/
class ConditionallyCompleteLinearOrderBot (α : Type*) extends ConditionallyCompleteLinearOrder α,
  Bot α where
  /-- `⊥` is the least element -/
  bot_le : ∀ x : α, ⊥ ≤ x
  /-- The supremum of the empty set is `⊥` -/
  csSup_empty : sSup ∅ = ⊥
goal: Type u_5

full_name: ConditionallyCompleteLinearOrderBot.toOrderBot
code: instance (priority := 100) ConditionallyCompleteLinearOrderBot.toOrderBot
    [h : ConditionallyCompleteLinearOrderBot α] : OrderBot α 
goal: OrderBot α

full_name: CompleteLattice.toConditionallyCompleteLattice
code: /-- A complete lattice is a conditionally complete lattice, as there are no restrictions
on the properties of sInf and sSup in a complete lattice. -/
instance (priority := 100) CompleteLattice.toConditionallyCompleteLattice [CompleteLattice α] :
    ConditionallyCompleteLattice α 
goal: ConditionallyCompleteLattice α

full_name: CompleteLinearOrder.toConditionallyCompleteLinearOrderBot
code: instance (priority := 100) CompleteLinearOrder.toConditionallyCompleteLinearOrderBot {α : Type*}
    [h : CompleteLinearOrder α] : ConditionallyCompleteLinearOrderBot α 
goal: ConditionallyCompleteLinearOrderBot α

full_name: IsWellOrder.conditionallyCompleteLinearOrderBot
code: /-- A well founded linear order is conditionally complete, with a bottom element. -/
noncomputable abbrev IsWellOrder.conditionallyCompleteLinearOrderBot (α : Type*)
  [i₁ : _root_.LinearOrder α] [i₂ : OrderBot α] [h : IsWellOrder α (· < ·)] :
    ConditionallyCompleteLinearOrderBot α 
goal: ConditionallyCompleteLinearOrderBot α

full_name: OrderDual.instConditionallyCompleteLattice
code: instance instConditionallyCompleteLattice (α : Type*) [ConditionallyCompleteLattice α] :
    ConditionallyCompleteLattice αᵒᵈ 
goal: ConditionallyCompleteLattice αᵒᵈ

full_name: OrderDual.instConditionallyCompleteLinearOrder
code: instance (α : Type*) [ConditionallyCompleteLinearOrder α] : ConditionallyCompleteLinearOrder αᵒᵈ 
goal: ConditionallyCompleteLinearOrder αᵒᵈ

full_name: conditionallyCompleteLatticeOfsSup
code: /-- Create a `ConditionallyCompleteLattice` from a `PartialOrder` and `sup` function
that returns the least upper bound of a nonempty set which is bounded above. 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
`ConditionallyCompleteLattice` instance as
```
instance : ConditionallyCompleteLattice my_T :=
  { inf := better_inf,
    le_inf := ...,
    inf_le_right := ...,
    inf_le_left := ...
    -- don't care to fix sup, sInf
    ..conditionallyCompleteLatticeOfsSup my_T _ }
```
-/
def conditionallyCompleteLatticeOfsSup (α : Type*) [H1 : PartialOrder α] [H2 : SupSet α]
    (bddAbove_pair : ∀ a b : α, BddAbove ({a, b} : Set α))
    (bddBelow_pair : ∀ a b : α, BddBelow ({a, b} : Set α))
    (isLUB_sSup : ∀ s : Set α, BddAbove s → s.Nonempty → IsLUB s (sSup s)) :
    ConditionallyCompleteLattice α 
goal: ConditionallyCompleteLattice α

full_name: conditionallyCompleteLatticeOfsInf
code: /-- Create a `ConditionallyCompleteLattice` from a `PartialOrder` and `inf` function
that returns the greatest lower bound of a nonempty set which is bounded below. 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
`ConditionallyCompleteLattice` instance as
```
instance : ConditionallyCompleteLattice my_T :=
  { inf := better_inf,
    le_inf := ...,
    inf_le_right := ...,
    inf_le_left := ...
    -- don't care to fix sup, sSup
    ..conditionallyCompleteLatticeOfsInf my_T _ }
```
-/
def conditionallyCompleteLatticeOfsInf (α : Type*) [H1 : PartialOrder α] [H2 : InfSet α]
    (bddAbove_pair : ∀ a b : α, BddAbove ({a, b} : Set α))
    (bddBelow_pair : ∀ a b : α, BddBelow ({a, b} : Set α))
    (isGLB_sInf : ∀ s : Set α, BddBelow s → s.Nonempty → IsGLB s (sInf s)) :
    ConditionallyCompleteLattice α 
goal: ConditionallyCompleteLattice α

full_name: conditionallyCompleteLatticeOfLatticeOfsSup
code: /-- A version of `conditionallyCompleteLatticeOfsSup` when we already know that `α` is a lattice.

This should only be used when it is both hard and unnecessary to provide `inf` explicitly. -/
def conditionallyCompleteLatticeOfLatticeOfsSup (α : Type*) [H1 : Lattice α] [SupSet α]
    (isLUB_sSup : ∀ s : Set α, BddAbove s → s.Nonempty → IsLUB s (sSup s)) :
    ConditionallyCompleteLattice α 
goal: ConditionallyCompleteLattice α

full_name: conditionallyCompleteLatticeOfLatticeOfsInf
code: /-- A version of `conditionallyCompleteLatticeOfsInf` when we already know that `α` is a lattice.

This should only be used when it is both hard and unnecessary to provide `sup` explicitly. -/
def conditionallyCompleteLatticeOfLatticeOfsInf (α : Type*) [H1 : Lattice α] [InfSet α]
    (isGLB_sInf : ∀ s : Set α, BddBelow s → s.Nonempty → IsGLB s (sInf s)) :
    ConditionallyCompleteLattice α 
goal: ConditionallyCompleteLattice α

full_name: le_csSup
code: theorem le_csSup (h₁ : BddAbove s) (h₂ : a ∈ s) : a ≤ sSup s 
goal: a ≤ sSup s

full_name: csSup_le
code: theorem csSup_le (h₁ : s.Nonempty) (h₂ : ∀ b ∈ s, b ≤ a) : sSup s ≤ a 
goal: sSup s ≤ a

full_name: csInf_le
code: theorem csInf_le (h₁ : BddBelow s) (h₂ : a ∈ s) : sInf s ≤ a 
goal: sInf s ≤ a

full_name: le_csInf
code: theorem le_csInf (h₁ : s.Nonempty) (h₂ : ∀ b ∈ s, a ≤ b) : a ≤ sInf s 
goal: a ≤ sInf s

full_name: le_csSup_of_le
code: theorem le_csSup_of_le (hs : BddAbove s) (hb : b ∈ s) (h : a ≤ b) : a ≤ sSup s 
goal: a ≤ sSup s

full_name: csInf_le_of_le
code: theorem csInf_le_of_le (hs : BddBelow s) (hb : b ∈ s) (h : b ≤ a) : sInf s ≤ a 
goal: sInf s ≤ a

full_name: csSup_le_csSup
code: theorem csSup_le_csSup (ht : BddAbove t) (hs : s.Nonempty) (h : s ⊆ t) : sSup s ≤ sSup t 
goal: sSup s ≤ sSup t

full_name: csInf_le_csInf
code: theorem csInf_le_csInf (ht : BddBelow t) (hs : s.Nonempty) (h : s ⊆ t) : sInf t ≤ sInf s 
goal: sInf t ≤ sInf s

full_name: le_csSup_iff
code: theorem le_csSup_iff (h : BddAbove s) (hs : s.Nonempty) :
    a ≤ sSup s ↔ ∀ b, b ∈ upperBounds s → a ≤ b 
goal: a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b

full_name: csInf_le_iff
code: theorem csInf_le_iff (h : BddBelow s) (hs : s.Nonempty) : sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a 
goal: sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a

full_name: isLUB_csSup
code: theorem isLUB_csSup (ne : s.Nonempty) (H : BddAbove s) : IsLUB s (sSup s) 
goal: IsLUB s (sSup s)

full_name: isLUB_ciSup
code: theorem isLUB_ciSup [Nonempty ι] {f : ι → α} (H : BddAbove (range f)) :
    IsLUB (range f) (⨆ i, f i) 
goal: IsLUB (Set.range f) (⨆ i, f i)

full_name: isLUB_ciSup_set
code: theorem isLUB_ciSup_set {f : β → α} {s : Set β} (H : BddAbove (f '' s)) (Hne : s.Nonempty) :
    IsLUB (f '' s) (⨆ i : s, f i) 
goal: IsLUB (f '' s) (⨆ i, f ↑i)

full_name: isGLB_csInf
code: theorem isGLB_csInf (ne : s.Nonempty) (H : BddBelow s) : IsGLB s (sInf s) 
goal: IsGLB s (sInf s)

full_name: isGLB_ciInf
code: theorem isGLB_ciInf [Nonempty ι] {f : ι → α} (H : BddBelow (range f)) :
    IsGLB (range f) (⨅ i, f i) 
goal: IsGLB (Set.range f) (⨅ i, f i)

full_name: isGLB_ciInf_set
code: theorem isGLB_ciInf_set {f : β → α} {s : Set β} (H : BddBelow (f '' s)) (Hne : s.Nonempty) :
    IsGLB (f '' s) (⨅ i : s, f i) 
goal: IsGLB (f '' s) (⨅ i, f ↑i)

full_name: ciSup_le_iff
code: theorem ciSup_le_iff [Nonempty ι] {f : ι → α} {a : α} (hf : BddAbove (range f)) :
    iSup f ≤ a ↔ ∀ i, f i ≤ a 
goal: iSup f ≤ a ↔ ∀ (i : ι), f i ≤ a

full_name: le_ciInf_iff
code: theorem le_ciInf_iff [Nonempty ι] {f : ι → α} {a : α} (hf : BddBelow (range f)) :
    a ≤ iInf f ↔ ∀ i, a ≤ f i 
goal: a ≤ iInf f ↔ ∀ (i : ι), a ≤ f i

full_name: ciSup_set_le_iff
code: theorem ciSup_set_le_iff {ι : Type*} {s : Set ι} {f : ι → α} {a : α} (hs : s.Nonempty)
    (hf : BddAbove (f '' s)) : ⨆ i : s, f i ≤ a ↔ ∀ i ∈ s, f i ≤ a 
goal: ⨆ i, f ↑i ≤ a ↔ ∀ i ∈ s, f i ≤ a

full_name: le_ciInf_set_iff
code: theorem le_ciInf_set_iff {ι : Type*} {s : Set ι} {f : ι → α} {a : α} (hs : s.Nonempty)
    (hf : BddBelow (f '' s)) : (a ≤ ⨅ i : s, f i) ↔ ∀ i ∈ s, a ≤ f i 
goal: a ≤ ⨅ i, f ↑i ↔ ∀ i ∈ s, a ≤ f i

full_name: IsLUB.csSup_eq
code: theorem IsLUB.csSup_eq (H : IsLUB s a) (ne : s.Nonempty) : sSup s = a 
goal: sSup s = a

full_name: IsLUB.ciSup_eq
code: theorem IsLUB.ciSup_eq [Nonempty ι] {f : ι → α} (H : IsLUB (range f) a) : ⨆ i, f i = a 
goal: ⨆ i, f i = a

full_name: IsLUB.ciSup_set_eq
code: theorem IsLUB.ciSup_set_eq {s : Set β} {f : β → α} (H : IsLUB (f '' s) a) (Hne : s.Nonempty) :
    ⨆ i : s, f i = a 
goal: ⨆ i, f ↑i = a

full_name: IsGreatest.csSup_eq
code: /-- A greatest element of a set is the supremum of this set. -/
theorem IsGreatest.csSup_eq (H : IsGreatest s a) : sSup s = a 
goal: sSup s = a

full_name: IsGreatest.csSup_mem
code: theorem IsGreatest.csSup_mem (H : IsGreatest s a) : sSup s ∈ s 
goal: sSup s ∈ s

full_name: IsGLB.csInf_eq
code: theorem IsGLB.csInf_eq (H : IsGLB s a) (ne : s.Nonempty) : sInf s = a 
goal: sInf s = a

full_name: IsGLB.ciInf_eq
code: theorem IsGLB.ciInf_eq [Nonempty ι] {f : ι → α} (H : IsGLB (range f) a) : ⨅ i, f i = a 
goal: ⨅ i, f i = a

full_name: IsGLB.ciInf_set_eq
code: theorem IsGLB.ciInf_set_eq {s : Set β} {f : β → α} (H : IsGLB (f '' s) a) (Hne : s.Nonempty) :
    ⨅ i : s, f i = a 
goal: ⨅ i, f ↑i = a

full_name: IsLeast.csInf_eq
code: /-- A least element of a set is the infimum of this set. -/
theorem IsLeast.csInf_eq (H : IsLeast s a) : sInf s = a 
goal: sInf s = a

full_name: IsLeast.csInf_mem
code: theorem IsLeast.csInf_mem (H : IsLeast s a) : sInf s ∈ s 
goal: sInf s ∈ s

full_name: subset_Icc_csInf_csSup
code: theorem subset_Icc_csInf_csSup (hb : BddBelow s) (ha : BddAbove s) : s ⊆ Icc (sInf s) (sSup s) 
goal: s ⊆ Set.Icc (sInf s) (sSup s)

full_name: csSup_le_iff
code: theorem csSup_le_iff (hb : BddAbove s) (hs : s.Nonempty) : sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a 
goal: sSup s ≤ a ↔ ∀ b ∈ s, b ≤ a

full_name: le_csInf_iff
code: theorem le_csInf_iff (hb : BddBelow s) (hs : s.Nonempty) : a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b 
goal: a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b

full_name: csSup_lower_bounds_eq_csInf
code: theorem csSup_lower_bounds_eq_csInf {s : Set α} (h : BddBelow s) (hs : s.Nonempty) :
    sSup (lowerBounds s) = sInf s 
goal: sSup (lowerBounds s) = sInf s

full_name: csInf_upper_bounds_eq_csSup
code: theorem csInf_upper_bounds_eq_csSup {s : Set α} (h : BddAbove s) (hs : s.Nonempty) :
    sInf (upperBounds s) = sSup s 
goal: sInf (upperBounds s) = sSup s

full_name: not_mem_of_lt_csInf
code: theorem not_mem_of_lt_csInf {x : α} {s : Set α} (h : x < sInf s) (hs : BddBelow s) : x ∉ s 
goal: x ∉ s

full_name: not_mem_of_csSup_lt
code: theorem not_mem_of_csSup_lt {x : α} {s : Set α} (h : sSup s < x) (hs : BddAbove s) : x ∉ s 
goal: x ∉ s

full_name: csSup_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 `sSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in complete lattices. -/
theorem csSup_eq_of_forall_le_of_forall_lt_exists_gt (hs : s.Nonempty) (H : ∀ a ∈ s, a ≤ b)
    (H' : ∀ w, w < b → ∃ a ∈ s, w < a) : sSup s = b 
goal: sSup s = b

full_name: csInf_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 `sInf_eq_of_forall_ge_of_forall_gt_exists_lt` for a version in complete lattices. -/
theorem csInf_eq_of_forall_ge_of_forall_gt_exists_lt :
    s.Nonempty → (∀ a ∈ s, b ≤ a) → (∀ w, b < w → ∃ a ∈ s, a < w) → sInf s = b 
goal: s.Nonempty → (∀ a ∈ s, b ≤ a) → (∀ (w : α), b < w → ∃ a ∈ s, a < w) → sInf s = b

full_name: lt_csSup_of_lt
code: /-- `b < sSup s` when there is an element `a` in `s` with `b < a`, when `s` is bounded above.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness above for one direction, nonemptiness and linear
order for the other one), so we formulate separately the two implications, contrary to
the `CompleteLattice` case. -/
theorem lt_csSup_of_lt (hs : BddAbove s) (ha : a ∈ s) (h : b < a) : b < sSup s 
goal: b < sSup s

full_name: csInf_lt_of_lt
code: /-- `sInf s < b` when there is an element `a` in `s` with `a < b`, when `s` is bounded below.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness below for one direction, nonemptiness and linear
order for the other one), so we formulate separately the two implications, contrary to
the `CompleteLattice` case. -/
theorem csInf_lt_of_lt : BddBelow s → a ∈ s → a < b → sInf s < b 
goal: BddBelow s → a ∈ s → a < b → sInf s < b

full_name: exists_between_of_forall_le
code: /-- If all elements of a nonempty set `s` are less than or equal to all elements
of a nonempty set `t`, then there exists an element between these sets. -/
theorem exists_between_of_forall_le (sne : s.Nonempty) (tne : t.Nonempty)
    (hst : ∀ x ∈ s, ∀ y ∈ t, x ≤ y) : (upperBounds s ∩ lowerBounds t).Nonempty 
goal: (upperBounds s ∩ lowerBounds t).Nonempty

full_name: csSup_singleton
code: /-- The supremum of a singleton is the element of the singleton-/
@[simp]
theorem csSup_singleton (a : α) : sSup {a} = a 
goal: sSup {a} = a

full_name: csInf_singleton
code: /-- The infimum of a singleton is the element of the singleton-/
@[simp]
theorem csInf_singleton (a : α) : sInf {a} = a 
goal: sInf {a} = a

full_name: csSup_pair
code: @[simp]
theorem csSup_pair (a b : α) : sSup {a, b} = a ⊔ b 
goal: sSup {a, b} = a ⊔ b

full_name: csInf_pair
code: @[simp]
theorem csInf_pair (a b : α) : sInf {a, b} = a ⊓ b 
goal: sInf {a, b} = a ⊓ b

full_name: csInf_le_csSup
code: /-- If a set is bounded below and above, and nonempty, its infimum is less than or equal to
its supremum. -/
theorem csInf_le_csSup (hb : BddBelow s) (ha : BddAbove s) (ne : s.Nonempty) : sInf s ≤ sSup s 
goal: sInf s ≤ sSup s

full_name: csSup_union
code: /-- The `sSup` of a union of two sets is the max of the suprema of each subset, under the
assumptions that all sets are bounded above and nonempty. -/
theorem csSup_union (hs : BddAbove s) (sne : s.Nonempty) (ht : BddAbove t) (tne : t.Nonempty) :
    sSup (s ∪ t) = sSup s ⊔ sSup t 
goal: sSup (s ∪ t) = sSup s ⊔ sSup t

full_name: csInf_union
code: /-- The `sInf` of a union of two sets is the min of the infima of each subset, under the assumptions
that all sets are bounded below and nonempty. -/
theorem csInf_union (hs : BddBelow s) (sne : s.Nonempty) (ht : BddBelow t) (tne : t.Nonempty) :
    sInf (s ∪ t) = sInf s ⊓ sInf t 
goal: sInf (s ∪ t) = sInf s ⊓ sInf t

full_name: csSup_inter_le
code: /-- The supremum of an intersection of two sets is bounded by the minimum of the suprema of each
set, if all sets are bounded above and nonempty. -/
theorem csSup_inter_le (hs : BddAbove s) (ht : BddAbove t) (hst : (s ∩ t).Nonempty) :
    sSup (s ∩ t) ≤ sSup s ⊓ sSup t 
goal: sSup (s ∩ t) ≤ sSup s ⊓ sSup t

full_name: le_csInf_inter
code: /-- The infimum of an intersection of two sets is bounded below by the maximum of the
infima of each set, if all sets are bounded below and nonempty. -/
theorem le_csInf_inter :
    BddBelow s → BddBelow t → (s ∩ t).Nonempty → sInf s ⊔ sInf t ≤ sInf (s ∩ t) 
goal: BddBelow s → BddBelow t → (s ∩ t).Nonempty → sInf s ⊔ sInf t ≤ sInf (s ∩ t)

full_name: csSup_insert
code: /-- The supremum of `insert a s` is the maximum of `a` and the supremum of `s`, if `s` is
nonempty and bounded above. -/
theorem csSup_insert (hs : BddAbove s) (sne : s.Nonempty) : sSup (insert a s) = a ⊔ sSup s 
goal: sSup (insert a s) = a ⊔ sSup s

full_name: csInf_insert
code: /-- The infimum of `insert a s` is the minimum of `a` and the infimum of `s`, if `s` is
nonempty and bounded below. -/
theorem csInf_insert (hs : BddBelow s) (sne : s.Nonempty) : sInf (insert a s) = a ⊓ sInf s 
goal: sInf (insert a s) = a ⊓ sInf s

full_name: csInf_Icc
code: @[simp]
theorem csInf_Icc (h : a ≤ b) : sInf (Icc a b) = a 
goal: sInf (Set.Icc a b) = a

full_name: csInf_Ici
code: @[simp]
theorem csInf_Ici : sInf (Ici a) = a 
goal: sInf (Set.Ici a) = a

full_name: csInf_Ico
code: @[simp]
theorem csInf_Ico (h : a < b) : sInf (Ico a b) = a 
goal: sInf (Set.Ico a b) = a

full_name: csInf_Ioc
code: @[simp]
theorem csInf_Ioc [DenselyOrdered α] (h : a < b) : sInf (Ioc a b) = a 
goal: sInf (Set.Ioc a b) = a

full_name: csInf_Ioi
code: @[simp]
theorem csInf_Ioi [NoMaxOrder α] [DenselyOrdered α] : sInf (Ioi a) = a 
goal: sInf (Set.Ioi a) = a

full_name: csInf_Ioo
code: @[simp]
theorem csInf_Ioo [DenselyOrdered α] (h : a < b) : sInf (Ioo a b) = a 
goal: sInf (Set.Ioo a b) = a

full_name: csSup_Icc
code: @[simp]
theorem csSup_Icc (h : a ≤ b) : sSup (Icc a b) = b 
goal: sSup (Set.Icc a b) = b

full_name: csSup_Ico
code: @[simp]
theorem csSup_Ico [DenselyOrdered α] (h : a < b) : sSup (Ico a b) = b 
goal: sSup (Set.Ico a b) = b

full_name: csSup_Iic
code: @[simp]
theorem csSup_Iic : sSup (Iic a) = a 
goal: sSup (Set.Iic a) = a

full_name: csSup_Iio
code: @[simp]
theorem csSup_Iio [NoMinOrder α] [DenselyOrdered α] : sSup (Iio a) = a 
goal: sSup (Set.Iio a) = a

full_name: csSup_Ioc
code: @[simp]
theorem csSup_Ioc (h : a < b) : sSup (Ioc a b) = b 
goal: sSup (Set.Ioc a b) = b

full_name: csSup_Ioo
code: @[simp]
theorem csSup_Ioo [DenselyOrdered α] (h : a < b) : sSup (Ioo a b) = b 
goal: sSup (Set.Ioo a b) = b

full_name: ciSup_le
code: /-- The indexed supremum of a function is bounded above by a uniform bound-/
theorem ciSup_le [Nonempty ι] {f : ι → α} {c : α} (H : ∀ x, f x ≤ c) : iSup f ≤ c 
goal: iSup f ≤ c

full_name: le_ciSup
code: /-- The indexed supremum of a function is bounded below by the value taken at one point-/
theorem le_ciSup {f : ι → α} (H : BddAbove (range f)) (c : ι) : f c ≤ iSup f 
goal: f c ≤ iSup f

full_name: le_ciSup_of_le
code: theorem le_ciSup_of_le {f : ι → α} (H : BddAbove (range f)) (c : ι) (h : a ≤ f c) : a ≤ iSup f 
goal: a ≤ iSup f

full_name: ciSup_mono
code: /-- The indexed supremum of two functions are comparable if the functions are pointwise comparable-/
theorem ciSup_mono {f g : ι → α} (B : BddAbove (range g)) (H : ∀ x, f x ≤ g x) :
    iSup f ≤ iSup g 
goal: iSup f ≤ iSup g

full_name: le_ciSup_set
code: theorem le_ciSup_set {f : β → α} {s : Set β} (H : BddAbove (f '' s)) {c : β} (hc : c ∈ s) :
    f c ≤ ⨆ i : s, f i 
goal: f c ≤ ⨆ i, f ↑i

full_name: ciInf_mono
code: /-- The indexed infimum of two functions are comparable if the functions are pointwise comparable-/
theorem ciInf_mono {f g : ι → α} (B : BddBelow (range f)) (H : ∀ x, f x ≤ g x) : iInf f ≤ iInf g 
goal: iInf f ≤ iInf g

full_name: le_ciInf
code: /-- The indexed minimum of a function is bounded below by a uniform lower bound-/
theorem le_ciInf [Nonempty ι] {f : ι → α} {c : α} (H : ∀ x, c ≤ f x) : c ≤ iInf f 
goal: c ≤ iInf f

full_name: ciInf_le
code: /-- The indexed infimum of a function is bounded above by the value taken at one point-/
theorem ciInf_le {f : ι → α} (H : BddBelow (range f)) (c : ι) : iInf f ≤ f c 
goal: iInf f ≤ f c

full_name: ciInf_le_of_le
code: theorem ciInf_le_of_le {f : ι → α} (H : BddBelow (range f)) (c : ι) (h : f c ≤ a) : iInf f ≤ a 
goal: iInf f ≤ a

full_name: ciInf_set_le
code: theorem ciInf_set_le {f : β → α} {s : Set β} (H : BddBelow (f '' s)) {c : β} (hc : c ∈ s) :
    ⨅ i : s, f i ≤ f c 
goal: ⨅ i, f ↑i ≤ f c

full_name: ciSup_const
code: @[simp]
theorem ciSup_const [hι : Nonempty ι] {a : α} : ⨆ _ : ι, a = a 
goal: ⨆ x, a = a

full_name: ciInf_const
code: @[simp]
theorem ciInf_const [Nonempty ι] {a : α} : ⨅ _ : ι, a = a 
goal: ⨅ x, a = a

full_name: ciSup_unique
code: @[simp]
theorem ciSup_unique [Unique ι] {s : ι → α} : ⨆ i, s i = s default 
goal: ⨆ i, s i = s default

full_name: ciInf_unique
code: @[simp]
theorem ciInf_unique [Unique ι] {s : ι → α} : ⨅ i, s i = s default 
goal: ⨅ i, s i = s default

full_name: ciSup_subsingleton
code: theorem ciSup_subsingleton [Subsingleton ι] (i : ι) (s : ι → α) : ⨆ i, s i = s i 
goal: ⨆ i, s i = s i

full_name: ciInf_subsingleton
code: theorem ciInf_subsingleton [Subsingleton ι] (i : ι) (s : ι → α) : ⨅ i, s i = s i 
goal: ⨅ i, s i = s i

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

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

full_name: ciSup_neg
code: lemma ciSup_neg {p : Prop} {f : p → α} (hp : ¬ p) :
    ⨆ (h : p), f h = sSup (∅ : Set α) 
goal: ⨆ (h : p), f h = sSup ∅

full_name: ciInf_neg
code: lemma ciInf_neg {p : Prop} {f : p → α} (hp : ¬ p) :
    ⨅ (h : p), f h = sInf (∅ : Set α) 
goal: ⨅ (h : p), f h = sInf ∅

full_name: ciSup_eq_ite
code: lemma ciSup_eq_ite {p : Prop} [Decidable p] {f : p → α} :
    (⨆ h : p, f h) = if h : p then f h else sSup (∅ : Set α) 
goal: ⨆ (h : p), f h = if h : p then f h else sSup ∅

full_name: ciInf_eq_ite
code: lemma ciInf_eq_ite {p : Prop} [Decidable p] {f : p → α} :
    (⨅ h : p, f h) = if h : p then f h else sInf (∅ : Set α) 
goal: ⨅ (h : p), f h = if h : p then f h else sInf ∅

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

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

full_name: ciSup_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 `iSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in complete lattices. -/
theorem ciSup_eq_of_forall_le_of_forall_lt_exists_gt [Nonempty ι] {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: ciInf_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 `iInf_eq_of_forall_ge_of_forall_gt_exists_lt` for a version in complete lattices. -/
theorem ciInf_eq_of_forall_ge_of_forall_gt_exists_lt [Nonempty ι] {f : ι → α} (h₁ : ∀ i, b ≤ f i)
    (h₂ : ∀ w, b < w → ∃ i, f i < w) : ⨅ i : ι, f i = b 
goal: ⨅ i, f i = b

full_name: Monotone.ciSup_mem_iInter_Icc_of_antitone
code: /-- **Nested intervals lemma**: if `f` is a monotone sequence, `g` is an antitone sequence, and
`f n ≤ g n` for all `n`, then `⨆ n, f n` belongs to all the intervals `[f n, g n]`. -/
theorem Monotone.ciSup_mem_iInter_Icc_of_antitone [SemilatticeSup β] {f g : β → α} (hf : Monotone f)
    (hg : Antitone g) (h : f ≤ g) : (⨆ n, f n) ∈ ⋂ n, Icc (f n) (g n) 
goal: ⨆ n, f n ∈ ⋂ n, Set.Icc (f n) (g n)

full_name: ciSup_mem_iInter_Icc_of_antitone_Icc
code: /-- Nested intervals lemma: if `[f n, g n]` is an antitone sequence of nonempty
closed intervals, then `⨆ n, f n` belongs to all the intervals `[f n, g n]`. -/
theorem ciSup_mem_iInter_Icc_of_antitone_Icc [SemilatticeSup β] {f g : β → α}
    (h : Antitone fun n => Icc (f n) (g n)) (h' : ∀ n, f n ≤ g n) :
    (⨆ n, f n) ∈ ⋂ n, Icc (f n) (g n) 
goal: ⨆ n, f n ∈ ⋂ n, Set.Icc (f n) (g n)

full_name: csSup_eq_of_is_forall_le_of_forall_le_imp_ge
code: /-- Introduction rule to prove that `b` is the supremum of `s`: it suffices to check that
1) `b` is an upper bound
2) every other upper bound `b'` satisfies `b ≤ b'`. -/
theorem csSup_eq_of_is_forall_le_of_forall_le_imp_ge (hs : s.Nonempty) (h_is_ub : ∀ a ∈ s, a ≤ b)
    (h_b_le_ub : ∀ ub, (∀ a ∈ s, a ≤ ub) → b ≤ ub) : sSup s = b 
goal: sSup s = b

full_name: Set.Iic_ciInf
code: lemma Set.Iic_ciInf [Nonempty ι] {f : ι → α} (hf : BddBelow (range f)) :
    Iic (⨅ i, f i) = ⋂ i, Iic (f i) 
goal: Set.Iic (⨅ i, f i) = ⋂ i, Set.Iic (f i)

full_name: Set.Ici_ciSup
code: lemma Set.Ici_ciSup [Nonempty ι] {f : ι → α} (hf : BddAbove (range f)) :
    Ici (⨆ i, f i) = ⋂ i, Ici (f i) 
goal: Set.Ici (⨆ i, f i) = ⋂ i, Set.Ici (f i)

full_name: sup_eq_top_of_top_mem
code: lemma sup_eq_top_of_top_mem [OrderTop α] (h : ⊤ ∈ s) : sSup s = ⊤ 
goal: sSup s = ⊤

full_name: inf_eq_bot_of_bot_mem
code: lemma inf_eq_bot_of_bot_mem [OrderBot α] (h : ⊥ ∈ s) : sInf s = ⊥ 
goal: sInf s = ⊥

full_name: Pi.conditionallyCompleteLattice
code: instance Pi.conditionallyCompleteLattice {ι : Type*} {α : ι → Type*}
    [∀ i, ConditionallyCompleteLattice (α i)] : ConditionallyCompleteLattice (∀ i, α i) 
goal: ConditionallyCompleteLattice ((i : ι) → α i)

full_name: exists_lt_of_lt_csSup
code: /-- When `b < sSup s`, there is an element `a` in `s` with `b < a`, if `s` is nonempty and the order
is a linear order. -/
theorem exists_lt_of_lt_csSup (hs : s.Nonempty) (hb : b < sSup s) : ∃ a ∈ s, b < a 
goal: ∃ a ∈ s, b < a

full_name: exists_lt_of_lt_ciSup
code: /-- Indexed version of the above lemma `exists_lt_of_lt_csSup`.
When `b < iSup f`, there is an element `i` such that `b < f i`.
-/
theorem exists_lt_of_lt_ciSup [Nonempty ι] {f : ι → α} (h : b < iSup f) : ∃ i, b < f i 
goal: ∃ i, b < f i

full_name: exists_lt_of_csInf_lt
code: /-- When `sInf s < b`, there is an element `a` in `s` with `a < b`, if `s` is nonempty and the order
is a linear order. -/
theorem exists_lt_of_csInf_lt (hs : s.Nonempty) (hb : sInf s < b) : ∃ a ∈ s, a < b 
goal: ∃ a ∈ s, a < b

full_name: exists_lt_of_ciInf_lt
code: /-- Indexed version of the above lemma `exists_lt_of_csInf_lt`
When `iInf f < a`, there is an element `i` such that `f i < a`.
-/
theorem exists_lt_of_ciInf_lt [Nonempty ι] {f : ι → α} (h : iInf f < a) : ∃ i, f i < a 
goal: ∃ i, f i < a

full_name: csSup_of_not_bddAbove
code: theorem csSup_of_not_bddAbove {s : Set α} (hs : ¬BddAbove s) : sSup s = sSup ∅ 
goal: sSup s = sSup ∅

full_name: csSup_eq_univ_of_not_bddAbove
code: theorem csSup_eq_univ_of_not_bddAbove {s : Set α} (hs : ¬BddAbove s) : sSup s = sSup univ 
goal: sSup s = sSup Set.univ

full_name: csInf_of_not_bddBelow
code: theorem csInf_of_not_bddBelow {s : Set α} (hs : ¬BddBelow s) : sInf s = sInf ∅ 
goal: sInf s = sInf ∅

full_name: csInf_eq_univ_of_not_bddBelow
code: theorem csInf_eq_univ_of_not_bddBelow {s : Set α} (hs : ¬BddBelow s) : sInf s = sInf univ 
goal: sInf s = sInf Set.univ

full_name: csSup_eq_csSup_of_forall_exists_le
code: /-- When every element of a set `s` is bounded by an element of a set `t`, and conversely, then
`s` and `t` have the same supremum. This holds even when the sets may be empty or unbounded. -/
theorem csSup_eq_csSup_of_forall_exists_le {s t : Set α}
    (hs : ∀ x ∈ s, ∃ y ∈ t, x ≤ y) (ht : ∀ y ∈ t, ∃ x ∈ s, y ≤ x) :
    sSup s = sSup t 
goal: sSup s = sSup t

full_name: csInf_eq_csInf_of_forall_exists_le
code: /-- When every element of a set `s` is bounded by an element of a set `t`, and conversely, then
`s` and `t` have the same infimum. This holds even when the sets may be empty or unbounded. -/
theorem csInf_eq_csInf_of_forall_exists_le {s t : Set α}
    (hs : ∀ x ∈ s, ∃ y ∈ t, y ≤ x) (ht : ∀ y ∈ t, ∃ x ∈ s, x ≤ y) :
    sInf s = sInf t 
goal: sInf s = sInf t

full_name: sSup_iUnion_Iic
code: lemma sSup_iUnion_Iic (f : ι → α) : sSup (⋃ (i : ι), Iic (f i)) = ⨆ i, f i 
goal: sSup (⋃ i, Set.Iic (f i)) = ⨆ i, f i

full_name: sInf_iUnion_Ici
code: lemma sInf_iUnion_Ici (f : ι → α) : sInf (⋃ (i : ι), Ici (f i)) = ⨅ i, f i 
goal: sInf (⋃ i, Set.Ici (f i)) = ⨅ i, f i

full_name: cbiSup_eq_of_not_forall
code: theorem cbiSup_eq_of_not_forall {p : ι → Prop} {f : Subtype p → α} (hp : ¬ (∀ i, p i)) :
    ⨆ (i) (h : p i), f ⟨i, h⟩ = iSup f ⊔ sSup ∅ 
goal: ⨆ i, ⨆ (h : p i), f ⟨i, h⟩ = iSup f ⊔ sSup ∅

full_name: cbiInf_eq_of_not_forall
code: theorem cbiInf_eq_of_not_forall {p : ι → Prop} {f : Subtype p → α} (hp : ¬ (∀ i, p i)) :
    ⨅ (i) (h : p i), f ⟨i, h⟩ = iInf f ⊓ sInf ∅ 
goal: ⨅ i, ⨅ (h : p i), f ⟨i, h⟩ = iInf f ⊓ sInf ∅

full_name: sInf_eq_argmin_on
code: theorem sInf_eq_argmin_on (hs : s.Nonempty) : sInf s = argminOn id wellFounded_lt s hs 
goal: sInf s = Function.argminOn id ⋯ s hs

full_name: isLeast_csInf
code: theorem isLeast_csInf (hs : s.Nonempty) : IsLeast s (sInf s) 
goal: IsLeast s (sInf s)

full_name: le_csInf_iff'
code: theorem le_csInf_iff' (hs : s.Nonempty) : b ≤ sInf s ↔ b ∈ lowerBounds s 
goal: b ≤ sInf s ↔ b ∈ lowerBounds s

full_name: csInf_mem
code: theorem csInf_mem (hs : s.Nonempty) : sInf s ∈ s 
goal: sInf s ∈ s

full_name: ciInf_mem
code: theorem ciInf_mem [Nonempty ι] (f : ι → α) : iInf f ∈ range f 
goal: iInf f ∈ Set.range f

full_name: MonotoneOn.map_csInf
code: theorem MonotoneOn.map_csInf {β : Type*} [ConditionallyCompleteLattice β] {f : α → β}
    (hf : MonotoneOn f s) (hs : s.Nonempty) : f (sInf s) = sInf (f '' s) 
goal: f (sInf s) = sInf (f '' s)

full_name: Monotone.map_csInf
code: theorem Monotone.map_csInf {β : Type*} [ConditionallyCompleteLattice β] {f : α → β}
    (hf : Monotone f) (hs : s.Nonempty) : f (sInf s) = sInf (f '' s) 
goal: f (sInf s) = sInf (f '' s)

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

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

full_name: ciSup_of_empty
code: @[simp]
theorem ciSup_of_empty [IsEmpty ι] (f : ι → α) : ⨆ i, f i = ⊥ 
goal: ⨆ i, f i = ⊥

full_name: ciSup_false
code: theorem ciSup_false (f : False → α) : ⨆ i, f i = ⊥ 
goal: ⨆ (i : False), f i = ⊥

full_name: isLUB_csSup'
code: theorem isLUB_csSup' {s : Set α} (hs : BddAbove s) : IsLUB s (sSup s) 
goal: IsLUB s (sSup s)

full_name: csSup_le_iff'
code: theorem csSup_le_iff' {s : Set α} (hs : BddAbove s) {a : α} : sSup s ≤ a ↔ ∀ x ∈ s, x ≤ a 
goal: sSup s ≤ a ↔ ∀ x ∈ s, x ≤ a

full_name: csSup_le'
code: theorem csSup_le' {s : Set α} {a : α} (h : a ∈ upperBounds s) : sSup s ≤ a 
goal: sSup s ≤ a

full_name: le_csSup_iff'
code: theorem le_csSup_iff' {s : Set α} {a : α} (h : BddAbove s) :
    a ≤ sSup s ↔ ∀ b, b ∈ upperBounds s → a ≤ b 
goal: a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b

full_name: le_ciSup_iff'
code: theorem le_ciSup_iff' {s : ι → α} {a : α} (h : BddAbove (range s)) :
    a ≤ iSup s ↔ ∀ b, (∀ i, s i ≤ b) → a ≤ b 
goal: a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b

full_name: le_csInf_iff''
code: theorem le_csInf_iff'' {s : Set α} {a : α} (ne : s.Nonempty) :
    a ≤ sInf s ↔ ∀ b : α, b ∈ s → a ≤ b 
goal: a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b

full_name: le_ciInf_iff'
code: theorem le_ciInf_iff' [Nonempty ι] {f : ι → α} {a : α} : a ≤ iInf f ↔ ∀ i, a ≤ f i 
goal: a ≤ iInf f ↔ ∀ (i : ι), a ≤ f i

full_name: csInf_le'
code: theorem csInf_le' (h : a ∈ s) : sInf s ≤ a 
goal: sInf s ≤ a

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

full_name: ciInf_le_of_le'
code: lemma ciInf_le_of_le' (c : ι) : f c ≤ a → iInf f ≤ a 
goal: f c ≤ a → iInf f ≤ a

full_name: exists_lt_of_lt_csSup'
code: theorem exists_lt_of_lt_csSup' {s : Set α} {a : α} (h : a < sSup s) : ∃ b ∈ s, a < b 
goal: ∃ b ∈ s, a < b

full_name: ciSup_le_iff'
code: theorem ciSup_le_iff' {f : ι → α} (h : BddAbove (range f)) {a : α} :
    ⨆ i, f i ≤ a ↔ ∀ i, f i ≤ a 
goal: ⨆ i, f i ≤ a ↔ ∀ (i : ι), f i ≤ a

full_name: ciSup_le'
code: theorem ciSup_le' {f : ι → α} {a : α} (h : ∀ i, f i ≤ a) : ⨆ i, f i ≤ a 
goal: ⨆ i, f i ≤ a

full_name: exists_lt_of_lt_ciSup'
code: theorem exists_lt_of_lt_ciSup' {f : ι → α} {a : α} (h : a < ⨆ i, f i) : ∃ i, a < f i 
goal: ∃ i, a < f i

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

full_name: csInf_le_csInf'
code: theorem csInf_le_csInf' {s t : Set α} (h₁ : t.Nonempty) (h₂ : t ⊆ s) : sInf s ≤ sInf t 
goal: sInf s ≤ sInf t

full_name: WithTop.isLUB_sSup'
code: /-- The `sSup` of a non-empty set is its least upper bound for a conditionally
complete lattice with a top. -/
theorem isLUB_sSup' {β : Type*} [ConditionallyCompleteLattice β] {s : Set (WithTop β)}
    (hs : s.Nonempty) : IsLUB s (sSup s) 
goal: IsLUB s (sSup s)

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

full_name: WithTop.isGLB_sInf'
code: /-- The `sInf` of a bounded-below set is its greatest lower bound for a conditionally
complete lattice with a top. -/
theorem isGLB_sInf' {β : Type*} [ConditionallyCompleteLattice β] {s : Set (WithTop β)}
    (hs : BddBelow s) : IsGLB s (sInf s) 
goal: IsGLB s (sInf s)

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

full_name: WithTop.instCompleteLinearOrder
code: noncomputable instance : CompleteLinearOrder (WithTop α) 
goal: CompleteLinearOrder (WithTop α)

full_name: WithTop.coe_sSup
code: /-- A version of `WithTop.coe_sSup'` with a more convenient but less general statement. -/
@[norm_cast]
theorem coe_sSup {s : Set α} (hb : BddAbove s) : ↑(sSup s) = (⨆ a ∈ s, ↑a : WithTop α) 
goal: ↑(sSup s) = ⨆ a ∈ s, ↑a

full_name: WithTop.coe_sInf
code: /-- A version of `WithTop.coe_sInf'` with a more convenient but less general statement. -/
@[norm_cast]
theorem coe_sInf {s : Set α} (hs : s.Nonempty) (h's : BddBelow s) :
    ↑(sInf s) = (⨅ a ∈ s, ↑a : WithTop α) 
goal: ↑(sInf s) = ⨅ a ∈ s, ↑a

full_name: Monotone.le_csSup_image
code: theorem le_csSup_image {s : Set α} {c : α} (hcs : c ∈ s) (h_bdd : BddAbove s) :
    f c ≤ sSup (f '' s) 
goal: f c ≤ sSup (f '' s)

full_name: Monotone.csSup_image_le
code: theorem csSup_image_le {s : Set α} (hs : s.Nonempty) {B : α} (hB : B ∈ upperBounds s) :
    sSup (f '' s) ≤ f B 
goal: sSup (f '' s) ≤ f B

full_name: Monotone.csInf_image_le
code: theorem csInf_image_le {s : Set α} {c : α} (hcs : c ∈ s) (h_bdd : BddBelow s) :
    sInf (f '' s) ≤ f c 
goal: sInf (f '' s) ≤ f c

full_name: Monotone.le_csInf_image
code: theorem le_csInf_image {s : Set α} (hs : s.Nonempty) {B : α} (hB : B ∈ lowerBounds s) :
    f B ≤ sInf (f '' s) 
goal: f B ≤ sInf (f '' s)

full_name: GaloisConnection.l_csSup
code: theorem l_csSup (gc : GaloisConnection l u) {s : Set α} (hne : s.Nonempty) (hbdd : BddAbove s) :
    l (sSup s) = ⨆ x : s, l x 
goal: l (sSup s) = ⨆ x, l ↑x

full_name: GaloisConnection.l_csSup'
code: theorem l_csSup' (gc : GaloisConnection l u) {s : Set α} (hne : s.Nonempty) (hbdd : BddAbove s) :
    l (sSup s) = sSup (l '' s) 
goal: l (sSup s) = sSup (l '' s)

full_name: GaloisConnection.l_ciSup
code: theorem l_ciSup (gc : GaloisConnection l u) {f : ι → α} (hf : BddAbove (range f)) :
    l (⨆ i, f i) = ⨆ i, l (f i) 
goal: l (⨆ i, f i) = ⨆ i, l (f i)

full_name: GaloisConnection.l_ciSup_set
code: theorem l_ciSup_set (gc : GaloisConnection l u) {s : Set γ} {f : γ → α} (hf : BddAbove (f '' s))
    (hne : s.Nonempty) : l (⨆ i : s, f i) = ⨆ i : s, l (f i) 
goal: l (⨆ i, f ↑i) = ⨆ i, l (f ↑i)

full_name: GaloisConnection.u_csInf
code: theorem u_csInf (gc : GaloisConnection l u) {s : Set β} (hne : s.Nonempty) (hbdd : BddBelow s) :
    u (sInf s) = ⨅ x : s, u x 
goal: u (sInf s) = ⨅ x, u ↑x

full_name: GaloisConnection.u_csInf'
code: theorem u_csInf' (gc : GaloisConnection l u) {s : Set β} (hne : s.Nonempty) (hbdd : BddBelow s) :
    u (sInf s) = sInf (u '' s) 
goal: u (sInf s) = sInf (u '' s)

full_name: GaloisConnection.u_ciInf
code: theorem u_ciInf (gc : GaloisConnection l u) {f : ι → β} (hf : BddBelow (range f)) :
    u (⨅ i, f i) = ⨅ i, u (f i) 
goal: u (⨅ i, f i) = ⨅ i, u (f i)

full_name: GaloisConnection.u_ciInf_set
code: theorem u_ciInf_set (gc : GaloisConnection l u) {s : Set γ} {f : γ → β} (hf : BddBelow (f '' s))
    (hne : s.Nonempty) : u (⨅ i : s, f i) = ⨅ i : s, u (f i) 
goal: u (⨅ i, f ↑i) = ⨅ i, u (f ↑i)

full_name: OrderIso.map_csSup
code: theorem map_csSup (e : α ≃o β) {s : Set α} (hne : s.Nonempty) (hbdd : BddAbove s) :
    e (sSup s) = ⨆ x : s, e x 
goal: e (sSup s) = ⨆ x, e ↑x

full_name: OrderIso.map_csSup'
code: theorem map_csSup' (e : α ≃o β) {s : Set α} (hne : s.Nonempty) (hbdd : BddAbove s) :
    e (sSup s) = sSup (e '' s) 
goal: e (sSup s) = sSup (⇑e '' s)

full_name: OrderIso.map_ciSup
code: theorem map_ciSup (e : α ≃o β) {f : ι → α} (hf : BddAbove (range f)) :
    e (⨆ i, f i) = ⨆ i, e (f i) 
goal: e (⨆ i, f i) = ⨆ i, e (f i)

full_name: OrderIso.map_ciSup_set
code: theorem map_ciSup_set (e : α ≃o β) {s : Set γ} {f : γ → α} (hf : BddAbove (f '' s))
    (hne : s.Nonempty) : e (⨆ i : s, f i) = ⨆ i : s, e (f i) 
goal: e (⨆ i, f ↑i) = ⨆ i, e (f ↑i)

full_name: OrderIso.map_csInf
code: theorem map_csInf (e : α ≃o β) {s : Set α} (hne : s.Nonempty) (hbdd : BddBelow s) :
    e (sInf s) = ⨅ x : s, e x 
goal: e (sInf s) = ⨅ x, e ↑x

full_name: OrderIso.map_csInf'
code: theorem map_csInf' (e : α ≃o β) {s : Set α} (hne : s.Nonempty) (hbdd : BddBelow s) :
    e (sInf s) = sInf (e '' s) 
goal: e (sInf s) = sInf (⇑e '' s)

full_name: OrderIso.map_ciInf
code: theorem map_ciInf (e : α ≃o β) {f : ι → α} (hf : BddBelow (range f)) :
    e (⨅ i, f i) = ⨅ i, e (f i) 
goal: e (⨅ i, f i) = ⨅ i, e (f i)

full_name: OrderIso.map_ciInf_set
code: theorem map_ciInf_set (e : α ≃o β) {s : Set γ} {f : γ → α} (hf : BddBelow (f '' s))
    (hne : s.Nonempty) : e (⨅ i : s, f i) = ⨅ i : s, e (f i) 
goal: e (⨅ i, f ↑i) = ⨅ i, e (f ↑i)

full_name: csSup_image2_eq_csSup_csSup
code: theorem csSup_image2_eq_csSup_csSup (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a) (u₂ a)) (hs₀ : s.Nonempty) (hs₁ : BddAbove s)
    (ht₀ : t.Nonempty) (ht₁ : BddAbove t) : sSup (image2 l s t) = l (sSup s) (sSup t) 
goal: sSup (Set.image2 l s t) = l (sSup s) (sSup t)

full_name: csSup_image2_eq_csSup_csInf
code: theorem csSup_image2_eq_csSup_csInf (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    s.Nonempty → BddAbove s → t.Nonempty → BddBelow t → sSup (image2 l s t) = l (sSup s) (sInf t) 
goal: s.Nonempty → BddAbove s → t.Nonempty → BddBelow t → sSup (Set.image2 l s t) = l (sSup s) (sInf t)

full_name: csSup_image2_eq_csInf_csSup
code: theorem csSup_image2_eq_csInf_csSup (h₁ : ∀ b, GaloisConnection (swap l b ∘ ofDual) (toDual ∘ u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a) (u₂ a)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddAbove t → sSup (image2 l s t) = l (sInf s) (sSup t) 
goal: s.Nonempty → BddBelow s → t.Nonempty → BddAbove t → sSup (Set.image2 l s t) = l (sInf s) (sSup t)

full_name: csSup_image2_eq_csInf_csInf
code: theorem csSup_image2_eq_csInf_csInf (h₁ : ∀ b, GaloisConnection (swap l b ∘ ofDual) (toDual ∘ u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sSup (image2 l s t) = l (sInf s) (sInf t) 
goal: s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sSup (Set.image2 l s t) = l (sInf s) (sInf t)

full_name: csInf_image2_eq_csInf_csInf
code: theorem csInf_image2_eq_csInf_csInf (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sInf (image2 u s t) = u (sInf s) (sInf t) 
goal: s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sInf (Set.image2 u s t) = u (sInf s) (sInf t)

full_name: csInf_image2_eq_csInf_csSup
code: theorem csInf_image2_eq_csInf_csSup (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddAbove t → sInf (image2 u s t) = u (sInf s) (sSup t) 
goal: s.Nonempty → BddBelow s → t.Nonempty → BddAbove t → sInf (Set.image2 u s t) = u (sInf s) (sSup t)

full_name: csInf_image2_eq_csSup_csInf
code: theorem csInf_image2_eq_csSup_csInf (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) :
    s.Nonempty → BddAbove s → t.Nonempty → BddBelow t → sInf (image2 u s t) = u (sSup s) (sInf t) 
goal: s.Nonempty → BddAbove s → t.Nonempty → BddBelow t → sInf (Set.image2 u s t) = u (sSup s) (sInf t)

full_name: csInf_image2_eq_csSup_csSup
code: theorem csInf_image2_eq_csSup_csSup (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    s.Nonempty → BddAbove s → t.Nonempty → BddAbove t → sInf (image2 u s t) = u (sSup s) (sSup t) 
goal: s.Nonempty → BddAbove s → t.Nonempty → BddAbove t → sInf (Set.image2 u s t) = u (sSup s) (sSup t)

full_name: WithTop.conditionallyCompleteLattice
code: /-- Adding a top element to a conditionally complete lattice
gives a conditionally complete lattice -/
noncomputable instance WithTop.conditionallyCompleteLattice {α : Type*}
    [ConditionallyCompleteLattice α] : ConditionallyCompleteLattice (WithTop α) 
goal: ConditionallyCompleteLattice (WithTop α)

full_name: WithBot.conditionallyCompleteLattice
code: /-- Adding a bottom element to a conditionally complete lattice
gives a conditionally complete lattice -/
noncomputable instance WithBot.conditionallyCompleteLattice {α : Type*}
    [ConditionallyCompleteLattice α] : ConditionallyCompleteLattice (WithBot α) 
goal: ConditionallyCompleteLattice (WithBot α)

full_name: WithTop.WithBot.completeLattice
code: noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) 
goal: CompleteLattice (WithTop (WithBot α))

full_name: WithTop.WithBot.completeLinearOrder
code: noncomputable instance WithTop.WithBot.completeLinearOrder {α : Type*}
    [ConditionallyCompleteLinearOrder α] : CompleteLinearOrder (WithTop (WithBot α)) 
goal: CompleteLinearOrder (WithTop (WithBot α))

full_name: WithBot.WithTop.completeLattice
code: noncomputable instance WithBot.WithTop.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithBot (WithTop α)) 
goal: CompleteLattice (WithBot (WithTop α))

full_name: WithBot.WithTop.completeLinearOrder
code: noncomputable instance WithBot.WithTop.completeLinearOrder {α : Type*}
    [ConditionallyCompleteLinearOrder α] : CompleteLinearOrder (WithBot (WithTop α)) 
goal: CompleteLinearOrder (WithBot (WithTop α))

full_name: WithTop.iSup_coe_eq_top
code: lemma iSup_coe_eq_top : ⨆ x, (f x : WithTop α) = ⊤ ↔ ¬BddAbove (range f) 
goal: ⨆ x, ↑(f x) = ⊤ ↔ ¬BddAbove (Set.range f)

full_name: WithTop.iSup_coe_lt_top
code: lemma iSup_coe_lt_top : ⨆ x, (f x : WithTop α) < ⊤ ↔ BddAbove (range f) 
goal: ⨆ x, ↑(f x) < ⊤ ↔ BddAbove (Set.range f)

full_name: WithTop.iInf_coe_eq_top
code: lemma iInf_coe_eq_top : ⨅ x, (f x : WithTop α) = ⊤ ↔ IsEmpty ι 
goal: ⨅ x, ↑(f x) = ⊤ ↔ IsEmpty ι

full_name: WithTop.iInf_coe_lt_top
code: lemma iInf_coe_lt_top : ⨅ i, (f i : WithTop α) < ⊤ ↔ Nonempty ι 
goal: ⨅ i, ↑(f i) < ⊤ ↔ Nonempty ι