awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Finite.Quotient (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Module R M
inst_3 : IsDomain R
inst_4 : IsPrincipalIdealRing R
inst_5 : Finite ι
F : Type u_4
inst_6 : CommRing F
inst_7 : Algebra F R
inst_8 : Module F M
inst_9 : IsScalarTower F R M
b : Basis ι R M
N : Submodule R M
h : finrank.{u_2, u_3} R ↥N = finrank R M
⊢ (M ⧸ N) ≃ₗ[F] ⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})
have haveI : (this : Fintype ι) →
  (M ⧸ N) ≃ₗ[F] ⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})
Tactic: haveI := Fintype.ofFinite ι
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Finite.Quotient (goal)
Goal:
R : Type u_2
M : Type u_3
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Module R M
inst_3 : IsDomain R
inst_4 : IsPrincipalIdealRing R
F : Type u_4
inst_5 : CommRing F
inst_6 : Algebra F R
inst_7 : Module F M
inst_8 : IsScalarTower F R M
N : Submodule R M
ι : Type u_5
inst_9 : Fintype ι
b : Basis ι R M
inst_10 : Nontrivial F
h : finrank.{u_2, u_3} R ↥N = finrank R M
inst_11 :
  ∀ (i : ι), Free.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
inst_12 :
  ∀ (i : ι),
    Module.Finite.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
⊢ finrank.{u_4, u_3} F (M ⧸ N) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
have rw : finrank F (⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})) =
  ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
Tactic: rw [LinearEquiv.finrank_eq <| quotientEquivDirectSum F b h, Module.finrank_directSum]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Finite.Quotient (goal)
Goal:
R : Type u_2
M : Type u_3
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Module R M
inst_3 : IsDomain R
inst_4 : IsPrincipalIdealRing R
F : Type u_4
inst_5 : CommRing F
inst_6 : Algebra F R
inst_7 : Module F M
inst_8 : IsScalarTower F R M
N : Submodule R M
ι : Type u_5
inst_9 : Fintype ι
b : Basis ι R M
inst_10 : Nontrivial F
h : finrank.{u_2, u_3} R ↥N = finrank R M
inst_11 :
  ∀ (i : ι), Free.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
inst_12 :
  ∀ (i : ι),
    Module.Finite.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
rw :
  finrank F (⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
⊢ finrank.{u_4, u_3} F (M ⧸ N) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i}))
have rw₁ : Eq (α := ℕ)
  (∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})))
  (∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (Ideal.span {smithNormalFormCoeffs b h i})))
Tactic: rw [LinearEquiv.finrank_eq <| quotientEquivDirectSum F b h, Module.finrank_directSum]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.IdealQuotient (goal)
Goal:
R : Type u_2
S : Type u_3
inst : CommRing R
inst_1 : CommRing S
inst_2 : Algebra R S
inst_3 : IsDomain R
inst_4 : IsPrincipalIdealRing R
inst_5 : IsDomain S
F : Type u_4
inst_6 : CommRing F
inst_7 : Algebra F R
inst_8 : Algebra F S
inst_9 : IsScalarTower F R S
I : Ideal S
hI : I ≠ ⊥
ι : Type u_5
inst_10 : Fintype ι
b : Basis ι R S
inst_11 : Nontrivial F
inst_12 : ∀ (i : ι), Free.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
inst_13 : ∀ (i : ι), Module.Finite.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
⊢ finrank.{u_4, u_3} F (S ⧸ I) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
have rw : finrank F (⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i})) =
  ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
Tactic: rw [LinearEquiv.finrank_eq <| quotientEquivDirectSum F b hI, Module.finrank_directSum]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.IdealQuotient (goal)
Goal:
R : Type u_2
S : Type u_3
inst : CommRing R
inst_1 : CommRing S
inst_2 : Algebra R S
inst_3 : IsDomain R
inst_4 : IsPrincipalIdealRing R
inst_5 : IsDomain S
F : Type u_4
inst_6 : CommRing F
inst_7 : Algebra F R
inst_8 : Algebra F S
inst_9 : IsScalarTower F R S
I : Ideal S
hI : I ≠ ⊥
ι : Type u_5
inst_10 : Fintype ι
b : Basis ι R S
inst_11 : Nontrivial F
inst_12 : ∀ (i : ι), Free.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
inst_13 : ∀ (i : ι), Module.Finite.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
rw :
  finrank F (⨁ (i : ι), HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i})) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
⊢ finrank.{u_4, u_3} F (S ⧸ I) =
    ∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i}))
have rw₁ : Eq (α := ℕ) (∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i})))
  (∑ i : ι, finrank.{u_4, u_2} F (HasQuotient.Quotient R (B := Ideal R) (span {smithCoeffs b I hI i})))
Tactic: rw [LinearEquiv.finrank_eq <| quotientEquivDirectSum F b hI, Module.finrank_directSum]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
snf : SmithNormalForm N ι n
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {snf.a i}))
have rcases : ∀ (bM : Basis ι R M) (bN : Basis.{0, u_2, u_3} (Fin n) R ↥N) (f : Fin n ↪ ι) (a : Fin n → R)
  (snf :
    ∀ (i : Fin n),
      (↑((bN : (a : Fin n) → ↥N) i) : M) =
        HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)),
  N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n,
        AddSubgroup.index.{u_2} (G := R)
          (Submodule.toAddSubgroup
            (Ideal.span {{ bM := bM, bN := bN, f := f, a := a, snf := snf : SmithNormalForm N ι n }.a i}))
Tactic: rcases snf with ⟨bM, bN, f, a, snf⟩
Cleared hypotheses: snf
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n,
        AddSubgroup.index.{u_2} (G := R)
          (Submodule.toAddSubgroup
            (Ideal.span {{ bM := bM, bN := bN, f := f, a := a, snf := snf : SmithNormalForm N ι n }.a i}))
have dsimp : N.toAddSubgroup.index =
  Nat.card R ^ (Fintype.card ι - n) *
    ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
Tactic: dsimp only
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (hypothesis)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
have hN' : let N' := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N;
N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
Tactic: set N' : Submodule R (ι → R) := N.map bM.equivFun.toLinearMap with hN'
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
i : Fin n
⊢ Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
    (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
have simp : Eq (α := ι → R) ((↑((bM.equivFun.submoduleMap N : (a : ↥N) → ↥N') ((bN : (a : Fin n) → ↥N) i)) : ι → R) : ι → R)
  (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
Tactic: simp only [map_apply, bN']
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
i : Fin n
⊢ Eq (α := ι → R) ((↑((bM.equivFun.submoduleMap N : (a : ↥N) → ↥N') ((bN : (a : Fin n) → ↥N) i)) : ι → R) : ι → R)
    (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
have rw : Eq (α := ι → R) ((bM.equivFun : (a : M) → ι → R) (↑((bN : (a : Fin n) → ↥N) i) : M) : ι → R)
  (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
Tactic: rw [LinearEquiv.submoduleMap_apply]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
i : Fin n
⊢ Eq (α := ι → R) ((bM.equivFun : (a : M) → ι → R) (↑((bN : (a : Fin n) → ↥N) i) : M) : ι → R)
    (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
have simp : HSMul.hSMul (β := ι → R) (a i) (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) 1 : (j : ι) → R) =
  Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i)
Tactic: simp only [equivFun_apply, snf, map_smul, repr_self, Finsupp.single_eq_pi_single]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
i : Fin n
⊢ HSMul.hSMul (β := ι → R) (a i) (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) 1 : (j : ι) → R) =
    Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i)
have h : ∀ (j : ι),
  HSMul.hSMul (β := ι → R) (a i) (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) 1 : (j : ι) → R) j =
    Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) j
Tactic: ext j
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (hypothesis)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
have snf' : ∀ (i : Fin n),
  Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
    (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
Tactic: have snf' : ∀ i, (bN' i : ι → R) = Pi.single (f i) (a i) := by
    intro i
    simp only [map_apply, bN']
    rw [LinearEquiv.submoduleMap_apply]
    simp only [equivFun_apply, snf, map_smul, repr_self, Finsupp.single_eq_pi_single]
    ext j
    simp [Pi.single_apply]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (hypothesis)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
⊢ N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
have he : let e : (ι → R) ≃+ M := (↑bM.equivFun.symm : (ι → R) ≃+ M);
e = (↑bM.equivFun.symm : (ι → R) ≃+ M)
Tactic: set e : (ι → R) ≃+ M := ↑bM.equivFun.symm with he
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (hypothesis)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
e : (ι → R) ≃+ M := (↑bM.equivFun.symm : (ι → R) ≃+ M)
he : e = (↑bM.equivFun.symm : (ι → R) ≃+ M)
e' : (ι → R) →+ M := (↑e : (ι → R) →+ M)
⊢ N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
have he' : Function.Surjective (α := ι → R) (β := M) (⇑e' : (a : ι → R) → M)
Tactic: have he' : Function.Surjective e' := e.surjective
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
e : (ι → R) ≃+ M := (↑bM.equivFun.symm : (ι → R) ≃+ M)
he : e = (↑bM.equivFun.symm : (ι → R) ≃+ M)
e' : (ι → R) →+ M := (↑e : (ι → R) →+ M)
he' : Function.Surjective (α := ι → R) (β := M) (⇑e' : (a : ι → R) → M)
⊢ N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
have h : Eq (α := AddGroup (ι → R)) AddCommGroup.toAddGroup (Pi.addGroup (f := fun (a : ι) ↦ R)) →
  Eq (α := AddSubgroup (ι → R)) N'.toAddSubgroup (AddSubgroup.comap e' N.toAddSubgroup)
Tactic: convert! (AddSubgroup.index_comap_of_surjective N.toAddSubgroup he').symm using 2
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
e : (ι → R) ≃+ M := (↑bM.equivFun.symm : (ι → R) ≃+ M)
he : e = (↑bM.equivFun.symm : (ι → R) ≃+ M)
e' : (ι → R) →+ M := (↑e : (ι → R) →+ M)
he' : Function.Surjective (α := ι → R) (β := M) (⇑e' : (a : ι → R) → M)
e_2 : Eq (α := AddGroup (ι → R)) AddCommGroup.toAddGroup (Pi.addGroup (f := fun (a : ι) ↦ R))
⊢ Eq (α := AddSubgroup (ι → R)) N'.toAddSubgroup (AddSubgroup.comap e' N.toAddSubgroup)
have h : Eq (α := AddSubgroup (ι → R)) (Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N).toAddSubgroup
  (AddSubgroup.map (↑(↑bM.equivFun : M ≃+ (ι → R)) : M →+ ι → R) N.toAddSubgroup)
Tactic: rw [AddSubgroup.comap_equiv_eq_map_symm, he, hN', LinearEquiv.coe_toAddEquiv_symm,
    AddEquiv.symm_symm]
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (hypothesis)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
have hNN' : N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
Tactic: have hNN' : N.toAddSubgroup.index = N'.toAddSubgroup.index := by
    set e : (ι → R) ≃+ M := ↑bM.equivFun.symm with he
    let e' : (ι → R) →+ M := e
    have he' : Function.Surjective e' := e.surjective
    convert! (AddSubgroup.index_comap_of_surjective N.toAddSubgroup he').symm using 2
    rw [AddSubgroup.comap_equiv_eq_map_symm, he, hN', LinearEquiv.coe_toAddEquiv_symm,
    AddEquiv.symm_symm]
    exact Submodule.map_toAddSubgroup ..
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
hNN' : N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
⊢ N.toAddSubgroup.index =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
have rw : AddSubgroup.index (G := ι → R) N'.toAddSubgroup =
  Nat.card R ^ (Fintype.card ι - n) *
    ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
Tactic: rw [hNN']
-- Lean 4 proof step from Mathlib.LinearAlgebra.FreeModule.Int (goal)
Goal:
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst : CommRing R
inst_1 : AddCommGroup M
inst_2 : Fintype ι
inst_3 : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis.{0, u_2, u_3} (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf :
  ∀ (i : Fin n),
    (↑((bN : (a : Fin n) → ↥N) i) : M) =
      HSMul.hSMul (β := M) (a i) ((bM : (a : ι) → M) ((f : (a : Fin n) → ι) i : ι) : M)
N' : Submodule R (ι → R) := Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
hN' : N' = Submodule.map (↑bM.equivFun : M →ₗ[R] ι → R) N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' :
  ∀ (i : Fin n),
    Eq (α := ι → R) ((↑((bN' : (a : Fin n) → ↥N') i) : ι → R) : ι → R)
      (Pi.single (M := fun (j : ι) ↦ R) ((f : (a : Fin n) → ι) i) (a i) : (j : ι) → R)
hNN' : N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
⊢ Eq (α := AddSubgroup (ι → R)) N'.toAddSubgroup
    (AddSubgroup.pi (f := fun (i : ι) ↦ R) Set.univ fun (i : ι) ↦
      Submodule.toAddSubgroup
        (Ideal.span
          {if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
              a (h.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
            else 0}))
have h : ∀ (g : ι → R),
  Membership.mem (γ := AddSubgroup (ι → R)) N'.toAddSubgroup g ↔
    Membership.mem (γ := AddSubgroup (ι → R))
      (AddSubgroup.pi (f := fun (i : ι) ↦ R) Set.univ fun (i : ι) ↦
        Submodule.toAddSubgroup
          (Ideal.span
            {if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
                a (h.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
              else 0}))
      g
Tactic: ext g