awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i
⊢ a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
      Exists.choose (p := fun (c : R) ↦
        g i =
          (if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
              a (Exists.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i) ⋯)
            else 0) *
            c)
        ⋯ =
    g i
have conv_rhs : a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
    Exists.choose (p := fun (c : R) ↦
      g i =
        (if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
            a (Exists.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i) sorry)
          else 0) *
          c)
      sorry =
  (if h :
        ∃ (j : Fin n),
          Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
            ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι) then
      a
        (h.choose (p := fun (j : Fin n) ↦
          Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
            ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι)))
    else 0) *
    Exists.choose (p := fun (c : R) ↦
      g ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))) =
        (if h :
              ∃ (j : Fin n),
                Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
                  ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι) then
            a
              (h.choose (p := fun (j : Fin n) ↦
                Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
                  ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι)))
          else 0) *
          c)
      sorry
Tactic: conv_rhs =>
                rw [← hj.choose_spec, (h (f hj.choose)).choose_spec]
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i
⊢ a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
      Exists.choose (p := fun (c : R) ↦
        g i =
          (if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
              a (Exists.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i) ⋯)
            else 0) *
            c)
        ⋯ =
    a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
      Exists.choose (p := fun (c : R) ↦
        g ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))) =
          a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) * c)
        ⋯
have h₁ : ∀ (x : R), i = (f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
Tactic: congr!
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i
h₁ : ∀ (x : R), i = (f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
⊢ a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
      Exists.choose (p := fun (c : R) ↦
        g i =
          (if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
              a (Exists.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i) ⋯)
            else 0) *
            c)
        ⋯ =
    a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) *
      Exists.choose (p := fun (c : R) ↦
        g ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))) =
          a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) * c)
        ⋯
have h₂ : ∀ (x : R),
  (if h : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i then
      a (Exists.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i) sorry)
    else 0) =
    a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
Tactic: congr!
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∃ (j : Fin n), (f : (a : Fin n) → ι) j = i
⊢ (∑ x : Fin n,
      if i = (f : (a : Fin n) → ι) x then
        Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
      else 0) =
    g i
have calc : (∑ x : Fin n,
    if i = (f : (a : Fin n) → ι) x then Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) sorry • a x
    else 0) =
  if i = (f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) then
    Exists.choose (p := fun (c : R) ↦
        g ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))) =
          (if h :
                ∃ (j : Fin n),
                  Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
                    ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι) then
              a
                (h.choose (p := fun (j : Fin n) ↦
                  Eq (α := ι) ((f : (a : Fin n) → ι) j : ι)
                    ((f : (a : Fin n) → ι) (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i)) : ι)))
            else 0) *
            c)
        sorry *
      a (hj.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = i))
  else 0
Tactic: calc ∑ x : Fin n, _ =
            if i = f hj.choose then (h (f hj.choose)).choose * a hj.choose else 0 := by
              convert! Finset.sum_eq_single (M := R) hj.choose ?_ ?_
              · simp
              · rintro j - h
                have hinj := f.injective.ne h
                rw [hj.choose_spec] at hinj
                simp [hinj.symm]
              · simp
          _ = g i := by
              simp only [hj.choose_spec, ↓reduceIte]
              rw [mul_comm]
              conv_rhs =>
                rw [← hj.choose_spec, (h (f hj.choose)).choose_spec]
              simp only [EmbeddingLike.apply_eq_iff_eq, exists_eq, ↓reduceDIte, Classical.choose_eq]
              congr!
              · exact hj.choose_spec.symm
              · simp [hj]
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∀ (j : Fin n), (f : (a : Fin n) → ι) j ≠ i
⊢ (∑ x : Fin n,
      if i = (f : (a : Fin n) → ι) x then
        Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
      else 0) =
    g i
have h₁ : ∀ (x : Fin n),
  Membership.mem (γ := Finset (Fin n)) Finset.univ x →
    (if i = (f : (a : Fin n) → ι) x then
        Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) sorry • a x
      else 0) =
      0
Tactic: convert! Finset.sum_const_zero with x
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∀ (j : Fin n), (f : (a : Fin n) → ι) j ≠ i
h₁ :
  ∀ (x : Fin n),
    Membership.mem (γ := Finset (Fin n)) Finset.univ x →
      (if i = (f : (a : Fin n) → ι) x then
          Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
        else 0) =
        0
⊢ (∑ x : Fin n,
      if i = (f : (a : Fin n) → ι) x then
        Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
      else 0) =
    g i
have h₂ : g i = 0
Tactic: convert! Finset.sum_const_zero with x
-- 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)
hNN' : N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∀ (j : Fin n), (f : (a : Fin n) → ι) j ≠ i
x : Fin n
h_1 : Membership.mem (γ := Finset (Fin n)) Finset.univ x
⊢ (if i = (f : (a : Fin n) → ι) x then Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
    else 0) =
    0
have hj₁ : (f : (a : Fin n) → ι) x ≠ i
Tactic: specialize hj x
Cleared hypotheses: hj
-- 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)
hNN' : N.toAddSubgroup.index = AddSubgroup.index (G := ι → R) N'.toAddSubgroup
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
x : Fin n
h_1 : Membership.mem (γ := Finset (Fin n)) Finset.univ x
hj : (f : (a : Fin n) → ι) x ≠ i
⊢ (if i = (f : (a : Fin n) → ι) x then Exists.choose (p := fun (c : R) ↦ g ((f : (a : Fin n) → ι) x) = a x * c) ⋯ • a x
    else 0) =
    0
have hj₁ : i ≠ (f : (a : Fin n) → ι) x
Tactic: rw [ne_comm] at hj
Cleared hypotheses: hj
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∀ (j : Fin n), (f : (a : Fin n) → ι) j ≠ i
⊢ g i = 0
have h₁ : 0 ∣ g i
Tactic: rw [← zero_dvd_iff]
-- 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
g : ι → R
h :
  ∀ (i : ι),
    (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 i
i : ι
hj : ∀ (j : Fin n), (f : (a : Fin n) → ι) j ≠ i
⊢ 0 ∣ g i
have h₁ : Eq.{u_2 + 1} (α := R) 0
  (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)
Tactic: convert! h i
-- 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'_1 : 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
hN' :
  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}))
⊢ 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}))
have simp : (∏ x ∈ Finset.attach {x : ι | ∃ (j : Fin n), (f : (a : Fin n) → ι) j = x},
      AddSubgroup.index.{u_2} (G := R)
        (Submodule.toAddSubgroup
          (Ideal.span {a (sorry.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = (↑x : ι)))}))) *
    Nat.card R ^ Finset.card.{u_1} (α := ι) {x : ι | ¬∃ (j : Fin n), (f : (a : Fin n) → ι) j = x} =
  Nat.card R ^ (Fintype.card ι - n) *
    ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
Tactic: simp only [hN', AddSubgroup.index_pi, apply_dite, Finset.prod_dite, Set.singleton_zero,
    Ideal.span_zero, Submodule.bot_toAddSubgroup, AddSubgroup.index_pi, AddSubgroup.index_bot,
    Finset.prod_const, Finset.univ_eq_attach, Finset.card_attach]
-- 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'_1 : 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
hN' :
  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}))
⊢ (∏ x ∈ Finset.attach {x : ι | ∃ (j : Fin n), (f : (a : Fin n) → ι) j = x},
        AddSubgroup.index.{u_2} (G := R)
          (Submodule.toAddSubgroup
            (Ideal.span {a (⋯.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = (↑x : ι)))}))) *
      Nat.card R ^ Finset.card.{u_1} (α := ι) {x : ι | ¬∃ (j : Fin n), (f : (a : Fin n) → ι) j = x} =
    Nat.card R ^ (Fintype.card ι - n) *
      ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
have rw : Nat.card R ^ Finset.card.{u_1} (α := ι) {x : ι | ¬∃ (j : Fin n), (f : (a : Fin n) → ι) j = x} *
    ∏ x ∈ Finset.attach {x : ι | ∃ (j : Fin n), (f : (a : Fin n) → ι) j = x},
      AddSubgroup.index.{u_2} (G := R)
        (Submodule.toAddSubgroup
          (Ideal.span {a (sorry.choose (p := fun (j : Fin n) ↦ (f : (a : Fin n) → ι) j = (↑x : ι)))})) =
  Nat.card R ^ (Fintype.card ι - n) *
    ∏ i : Fin n, AddSubgroup.index.{u_2} (G := R) (Submodule.toAddSubgroup (Ideal.span {a i}))
Tactic: rw [mul_comm]