l3lab/ntp-mathlib huggingface dataset:
/-- The categorical subobjects of a module `M` are in one-to-one correspondence with its
    submodules.-/
noncomputable def subobjectModule : Subobject M ≃o Submodule R M :=
  OrderIso.symm
    { invFun := fun S => LinearMap.range S.arrow
      toFun := fun N => Subobject.mk (↾N.subtype)
      right_inv := fun S => Eq.symm (by
        fapply eq_mk_of_comm
        · apply LinearEquiv.toModuleIso'Left
          apply LinearEquiv.ofBijective (LinearMap.codRestrict (LinearMap.range S.arrow) S.arrow _)
          constructor
          · simp [← LinearMap.ker_eq_bot, LinearMap.ker_codRestrict]
            rw [ker_eq_bot_of_mono]
          · rw [← LinearMap.range_eq_top, LinearMap.range_codRestrict, Submodule.comap_subtype_self]
            exact LinearMap.mem_range_self _
        · apply LinearMap.ext
          intro x
          rfl)
      left_inv := fun N => by
        -- Porting note: The type of `↾N.subtype` was ambiguous. Not entirely sure, I made the right
        -- choice here
        convert congr_arg LinearMap.range
            (underlyingIso_arrow (↾N.subtype : of R { x // x ∈ N } ⟶ M)) using 1
        · have :
            -- Porting note: added the `.toLinearEquiv.toLinearMap`
            (underlyingIso (↾N.subtype : of R _ ⟶ M)).inv =
              (underlyingIso (↾N.subtype : of R _ ⟶ M)).symm.toLinearEquiv.toLinearMap := by
              apply LinearMap.ext
              intro x
              rfl
          rw [this, comp_def, LinearEquiv.range_comp]
        · exact (Submodule.range_subtype _).symm
      map_rel_iff' := fun {S T} => by
        refine' ⟨fun h => _, fun h => mk_le_mk_of_comm (↟(Submodule.inclusion h)) rfl⟩
        

Proof state:
R : Type u
inst✝ : Ring R
M : ModuleCat R
S T : Submodule R ↑M
h :
  { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      S ≤
    { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      T
⊢ S ≤ T

Next tactic:
convert LinearMap.range_comp_le_range (ofMkLEMk _ _ h) (↾T.subtype)
/-- The categorical subobjects of a module `M` are in one-to-one correspondence with its
    submodules.-/
noncomputable def subobjectModule : Subobject M ≃o Submodule R M :=
  OrderIso.symm
    { invFun := fun S => LinearMap.range S.arrow
      toFun := fun N => Subobject.mk (↾N.subtype)
      right_inv := fun S => Eq.symm (by
        fapply eq_mk_of_comm
        · apply LinearEquiv.toModuleIso'Left
          apply LinearEquiv.ofBijective (LinearMap.codRestrict (LinearMap.range S.arrow) S.arrow _)
          constructor
          · simp [← LinearMap.ker_eq_bot, LinearMap.ker_codRestrict]
            rw [ker_eq_bot_of_mono]
          · rw [← LinearMap.range_eq_top, LinearMap.range_codRestrict, Submodule.comap_subtype_self]
            exact LinearMap.mem_range_self _
        · apply LinearMap.ext
          intro x
          rfl)
      left_inv := fun N => by
        -- Porting note: The type of `↾N.subtype` was ambiguous. Not entirely sure, I made the right
        -- choice here
        convert congr_arg LinearMap.range
            (underlyingIso_arrow (↾N.subtype : of R { x // x ∈ N } ⟶ M)) using 1
        · have :
            -- Porting note: added the `.toLinearEquiv.toLinearMap`
            (underlyingIso (↾N.subtype : of R _ ⟶ M)).inv =
              (underlyingIso (↾N.subtype : of R _ ⟶ M)).symm.toLinearEquiv.toLinearMap := by
              apply LinearMap.ext
              intro x
              rfl
          rw [this, comp_def, LinearEquiv.range_comp]
        · exact (Submodule.range_subtype _).symm
      map_rel_iff' := fun {S T} => by
        refine' ⟨fun h => _, fun h => mk_le_mk_of_comm (↟(Submodule.inclusion h)) rfl⟩
        convert LinearMap.range_comp_le_range (ofMkLEMk _ _ h) (↾T.subtype)
        · 

Proof state:
case h.e'_3
R : Type u
inst✝ : Ring R
M : ModuleCat R
S T : Submodule R ↑M
h :
  { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      S ≤
    { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      T
⊢ S = LinearMap.range (↾(Submodule.subtype T) ∘ₗ ofMkLEMk (↾(Submodule.subtype S)) (↾(Submodule.subtype T)) h)

Next tactic:
simpa only [← comp_def, ofMkLEMk_comp] using (Submodule.range_subtype _).symm
/-- The categorical subobjects of a module `M` are in one-to-one correspondence with its
    submodules.-/
noncomputable def subobjectModule : Subobject M ≃o Submodule R M :=
  OrderIso.symm
    { invFun := fun S => LinearMap.range S.arrow
      toFun := fun N => Subobject.mk (↾N.subtype)
      right_inv := fun S => Eq.symm (by
        fapply eq_mk_of_comm
        · apply LinearEquiv.toModuleIso'Left
          apply LinearEquiv.ofBijective (LinearMap.codRestrict (LinearMap.range S.arrow) S.arrow _)
          constructor
          · simp [← LinearMap.ker_eq_bot, LinearMap.ker_codRestrict]
            rw [ker_eq_bot_of_mono]
          · rw [← LinearMap.range_eq_top, LinearMap.range_codRestrict, Submodule.comap_subtype_self]
            exact LinearMap.mem_range_self _
        · apply LinearMap.ext
          intro x
          rfl)
      left_inv := fun N => by
        -- Porting note: The type of `↾N.subtype` was ambiguous. Not entirely sure, I made the right
        -- choice here
        convert congr_arg LinearMap.range
            (underlyingIso_arrow (↾N.subtype : of R { x // x ∈ N } ⟶ M)) using 1
        · have :
            -- Porting note: added the `.toLinearEquiv.toLinearMap`
            (underlyingIso (↾N.subtype : of R _ ⟶ M)).inv =
              (underlyingIso (↾N.subtype : of R _ ⟶ M)).symm.toLinearEquiv.toLinearMap := by
              apply LinearMap.ext
              intro x
              rfl
          rw [this, comp_def, LinearEquiv.range_comp]
        · exact (Submodule.range_subtype _).symm
      map_rel_iff' := fun {S T} => by
        refine' ⟨fun h => _, fun h => mk_le_mk_of_comm (↟(Submodule.inclusion h)) rfl⟩
        convert LinearMap.range_comp_le_range (ofMkLEMk _ _ h) (↾T.subtype)
        · simpa only [← comp_def, ofMkLEMk_comp] using (Submodule.range_subtype _).symm
        · 

Proof state:
case h.e'_4
R : Type u
inst✝ : Ring R
M : ModuleCat R
S T : Submodule R ↑M
h :
  { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      S ≤
    { toFun := fun N => Subobject.mk (↾(Submodule.subtype N)), invFun := fun S => LinearMap.range (arrow S),
        left_inv :=
          (_ :
            ∀ (N : Submodule R ↑M),
              (fun S => LinearMap.range (arrow S)) ((fun N => Subobject.mk (↾(Submodule.subtype N))) N) = N),
        right_inv :=
          (_ :
            ∀ (S : Subobject M),
              (fun N => Subobject.mk (↾(Submodule.subtype N))) ((fun S => LinearMap.range (arrow S)) S) = S) }
      T
⊢ T = LinearMap.range (↾(Submodule.subtype T))

Next tactic:
exact (Submodule.range_subtype _).symm
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 := by
  -- Porting note: The whole proof was just `simp [toKernelSubobject]`.
  

Proof state:
R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (arrow (kernelSubobject f)) (toKernelSubobject x) = ↑x

Next tactic:
suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
    convert this
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 := by
  -- Porting note: The whole proof was just `simp [toKernelSubobject]`.
  suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
    

Proof state:
R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
this : (⇑(arrow (kernelSubobject f)) ∘ ⇑(kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = ↑x
⊢ (arrow (kernelSubobject f)) (toKernelSubobject x) = ↑x

Next tactic:
convert this
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 := by
  -- Porting note: The whole proof was just `simp [toKernelSubobject]`.
  suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
    convert this
  

Proof state:
R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (⇑(arrow (kernelSubobject f)) ∘ ⇑(kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = ↑x

Next tactic:
rw [Iso.trans_inv, ← coe_comp, Category.assoc]
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 := by
  -- Porting note: The whole proof was just `simp [toKernelSubobject]`.
  suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
    convert this
  rw [Iso.trans_inv, ← coe_comp, Category.assoc]
  

Proof state:
R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ ((kernelIsoKer f).inv ≫ (kernelSubobjectIso f).inv ≫ arrow (kernelSubobject f)) x = ↑x

Next tactic:
simp only [Category.assoc, kernelSubobject_arrow', kernelIsoKer_inv_kernel_ι]
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 := by
  -- Porting note: The whole proof was just `simp [toKernelSubobject]`.
  suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
    convert this
  rw [Iso.trans_inv, ← coe_comp, Category.assoc]
  simp only [Category.assoc, kernelSubobject_arrow', kernelIsoKer_inv_kernel_ι]
  

Proof state:
R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (Submodule.subtype (LinearMap.ker f)) x = ↑x

Next tactic:
aesop_cat
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
x y : ↑N
l : ↑L
w : x = y + g ((factorThruImageSubobject f) l)
⊢ (cokernel.π g) x = (cokernel.π g) y

Next tactic:
subst w
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  subst w
  -- Porting note: The proof from here used to just be `simp`.
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
y : ↑N
l : ↑L
⊢ (cokernel.π g) (y + g ((factorThruImageSubobject f) l)) = (cokernel.π g) y

Next tactic:
simp only [map_add, add_right_eq_self]
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  subst w
  -- Porting note: The proof from here used to just be `simp`.
  simp only [map_add, add_right_eq_self]
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
y : ↑N
l : ↑L
⊢ (cokernel.π g) (g ((factorThruImageSubobject f) l)) = 0

Next tactic:
change ((cokernel.π g) ∘ (g) ∘ (factorThruImageSubobject f)) l = 0
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  subst w
  -- Porting note: The proof from here used to just be `simp`.
  simp only [map_add, add_right_eq_self]
  change ((cokernel.π g) ∘ (g) ∘ (factorThruImageSubobject f)) l = 0
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
y : ↑N
l : ↑L
⊢ (⇑(cokernel.π g) ∘ ⇑g ∘ ⇑(factorThruImageSubobject f)) l = 0

Next tactic:
rw [← coe_comp, ← coe_comp, Category.assoc]
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  subst w
  -- Porting note: The proof from here used to just be `simp`.
  simp only [map_add, add_right_eq_self]
  change ((cokernel.π g) ∘ (g) ∘ (factorThruImageSubobject f)) l = 0
  rw [← coe_comp, ← coe_comp, Category.assoc]
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
y : ↑N
l : ↑L
⊢ (factorThruImageSubobject f ≫ g ≫ cokernel.π g) l = 0

Next tactic:
simp only [cokernel.condition, comp_zero]
/-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note: TODO compiler complains that this is marked with `@[ext]`. Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y := by
  subst w
  -- Porting note: The proof from here used to just be `simp`.
  simp only [map_add, add_right_eq_self]
  change ((cokernel.π g) ∘ (g) ∘ (factorThruImageSubobject f)) l = 0
  rw [← coe_comp, ← coe_comp, Category.assoc]
  simp only [cokernel.condition, comp_zero]
  

Proof state:
R : Type u
inst✝² : Ring R
M✝ L M N : ModuleCat R
f : L ⟶ M
inst✝¹ : HasImage f
g : underlying.obj (imageSubobject f) ⟶ N
inst✝ : HasCokernel g
y : ↑N
l : ↑L
⊢ 0 l = 0

Next tactic:
rfl
instance instSetLike : SetLike (Sublattice α) α where
  coe L := L.carrier
  coe_injective' L M h := by 

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L✝ M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
L M : Sublattice α
h : (fun L => L.carrier) L = (fun L => L.carrier) M
⊢ L = M

Next tactic:
cases L
instance instSetLike : SetLike (Sublattice α) α where
  coe L := L.carrier
  coe_injective' L M h := by cases L; 

Proof state:
case mk
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
M : Sublattice α
carrier✝ : Set α
supClosed'✝ : SupClosed carrier✝
infClosed'✝ : InfClosed carrier✝
h :
  (fun L => L.carrier) { carrier := carrier✝, supClosed' := supClosed'✝, infClosed' := infClosed'✝ } =
    (fun L => L.carrier) M
⊢ { carrier := carrier✝, supClosed' := supClosed'✝, infClosed' := infClosed'✝ } = M

Next tactic:
congr
@[simp, norm_cast] lemma coe_iInf (f : ι → Sublattice α) : ⨅ i, f i = ⋂ i, (f i : Set α) := by
  

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : ι → Sublattice α
⊢ ↑(⨅ i, f i) = ⋂ i, ↑(f i)

Next tactic:
simp [iInf]
@[simp, norm_cast] lemma coe_eq_univ : L = (univ : Set α) ↔ L = ⊤ := by 

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
⊢ ↑L = univ ↔ L = ⊤

Next tactic:
rw [← coe_top, coe_inj]
@[simp, norm_cast] lemma coe_eq_empty : L = (∅ : Set α) ↔ L = ⊥ := by 

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
⊢ ↑L = ∅ ↔ L = ⊥

Next tactic:
rw [← coe_bot, coe_inj]
@[simp] lemma mem_sInf {S : Set (Sublattice α)} : a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L := by
  

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
S : Set (Sublattice α)
⊢ a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L

Next tactic:
rw [← SetLike.mem_coe]
@[simp] lemma mem_sInf {S : Set (Sublattice α)} : a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L := by
  rw [← SetLike.mem_coe]; 

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
S : Set (Sublattice α)
⊢ a ∈ ↑(sInf S) ↔ ∀ L ∈ S, a ∈ L

Next tactic:
simp
@[simp] lemma mem_iInf {f : ι → Sublattice α} : a ∈ ⨅ i, f i ↔ ∀ i, a ∈ f i := by
  

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : ι → Sublattice α
⊢ a ∈ ⨅ i, f i ↔ ∀ (i : ι), a ∈ f i

Next tactic:
rw [← SetLike.mem_coe]
@[simp] lemma mem_iInf {f : ι → Sublattice α} : a ∈ ⨅ i, f i ↔ ∀ i, a ∈ f i := by
  rw [← SetLike.mem_coe]; 

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : ι → Sublattice α
⊢ a ∈ ↑(⨅ i, f i) ↔ ∀ (i : ι), a ∈ f i

Next tactic:
simp
lemma map_symm_eq_iff_eq_map {M : Sublattice β} {e : β ≃o α} :
    L.map ↑e.symm = M ↔ L = M.map ↑e := by
  

Proof state:
ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
M : Sublattice β
e : β ≃o α
⊢ map
        {
          toSupHom :=
            { toFun := ⇑(OrderIso.symm e),
              map_sup' := (_ : ∀ (a b : α), (OrderIso.symm e) (a ⊔ b) = (OrderIso.symm e) a ⊔ (OrderIso.symm e) b) },
          map_inf' := (_ : ∀ (a b : α), (OrderIso.symm e) (a ⊓ b) = (OrderIso.symm e) a ⊓ (OrderIso.symm e) b) }
        L =
      M ↔
    L =
      map
        { toSupHom := { toFun := ⇑e, map_sup' := (_ : ∀ (a b : β), e (a ⊔ b) = e a ⊔ e b) },
          map_inf' := (_ : ∀ (a b : β), e (a ⊓ b) = e a ⊓ e b) }
        M

Next tactic:
simp_rw [← coe_inj]