l3lab/ntp-mathlib huggingface dataset:
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  

Proof state:
case inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a b : ℕ
hab : Coprime a b
ha : a ≠ 0
⊢ Finset.filter IsPrimePow (divisors (a * b)) = Finset.filter IsPrimePow (divisors a ∪ divisors b)

Next tactic:
rcases eq_or_ne b 0 with (rfl | hb)
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  rcases eq_or_ne b 0 with (rfl | hb)
  · 

Proof state:
case inr.inl
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a : ℕ
ha : a ≠ 0
hab : Coprime a 0
⊢ Finset.filter IsPrimePow (divisors (a * 0)) = Finset.filter IsPrimePow (divisors a ∪ divisors 0)

Next tactic:
simp only [Nat.coprime_zero_right] at hab
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  rcases eq_or_ne b 0 with (rfl | hb)
  · simp only [Nat.coprime_zero_right] at hab
    

Proof state:
case inr.inl
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a : ℕ
ha : a ≠ 0
hab : a = 1
⊢ Finset.filter IsPrimePow (divisors (a * 0)) = Finset.filter IsPrimePow (divisors a ∪ divisors 0)

Next tactic:
simp [hab, Finset.filter_singleton, not_isPrimePow_one]
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  rcases eq_or_ne b 0 with (rfl | hb)
  · simp only [Nat.coprime_zero_right] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  

Proof state:
case inr.inr
R : Type u_1
inst✝ : CommMonoidWithZero R
n p : R
k a b : ℕ
hab : Coprime a b
ha : a ≠ 0
hb : b ≠ 0
⊢ Finset.filter IsPrimePow (divisors (a * b)) = Finset.filter IsPrimePow (divisors a ∪ divisors b)

Next tactic:
ext n
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  rcases eq_or_ne b 0 with (rfl | hb)
  · simp only [Nat.coprime_zero_right] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  ext n
  

Proof state:
case inr.inr.a
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k a b : ℕ
hab : Coprime a b
ha : a ≠ 0
hb : b ≠ 0
n : ℕ
⊢ n ∈ Finset.filter IsPrimePow (divisors (a * b)) ↔ n ∈ Finset.filter IsPrimePow (divisors a ∪ divisors b)

Next tactic:
simp only [ha, hb, Finset.mem_union, Finset.mem_filter, Nat.mul_eq_zero, and_true_iff, Ne.def,
    and_congr_left_iff, not_false_iff, Nat.mem_divisors, or_self_iff]
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow := by
  rcases eq_or_ne a 0 with (rfl | ha)
  · simp only [Nat.coprime_zero_left] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  rcases eq_or_ne b 0 with (rfl | hb)
  · simp only [Nat.coprime_zero_right] at hab
    simp [hab, Finset.filter_singleton, not_isPrimePow_one]
  ext n
  simp only [ha, hb, Finset.mem_union, Finset.mem_filter, Nat.mul_eq_zero, and_true_iff, Ne.def,
    and_congr_left_iff, not_false_iff, Nat.mem_divisors, or_self_iff]
  

Proof state:
case inr.inr.a
R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p : R
k a b : ℕ
hab : Coprime a b
ha : a ≠ 0
hb : b ≠ 0
n : ℕ
⊢ IsPrimePow n → (n ∣ a * b ↔ n ∣ a ∨ n ∣ b)

Next tactic:
apply hab.isPrimePow_dvd_mul
@[simp]
theorem WithTop.iInf_empty {α : Type*} [IsEmpty ι] [InfSet α] (f : ι → WithTop α) :
    ⨅ i, f i = ⊤ := by 

Proof state:
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝¹ : IsEmpty ι
inst✝ : InfSet α
f : ι → WithTop α
⊢ ⨅ i, f i = ⊤

Next tactic:
rw [iInf, range_eq_empty, WithTop.sInf_empty]
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
hs : Set.Nonempty s
⊢ ↑(sInf s) = sInf ((fun a => ↑a) '' s)

Next tactic:
obtain ⟨x, hx⟩ := hs
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  obtain ⟨x, hx⟩ := hs
  

Proof state:
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
⊢ ↑(sInf s) = sInf ((fun a => ↑a) '' s)

Next tactic:
change _ = ite _ _ _
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  obtain ⟨x, hx⟩ := hs
  change _ = ite _ _ _
  

Proof state:
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
⊢ ↑(sInf s) = if (fun a => ↑a) '' s ⊆ {⊤} then ⊤ else ↑(sInf ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)))

Next tactic:
split_ifs with h
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  obtain ⟨x, hx⟩ := hs
  change _ = ite _ _ _
  split_ifs with h
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : (fun a => ↑a) '' s ⊆ {⊤}
⊢ ↑(sInf s) = ⊤

Next tactic:
cases h (mem_image_of_mem _ hx)
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  obtain ⟨x, hx⟩ := hs
  change _ = ite _ _ _
  split_ifs with h
  · cases h (mem_image_of_mem _ hx)
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : ¬(fun a => ↑a) '' s ⊆ {⊤}
⊢ ↑(sInf s) = ↑(sInf ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)))

Next tactic:
rw [preimage_image_eq]
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  obtain ⟨x, hx⟩ := hs
  change _ = ite _ _ _
  split_ifs with h
  · cases h (mem_image_of_mem _ hx)
  · rw [preimage_image_eq]
    

Proof state:
case neg.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : ¬(fun a => ↑a) '' s ⊆ {⊤}
⊢ Injective fun a => ↑a

Next tactic:
exact Option.some_injective _
@[norm_cast]
theorem WithTop.coe_iInf [Nonempty ι] [InfSet α] (f : ι → α) :
    ↑(⨅ i, f i) = (⨅ i, f i : WithTop α) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Nonempty ι
inst✝ : InfSet α
f : ι → α
⊢ ↑(⨅ i, f i) = ⨅ i, ↑(f i)

Next tactic:
rw [iInf, iInf, WithTop.coe_sInf' (range_nonempty f), ← range_comp]
@[norm_cast]
theorem WithTop.coe_iInf [Nonempty ι] [InfSet α] (f : ι → α) :
    ↑(⨅ i, f i) = (⨅ i, f i : WithTop α) := by
  rw [iInf, iInf, WithTop.coe_sInf' (range_nonempty f), ← range_comp]; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Nonempty ι
inst✝ : InfSet α
f : ι → α
⊢ sInf (range ((fun a => ↑a) ∘ f)) = sInf (range fun i => ↑(f i))

Next tactic:
rfl
theorem WithTop.coe_sSup' [Preorder α] [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) = sSup ((fun a => ↑a) '' s)

Next tactic:
change _ = ite _ _ _
theorem WithTop.coe_sSup' [Preorder α] [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  change _ = ite _ _ _
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) =
    if ⊤ ∈ (fun a => ↑a) '' s then ⊤
    else
      if BddAbove ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)) then ↑(sSup ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s))) else ⊤

Next tactic:
rw [if_neg, preimage_image_eq, if_pos hs]
theorem WithTop.coe_sSup' [Preorder α] [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  change _ = ite _ _ _
  rw [if_neg, preimage_image_eq, if_pos hs]
  · 

Proof state:
case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ Injective fun a => ↑a

Next tactic:
exact Option.some_injective _
theorem WithTop.coe_sSup' [Preorder α] [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) := by
  change _ = ite _ _ _
  rw [if_neg, preimage_image_eq, if_pos hs]
  · exact Option.some_injective _
  · 

Proof state:
case hnc
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ⊤ ∉ (fun a => ↑a) '' s

Next tactic:
rintro ⟨x, _, ⟨⟩⟩
@[norm_cast]
theorem WithTop.coe_iSup [Preorder α] [SupSet α] (f : ι → α) (h : BddAbove (Set.range f)) :
    ↑(⨆ i, f i) = (⨆ i, f i : WithTop α) := by
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
f : ι → α
h : BddAbove (range f)
⊢ ↑(⨆ i, f i) = ⨆ i, ↑(f i)

Next tactic:
rw [iSup, iSup, WithTop.coe_sSup' h, ← range_comp]
@[norm_cast]
theorem WithTop.coe_iSup [Preorder α] [SupSet α] (f : ι → α) (h : BddAbove (Set.range f)) :
    ↑(⨆ i, f i) = (⨆ i, f i : WithTop α) := by
    rw [iSup, iSup, WithTop.coe_sSup' h, ← range_comp]; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
f : ι → α
h : BddAbove (range f)
⊢ sSup (range ((fun a => ↑a) ∘ f)) = sSup (range fun i => ↑(f i))

Next tactic:
rfl
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      

Proof state:
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
⊢ min a b = if a ≤ b then a else b

Next tactic:
by_cases hab : a = b
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · 

Proof state:
case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : a = b
⊢ min a b = if a ≤ b then a else b

Next tactic:
simp [hab]
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · 

Proof state:
case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
⊢ min a b = if a ≤ b then a else b

Next tactic:
rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · 

Proof state:
case neg.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
h₁ : a ≤ b
⊢ min a b = if a ≤ b then a else b

Next tactic:
simp [h₁]
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · 

Proof state:
case neg.inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
h₂ : b ≤ a
⊢ min a b = if a ≤ b then a else b

Next tactic:
simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
    max_def := fun a b ↦ by
      

Proof state:
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
⊢ max a b = if a ≤ b then b else a

Next tactic:
by_cases hab : a = b
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
    max_def := fun a b ↦ by
      by_cases hab : a = b
      · 

Proof state:
case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : a = b
⊢ max a b = if a ≤ b then b else a

Next tactic:
simp [hab]
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
    max_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · 

Proof state:
case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
⊢ max a b = if a ≤ b then b else a

Next tactic:
rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
    max_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · 

Proof state:
case neg.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
h₁ : a ≤ b
⊢ max a b = if a ≤ b then b else a

Next tactic:
simp [h₁]
instance (α : Type*) [ConditionallyCompleteLinearOrder α] : LinearOrder α :=
  { ‹ConditionallyCompleteLinearOrder α› with
    max := Sup.sup, min := Inf.inf,
    min_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
    max_def := fun a b ↦ by
      by_cases hab : a = b
      · simp [hab]
      · rcases ConditionallyCompleteLinearOrder.le_total a b with (h₁ | h₂)
        · simp [h₁]
        · 

Proof state:
case neg.inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLinearOrder α
src✝ : ConditionallyCompleteLinearOrder α := inst✝
a b : α
hab : ¬a = b
h₂ : b ≤ a
⊢ max a b = if a ≤ b then b else a

Next tactic:
simp [show ¬(a ≤ b) from fun h => hab (le_antisymm h h₂), h₂]
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
⊢ ∀ (s : Set α) (a : α), BddAbove s → a ∈ s → a ≤ sSup s

Next tactic:
intros
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : BddAbove s✝
a✝ : a✝² ∈ s✝
⊢ a✝² ≤ sSup s✝

Next tactic:
apply le_sSup
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; 

Proof state:
case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : BddAbove s✝
a✝ : a✝² ∈ s✝
⊢ a✝² ∈ s✝

Next tactic:
assumption
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
⊢ ∀ (s : Set α) (a : α), Set.Nonempty s → a ∈ upperBounds s → sSup s ≤ a

Next tactic:
intros
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : Set.Nonempty s✝
a✝ : a✝² ∈ upperBounds s✝
⊢ sSup s✝ ≤ a✝²

Next tactic:
apply sSup_le
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; 

Proof state:
case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : Set.Nonempty s✝
a✝ : a✝² ∈ upperBounds s✝
⊢ ∀ b ∈ s✝, b ≤ a✝²

Next tactic:
assumption
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; assumption
    csInf_le := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
⊢ ∀ (s : Set α) (a : α), BddBelow s → a ∈ s → sInf s ≤ a

Next tactic:
intros
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; assumption
    csInf_le := by intros; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : BddBelow s✝
a✝ : a✝² ∈ s✝
⊢ sInf s✝ ≤ a✝²

Next tactic:
apply sInf_le
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; assumption
    csInf_le := by intros; apply sInf_le; 

Proof state:
case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : BddBelow s✝
a✝ : a✝² ∈ s✝
⊢ a✝² ∈ s✝

Next tactic:
assumption
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; assumption
    csInf_le := by intros; apply sInf_le; assumption
    le_csInf := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
⊢ ∀ (s : Set α) (a : α), Set.Nonempty s → a ∈ lowerBounds s → a ≤ sInf s

Next tactic:
intros
/-- 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 α :=
  { ‹CompleteLattice α› with
    le_csSup := by intros; apply le_sSup; assumption
    csSup_le := by intros; apply sSup_le; assumption
    csInf_le := by intros; apply sInf_le; assumption
    le_csInf := by intros; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : CompleteLattice α
src✝ : CompleteLattice α := inst✝
s✝ : Set α
a✝² : α
a✝¹ : Set.Nonempty s✝
a✝ : a✝² ∈ lowerBounds s✝
⊢ a✝² ≤ sInf s✝

Next tactic:
apply le_sInf