Theorem: Ideal.quotientToQuotientRangePowQuotSucc_surjective
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rintro ⟨⟨⟨x⟩, hx⟩⟩
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
⊢ Function.Surjective ↑(quotientToQuotientRangePowQuotSucc f p P a_mem)

tactic: have Pe_le_Pi : P ^ e ≤ P ^ i := Ideal.pow_le_pow hi.le
state_before: case mk.mk.mk
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r x, property := hx }

tactic: rw [Submodule.Quotient.quot_mk_eq_mk, Ideal.Quotient.mk_eq_mk, Ideal.mem_quotient_iff_mem_sup,
  sup_eq_left.mpr Pe_le_Pi] at hx
state_before: case mk.mk.mk
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
Pe_le_Pi : P ^ e ≤ P ^ i
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r x, property := hx }

tactic: suffices hx' : x ∈ Ideal.span {a} ⊔ P ^ (i + 1)
state_before: case mk.mk.mk
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r x, property := hx✝ }

tactic: letI := Classical.decEq (Ideal S)
state_before: case hx'
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
⊢ x ∈ span {a} ⊔ P ^ (i + 1)

tactic: rw [sup_eq_prod_inf_factors _ (pow_ne_zero _ hP0), normalizedFactors_pow,
  normalizedFactors_irreducible ((Ideal.prime_iff_isPrime hP0).mpr hP).irreducible, normalize_eq,
  Multiset.nsmul_singleton, Multiset.inter_replicate, Multiset.prod_replicate]
state_before: case hx'
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ x ∈ span {a} ⊔ P ^ (i + 1)

tactic: rw [← Submodule.span_singleton_le_iff_mem, Ideal.submodule_span_eq] at a_mem a_not_mem
state_before: case hx'
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ x ∈ P ^ min (Multiset.count P (normalizedFactors (span {a}))) (i + 1)

R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ span {a} ≠ ⊥

tactic: rwa [Ideal.count_normalizedFactors_eq a_mem a_not_mem, min_eq_left i.le_succ]
state_before: case hx'
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : span {a} ≤ P ^ i
a_not_mem : ¬span {a} ≤ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ x ∈ P ^ min (Multiset.count P (normalizedFactors (span {a}))) (i + 1)

R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ span {a} ≠ ⊥

tactic: obtain ⟨y', hy', z, hz, rfl⟩ := Submodule.mem_sup.mp hx'
state_before: case mk.mk.mk
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
hx' : x ∈ span {a} ⊔ P ^ (i + 1)
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r x, property := hx✝ }

tactic: obtain ⟨y, rfl⟩ := Ideal.mem_span_singleton.mp hy'
state_before: case mk.mk.mk.intro.intro.intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
Pe_le_Pi : P ^ e ≤ P ^ i
y' : S
hy' : y' ∈ span {a}
z : S
hz : z ∈ P ^ (i + 1)
hx✝ : Quot.mk Setoid.r (y' + z) ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : y' + z ∈ P ^ i
hx' : y' + z ∈ span {a} ⊔ P ^ (i + 1)
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r (y' + z), property := hx✝ }

tactic: refine ⟨Submodule.Quotient.mk y, ?_⟩
state_before: case mk.mk.mk.intro.intro.intro.intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
Pe_le_Pi : P ^ e ≤ P ^ i
z : S
hz : z ∈ P ^ (i + 1)
y : S
hy' : a * y ∈ span {a}
hx✝ : Quot.mk Setoid.r (a * y + z) ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : a * y + z ∈ P ^ i
hx' : a * y + z ∈ span {a} ⊔ P ^ (i + 1)
⊢ ∃ a_1,
    ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) a_1 =
      Quot.mk Setoid.r { val := Quot.mk Setoid.r (a * y + z), property := hx✝ }

tactic: simp only [Submodule.Quotient.quot_mk_eq_mk, quotientToQuotientRangePowQuotSucc_mk,
  Submodule.Quotient.eq, LinearMap.mem_range, Subtype.ext_iff, Subtype.coe_mk,
  Submodule.coe_sub]
state_before: case mk.mk.mk.intro.intro.intro.intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
Pe_le_Pi : P ^ e ≤ P ^ i
z : S
hz : z ∈ P ^ (i + 1)
y : S
hy' : a * y ∈ span {a}
hx✝ : Quot.mk Setoid.r (a * y + z) ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : a * y + z ∈ P ^ i
hx' : a * y + z ∈ span {a} ⊔ P ^ (i + 1)
⊢ ↑(quotientToQuotientRangePowQuotSucc f p P a_mem) (Submodule.Quotient.mk y) =
    Quot.mk Setoid.r { val := Quot.mk Setoid.r (a * y + z), property := hx✝ }

tactic: refine ⟨⟨_, Ideal.mem_map_of_mem _ (Submodule.neg_mem _ hz)⟩, ?_⟩
state_before: case mk.mk.mk.intro.intro.intro.intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
Pe_le_Pi : P ^ e ≤ P ^ i
z : S
hz : z ∈ P ^ (i + 1)
y : S
hy' : a * y ∈ span {a}
hx✝ : Quot.mk Setoid.r (a * y + z) ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : a * y + z ∈ P ^ i
hx' : a * y + z ∈ span {a} ⊔ P ^ (i + 1)
⊢ ∃ y_1, ↑(↑(powQuotSuccInclusion f p P i) y_1) = ↑(Quotient.mk (P ^ e)) (y * a) - Submodule.Quotient.mk (a * y + z)

tactic: rw [powQuotSuccInclusion_apply_coe, Subtype.coe_mk, Ideal.Quotient.mk_eq_mk, map_add,
  mul_comm y a, sub_add_cancel', map_neg]
state_before: case mk.mk.mk.intro.intro.intro.intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
Pe_le_Pi : P ^ e ≤ P ^ i
z : S
hz : z ∈ P ^ (i + 1)
y : S
hy' : a * y ∈ span {a}
hx✝ : Quot.mk Setoid.r (a * y + z) ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : a * y + z ∈ P ^ i
hx' : a * y + z ∈ span {a} ⊔ P ^ (i + 1)
⊢ ↑(↑(powQuotSuccInclusion f p P i)
        { val := ↑(Quotient.mk (P ^ e)) (-z),
          property := (_ : ↑(Quotient.mk (P ^ e)) (-z) ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))) }) =
    ↑(Quotient.mk (P ^ e)) (y * a) - Submodule.Quotient.mk (a * y + z)

tactic: intro ha
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
⊢ span {a} ≠ ⊥

tactic: rw [Ideal.span_singleton_eq_bot.mp ha] at a_not_mem
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬a ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
ha : span {a} = ⊥
⊢ False

tactic: have := (P ^ (i + 1)).zero_mem
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬0 ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
ha : span {a} = ⊥
⊢ False

tactic: contradiction
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hP0 : P ≠ ⊥
hP : IsPrime P
i : ℕ
hi : i < e
a : S
a_mem : a ∈ P ^ i
a_not_mem : ¬0 ∈ P ^ (i + 1)
b✝ : { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)
val✝ : S ⧸ P ^ e
x : S
hx✝ : Quot.mk Setoid.r x ∈ map (Quotient.mk (P ^ e)) (P ^ i)
hx : x ∈ P ^ i
Pe_le_Pi : P ^ e ≤ P ^ i
this✝ : DecidableEq (Ideal S) := Classical.decEq (Ideal S)
ha : span {a} = ⊥
this : 0 ∈ P ^ (i + 1)
⊢ False