Theorem: Module.equiv_directSum_of_isTorsion
File: Mathlib/Algebra/Module/PID.lean

tactic: obtain ⟨I, fI, _, p, hp, e, h⟩ := Submodule.exists_isInternal_prime_power_torsion_of_pid hN
state_before: R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})
state_after: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})

tactic: haveI := fI
state_before: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})
state_after: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this : Fintype I
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})

tactic: have :
  ∀ i,
    ∃ (d : ℕ) (k : Fin d → ℕ),
      Nonempty <| torsionBy R N (p i ^ e i) ≃ₗ[R] ⨁ j, R ⧸ R ∙ p i ^ k j := by
  haveI := fun i => isNoetherian_submodule' (torsionBy R N <| p i ^ e i)
  exact fun i =>
    torsion_by_prime_power_decomposition.{u, v} (hp i)
      ((isTorsion'_powers_iff <| p i).mpr fun x => ⟨e i, smul_torsionBy _ _⟩)
state_before: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this : Fintype I
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})
state_after: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})

tactic: classical
refine
  ⟨Σ i, Fin (this i).choose, inferInstance, fun ⟨i, _⟩ => p i, fun ⟨i, _⟩ => hp i, fun ⟨i, j⟩ =>
    (this i).choose_spec.choose j,
    ⟨(LinearEquiv.ofBijective (DirectSum.coeLinearMap _) h).symm.trans <|
        (DFinsupp.mapRange.linearEquiv fun i => (this i).choose_spec.choose_spec.some).trans <|
          (DirectSum.sigmaLcurryEquiv R).symm.trans
            (DFinsupp.mapRange.linearEquiv fun i => quotEquivOfEq _ _ ?_)⟩⟩
cases' i with i j
simp only
state_before: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})
state_after: no goals

tactic: haveI := fun i => isNoetherian_submodule' (torsionBy R N <| p i ^ e i)
state_before: R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this : Fintype I
⊢ ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
state_after: R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), IsNoetherian R ↥(torsionBy R N (p i ^ e i))
⊢ ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})

tactic: exact fun i =>
  torsion_by_prime_power_decomposition.{u, v} (hp i)
    ((isTorsion'_powers_iff <| p i).mpr fun x => ⟨e i, smul_torsionBy _ _⟩)
state_before: R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), IsNoetherian R ↥(torsionBy R N (p i ^ e i))
⊢ ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
state_after: no goals

tactic: refine
  ⟨Σ i, Fin (this i).choose, inferInstance, fun ⟨i, _⟩ => p i, fun ⟨i, _⟩ => hp i, fun ⟨i, j⟩ =>
    (this i).choose_spec.choose j,
    ⟨(LinearEquiv.ofBijective (DirectSum.coeLinearMap _) h).symm.trans <|
        (DFinsupp.mapRange.linearEquiv fun i => (this i).choose_spec.choose_spec.some).trans <|
          (DirectSum.sigmaLcurryEquiv R).symm.trans
            (DFinsupp.mapRange.linearEquiv fun i => quotEquivOfEq _ _ ?_)⟩⟩
state_before: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ span R {p i ^ e i})
state_after: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
i : (x : I) × Fin ⋯.choose
⊢ span R {p i.fst ^ ⋯.choose i.snd} =
    span R
      {(fun x =>
              match x with
              | ⟨i, snd⟩ => p i)
            i ^
          (fun x =>
              match x with
              | ⟨i, j⟩ => ⋯.choose j)
            i}

tactic: cases' i with i j
state_before: case intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
i : (x : I) × Fin ⋯.choose
⊢ span R {p i.fst ^ ⋯.choose i.snd} =
    span R
      {(fun x =>
              match x with
              | ⟨i, snd⟩ => p i)
            i ^
          (fun x =>
              match x with
              | ⟨i, j⟩ => ⋯.choose j)
            i}
state_after: case intro.intro.intro.intro.intro.intro.mk
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
i : I
j : Fin ⋯.choose
⊢ span R {p ⟨i, j⟩.fst ^ ⋯.choose ⟨i, j⟩.snd} =
    span R
      {(fun x =>
              match x with
              | ⟨i, snd⟩ => p i)
            ⟨i, j⟩ ^
          (fun x =>
              match x with
              | ⟨i, j⟩ => ⋯.choose j)
            ⟨i, j⟩}

tactic: simp only
state_before: case intro.intro.intro.intro.intro.intro.mk
R : Type u
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type (max u v)
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h' : Finite R N
hN : IsTorsion R N
I : Type u
fI : Fintype I
w✝ : DecidableEq I
p : I → R
hp : ∀ (i : I), Irreducible (p i)
e : I → ℕ
h : DirectSum.IsInternal fun i => torsionBy R N (p i ^ e i)
this✝ : Fintype I
this : ∀ (i : I), ∃ d k, Nonempty (↥(torsionBy R N (p i ^ e i)) ≃ₗ[R] ⨁ (j : Fin d), R ⧸ span R {p i ^ k j})
i : I
j : Fin ⋯.choose
⊢ span R {p ⟨i, j⟩.fst ^ ⋯.choose ⟨i, j⟩.snd} =
    span R
      {(fun x =>
              match x with
              | ⟨i, snd⟩ => p i)
            ⟨i, j⟩ ^
          (fun x =>
              match x with
              | ⟨i, j⟩ => ⋯.choose j)
            ⟨i, j⟩}
state_after: no goals