[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
⊢ eigenspace f (-coeff q 0 / leadingCoeff q) =
    LinearMap.ker (leadingCoeff q • f - ↑(algebraMap K (End K V)) (-coeff q 0))
[PROOFSTEP]
rw [eigenspace_div]
[GOAL]
case hb
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
⊢ leadingCoeff q ≠ 0
[PROOFSTEP]
intro h
[GOAL]
case hb
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
h : leadingCoeff q = 0
⊢ False
[PROOFSTEP]
rw [leadingCoeff_eq_zero_iff_deg_eq_bot.1 h] at hq
[GOAL]
case hb
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : ⊥ = 1
h : leadingCoeff q = 0
⊢ False
[PROOFSTEP]
cases hq
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
⊢ LinearMap.ker (leadingCoeff q • f - ↑(algebraMap K (End K V)) (-coeff q 0)) =
    LinearMap.ker (↑(aeval f) (↑C (leadingCoeff q) * X + ↑C (coeff q 0)))
[PROOFSTEP]
rw [C_mul', aeval_def]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
⊢ LinearMap.ker (leadingCoeff q • f - ↑(algebraMap K (End K V)) (-coeff q 0)) =
    LinearMap.ker (eval₂ (algebraMap K (End K V)) f (leadingCoeff q • X + ↑C (coeff q 0)))
[PROOFSTEP]
simp [algebraMap, Algebra.toRingHom]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
q : K[X]
hq : degree q = 1
⊢ LinearMap.ker (↑(aeval f) (↑C (leadingCoeff q) * X + ↑C (coeff q 0))) = LinearMap.ker (↑(aeval f) q)
[PROOFSTEP]
rwa [← eq_X_add_C_of_degree_eq_one]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
c : K[X]ˣ
⊢ LinearMap.ker (↑(aeval f) ↑c) = ⊥
[PROOFSTEP]
rw [Polynomial.eq_C_of_degree_eq_zero (degree_coe_units c)]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
c : K[X]ˣ
⊢ LinearMap.ker (↑(aeval f) (↑C (coeff (↑c) 0))) = ⊥
[PROOFSTEP]
simp only [aeval_def, eval₂_C]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
c : K[X]ˣ
⊢ LinearMap.ker (↑(algebraMap K (End K V)) (coeff (↑c) 0)) = ⊥
[PROOFSTEP]
apply ker_algebraMap_end
[GOAL]
case ha
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
c : K[X]ˣ
⊢ coeff (↑c) 0 ≠ 0
[PROOFSTEP]
apply coeff_coe_units_zero_ne_zero c
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
⊢ ↑(↑(aeval f) p) x = eval μ p • x
[PROOFSTEP]
refine' p.induction_on _ _ _
[GOAL]
case refine'_1
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
⊢ ∀ (a : K), ↑(↑(aeval f) (↑C a)) x = eval μ (↑C a) • x
[PROOFSTEP]
intro a
[GOAL]
case refine'_1
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
a : K
⊢ ↑(↑(aeval f) (↑C a)) x = eval μ (↑C a) • x
[PROOFSTEP]
simp [Module.algebraMap_end_apply]
[GOAL]
case refine'_2
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
⊢ ∀ (p q : K[X]),
    ↑(↑(aeval f) p) x = eval μ p • x → ↑(↑(aeval f) q) x = eval μ q • x → ↑(↑(aeval f) (p + q)) x = eval μ (p + q) • x
[PROOFSTEP]
intro p q hp hq
[GOAL]
case refine'_2
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p✝ : K[X]
μ : K
x : V
h : HasEigenvector f μ x
p q : K[X]
hp : ↑(↑(aeval f) p) x = eval μ p • x
hq : ↑(↑(aeval f) q) x = eval μ q • x
⊢ ↑(↑(aeval f) (p + q)) x = eval μ (p + q) • x
[PROOFSTEP]
simp [hp, hq, add_smul]
[GOAL]
case refine'_3
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
⊢ ∀ (n : ℕ) (a : K),
    ↑(↑(aeval f) (↑C a * X ^ n)) x = eval μ (↑C a * X ^ n) • x →
      ↑(↑(aeval f) (↑C a * X ^ (n + 1))) x = eval μ (↑C a * X ^ (n + 1)) • x
[PROOFSTEP]
intro n a hna
[GOAL]
case refine'_3
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
n : ℕ
a : K
hna : ↑(↑(aeval f) (↑C a * X ^ n)) x = eval μ (↑C a * X ^ n) • x
⊢ ↑(↑(aeval f) (↑C a * X ^ (n + 1))) x = eval μ (↑C a * X ^ (n + 1)) • x
[PROOFSTEP]
rw [mul_comm, pow_succ, mul_assoc, AlgHom.map_mul, LinearMap.mul_apply, mul_comm, hna]
[GOAL]
case refine'_3
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
p : K[X]
μ : K
x : V
h : HasEigenvector f μ x
n : ℕ
a : K
hna : ↑(↑(aeval f) (↑C a * X ^ n)) x = eval μ (↑C a * X ^ n) • x
⊢ ↑(↑(aeval f) X) (eval μ (↑C a * X ^ n) • x) = eval μ (X * (↑C a * X ^ n)) • x
[PROOFSTEP]
simp only [mem_eigenspace_iff.1 h.1, smul_smul, aeval_X, eval_mul, eval_C, eval_pow, eval_X, LinearMap.map_smulₛₗ,
  RingHom.id_apply, mul_comm]
[GOAL]
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : HasEigenvalue f μ
⊢ IsRoot (minpoly K f) μ
[PROOFSTEP]
rcases(Submodule.ne_bot_iff _).1 h with ⟨w, ⟨H, ne0⟩⟩
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : HasEigenvalue f μ
w : V
H : w ∈ eigenspace f μ
ne0 : w ≠ 0
⊢ IsRoot (minpoly K f) μ
[PROOFSTEP]
refine' Or.resolve_right (smul_eq_zero.1 _) ne0
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
μ : K
h : HasEigenvalue f μ
w : V
H : w ∈ eigenspace f μ
ne0 : w ≠ 0
⊢ eval μ (minpoly K f) • w = 0
[PROOFSTEP]
simp [← aeval_apply_of_hasEigenvector ⟨H, ne0⟩, minpoly.aeval K f]
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
⊢ HasEigenvalue f μ
[PROOFSTEP]
cases' dvd_iff_isRoot.2 h with p hp
[GOAL]
case intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
⊢ HasEigenvalue f μ
[PROOFSTEP]
rw [HasEigenvalue, eigenspace]
[GOAL]
case intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
⊢ LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) ≠ ⊥
[PROOFSTEP]
intro con
[GOAL]
case intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
⊢ False
[PROOFSTEP]
cases' (LinearMap.isUnit_iff_ker_eq_bot _).2 con with u hu
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
⊢ False
[PROOFSTEP]
have p_ne_0 : p ≠ 0 := by
  intro con
  apply minpoly.ne_zero f.isIntegral
  rw [hp, con, mul_zero]
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
⊢ p ≠ 0
[PROOFSTEP]
intro con
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con✝ : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
con : p = 0
⊢ False
[PROOFSTEP]
apply minpoly.ne_zero f.isIntegral
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con✝ : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
con : p = 0
⊢ minpoly K f = 0
[PROOFSTEP]
rw [hp, con, mul_zero]
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
⊢ False
[PROOFSTEP]
have : (aeval f) p = 0 := by
  have h_aeval := minpoly.aeval K f
  revert h_aeval
  simp [hp, ← hu]
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
⊢ ↑(aeval f) p = 0
[PROOFSTEP]
have h_aeval := minpoly.aeval K f
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
h_aeval : ↑(aeval f) (minpoly K f) = 0
⊢ ↑(aeval f) p = 0
[PROOFSTEP]
revert h_aeval
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
⊢ ↑(aeval f) (minpoly K f) = 0 → ↑(aeval f) p = 0
[PROOFSTEP]
simp [hp, ← hu]
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
this : ↑(aeval f) p = 0
⊢ False
[PROOFSTEP]
have h_deg := minpoly.degree_le_of_ne_zero K f p_ne_0 this
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
this : ↑(aeval f) p = 0
h_deg : degree (minpoly K f) ≤ degree p
⊢ False
[PROOFSTEP]
rw [hp, degree_mul, degree_X_sub_C, Polynomial.degree_eq_natDegree p_ne_0] at h_deg
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
this : ↑(aeval f) p = 0
h_deg : 1 + ↑(natDegree p) ≤ ↑(natDegree p)
⊢ False
[PROOFSTEP]
norm_cast at h_deg
[GOAL]
case intro.intro
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : IsRoot (minpoly K f) μ
p : K[X]
hp : minpoly K f = (X - ↑C μ) * p
con : LinearMap.ker (f - ↑(algebraMap K (End K V)) μ) = ⊥
u : (V →ₗ[K] V)ˣ
hu : ↑u = f - ↑(algebraMap K (End K V)) μ
p_ne_0 : p ≠ 0
this : ↑(aeval f) p = 0
h_deg : 1 + natDegree p ≤ natDegree p
⊢ False
[PROOFSTEP]
linarith
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f✝ : End K V
μ : K
f : End K V
⊢ Set.Finite {μ | eigenspace f μ ≠ ⊥}
[PROOFSTEP]
have h : minpoly K f ≠ 0 := minpoly.ne_zero f.isIntegral
[GOAL]
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f✝ : End K V
μ : K
f : End K V
h : minpoly K f ≠ 0
⊢ Set.Finite {μ | eigenspace f μ ≠ ⊥}
[PROOFSTEP]
convert (minpoly K f).rootSet_finite K
[GOAL]
case h.e'_2
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f✝ : End K V
μ : K
f : End K V
h : minpoly K f ≠ 0
⊢ {μ | eigenspace f μ ≠ ⊥} = rootSet (minpoly K f) K
[PROOFSTEP]
ext μ
[GOAL]
case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f✝ : End K V
μ✝ : K
f : End K V
h : minpoly K f ≠ 0
μ : K
⊢ μ ∈ {μ | eigenspace f μ ≠ ⊥} ↔ μ ∈ rootSet (minpoly K f) K
[PROOFSTEP]
rw [Set.mem_setOf_eq, ← HasEigenvalue, hasEigenvalue_iff_isRoot, mem_rootSet_of_ne h, IsRoot, coe_aeval_eq_eval]


[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : C
f : End X
h : IsIso f
⊢ f * inv f = 1
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : C
f : End X
h : IsIso f
⊢ inv f * f = 1
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : C
f g : (End X)ˣ
⊢ Equiv.toFun
      { toFun := fun f => Iso.mk (↑f) f.inv,
        invFun := fun f =>
          { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
        left_inv :=
          (_ :
            ∀ (x : (End X)ˣ),
              (fun f =>
                    { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                      inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                  ((fun f => Iso.mk (↑f) f.inv) x) =
                x),
        right_inv :=
          (_ :
            ∀ (x : Aut X),
              (fun f => Iso.mk (↑f) f.inv)
                  ((fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    x) =
                x) }
      (f * g) =
    Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        f *
      Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        g
[PROOFSTEP]
cases f
[GOAL]
case mk
C : Type u
inst✝ : Category.{v, u} C
X : C
g : (End X)ˣ
val✝ inv✝ : End X
val_inv✝ : val✝ * inv✝ = 1
inv_val✝ : inv✝ * val✝ = 1
⊢ Equiv.toFun
      { toFun := fun f => Iso.mk (↑f) f.inv,
        invFun := fun f =>
          { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
        left_inv :=
          (_ :
            ∀ (x : (End X)ˣ),
              (fun f =>
                    { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                      inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                  ((fun f => Iso.mk (↑f) f.inv) x) =
                x),
        right_inv :=
          (_ :
            ∀ (x : Aut X),
              (fun f => Iso.mk (↑f) f.inv)
                  ((fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    x) =
                x) }
      ({ val := val✝, inv := inv✝, val_inv := val_inv✝, inv_val := inv_val✝ } * g) =
    Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        { val := val✝, inv := inv✝, val_inv := val_inv✝, inv_val := inv_val✝ } *
      Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
C : Type u
inst✝ : Category.{v, u} C
X : C
val✝¹ inv✝¹ : End X
val_inv✝¹ : val✝¹ * inv✝¹ = 1
inv_val✝¹ : inv✝¹ * val✝¹ = 1
val✝ inv✝ : End X
val_inv✝ : val✝ * inv✝ = 1
inv_val✝ : inv✝ * val✝ = 1
⊢ Equiv.toFun
      { toFun := fun f => Iso.mk (↑f) f.inv,
        invFun := fun f =>
          { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
        left_inv :=
          (_ :
            ∀ (x : (End X)ˣ),
              (fun f =>
                    { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                      inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                  ((fun f => Iso.mk (↑f) f.inv) x) =
                x),
        right_inv :=
          (_ :
            ∀ (x : Aut X),
              (fun f => Iso.mk (↑f) f.inv)
                  ((fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    x) =
                x) }
      ({ val := val✝¹, inv := inv✝¹, val_inv := val_inv✝¹, inv_val := inv_val✝¹ } *
        { val := val✝, inv := inv✝, val_inv := val_inv✝, inv_val := inv_val✝ }) =
    Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        { val := val✝¹, inv := inv✝¹, val_inv := val_inv✝¹, inv_val := inv_val✝¹ } *
      Equiv.toFun
        { toFun := fun f => Iso.mk (↑f) f.inv,
          invFun := fun f =>
            { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X), inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) },
          left_inv :=
            (_ :
              ∀ (x : (End X)ˣ),
                (fun f =>
                      { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                        inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                    ((fun f => Iso.mk (↑f) f.inv) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun f => Iso.mk (↑f) f.inv)
                    ((fun f =>
                        { val := f.hom, inv := f.inv, val_inv := (_ : f.inv ≫ f.hom = 𝟙 X),
                          inv_val := (_ : f.hom ≫ f.inv = 𝟙 X) })
                      x) =
                  x) }
        { val := val✝, inv := inv✝, val_inv := val_inv✝, inv_val := inv_val✝ }
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X Y : C
h : X ≅ Y
x✝ : Aut X
⊢ (fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv))
      ((fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom)) x✝) =
    x✝
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X Y : C
h : X ≅ Y
x✝ : Aut Y
⊢ (fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom))
      ((fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv)) x✝) =
    x✝
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X Y : C
h : X ≅ Y
⊢ ∀ (x y : Aut X),
    Equiv.toFun
        { toFun := fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom),
          invFun := fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv),
          left_inv :=
            (_ :
              ∀ (x : Aut X),
                (fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv))
                    ((fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom)) x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : Aut Y),
                (fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom))
                    ((fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv)) x) =
                  x) }
        (x * y) =
      Equiv.toFun
          { toFun := fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom),
            invFun := fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv),
            left_inv :=
              (_ :
                ∀ (x : Aut X),
                  (fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv))
                      ((fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom)) x) =
                    x),
            right_inv :=
              (_ :
                ∀ (x : Aut Y),
                  (fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom))
                      ((fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv)) x) =
                    x) }
          x *
        Equiv.toFun
          { toFun := fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom),
            invFun := fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv),
            left_inv :=
              (_ :
                ∀ (x : Aut X),
                  (fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv))
                      ((fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom)) x) =
                    x),
            right_inv :=
              (_ :
                ∀ (x : Aut Y),
                  (fun x => Iso.mk (h.inv ≫ x.hom ≫ h.hom) (h.inv ≫ x.inv ≫ h.hom))
                      ((fun y => Iso.mk (h.hom ≫ y.hom ≫ h.inv) (h.hom ≫ y.inv ≫ h.inv)) x) =
                    x) }
          y
[PROOFSTEP]
simp [Aut_mul_def]


[GOAL]
α : Type u
h h' : LE α
c : BoundedOrder α
top : α
⊢ Top α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
h h' : LE α
c : BoundedOrder α
top : α
eq_top : top = ⊤
bot : α
⊢ Bot α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
h h' : LE α
c : BoundedOrder α
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
le_eq : ∀ (x y : α), x ≤ y ↔ x ≤ y
x✝ : α
⊢ x✝ ≤ ⊤
[PROOFSTEP]
simp [eq_top, le_eq]
[GOAL]
α : Type u
h h' : LE α
c : BoundedOrder α
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
le_eq : ∀ (x y : α), x ≤ y ↔ x ≤ y
x✝ : α
⊢ ⊥ ≤ x✝
[PROOFSTEP]
simp [eq_bot, le_eq]
[GOAL]
α : Type u
c : Lattice α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ Lattice α
[PROOFSTEP]
refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬le b a .. }
[GOAL]
case refine'_1
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a : α), a ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_1
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ : α
⊢ a✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_2
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c
[PROOFSTEP]
intro _ _ _ hab hbc
[GOAL]
case refine'_2
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
rw [eq_le] at hab hbc ⊢
[GOAL]
case refine'_2
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
exact le_trans hab hbc
[GOAL]
case refine'_3
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_3
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ < b✝ ↔ a✝ ≤ b✝ ∧ ¬b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_4
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ≤ b → b ≤ a → a = b
[PROOFSTEP]
intro _ _ hab hba
[GOAL]
case refine'_4
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
simp_rw [eq_le] at hab hba
[GOAL]
case refine'_4
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
exact le_antisymm hab hba
[GOAL]
case refine'_5
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_5
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_6
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), b ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_6
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ b✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_7
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c_1 : α), a ≤ c_1 → b ≤ c_1 → a ⊔ b ≤ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_7
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ a✝ ⊔ b✝ ≤ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_7
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ sup a✝ b✝ ≤ c✝
[PROOFSTEP]
simp [eq_sup, hac, hbc]
[GOAL]
case refine'_8
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ⊓ b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_8
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_9
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ⊓ b ≤ b
[PROOFSTEP]
intros
[GOAL]
case refine'_9
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ b✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_10
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c_1 : α), a ≤ b → a ≤ c_1 → a ≤ b ⊓ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_10
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ b✝ ⊓ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_10
α : Type u
c : Lattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ inf b✝ c✝
[PROOFSTEP]
simp [eq_inf, hac, hbc]
[GOAL]
α : Type u
c : DistribLattice α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ DistribLattice α
[PROOFSTEP]
refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬le b a .. }
[GOAL]
case refine'_1
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a : α), a ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_1
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ : α
⊢ a✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_2
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c
[PROOFSTEP]
intro _ _ _ hab hbc
[GOAL]
case refine'_2
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
rw [eq_le] at hab hbc ⊢
[GOAL]
case refine'_2
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
exact le_trans hab hbc
[GOAL]
case refine'_3
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_3
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ < b✝ ↔ a✝ ≤ b✝ ∧ ¬b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_4
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ≤ b → b ≤ a → a = b
[PROOFSTEP]
intro _ _ hab hba
[GOAL]
case refine'_4
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
simp_rw [eq_le] at hab hba
[GOAL]
case refine'_4
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
exact le_antisymm hab hba
[GOAL]
case refine'_5
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_5
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_6
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), b ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_6
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ b✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_7
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c_1 : α), a ≤ c_1 → b ≤ c_1 → a ⊔ b ≤ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_7
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ a✝ ⊔ b✝ ≤ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_7
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ sup a✝ b✝ ≤ c✝
[PROOFSTEP]
simp [eq_sup, hac, hbc]
[GOAL]
case refine'_8
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ⊓ b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_8
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_9
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b : α), a ⊓ b ≤ b
[PROOFSTEP]
intros
[GOAL]
case refine'_9
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ b✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_10
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (a b c_1 : α), a ≤ b → a ≤ c_1 → a ≤ b ⊓ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_10
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ b✝ ⊓ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_10
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ inf b✝ c✝
[PROOFSTEP]
simp [eq_inf, hac, hbc]
[GOAL]
case refine'_11
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
⊢ ∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z
[PROOFSTEP]
intros
[GOAL]
case refine'_11
α : Type u
c : DistribLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
x✝ y✝ z✝ : α
⊢ (x✝ ⊔ y✝) ⊓ (x✝ ⊔ z✝) ≤ x✝ ⊔ y✝ ⊓ z✝
[PROOFSTEP]
simp [eq_le, eq_inf, eq_sup, le_sup_inf]
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
⊢ Top α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
⊢ Bot α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
⊢ SupSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
⊢ InfSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ CompleteLattice α
[PROOFSTEP]
refine'
  { Lattice.copy (@CompleteLattice.toLattice α c) le eq_le sup eq_sup inf eq_inf with le := le, top := top, bot := bot,
    sup := sup, inf := inf, sSup := sSup, sInf := sInf .. }
[GOAL]
case refine'_1
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (s : Set α) (a : α), a ∈ s → a ≤ SupSet.sSup s
[PROOFSTEP]
intro _ _ h
[GOAL]
case refine'_1
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
s✝ : Set α
a✝ : α
h : a✝ ∈ s✝
⊢ a✝ ≤ SupSet.sSup s✝
[PROOFSTEP]
simp [eq_le, eq_sSup, le_sSup _ _ h]
[GOAL]
case refine'_2
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (s : Set α) (a : α), (∀ (b : α), b ∈ s → b ≤ a) → SupSet.sSup s ≤ a
[PROOFSTEP]
intro _ _ h
[GOAL]
case refine'_2
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
s✝ : Set α
a✝ : α
h : ∀ (b : α), b ∈ s✝ → b ≤ a✝
⊢ SupSet.sSup s✝ ≤ a✝
[PROOFSTEP]
simpa [eq_le, eq_sSup] using h
[GOAL]
case refine'_3
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (s : Set α) (a : α), a ∈ s → InfSet.sInf s ≤ a
[PROOFSTEP]
intro _ _ h
[GOAL]
case refine'_3
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
s✝ : Set α
a✝ : α
h : a✝ ∈ s✝
⊢ InfSet.sInf s✝ ≤ a✝
[PROOFSTEP]
simp [eq_le, eq_sInf, sInf_le _ _ h]
[GOAL]
case refine'_4
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (s : Set α) (a : α), (∀ (b : α), b ∈ s → a ≤ b) → a ≤ InfSet.sInf s
[PROOFSTEP]
intro _ _ h
[GOAL]
case refine'_4
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
s✝ : Set α
a✝ : α
h : ∀ (b : α), b ∈ s✝ → a✝ ≤ b
⊢ a✝ ≤ InfSet.sInf s✝
[PROOFSTEP]
simpa [eq_le, eq_sInf] using h
[GOAL]
case refine'_5
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (x : α), x ≤ ⊤
[PROOFSTEP]
intros
[GOAL]
case refine'_5
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
x✝ : α
⊢ x✝ ≤ ⊤
[PROOFSTEP]
simp [eq_le, eq_top]
[GOAL]
case refine'_6
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
⊢ ∀ (x : α), ⊥ ≤ x
[PROOFSTEP]
intros
[GOAL]
case refine'_6
α : Type u
c : CompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : Lattice α := Lattice.copy toLattice le eq_le sup eq_sup inf eq_inf
x✝ : α
⊢ ⊥ ≤ x✝
[PROOFSTEP]
simp [eq_le, eq_bot]
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
⊢ Top α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
⊢ Bot α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
⊢ SupSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
⊢ InfSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Frame α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : CompleteLattice α :=
  CompleteLattice.copy Frame.toCompleteLattice le eq_le top eq_top bot eq_bot sup eq_sup inf eq_inf sSup eq_sSup sInf
    eq_sInf
a : α
s : Set α
⊢ a ⊓ SupSet.sSup s ≤ ⨆ (b : α) (_ : b ∈ s), a ⊓ b
[PROOFSTEP]
simp [eq_le, eq_sup, eq_inf, eq_sSup, @Order.Frame.inf_sSup_le_iSup_inf α _ a s]
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
⊢ Top α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
⊢ Bot α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
⊢ SupSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
⊢ InfSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : Coframe α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
src✝ : CompleteLattice α :=
  CompleteLattice.copy Coframe.toCompleteLattice le eq_le top eq_top bot eq_bot sup eq_sup inf eq_inf sSup eq_sSup sInf
    eq_sInf
a : α
s : Set α
⊢ ⨅ (b : α) (_ : b ∈ s), a ⊔ b ≤ a ⊔ InfSet.sInf s
[PROOFSTEP]
simp [eq_le, eq_sup, eq_inf, eq_sInf, @Order.Coframe.iInf_sup_le_sup_sInf α _ a s]
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
⊢ Top α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
⊢ Bot α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
⊢ SupSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : CompleteDistribLattice α
le : α → α → Prop
eq_le : le = LE.le
top : α
eq_top : top = ⊤
bot : α
eq_bot : bot = ⊥
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
⊢ InfSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
⊢ LE α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
⊢ Sup α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
⊢ Inf α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
⊢ SupSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
⊢ InfSet α
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ConditionallyCompleteLattice α
[PROOFSTEP]
refine' { le := le, sup := sup, inf := inf, sSup := sSup, sInf := sInf .. }
[GOAL]
case refine'_1
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ α → α → Prop
[PROOFSTEP]
intro a b
[GOAL]
case refine'_1
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a b : α
⊢ Prop
[PROOFSTEP]
exact le a b ∧ ¬le b a
[GOAL]
case refine'_2
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a : α), a ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_2
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ : α
⊢ a✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_3
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c
[PROOFSTEP]
intro _ _ _ hab hbc
[GOAL]
case refine'_3
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
rw [eq_le] at hab hbc ⊢
[GOAL]
case refine'_3
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hab : a✝ ≤ b✝
hbc : b✝ ≤ c✝
⊢ a✝ ≤ c✝
[PROOFSTEP]
exact le_trans hab hbc
[GOAL]
case refine'_4
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_4
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
⊢ a✝ < b✝ ↔ a✝ ≤ b✝ ∧ ¬b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le]
[GOAL]
case refine'_5
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), a ≤ b → b ≤ a → a = b
[PROOFSTEP]
intro _ _ hab hba
[GOAL]
case refine'_5
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
simp_rw [eq_le] at hab hba
[GOAL]
case refine'_5
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
hab : a✝ ≤ b✝
hba : b✝ ≤ a✝
⊢ a✝ = b✝
[PROOFSTEP]
exact le_antisymm hab hba
[GOAL]
case refine'_6
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), a ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_6
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
⊢ a✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_7
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), b ≤ a ⊔ b
[PROOFSTEP]
intros
[GOAL]
case refine'_7
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
⊢ b✝ ≤ a✝ ⊔ b✝
[PROOFSTEP]
simp [eq_le, eq_sup]
[GOAL]
case refine'_8
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b c_1 : α), a ≤ c_1 → b ≤ c_1 → a ⊔ b ≤ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_8
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ a✝ ⊔ b✝ ≤ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_8
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hac : a✝ ≤ c✝
hbc : b✝ ≤ c✝
⊢ sup a✝ b✝ ≤ c✝
[PROOFSTEP]
simp [eq_sup, hac, hbc]
[GOAL]
case refine'_9
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), a ⊓ b ≤ a
[PROOFSTEP]
intros
[GOAL]
case refine'_9
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ a✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_10
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b : α), a ⊓ b ≤ b
[PROOFSTEP]
intros
[GOAL]
case refine'_10
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ : α
⊢ a✝ ⊓ b✝ ≤ b✝
[PROOFSTEP]
simp [eq_le, eq_inf]
[GOAL]
case refine'_11
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (a b c_1 : α), a ≤ b → a ≤ c_1 → a ≤ b ⊓ c_1
[PROOFSTEP]
intro _ _ _ hac hbc
[GOAL]
case refine'_11
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ b✝ ⊓ c✝
[PROOFSTEP]
simp_rw [eq_le] at hac hbc ⊢
[GOAL]
case refine'_11
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
a✝ b✝ c✝ : α
hac : a✝ ≤ b✝
hbc : a✝ ≤ c✝
⊢ a✝ ≤ inf b✝ c✝
[PROOFSTEP]
simp [eq_inf, hac, hbc]
[GOAL]
case refine'_12
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (s : Set α) (a : α), BddAbove s → a ∈ s → a ≤ SupSet.sSup s
[PROOFSTEP]
intro _ _ hb h
[GOAL]
case refine'_12
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
s✝ : Set α
a✝ : α
hb : BddAbove s✝
h : a✝ ∈ s✝
⊢ a✝ ≤ SupSet.sSup s✝
[PROOFSTEP]
subst_vars
[GOAL]
case refine'_12
α : Type u
c : ConditionallyCompleteLattice α
s✝ : Set α
a✝ : α
h : a✝ ∈ s✝
hb : BddAbove s✝
⊢ a✝ ≤ sSup s✝
[PROOFSTEP]
exact le_csSup _ _ hb h
[GOAL]
case refine'_13
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (s : Set α) (a : α), Set.Nonempty s → a ∈ upperBounds s → SupSet.sSup s ≤ a
[PROOFSTEP]
intro _ _ hb h
[GOAL]
case refine'_13
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
s✝ : Set α
a✝ : α
hb : Set.Nonempty s✝
h : a✝ ∈ upperBounds s✝
⊢ SupSet.sSup s✝ ≤ a✝
[PROOFSTEP]
subst_vars
[GOAL]
case refine'_13
α : Type u
c : ConditionallyCompleteLattice α
s✝ : Set α
a✝ : α
hb : Set.Nonempty s✝
h : a✝ ∈ upperBounds s✝
⊢ sSup s✝ ≤ a✝
[PROOFSTEP]
exact csSup_le _ _ hb h
[GOAL]
case refine'_14
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (s : Set α) (a : α), BddBelow s → a ∈ s → InfSet.sInf s ≤ a
[PROOFSTEP]
intro _ _ hb h
[GOAL]
case refine'_14
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
s✝ : Set α
a✝ : α
hb : BddBelow s✝
h : a✝ ∈ s✝
⊢ InfSet.sInf s✝ ≤ a✝
[PROOFSTEP]
subst_vars
[GOAL]
case refine'_14
α : Type u
c : ConditionallyCompleteLattice α
s✝ : Set α
a✝ : α
h : a✝ ∈ s✝
hb : BddBelow s✝
⊢ sInf s✝ ≤ a✝
[PROOFSTEP]
exact csInf_le _ _ hb h
[GOAL]
case refine'_15
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
⊢ ∀ (s : Set α) (a : α), Set.Nonempty s → a ∈ lowerBounds s → a ≤ InfSet.sInf s
[PROOFSTEP]
intro _ _ hb h
[GOAL]
case refine'_15
α : Type u
c : ConditionallyCompleteLattice α
le : α → α → Prop
eq_le : le = LE.le
sup : α → α → α
eq_sup : sup = Sup.sup
inf : α → α → α
eq_inf : inf = Inf.inf
sSup : Set α → α
eq_sSup : sSup = SupSet.sSup
sInf : Set α → α
eq_sInf : sInf = InfSet.sInf
s✝ : Set α
a✝ : α
hb : Set.Nonempty s✝
h : a✝ ∈ lowerBounds s✝
⊢ a✝ ≤ InfSet.sInf s✝
[PROOFSTEP]
subst_vars
[GOAL]
case refine'_15
α : Type u
c : ConditionallyCompleteLattice α
s✝ : Set α
a✝ : α
hb : Set.Nonempty s✝
h : a✝ ∈ lowerBounds s✝
⊢ a✝ ≤ sInf s✝
[PROOFSTEP]
exact le_csInf _ _ hb h