l3lab/ntp-mathlib huggingface dataset:
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    

Proof state:
case mp.intro
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b✝ b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
b : Basis ι R M
⊢ ∃ x, ∃ (_ : x ≠ 0), ∀ (y : M), ∃ r, r • x = y

Next tactic:
refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    

Proof state:
case mp.intro
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b✝ b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
b : Basis ι R M
⊢ ∀ (y : M), ∃ r, r • b default = y

Next tactic:
simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · 

Proof state:
case mpr
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
⊢ (∃ x, ∃ (_ : x ≠ 0), ∀ (y : M), ∃ r, r • x = y) → Nonempty (Basis ι R M)

Next tactic:
rintro ⟨x, nz, w⟩
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    

Proof state:
case mpr.intro.intro
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
⊢ Nonempty (Basis ι R M)

Next tactic:
refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · 

Proof state:
case mpr.intro.intro.refine_1
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
y z : ι →₀ R
⊢ (fun f => f default • x) (y + z) = (fun f => f default • x) y + (fun f => f default • x) z

Next tactic:
simp [Finsupp.add_apply, add_smul]
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · 

Proof state:
case mpr.intro.intro.refine_2
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c✝ : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
c : R
y : ι →₀ R
⊢ AddHom.toFun
      { toFun := fun f => f default • x,
        map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
      (c • y) =
    (RingHom.id R) c •
      AddHom.toFun
        { toFun := fun f => f default • x,
          map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
        y

Next tactic:
simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      

Proof state:
case mpr.intro.intro.refine_2
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c✝ : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
c : R
y : ι →₀ R
⊢ (c • y default) • x = c • y default • x

Next tactic:
rw [← smul_assoc, smul_eq_mul]
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      rw [← smul_assoc, smul_eq_mul]
    · 

Proof state:
case mpr.intro.intro.refine_3
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
f : ι →₀ R
⊢ ((fun y => fun₀ | default => Exists.choose (_ : ∃ r, r • x = y))
        (AddHom.toFun
          {
              toAddHom :=
                { toFun := fun f => f default • x,
                  map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) },
              map_smul' :=
                (_ :
                  ∀ (c : R) (y : ι →₀ R),
                    AddHom.toFun
                        { toFun := fun f => f default • x,
                          map_add' :=
                            (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                        (c • y) =
                      (RingHom.id R) c •
                        AddHom.toFun
                          { toFun := fun f => f default • x,
                            map_add' :=
                              (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                          y) }.toAddHom
          f))
      default =
    f default

Next tactic:
refine' smul_left_injective _ nz _
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      rw [← smul_assoc, smul_eq_mul]
    · refine' smul_left_injective _ nz _
      

Proof state:
case mpr.intro.intro.refine_3
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
f : ι →₀ R
⊢ (fun c => c • x)
      (((fun y => fun₀ | default => Exists.choose (_ : ∃ r, r • x = y))
          (AddHom.toFun
            {
                toAddHom :=
                  { toFun := fun f => f default • x,
                    map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) },
                map_smul' :=
                  (_ :
                    ∀ (c : R) (y : ι →₀ R),
                      AddHom.toFun
                          { toFun := fun f => f default • x,
                            map_add' :=
                              (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                          (c • y) =
                        (RingHom.id R) c •
                          AddHom.toFun
                            { toFun := fun f => f default • x,
                              map_add' :=
                                (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                            y) }.toAddHom
            f))
        default) =
    (fun c => c • x) (f default)

Next tactic:
simp only [Finsupp.single_eq_same]
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      rw [← smul_assoc, smul_eq_mul]
    · refine' smul_left_injective _ nz _
      simp only [Finsupp.single_eq_same]
      

Proof state:
case mpr.intro.intro.refine_3
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
f : ι →₀ R
⊢ Exists.choose
        (_ :
          ∃ r,
            r • x =
              AddHom.toFun
                {
                    toAddHom :=
                      { toFun := fun f => f default • x,
                        map_add' :=
                          (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) },
                    map_smul' :=
                      (_ :
                        ∀ (c : R) (y : ι →₀ R),
                          AddHom.toFun
                              { toFun := fun f => f default • x,
                                map_add' :=
                                  (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                              (c • y) =
                            (RingHom.id R) c •
                              AddHom.toFun
                                { toFun := fun f => f default • x,
                                  map_add' :=
                                    (_ :
                                      ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                                y) }.toAddHom
                f) •
      x =
    f default • x

Next tactic:
exact (w (f default • x)).choose_spec
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      rw [← smul_assoc, smul_eq_mul]
    · refine' smul_left_injective _ nz _
      simp only [Finsupp.single_eq_same]
      exact (w (f default • x)).choose_spec
    · 

Proof state:
case mpr.intro.intro.refine_4
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
y : M
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := fun f => f default • x,
              map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) },
          map_smul' :=
            (_ :
              ∀ (c : R) (y : ι →₀ R),
                AddHom.toFun
                    { toFun := fun f => f default • x,
                      map_add' := (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                    (c • y) =
                  (RingHom.id R) c •
                    AddHom.toFun
                      { toFun := fun f => f default • x,
                        map_add' :=
                          (_ : ∀ (y z : ι →₀ R), (y default + z default) • x = y default • x + z default • x) }
                      y) }.toAddHom
      ((fun y => fun₀ | default => Exists.choose (_ : ∃ r, r • x = y)) y) =
    y

Next tactic:
simp only [Finsupp.single_eq_same]
theorem basis_singleton_iff {R M : Type*} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] (ι : Type*) [Unique ι] :
    Nonempty (Basis ι R M) ↔ ∃ (x : _) (_ : x ≠ 0), ∀ y : M, ∃ r : R, r • x = y := by
  constructor
  · rintro ⟨b⟩
    refine' ⟨b default, b.linearIndependent.ne_zero _, _⟩
    simpa [span_singleton_eq_top_iff, Set.range_unique] using b.span_eq
  · rintro ⟨x, nz, w⟩
    refine ⟨ofRepr <| LinearEquiv.symm
      { toFun := fun f => f default • x
        invFun := fun y => Finsupp.single default (w y).choose
        left_inv := fun f => Finsupp.unique_ext ?_
        right_inv := fun y => ?_
        map_add' := fun y z => ?_
        map_smul' := fun c y => ?_ }⟩
    · simp [Finsupp.add_apply, add_smul]
    · simp only [Finsupp.coe_smul, Pi.smul_apply, RingHom.id_apply]
      rw [← smul_assoc, smul_eq_mul]
    · refine' smul_left_injective _ nz _
      simp only [Finsupp.single_eq_same]
      exact (w (f default • x)).choose_spec
    · simp only [Finsupp.single_eq_same]
      

Proof state:
case mpr.intro.intro.refine_4
ι✝ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R✝ M'
b b₁ : Basis ι✝ R✝ M✝
i : ι✝
c : R✝
x✝ : M✝
R : Type u_10
M : Type u_11
inst✝⁵ : Ring R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
ι : Type u_12
inst✝ : Unique ι
x : M
nz : x ≠ 0
w : ∀ (y : M), ∃ r, r • x = y
y : M
⊢ Exists.choose (_ : ∃ r, r • x = y) • x = y

Next tactic:
exact (w y).choose_spec
theorem Module.card_fintype (b : Basis ι R M) [Fintype R] [Fintype M] :
    card M = card R ^ card ι := by
  

Proof state:
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : Fintype ι
b✝ b : Basis ι R M
inst✝¹ : Fintype R
inst✝ : Fintype M
⊢ card M = card R ^ card ι

Next tactic:
classical
    calc
      card M = card (ι → R) := card_congr b.equivFun.toEquiv
      _ = card R ^ card ι := card_fun
theorem Module.card_fintype (b : Basis ι R M) [Fintype R] [Fintype M] :
    card M = card R ^ card ι := by
  classical
    

Proof state:
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : Fintype ι
b✝ b : Basis ι R M
inst✝¹ : Fintype R
inst✝ : Fintype M
⊢ card M = card R ^ card ι

Next tactic:
calc
      card M = card (ι → R) := card_congr b.equivFun.toEquiv
      _ = card R ^ card ι := card_fun
/-- Given a basis `v` indexed by `ι`, the canonical linear equivalence between `ι → R` and `M` maps
a function `x : ι → R` to the linear combination `∑_i x i • v i`. -/
@[simp]
theorem Basis.equivFun_symm_apply (x : ι → R) : b.equivFun.symm x = ∑ i, x i • b i := by
  

Proof state:
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
x : ι → R
⊢ (LinearEquiv.symm (equivFun b)) x = ∑ i : ι, x i • b i

Next tactic:
simp [Basis.equivFun, Finsupp.total_apply, Finsupp.sum_fintype, Finsupp.equivFunOnFinite]
theorem Basis.sum_equivFun (u : M) : ∑ i, b.equivFun u i • b i = u := by
  

Proof state:
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
u : M
⊢ ∑ i : ι, (equivFun b) u i • b i = u

Next tactic:
conv_rhs => rw [← b.total_repr u]
theorem Basis.sum_equivFun (u : M) : ∑ i, b.equivFun u i • b i = u := by
  conv_rhs => 

Proof state:
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
u : M
| u

Next tactic:
rw [← b.total_repr u]