[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝ : Add α
h : Periodic f c
g : β → γ
⊢ Periodic (g ∘ f) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Add α
inst✝ : Add γ
h : Periodic f c
g : AddHom γ α
g_inv : α → γ
hg : RightInverse g_inv ↑g
x : γ
⊢ (f ∘ ↑g) (x + g_inv c) = (f ∘ ↑g) x
[PROOFSTEP]
simp only [hg c, h (g x), map_add, comp_apply]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Mul β
hf : Periodic f c
hg : Periodic g c
⊢ Periodic (f * g) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Div β
hf : Periodic f c
hg : Periodic g c
⊢ Periodic (f / g) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl : ∀ (f : α → β), f ∈ l → Periodic f c
⊢ Periodic (List.prod l) c
[PROOFSTEP]
induction' l with g l ih hl
[GOAL]
case nil
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l → Periodic f c
hl : ∀ (f : α → β), f ∈ [] → Periodic f c
⊢ Periodic (List.prod []) c
[PROOFSTEP]
simp
[GOAL]
case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l✝ : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l✝ → Periodic f c
g : α → β
l : List (α → β)
ih : (∀ (f : α → β), f ∈ l → Periodic f c) → Periodic (List.prod l) c
hl : ∀ (f : α → β), f ∈ g :: l → Periodic f c
⊢ Periodic (List.prod (g :: l)) c
[PROOFSTEP]
rw [List.forall_mem_cons] at hl
[GOAL]
case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l✝ : List (α → β)
hl✝ : ∀ (f : α → β), f ∈ l✝ → Periodic f c
g : α → β
l : List (α → β)
ih : (∀ (f : α → β), f ∈ l → Periodic f c) → Periodic (List.prod l) c
hl : Periodic g c ∧ ∀ (x : α → β), x ∈ l → Periodic x c
⊢ Periodic (List.prod (g :: l)) c
[PROOFSTEP]
simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : CommMonoid β
ι : Type u_4
f : ι → α → β
s : Finset ι
hs : ∀ (i : ι), i ∈ s → Periodic (f i) c
⊢ ∀ (f_1 : α → β), f_1 ∈ List.map f (Finset.toList s) → Periodic f_1 c
[PROOFSTEP]
simpa [-Periodic]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : SMul γ β
h : Periodic f c
a : γ
⊢ Periodic (a • f) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
[PROOFSTEP]
simpa only [smul_add, smul_inv_smul] using h (a • x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
[PROOFSTEP]
by_cases ha : a = 0
[GOAL]
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
[PROOFSTEP]
simp only [ha, zero_smul]
[GOAL]
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : ¬a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
[PROOFSTEP]
simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
[PROOFSTEP]
simpa only [inv_inv] using h.const_smul a⁻¹
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
[PROOFSTEP]
simpa only [inv_inv] using h.const_smul₀ a⁻¹
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x * a)) (c / a)
[PROOFSTEP]
simpa only [div_eq_mul_inv] using h.mul_const a
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x / a)) (c * a)
[PROOFSTEP]
simpa only [div_eq_mul_inv] using h.mul_const_inv a
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddSemigroup α
h1 : Periodic f c₁
h2 : Periodic f c₂
⊢ Periodic f (c₁ + c₂)
[PROOFSTEP]
simp_all [← add_assoc]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h : Periodic f c
x : α
⊢ f (x - c) = f x
[PROOFSTEP]
simpa only [sub_add_cancel] using (h (x - c)).symm
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddCommGroup α
h : Periodic f c
⊢ f (c - x) = f (-x)
[PROOFSTEP]
simpa only [sub_eq_neg_add] using h (-x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
⊢ Periodic f (-c)
[PROOFSTEP]
simpa only [sub_eq_add_neg, Periodic] using h.sub_eq
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h1 : Periodic f c₁
h2 : Periodic f c₂
x : α
⊢ f (x + (c₁ - c₂)) = f x
[PROOFSTEP]
rw [sub_eq_add_neg, ← add_assoc, h2.neg, h1]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = (fun x => f (a + x)) x
[PROOFSTEP]
simpa [add_assoc] using h (a + x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (x + a)) (x + c) = (fun x => f (x + a)) x
[PROOFSTEP]
simpa only [add_right_comm] using h (x + a)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommGroup α
h : Periodic f c
a x : α
⊢ (fun x => f (a - x)) (x + c) = (fun x => f (a - x)) x
[PROOFSTEP]
simp only [← sub_sub, h.sub_eq]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddCommGroup α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x - a)) c
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h.add_const (-a)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddMonoid α
h : Periodic f c
n : ℕ
⊢ Periodic f (n • c)
[PROOFSTEP]
induction n
[GOAL]
case zero
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddMonoid α
h : Periodic f c
⊢ Periodic f (Nat.zero • c)
[PROOFSTEP]
simp_all [Nat.succ_eq_add_one, add_nsmul, ← add_assoc, zero_nsmul]
[GOAL]
case succ
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddMonoid α
h : Periodic f c
n✝ : ℕ
n_ih✝ : Periodic f (n✝ • c)
⊢ Periodic f (Nat.succ n✝ • c)
[PROOFSTEP]
simp_all [Nat.succ_eq_add_one, add_nsmul, ← add_assoc, zero_nsmul]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : Semiring α
h : Periodic f c
n : ℕ
⊢ Periodic f (↑n * c)
[PROOFSTEP]
simpa only [nsmul_eq_mul] using h.nsmul n
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
n : ℕ
⊢ f (x - n • c) = f x
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h.neg_nsmul n x
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (x - ↑n * c) = f x
[PROOFSTEP]
simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (↑n * c - x) = f (-x)
[PROOFSTEP]
simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
n : ℤ
⊢ Periodic f (n • c)
[PROOFSTEP]
cases' n with n n
[GOAL]
case ofNat
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
n : ℕ
⊢ Periodic f (Int.ofNat n • c)
[PROOFSTEP]
simpa only [Int.ofNat_eq_coe, coe_nat_zsmul] using h.nsmul n
[GOAL]
case negSucc
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddGroup α
h : Periodic f c
n : ℕ
⊢ Periodic f (Int.negSucc n • c)
[PROOFSTEP]
simpa only [negSucc_zsmul] using (h.nsmul (n + 1)).neg
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℤ
⊢ Periodic f (↑n * c)
[PROOFSTEP]
simpa only [zsmul_eq_mul] using h.zsmul n
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddZeroClass α
h : Periodic f c
⊢ f c = f 0
[PROOFSTEP]
simpa only [zero_add] using h 0
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc : c ≠ 0
a : α
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]
cases hc.lt_or_lt with
| inl hc =>
  rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c), add_neg_cancel_right]
| inr hc => rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc : c ≠ 0
a : α
x✝ : c < 0 ∨ 0 < c
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]
cases hc.lt_or_lt with
| inl hc =>
  rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c), add_neg_cancel_right]
| inr hc => rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
[GOAL]
case inl
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : c < 0
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]

| inl hc =>
  rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c), add_neg_cancel_right]
[GOAL]
case inl
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : c < 0
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]
rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c), add_neg_cancel_right]
[GOAL]
case inr
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : 0 < c
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]

| inr hc => rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
[GOAL]
case inr
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
h : Periodic f c
hc✝ : c ≠ 0
a : α
hc : 0 < c
⊢ f '' uIcc a (a + c) = range f
[PROOFSTEP]
rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddZeroClass α
f : α → β
x : α
⊢ f (x + 0) = f x
[PROOFSTEP]
rw [add_zero]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommGroup α
hf : Periodic f c
a : { x // x ∈ AddSubgroup.zmultiples c }
x : α
⊢ f (a +ᵥ x) = f x
[PROOFSTEP]
rcases a with ⟨_, m, rfl⟩
[GOAL]
case mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommGroup α
hf : Periodic f c
x : α
m : ℤ
⊢ f ({ val := (fun x => x • c) m, property := (_ : ∃ y, (fun x => x • c) y = (fun x => x • c) m) } +ᵥ x) = f x
[PROOFSTEP]
simp [AddSubgroup.vadd_def, add_comm _ x, hf.zsmul m x]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommMonoid α
hf : Periodic f c
a : { x // x ∈ AddSubmonoid.multiples c }
x : α
⊢ f (a +ᵥ x) = f x
[PROOFSTEP]
rcases a with ⟨_, m, rfl⟩
[GOAL]
case mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommMonoid α
hf : Periodic f c
x : α
m : ℕ
⊢ f ({ val := (fun i => i • c) m, property := (_ : ∃ y, (fun i => i • c) y = (fun i => i • c) m) } +ᵥ x) = f x
[PROOFSTEP]
simp [AddSubmonoid.vadd_def, add_comm _ x, hf.nsmul m x]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h : Periodic f c
x : α ⧸ AddSubgroup.zmultiples c
a b : α
h' : Setoid.r a b
⊢ f a = f b
[PROOFSTEP]
rw [QuotientAddGroup.leftRel_apply] at h'
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h : Periodic f c
x : α ⧸ AddSubgroup.zmultiples c
a b : α
h' : -a + b ∈ AddSubgroup.zmultiples c
⊢ f a = f b
[PROOFSTEP]
obtain ⟨k, hk⟩ := h'
[GOAL]
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h : Periodic f c
x : α ⧸ AddSubgroup.zmultiples c
a b : α
k : ℤ
hk : (fun x => x • c) k = -a + b
⊢ f a = f b
[PROOFSTEP]
exact (h.zsmul k _).symm.trans (congr_arg f (add_eq_of_eq_neg_add hk))
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ Periodic f (2 * c)
[PROOFSTEP]
simp [two_mul, ← add_assoc, h _]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddZeroClass α
inst✝ : Neg β
h : Antiperiodic f c
⊢ f c = -f 0
[PROOFSTEP]
simpa only [zero_add] using h 0
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Semiring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℕ
x : α
⊢ f (x + (↑n * (2 * c) + c)) = -f x
[PROOFSTEP]
rw [← add_assoc, h, h.periodic.nat_mul]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Ring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℤ
x : α
⊢ f (x + (↑n * (2 * c) + c)) = -f x
[PROOFSTEP]
rw [← add_assoc, h, h.periodic.int_mul]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
x : α
⊢ f (x - c) = -f x
[PROOFSTEP]
simp only [← neg_eq_iff_eq_neg, ← h (x - c), sub_add_cancel]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : Neg β
h : Antiperiodic f c
⊢ f (c - x) = -f (-x)
[PROOFSTEP]
simpa only [sub_eq_neg_add] using h (-x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ Antiperiodic f (-c)
[PROOFSTEP]
simpa only [sub_eq_add_neg, Antiperiodic] using h.sub_eq
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ f (-c) = -f 0
[PROOFSTEP]
simpa only [zero_add] using h.neg 0
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : NegZeroClass β
h : Antiperiodic f c
hi : f 0 = 0
⊢ f (↑0 * c) = 0
[PROOFSTEP]
rwa [Nat.cast_zero, zero_mul]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : NegZeroClass β
h : Antiperiodic f c
hi : f 0 = 0
n : ℕ
⊢ f (↑(n + 1) * c) = 0
[PROOFSTEP]
simp [add_mul, h _, Antiperiodic.nat_mul_eq_of_eq_zero h hi n]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Ring α
inst✝ : SubtractionMonoid β
h : Antiperiodic f c
hi : f 0 = 0
n : ℕ
⊢ f (↑↑n * c) = 0
[PROOFSTEP]
rw [Int.cast_ofNat, h.nat_mul_eq_of_eq_zero hi n]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Ring α
inst✝ : SubtractionMonoid β
h : Antiperiodic f c
hi : f 0 = 0
n : ℕ
⊢ f (↑(Int.negSucc n) * c) = 0
[PROOFSTEP]
rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddSemigroup α
inst✝ : Neg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = -(fun x => f (a + x)) x
[PROOFSTEP]
simpa [add_assoc] using h (a + x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddCommSemigroup α
inst✝ : Neg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (x + a)) (x + c) = -(fun x => f (x + a)) x
[PROOFSTEP]
simpa only [add_right_comm] using h (x + a)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddCommGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a - x)) (x + c) = -(fun x => f (a - x)) x
[PROOFSTEP]
simp only [← sub_sub, h.sub_eq]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : Neg β
h : Antiperiodic f c
a : α
⊢ Antiperiodic (fun x => f (x - a)) c
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h.add_const (-a)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝³ : Add α
inst✝² : Monoid γ
inst✝¹ : AddGroup β
inst✝ : DistribMulAction γ β
h : Antiperiodic f c
a : γ
⊢ Antiperiodic (a • f) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝³ : AddMonoid α
inst✝² : Neg β
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Antiperiodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = -(fun x => f (a • x)) x
[PROOFSTEP]
simpa only [smul_add, smul_inv_smul] using h (a • x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝³ : AddCommMonoid α
inst✝² : Neg β
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Antiperiodic f c
a : γ
ha : a ≠ 0
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = -(fun x => f (a • x)) x
[PROOFSTEP]
simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝³ : AddMonoid α
inst✝² : Neg β
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Antiperiodic f c
a : γ
⊢ Antiperiodic (fun x => f (a⁻¹ • x)) (a • c)
[PROOFSTEP]
simpa only [inv_inv] using h.const_smul a⁻¹
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝³ : AddCommMonoid α
inst✝² : Neg β
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Antiperiodic f c
a : γ
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (a⁻¹ • x)) (a • c)
[PROOFSTEP]
simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : DivisionSemiring α
inst✝ : Neg β
h : Antiperiodic f c
a : α
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (x * a)) (c / a)
[PROOFSTEP]
simpa only [div_eq_mul_inv] using h.mul_const ha
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : DivisionSemiring α
inst✝ : Neg β
h : Antiperiodic f c
a : α
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (x / a)) (c * a)
[PROOFSTEP]
simpa only [div_eq_mul_inv] using h.mul_const_inv ha
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Antiperiodic f c₁
h2 : Antiperiodic f c₂
⊢ Periodic f (c₁ + c₂)
[PROOFSTEP]
simp_all [← add_assoc]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Antiperiodic f c₁
h2 : Antiperiodic f c₂
⊢ Periodic f (c₁ - c₂)
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h1.add h2.neg
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : Neg β
h1 : Periodic f c₁
h2 : Antiperiodic f c₂
⊢ Antiperiodic f (c₁ + c₂)
[PROOFSTEP]
simp_all [← add_assoc]
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Periodic f c₁
h2 : Antiperiodic f c₂
⊢ Antiperiodic f (c₁ - c₂)
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : Add α
inst✝¹ : Mul β
inst✝ : HasDistribNeg β
hf : Antiperiodic f c
hg : Antiperiodic g c
⊢ Periodic (f * g) c
[PROOFSTEP]
simp_all
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : Add α
inst✝¹ : DivisionMonoid β
inst✝ : HasDistribNeg β
hf : Antiperiodic f c
hg : Antiperiodic g c
⊢ Periodic (f / g) c
[PROOFSTEP]
simp_all [neg_div_neg_eq]
[GOAL]
α✝ : Type u_1
β : Type u_2
γ : Type u_3
f g : α✝ → β
c c₁ c₂ x : α✝
α : Type u_4
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
a : α
⊢ fract (a + 1) = fract a
[PROOFSTEP]
exact_mod_cast Int.fract_add_int a 1


[GOAL]
R : Type u
inst✝ : Semiring R
⊢ StrongRankCondition R ↔ ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ↑f
[PROOFSTEP]
refine' ⟨fun h n => fun f hf => _, fun h => ⟨@fun n m f hf => _⟩⟩
[GOAL]
case refine'_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ↑f
⊢ False
[PROOFSTEP]
letI : StrongRankCondition R := h
[GOAL]
case refine'_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ↑f
this : StrongRankCondition R := h
⊢ False
[PROOFSTEP]
exact Nat.not_succ_le_self n (le_of_fin_injective R f hf)
[GOAL]
case refine'_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ↑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ↑f
⊢ n ≤ m
[PROOFSTEP]
by_contra H
[GOAL]
case refine'_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ↑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ↑f
H : ¬n ≤ m
⊢ False
[PROOFSTEP]
exact
  h m (f.comp (Function.ExtendByZero.linearMap R (Fin.castLE (not_le.1 H))))
    (hf.comp (Function.extend_injective (Fin.strictMono_castLE _).injective _))
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
exact
  le_of_fin_injective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
    (((LinearEquiv.symm Q).injective.comp i).comp (LinearEquiv.injective P))
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
let P := Finsupp.linearEquivFunOnFinite R R β
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
let Q := (Finsupp.linearEquivFunOnFinite R R α).symm
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
Q : (α → R) ≃ₗ[R] α →₀ R := LinearEquiv.symm (Finsupp.linearEquivFunOnFinite R R α)
⊢ Fintype.card α ≤ Fintype.card β
[PROOFSTEP]
exact card_le_of_injective R ((P.toLinearMap.comp f).comp Q.toLinearMap) ((P.injective.comp i).comp Q.injective)
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ↑f
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Surjective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
exact
  le_of_fin_surjective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
    (((LinearEquiv.symm Q).surjective.comp i).comp (LinearEquiv.surjective P))
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Surjective ↑f
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
let P := Finsupp.linearEquivFunOnFinite R R β
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Surjective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
let Q := (Finsupp.linearEquivFunOnFinite R R α).symm
[GOAL]
R : Type u
inst✝³ : Semiring R
inst✝² : RankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Surjective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
Q : (α → R) ≃ₗ[R] α →₀ R := LinearEquiv.symm (Finsupp.linearEquivFunOnFinite R R α)
⊢ Fintype.card β ≤ Fintype.card α
[PROOFSTEP]
exact card_le_of_surjective R ((P.toLinearMap.comp f).comp Q.toLinearMap) ((P.surjective.comp i).comp Q.surjective)
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
⊢ Nontrivial R
[PROOFSTEP]
by_contra h
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
⊢ False
[PROOFSTEP]
refine' zero_ne_one (eq_of_fin_equiv R _)
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R
[PROOFSTEP]
haveI := not_nontrivial_iff_subsingleton.1 h
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this : Subsingleton R
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R
[PROOFSTEP]
haveI : Subsingleton (Fin 1 → R) := Subsingleton.intro <| fun a b => funext fun x => Subsingleton.elim _ _
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R
[PROOFSTEP]
exact
  { toFun := 0
    invFun := 0
    map_add' := by aesop
    map_smul' := by aesop
    left_inv := fun _ => by simp
    right_inv := fun _ => by simp }
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = OfNat.ofNat 0 x + OfNat.ofNat 0 y
[PROOFSTEP]
aesop
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ ∀ (r : R) (x : Fin 0 → R),
    AddHom.toFun { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) } (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) } x
[PROOFSTEP]
aesop
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
x✝ : Fin 0 → R
⊢ OfNat.ofNat 0
      (AddHom.toFun
        { toAddHom := { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) },
            map_smul' := (_ : ∀ (r : R) (x : Fin 0 → R), OfNat.ofNat 0 (r • x) = r • 0) }.toAddHom
        x✝) =
    x✝
[PROOFSTEP]
simp
[GOAL]
R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
x✝ : Fin 1 → R
⊢ AddHom.toFun
      { toAddHom := { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) },
          map_smul' := (_ : ∀ (r : R) (x : Fin 0 → R), OfNat.ofNat 0 (r • x) = r • 0) }.toAddHom
      (OfNat.ofNat 0 x✝) =
    x✝
[PROOFSTEP]
simp
[GOAL]
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
⊢ StrongRankCondition R
[PROOFSTEP]
constructor
[GOAL]
case le_of_fin_injective
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
⊢ ∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Injective ↑f → n ≤ m
[PROOFSTEP]
intro m n f i
[GOAL]
case le_of_fin_injective
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
m n : ℕ
f : (Fin m → R) →ₗ[R] Fin n → R
i : Injective ↑f
⊢ m ≤ n
[PROOFSTEP]
by_contra h
[GOAL]
case le_of_fin_injective
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
m n : ℕ
f : (Fin m → R) →ₗ[R] Fin n → R
i : Injective ↑f
h : ¬m ≤ n
⊢ False
[PROOFSTEP]
rw [not_le, ← Nat.add_one_le_iff, le_iff_exists_add] at h
[GOAL]
case le_of_fin_injective
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
m n : ℕ
f : (Fin m → R) →ₗ[R] Fin n → R
i : Injective ↑f
h : ∃ c, m = n + 1 + c
⊢ False
[PROOFSTEP]
obtain ⟨m, rfl⟩ := h
[GOAL]
case le_of_fin_injective.intro
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
⊢ False
[PROOFSTEP]
let e : Fin (n + 1 + m) ≃ Sum (Fin n) (Fin (1 + m)) := (finCongr (add_assoc _ _ _)).trans finSumFinEquiv.symm
[GOAL]
case le_of_fin_injective.intro
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
e : Fin (n + 1 + m) ≃ Fin n ⊕ Fin (1 + m) := (finCongr (_ : n + 1 + m = n + (1 + m))).trans finSumFinEquiv.symm
⊢ False
[PROOFSTEP]
let f' := f.comp ((LinearEquiv.sumArrowLequivProdArrow _ _ R R).symm.trans (LinearEquiv.funCongrLeft R R e)).toLinearMap
[GOAL]
case le_of_fin_injective.intro
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
e : Fin (n + 1 + m) ≃ Fin n ⊕ Fin (1 + m) := (finCongr (_ : n + 1 + m = n + (1 + m))).trans finSumFinEquiv.symm
f' : (Fin n → R) × (Fin (1 + m) → R) →ₗ[R] Fin n → R :=
  LinearMap.comp f
    ↑(LinearEquiv.trans (LinearEquiv.symm (LinearEquiv.sumArrowLequivProdArrow (Fin n) (Fin (1 + m)) R R))
        (LinearEquiv.funCongrLeft R R e))
⊢ False
[PROOFSTEP]
have i' : Injective f' := i.comp (LinearEquiv.injective _)
[GOAL]
case le_of_fin_injective.intro
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
e : Fin (n + 1 + m) ≃ Fin n ⊕ Fin (1 + m) := (finCongr (_ : n + 1 + m = n + (1 + m))).trans finSumFinEquiv.symm
f' : (Fin n → R) × (Fin (1 + m) → R) →ₗ[R] Fin n → R :=
  LinearMap.comp f
    ↑(LinearEquiv.trans (LinearEquiv.symm (LinearEquiv.sumArrowLequivProdArrow (Fin n) (Fin (1 + m)) R R))
        (LinearEquiv.funCongrLeft R R e))
i' : Injective ↑f'
⊢ False
[PROOFSTEP]
apply @zero_ne_one (Fin (1 + m) → R) _ _
[GOAL]
case le_of_fin_injective.intro.a
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
e : Fin (n + 1 + m) ≃ Fin n ⊕ Fin (1 + m) := (finCongr (_ : n + 1 + m = n + (1 + m))).trans finSumFinEquiv.symm
f' : (Fin n → R) × (Fin (1 + m) → R) →ₗ[R] Fin n → R :=
  LinearMap.comp f
    ↑(LinearEquiv.trans (LinearEquiv.symm (LinearEquiv.sumArrowLequivProdArrow (Fin n) (Fin (1 + m)) R R))
        (LinearEquiv.funCongrLeft R R e))
i' : Injective ↑f'
⊢ 0 = 1
[PROOFSTEP]
apply (IsNoetherian.equivPUnitOfProdInjective f' i').injective
[GOAL]
case le_of_fin_injective.intro.a.a
R : Type u
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : IsNoetherianRing R
n m : ℕ
f : (Fin (n + 1 + m) → R) →ₗ[R] Fin n → R
i : Injective ↑f
e : Fin (n + 1 + m) ≃ Fin n ⊕ Fin (1 + m) := (finCongr (_ : n + 1 + m = n + (1 + m))).trans finSumFinEquiv.symm
f' : (Fin n → R) × (Fin (1 + m) → R) →ₗ[R] Fin n → R :=
  LinearMap.comp f
    ↑(LinearEquiv.trans (LinearEquiv.symm (LinearEquiv.sumArrowLequivProdArrow (Fin n) (Fin (1 + m)) R R))
        (LinearEquiv.funCongrLeft R R e))
i' : Injective ↑f'
⊢ ↑(IsNoetherian.equivPUnitOfProdInjective f' i') 0 = ↑(IsNoetherian.equivPUnitOfProdInjective f' i') 1
[PROOFSTEP]
ext
[GOAL]
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
ι : Type v
inst✝ : Fintype ι
ι' : Type w
I : Ideal R
e : (ι → R) →ₗ[R] ι' → R
x : (ι → R) ⧸ Ideal.pi I ι
⊢ ∀ (a b : ι → R),
    Setoid.r a b →
      (fun y => ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (↑e y)) a =
        (fun y => ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (↑e y)) b
[PROOFSTEP]
refine' fun a b hab => Ideal.Quotient.eq.2 fun h => _
[GOAL]
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
ι : Type v
inst✝ : Fintype ι
ι' : Type w
I : Ideal R
e : (ι → R) →ₗ[R] ι' → R
x : (ι → R) ⧸ Ideal.pi I ι
a b : ι → R
hab : Setoid.r a b
h : ι'
⊢ (↑e a - ↑e b) h ∈ I
[PROOFSTEP]
rw [Submodule.quotientRel_r_def] at hab
[GOAL]
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
ι : Type v
inst✝ : Fintype ι
ι' : Type w
I : Ideal R
e : (ι → R) →ₗ[R] ι' → R
x : (ι → R) ⧸ Ideal.pi I ι
a b : ι → R
hab : a - b ∈ Ideal.pi I ι
h : ι'
⊢ (↑e a - ↑e b) h ∈ I
[PROOFSTEP]
rw [← LinearMap.map_sub]
[GOAL]
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
ι : Type v
inst✝ : Fintype ι
ι' : Type w
I : Ideal R
e : (ι → R) →ₗ[R] ι' → R
x : (ι → R) ⧸ Ideal.pi I ι
a b : ι → R
hab : a - b ∈ Ideal.pi I ι
h : ι'
⊢ ↑e (a - b) h ∈ I
[PROOFSTEP]
exact Ideal.map_pi _ _ hab e h
[GOAL]
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ((ι → R) ⧸ Ideal.pi I ι) ≃ₗ[R ⧸ I] (ι' → R) ⧸ Ideal.pi I ι'
[PROOFSTEP]
refine'
  { toFun := induced_map I e
    invFun := induced_map I e.symm .. }
[GOAL]
case refine'_1
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (x y : (ι → R) ⧸ Ideal.pi I ι), induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y
case refine'_2
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
    AddHom.toFun { toFun := induced_map I ↑e, map_add' := ?refine'_1 } (r • x) =
      ↑(RingHom.id (R ⧸ I)) r • AddHom.toFun { toFun := induced_map I ↑e, map_add' := ?refine'_1 } x
case refine'_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ LeftInverse (induced_map I ↑(LinearEquiv.symm e))
    { toAddHom := { toFun := induced_map I ↑e, map_add' := ?refine'_1 }, map_smul' := ?refine'_2 }.toAddHom.toFun
case refine'_4
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ Function.RightInverse (induced_map I ↑(LinearEquiv.symm e))
    { toAddHom := { toFun := induced_map I ↑e, map_add' := ?refine'_1 }, map_smul' := ?refine'_2 }.toAddHom.toFun
[PROOFSTEP]
all_goals
  first
  | rintro ⟨a⟩ ⟨b⟩
  |
    rintro
      ⟨a⟩
          -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
            -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_1
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (x y : (ι → R) ⧸ Ideal.pi I ι), induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y
[PROOFSTEP]
first
| rintro ⟨a⟩ ⟨b⟩
|
  rintro
    ⟨a⟩
        -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
          -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_1
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (x y : (ι → R) ⧸ Ideal.pi I ι), induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case refine'_2
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
    AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (r • x) =
      ↑(RingHom.id (R ⧸ I)) r •
        AddHom.toFun
          { toFun := induced_map I ↑e,
            map_add' :=
              (_ :
                ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                  induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
          x
[PROOFSTEP]
first
| rintro ⟨a⟩ ⟨b⟩
|
  rintro
    ⟨a⟩
        -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
          -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_2
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
    AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (r • x) =
      ↑(RingHom.id (R ⧸ I)) r •
        AddHom.toFun
          { toFun := induced_map I ↑e,
            map_add' :=
              (_ :
                ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                  induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
          x
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case refine'_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ LeftInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
first
| rintro ⟨a⟩ ⟨b⟩
|
  rintro
    ⟨a⟩
        -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
          -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ LeftInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case refine'_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ LeftInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
rintro
  ⟨a⟩
      -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
        -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_4
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ Function.RightInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
first
| rintro ⟨a⟩ ⟨b⟩
|
  rintro
    ⟨a⟩
        -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
          -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_4
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ Function.RightInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case refine'_4
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
⊢ Function.RightInverse (induced_map I ↑(LinearEquiv.symm e))
    {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom.toFun
[PROOFSTEP]
rintro
  ⟨a⟩
      -- porting note: the next 4 lines were necessary because Lean couldn't correctly infer `(I.pi ι)`
        -- and `(I.pi ι')` on its own.
[GOAL]
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
case refine'_3.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
⊢ induced_map I (↑(LinearEquiv.symm e))
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := induced_map I ↑e,
                map_add' :=
                  (_ :
                    ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                      induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
            map_smul' :=
              (_ :
                ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                  AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      (r • x) =
                    ↑(RingHom.id (R ⧸ I)) r •
                      AddHom.toFun
                        { toFun := induced_map I ↑e,
                          map_add' :=
                            (_ :
                              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                        x) }.toAddHom
        (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
pick_goal 3
[GOAL]
case refine'_3.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
⊢ induced_map I (↑(LinearEquiv.symm e))
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := induced_map I ↑e,
                map_add' :=
                  (_ :
                    ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                      induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
            map_smul' :=
              (_ :
                ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                  AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      (r • x) =
                    ↑(RingHom.id (R ⧸ I)) r •
                      AddHom.toFun
                        { toFun := induced_map I ↑e,
                          map_add' :=
                            (_ :
                              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                        x) }.toAddHom
        (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
convert_to Ideal.Quotient.mk (I.pi ι) _ = Ideal.Quotient.mk (I.pi ι) _
[GOAL]
case refine'_3.mk.convert_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
⊢ ↑(Ideal.Quotient.mk (Ideal.pi I ι)) (↑↑(LinearEquiv.symm e) (↑↑e a)) = ↑(Ideal.Quotient.mk (Ideal.pi I ι)) a
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
congr
[GOAL]
case refine'_3.mk.convert_3.h.e_6.h
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
⊢ ↑↑(LinearEquiv.symm e) (↑↑e a) = a
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
simp only [LinearEquiv.coe_coe, LinearEquiv.symm_apply_apply]
[GOAL]
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
all_goals
  convert_to Ideal.Quotient.mk (I.pi ι') _ = Ideal.Quotient.mk (I.pi ι') _
  congr
  simp only [map_add, LinearEquiv.coe_coe, LinearEquiv.map_smulₛₗ, RingHom.id_apply, LinearEquiv.apply_symm_apply]
[GOAL]
case refine'_1.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ induced_map I (↑e) (Quot.mk Setoid.r a + Quot.mk Setoid.r b) =
    induced_map I (↑e) (Quot.mk Setoid.r a) + induced_map I (↑e) (Quot.mk Setoid.r b)
[PROOFSTEP]
convert_to Ideal.Quotient.mk (I.pi ι') _ = Ideal.Quotient.mk (I.pi ι') _
[GOAL]
case refine'_1.mk.mk.convert_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (↑↑e ((fun x x_1 => x + x_1) a b)) =
    ↑(Ideal.Quotient.mk (Ideal.pi I ι')) ((fun x x_1 => x + x_1) (↑↑e a) (↑↑e b))
[PROOFSTEP]
congr
[GOAL]
case refine'_1.mk.mk.convert_3.h.e_6.h
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι → R) ⧸ Ideal.pi I ι
a : ι → R
y✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ ↑↑e ((fun x x_1 => x + x_1) a b) = (fun x x_1 => x + x_1) (↑↑e a) (↑↑e b)
[PROOFSTEP]
simp only [map_add, LinearEquiv.coe_coe, LinearEquiv.map_smulₛₗ, RingHom.id_apply, LinearEquiv.apply_symm_apply]
[GOAL]
case refine'_2.mk.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ AddHom.toFun
      { toFun := induced_map I ↑e,
        map_add' :=
          (_ :
            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
      (Quot.mk Setoid.r a • Quot.mk Setoid.r b) =
    ↑(RingHom.id (R ⧸ I)) (Quot.mk Setoid.r a) •
      AddHom.toFun
        { toFun := induced_map I ↑e,
          map_add' :=
            (_ :
              ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
        (Quot.mk Setoid.r b)
[PROOFSTEP]
convert_to Ideal.Quotient.mk (I.pi ι') _ = Ideal.Quotient.mk (I.pi ι') _
[GOAL]
case refine'_2.mk.mk.convert_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (↑↑e (a • b)) = ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (a • ↑↑e b)
[PROOFSTEP]
congr
[GOAL]
case refine'_2.mk.mk.convert_3.h.e_6.h
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
r✝ : R ⧸ I
a : R
x✝ : (ι → R) ⧸ Ideal.pi I ι
b : ι → R
⊢ ↑↑e (a • b) = a • ↑↑e b
[PROOFSTEP]
simp only [map_add, LinearEquiv.coe_coe, LinearEquiv.map_smulₛₗ, RingHom.id_apply, LinearEquiv.apply_symm_apply]
[GOAL]
case refine'_4.mk
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := induced_map I ↑e,
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                    induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ Ideal.pi I ι),
                AddHom.toFun
                    { toFun := induced_map I ↑e,
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                            induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                    (r • x) =
                  ↑(RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      { toFun := induced_map I ↑e,
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ Ideal.pi I ι),
                              induced_map I (↑e) (x + y) = induced_map I (↑e) x + induced_map I (↑e) y) }
                      x) }.toAddHom
      (induced_map I (↑(LinearEquiv.symm e)) (Quot.mk Setoid.r a)) =
    Quot.mk Setoid.r a
[PROOFSTEP]
convert_to Ideal.Quotient.mk (I.pi ι') _ = Ideal.Quotient.mk (I.pi ι') _
[GOAL]
case refine'_4.mk.convert_3
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ ↑(Ideal.Quotient.mk (Ideal.pi I ι')) (↑↑e (↑↑(LinearEquiv.symm e) a)) = ↑(Ideal.Quotient.mk (Ideal.pi I ι')) a
[PROOFSTEP]
congr
[GOAL]
case refine'_4.mk.convert_3.h.e_6.h
R : Type u
inst✝² : CommRing R
I✝ : Ideal R
ι : Type v
inst✝¹ : Fintype ι
ι' : Type w
inst✝ : Fintype ι'
I : Ideal R
e : (ι → R) ≃ₗ[R] ι' → R
x✝ : (ι' → R) ⧸ Ideal.pi I ι'
a : ι' → R
⊢ ↑↑e (↑↑(LinearEquiv.symm e) a) = a
[PROOFSTEP]
simp only [map_add, LinearEquiv.coe_coe, LinearEquiv.map_smulₛₗ, RingHom.id_apply, LinearEquiv.apply_symm_apply]