awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE : Epi S.g
refine_1 :
  Sum.elim
        ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
                (CC := carrier) S.f) :
            (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
          v)
        (Function.invFun (Hom.hom S.g).toFun ∘ w) ∘
      Sum.inl =
    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.f) :
        (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
      v
⊢ LE.le (α := Submodule R (↑S.X₂ : Type u_4)) ⊤
    (span R
      (range
        (Sum.elim
          ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦
                  (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC := carrier) S.f) :
              (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
            v)
          (Function.invFun (Hom.hom S.g).toFun ∘ w))))
have refine_2 : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤
  (span R
    (range
      ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
              (CC := carrier) S.g) :
          (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘
        Sum.elim
            ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦
                    (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC := carrier) S.f) :
                (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
              v)
            (Function.invFun (Hom.hom S.g).toFun ∘ w) ∘
          Sum.inr)))
Tactic: refine span_exact hS ?_ hv ?_
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE : Epi S.g
⊢ LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤
    (span R
      (range
        ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
                (CC := carrier) S.g) :
            (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘
          Sum.elim
              ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦
                      (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC := carrier) S.f) :
                  (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
                v)
              (Function.invFun (Hom.hom S.g).toFun ∘ w) ∘
            Sum.inr)))
have h : (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC :=
          carrier) S.g) :
      (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘
    Sum.elim
        ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
                (CC := carrier) S.f) :
            (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
          v)
        (Function.invFun (Hom.hom S.g).toFun ∘ w) ∘
      Sum.inr =
  w
Tactic: convert! hw
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE : Epi S.g
⊢ (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC :=
            carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘
      Sum.elim
          ((⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦
                  (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC := carrier) S.f) :
              (a : (↑S.X₁ : Type u_4)) → (↑S.X₂ : Type u_4)) ∘
            v)
          (Function.invFun (Hom.hom S.g).toFun ∘ w) ∘
        Sum.inr =
    w
have h : Function.comp (β := (↑S.X₂ : Type u_4))
    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
          (CC := carrier) S.g) :
      (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
    (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘ w) =
  w
Tactic: simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, Sum.elim_comp_inr]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (hypothesis)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE : Epi S.g
⊢ Function.comp (β := (↑S.X₂ : Type u_4))
      (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
      (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘ w) =
    w
have hE₁ : Function.Surjective (α := (↑S.X₂ : Type u_4)) (β := (↑S.X₃ : Type u_4))
  (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4)) (CC :=
        carrier) S.g) :
    (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
Tactic: rw [ModuleCat.epi_iff_surjective] at hE
Cleared hypotheses: hE
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE :
  Function.Surjective (α := (↑S.X₂ : Type u_4)) (β := (↑S.X₃ : Type u_4))
    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
          (CC := carrier) S.g) :
      (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
⊢ Function.comp (β := (↑S.X₂ : Type u_4))
      (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
      (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘ w) =
    w
have h : Function.comp (β := (↑S.X₂ : Type u_4))
      (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
      (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))) ∘
    w =
  w
Tactic: rw [← Function.comp_assoc, Function.RightInverse.comp_eq_id (Function.rightInverse_invFun hE),
      Function.id_comp]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE :
  Function.Surjective (α := (↑S.X₂ : Type u_4)) (β := (↑S.X₃ : Type u_4))
    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
          (CC := carrier) S.g) :
      (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
h :
  Function.comp (β := (↑S.X₂ : Type u_4))
        (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
              (CC := carrier) S.g) :
          (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
        (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))) ∘
      w =
    w
⊢ Function.comp (β := (↑S.X₂ : Type u_4))
      (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
      (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘ w) =
    w
have h₁ : id ∘ w = w
Tactic: rw [← Function.comp_assoc, Function.RightInverse.comp_eq_id (Function.rightInverse_invFun hE),
      Function.id_comp]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS : S.Exact
v : ι → (↑S.X₁ : Type u_4)
w : ι' → (↑S.X₃ : Type u_4)
hv : LE.le (α := Submodule R (↑S.X₁ : Type u_4)) ⊤ (span R (range v))
hw : LE.le (α := Submodule R (↑S.X₃ : Type u_4)) ⊤ (span R (range w))
hE :
  Function.Surjective (α := (↑S.X₂ : Type u_4)) (β := (↑S.X₃ : Type u_4))
    (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
          (CC := carrier) S.g) :
      (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
h :
  Function.comp (β := (↑S.X₂ : Type u_4))
        (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
              (CC := carrier) S.g) :
          (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
        (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))) ∘
      w =
    w
h₁ : id ∘ w = w
⊢ Function.comp (β := (↑S.X₂ : Type u_4))
      (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{u_4, u_3} R) ↦ (↑x1 : Type u_4) →ₗ[R] (↑x2 : Type u_4))
            (CC := carrier) S.g) :
        (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4))
      (Function.invFun (⇑(Hom.hom S.g) : (a : (↑S.X₂ : Type u_4)) → (↑S.X₃ : Type u_4)) ∘ w) =
    w
have h₂ : w = w
Tactic: rw [← Function.comp_assoc, Function.RightInverse.comp_eq_id (Function.rightInverse_invFun hE),
      Function.id_comp]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (hypothesis)
Goal:
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS' : S.ShortExact
inst_1 : Free.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_2 : Free.{u_3, u_4} R (↑S.X₃ : Type u_4)
inst_3 : StrongRankCondition R
⊢ Module.rank R (↑S.X₂ : Type u_4) = Module.rank R (↑S.X₁ : Type u_4) + Module.rank R (↑S.X₃ : Type u_4)
have this : Free.{u_3, u_4} R (↑S.X₂ : Type u_4)
Tactic: haveI := free_shortExact hS'
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS' : S.ShortExact
inst_1 : Free.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_2 : Free.{u_3, u_4} R (↑S.X₃ : Type u_4)
inst_3 : StrongRankCondition R
this : Free.{u_3, u_4} R (↑S.X₂ : Type u_4)
⊢ Module.rank R (↑S.X₂ : Type u_4) = Module.rank R (↑S.X₁ : Type u_4) + Module.rank R (↑S.X₃ : Type u_4)
have rw : Nonempty.{u_4 + 1}
  (Free.ChooseBasisIndex R (↑S.X₂ : Type u_4) ≃
    Free.ChooseBasisIndex R (↑S.X₁ : Type u_4) ⊕ Free.ChooseBasisIndex R (↑S.X₃ : Type u_4))
Tactic: rw [Module.Free.rank_eq_card_chooseBasisIndex, Module.Free.rank_eq_card_chooseBasisIndex R S.X₁,
    Module.Free.rank_eq_card_chooseBasisIndex R S.X₃, Cardinal.add_def, Cardinal.eq]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS' : S.ShortExact
n p : ℕ
inst_1 : Free.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_2 : Free.{u_3, u_4} R (↑S.X₃ : Type u_4)
inst_3 : Module.Finite.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_4 : Module.Finite.{u_3, u_4} R (↑S.X₃ : Type u_4)
hN : finrank.{u_3, u_4} R (↑S.X₁ : Type u_4) = n
hP : finrank.{u_3, u_4} R (↑S.X₃ : Type u_4) = p
inst_5 : StrongRankCondition R
⊢ finrank.{u_3, u_4} R (↑S.X₂ : Type u_4) = n + p
have h : Module.rank R (↑S.X₂ : Type u_4) = (↑(n + p) : Cardinal.{u_4})
Tactic: apply finrank_eq_of_rank_eq
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Free (goal)
Goal:
R : Type u_3
inst : Ring R
S : ShortComplex (ModuleCat.{u_4, u_3} R)
hS' : S.ShortExact
n p : ℕ
inst_1 : Free.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_2 : Free.{u_3, u_4} R (↑S.X₃ : Type u_4)
inst_3 : Module.Finite.{u_3, u_4} R (↑S.X₁ : Type u_4)
inst_4 : Module.Finite.{u_3, u_4} R (↑S.X₃ : Type u_4)
hN : finrank.{u_3, u_4} R (↑S.X₁ : Type u_4) = n
hP : finrank.{u_3, u_4} R (↑S.X₃ : Type u_4) = p
inst_5 : StrongRankCondition R
⊢ Module.rank R (↑S.X₂ : Type u_4) = (↑(n + p) : Cardinal.{u_4})
have h : Module.rank R (↑S.X₁ : Type u_4) + Module.rank R (↑S.X₃ : Type u_4) =
  (↑(finrank.{u_3, u_4} R (↑S.X₁ : Type u_4) + finrank.{u_3, u_4} R (↑S.X₃ : Type u_4)) : Cardinal.{u_4})
Tactic: rw [free_shortExact_rank_add hS', ← hN, ← hP]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Images (goal)
Goal:
R : Type u
inst : Ring R
G H : ModuleCat.{v, u} R
f : G ⟶ H
F' : MonoFactorisation f
x y : ↥(Hom.hom f).range
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          F'.e :
        (a : (↑G : Type v)) → (↑F'.I : Type v))
      (↑(Classical.indefiniteDescription
            (fun (x_1 : (↑G : Type v)) ↦
              (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(x + y) : (↑H : Type v)))
            ⋯) :
        (↑G : Type v)) =
    HAdd.hAdd (α := (↑F'.1 : Type v)) (β := (↑F'.1 : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) F'.e :
            (a : (↑G : Type v)) → (↑F'.I : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x_1 : (↑G : Type v)) ↦
                  (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑F'.I : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) F'.e :
            (a : (↑G : Type v)) → (↑F'.I : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x : (↑G : Type v)) ↦ (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x = (↑y : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑F'.I : Type v))
have a : Mono F'.m
Tactic: apply (mono_iff_injective F'.m).1
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Images (goal)
Goal:
R : Type u
inst : Ring R
G H : ModuleCat.{v, u} R
f : G ⟶ H
F' : MonoFactorisation f
x y : ↥(Hom.hom f).range
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          (F'.e ≫ F'.m) :
        (a : (↑G : Type v)) → (↑H : Type v))
      (↑(Classical.indefiniteDescription
            (fun (x_1 : (↑G : Type v)) ↦
              (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(x + y) : (↑H : Type v)))
            ⋯) :
        (↑G : Type v)) =
    HAdd.hAdd (α := (↑H : Type v)) (β := (↑H : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) (F'.e ≫ F'.m) :
            (a : (↑G : Type v)) → (↑H : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x_1 : (↑G : Type v)) ↦
                  (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑H : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) (F'.e ≫ F'.m) :
            (a : (↑G : Type v)) → (↑H : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x : (↑G : Type v)) ↦ (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x = (↑y : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑H : Type v))
have a : (↑(x + y) : (↑H : Type v)) = (↑x : (↑H : Type v)) + (↑y : (↑H : Type v))
Tactic: simp_rw [F'.fac, (Classical.indefiniteDescription (fun z => f z = _) _).2]
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Images (goal)
Goal:
R : Type u
inst : Ring R
G H : ModuleCat.{v, u} R
f : G ⟶ H
F' : MonoFactorisation f
c : R
x : ↥(Hom.hom f).range
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          F'.e :
        (a : (↑G : Type v)) → (↑F'.I : Type v))
      (↑(Classical.indefiniteDescription
            (fun (x_1 : (↑G : Type v)) ↦
              (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(c • x) : (↑H : Type v)))
            ⋯) :
        (↑G : Type v)) =
    HSMul.hSMul (α := R) (β := (↑F'.1 : Type v)) ((RingHom.id R : (a : R) → R) c : R)
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) F'.e :
            (a : (↑G : Type v)) → (↑F'.I : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x_1 : (↑G : Type v)) ↦
                  (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑F'.I : Type v))
have a : Mono F'.m
Tactic: apply (mono_iff_injective F'.m).1
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Images (goal)
Goal:
R : Type u
inst : Ring R
G H : ModuleCat.{v, u} R
f : G ⟶ H
F' : MonoFactorisation f
c : R
x : ↥(Hom.hom f).range
a : Mono F'.m
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          F'.e :
        (a : (↑G : Type v)) → (↑F'.I : Type v))
      (↑(Classical.indefiniteDescription
            (fun (x_1 : (↑G : Type v)) ↦
              (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(c • x) : (↑H : Type v)))
            ⋯) :
        (↑G : Type v)) =
    HSMul.hSMul (α := R) (β := (↑F'.1 : Type v)) ((RingHom.id R : (a : R) → R) c : R)
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) F'.e :
            (a : (↑G : Type v)) → (↑F'.I : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x_1 : (↑G : Type v)) ↦
                  (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                ⋯) :
            (↑G : Type v)) :
        (↑F'.I : Type v))
have a₁ : Eq (α := (↑H : Type v))
  ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          F'.m :
        (a : (↑F'.I : Type v)) → (↑H : Type v))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
              carrier) F'.e :
            (a : (↑G : Type v)) → (↑F'.I : Type v))
          (↑(Classical.indefiniteDescription
                (fun (x_1 : (↑G : Type v)) ↦
                  (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(c • x) : (↑H : Type v)))
                sorry) :
            (↑G : Type v)) :
        (↑F'.I : Type v)) :
    (↑H : Type v))
  ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
          F'.m :
        (a : (↑F'.I : Type v)) → (↑H : Type v))
      (HSMul.hSMul (α := R) (β := (↑F'.1 : Type v)) ((RingHom.id R : (a : R) → R) c : R)
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
                carrier) F'.e :
              (a : (↑G : Type v)) → (↑F'.I : Type v))
            (↑(Classical.indefiniteDescription
                  (fun (x_1 : (↑G : Type v)) ↦
                    (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                  sorry) :
              (↑G : Type v)) :
          (↑F'.I : Type v))) :
    (↑H : Type v))
Tactic: apply (mono_iff_injective F'.m).1
-- Lean 4 proof step from Mathlib.Algebra.Category.ModuleCat.Images (goal)
Goal:
R : Type u
inst : Ring R
G H : ModuleCat.{v, u} R
f : G ⟶ H
F' : MonoFactorisation f
c : R
x : ↥(Hom.hom f).range
⊢ Eq (α := (↑H : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
            carrier) F'.m :
          (a : (↑F'.I : Type v)) → (↑H : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
                carrier) F'.e :
              (a : (↑G : Type v)) → (↑F'.I : Type v))
            (↑(Classical.indefiniteDescription
                  (fun (x_1 : (↑G : Type v)) ↦
                    (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(c • x) : (↑H : Type v)))
                  ⋯) :
              (↑G : Type v)) :
          (↑F'.I : Type v)) :
      (↑H : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
            carrier) F'.m :
          (a : (↑F'.I : Type v)) → (↑H : Type v))
        (HSMul.hSMul (α := R) (β := (↑F'.1 : Type v)) ((RingHom.id R : (a : R) → R) c : R)
          ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
                  carrier) F'.e :
                (a : (↑G : Type v)) → (↑F'.I : Type v))
              (↑(Classical.indefiniteDescription
                    (fun (x_1 : (↑G : Type v)) ↦
                      (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                    ⋯) :
                (↑G : Type v)) :
            (↑F'.I : Type v))) :
      (↑H : Type v))
have a : (ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC := carrier)
        F'.m :
      (a : (↑F'.I : Type v)) → (↑H : Type v))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
            carrier) F'.e :
          (a : (↑G : Type v)) → (↑F'.I : Type v))
        (↑(Classical.indefiniteDescription
              (fun (x_1 : (↑G : Type v)) ↦
                (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑(c • x) : (↑H : Type v)))
              sorry) :
          (↑G : Type v)) :
      (↑F'.I : Type v)) =
  HSMul.hSMul (α := R) (β := (↑H : Type v)) ((RingHom.id R : (a : R) → R) c : R)
    ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
            carrier) F'.m :
          (a : (↑F'.I : Type v)) → (↑H : Type v))
        ((ConcreteCategory.hom (FC := fun (x1 x2 : ModuleCat.{v, u} R) ↦ (↑x1 : Type v) →ₗ[R] (↑x2 : Type v)) (CC :=
                carrier) F'.e :
              (a : (↑G : Type v)) → (↑F'.I : Type v))
            (↑(Classical.indefiniteDescription
                  (fun (x_1 : (↑G : Type v)) ↦
                    (Hom.hom f : (a : (↑G : Type v)) → (↑H : Type v)) x_1 = (↑x : (↑H : Type v)))
                  sorry) :
              (↑G : Type v)) :
          (↑F'.I : Type v)) :
      (↑H : Type v))
Tactic: rw [map_smul]