l3lab/ntp-mathlib huggingface dataset:
theorem rnDeriv_add (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [(s + t).HaveLebesgueDecomposition μ] :
    (s + t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ + t.rnDeriv μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝² : HaveLebesgueDecomposition s μ
inst✝¹ : HaveLebesgueDecomposition t μ
inst✝ : HaveLebesgueDecomposition (s + t) μ
⊢ rnDeriv (s + t) μ =ᶠ[ae μ] rnDeriv s μ + rnDeriv t μ

Next tactic:
refine'
    Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _)
      ((integrable_rnDeriv _ _).add (integrable_rnDeriv _ _)) _
theorem rnDeriv_add (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [(s + t).HaveLebesgueDecomposition μ] :
    (s + t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ + t.rnDeriv μ := by
  refine'
    Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _)
      ((integrable_rnDeriv _ _).add (integrable_rnDeriv _ _)) _
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝² : HaveLebesgueDecomposition s μ
inst✝¹ : HaveLebesgueDecomposition t μ
inst✝ : HaveLebesgueDecomposition (s + t) μ
⊢ withDensityᵥ μ (rnDeriv (s + t) μ) = withDensityᵥ μ (rnDeriv s μ + rnDeriv t μ)

Next tactic:
rw [← add_right_inj ((s + t).singularPart μ), singularPart_add_withDensity_rnDeriv_eq,
    withDensityᵥ_add (integrable_rnDeriv _ _) (integrable_rnDeriv _ _), singularPart_add,
    add_assoc, add_comm (t.singularPart μ), add_assoc, add_comm _ (t.singularPart μ),
    singularPart_add_withDensity_rnDeriv_eq, ← add_assoc,
    singularPart_add_withDensity_rnDeriv_eq]
theorem rnDeriv_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [hst : (s - t).HaveLebesgueDecomposition μ] :
    (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
hst : HaveLebesgueDecomposition (s - t) μ
⊢ rnDeriv (s - t) μ =ᶠ[ae μ] rnDeriv s μ - rnDeriv t μ

Next tactic:
rw [sub_eq_add_neg] at hst
theorem rnDeriv_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [hst : (s - t).HaveLebesgueDecomposition μ] :
    (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ := by
  rw [sub_eq_add_neg] at hst
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
hst : HaveLebesgueDecomposition (s + -t) μ
⊢ rnDeriv (s - t) μ =ᶠ[ae μ] rnDeriv s μ - rnDeriv t μ

Next tactic:
rw [sub_eq_add_neg, sub_eq_add_neg]
theorem rnDeriv_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [hst : (s - t).HaveLebesgueDecomposition μ] :
    (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ := by
  rw [sub_eq_add_neg] at hst
  rw [sub_eq_add_neg, sub_eq_add_neg]
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : HaveLebesgueDecomposition s μ
inst✝ : HaveLebesgueDecomposition t μ
hst : HaveLebesgueDecomposition (s + -t) μ
⊢ rnDeriv (s + -t) μ =ᶠ[ae μ] rnDeriv s μ + -rnDeriv t μ

Next tactic:
exact ae_eq_trans (rnDeriv_add _ _ _) (Filter.EventuallyEq.add (ae_eq_refl _) (rnDeriv_neg _ _))
theorem integrable_rnDeriv (c : ComplexMeasure α) (μ : Measure α) : Integrable (c.rnDeriv μ) μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
c✝ c : ComplexMeasure α
μ : Measure α
⊢ Integrable (rnDeriv c μ)

Next tactic:
rw [← memℒp_one_iff_integrable, ← memℒp_re_im_iff]
theorem integrable_rnDeriv (c : ComplexMeasure α) (μ : Measure α) : Integrable (c.rnDeriv μ) μ := by
  rw [← memℒp_one_iff_integrable, ← memℒp_re_im_iff]
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
c✝ c : ComplexMeasure α
μ : Measure α
⊢ Memℒp (fun x => IsROrC.re (rnDeriv c μ x)) 1 ∧ Memℒp (fun x => IsROrC.im (rnDeriv c μ x)) 1

Next tactic:
exact
    ⟨memℒp_one_iff_integrable.2 (SignedMeasure.integrable_rnDeriv _ _),
      memℒp_one_iff_integrable.2 (SignedMeasure.integrable_rnDeriv _ _)⟩
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
⊢ singularPart c μ + Measure.withDensityᵥ μ (rnDeriv c μ) = c

Next tactic:
conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => 

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
| c

Next tactic:
rw [← c.toComplexMeasure_to_signedMeasure]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
⊢ singularPart c μ + Measure.withDensityᵥ μ (rnDeriv c μ) = SignedMeasure.toComplexMeasure (re c) (im c)

Next tactic:
ext i hi : 1
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  

Proof state:
case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ ↑(singularPart c μ + Measure.withDensityᵥ μ (rnDeriv c μ)) i = ↑(SignedMeasure.toComplexMeasure (re c) (im c)) i

Next tactic:
rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  

Proof state:
case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ ↑(singularPart c μ) i + ↑(Measure.withDensityᵥ μ (rnDeriv c μ)) i = { re := ↑(re c) i, im := ↑(im c) i }

Next tactic:
apply Complex.ext
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · 

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ (↑(singularPart c μ) i + ↑(Measure.withDensityᵥ μ (rnDeriv c μ)) i).re = { re := ↑(re c) i, im := ↑(im c) i }.re

Next tactic:
rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · 

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ (↑(singularPart c μ) i).re + ↑(Measure.withDensityᵥ μ fun a => (rnDeriv c μ a).re) i =
    { re := ↑(re c) i, im := ↑(im c) i }.re

Next tactic:
change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ ↑(SignedMeasure.singularPart (re c) μ + Measure.withDensityᵥ μ (SignedMeasure.rnDeriv (re c) μ)) i =
    { re := ↑(re c) i, im := ↑(im c) i }.re

Next tactic:
rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
    · 

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ Integrable fun a => (rnDeriv c μ a).re

Next tactic:
exact SignedMeasure.integrable_rnDeriv _ _
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
    · exact SignedMeasure.integrable_rnDeriv _ _
  · 

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ (↑(singularPart c μ) i + ↑(Measure.withDensityᵥ μ (rnDeriv c μ)) i).im = { re := ↑(re c) i, im := ↑(im c) i }.im

Next tactic:
rw [Complex.add_im, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.im_eq_complex_im,
      ← integral_im (c.integrable_rnDeriv μ).integrableOn, IsROrC.im_eq_complex_im,
      ← withDensityᵥ_apply _ hi]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
    · exact SignedMeasure.integrable_rnDeriv _ _
  · rw [Complex.add_im, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.im_eq_complex_im,
      ← integral_im (c.integrable_rnDeriv μ).integrableOn, IsROrC.im_eq_complex_im,
      ← withDensityᵥ_apply _ hi]
    · 

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ (↑(singularPart c μ) i).im + ↑(Measure.withDensityᵥ μ fun a => (rnDeriv c μ a).im) i =
    { re := ↑(re c) i, im := ↑(im c) i }.im

Next tactic:
change (c.im.singularPart μ + μ.withDensityᵥ (c.im.rnDeriv μ)) i = _
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
    · exact SignedMeasure.integrable_rnDeriv _ _
  · rw [Complex.add_im, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.im_eq_complex_im,
      ← integral_im (c.integrable_rnDeriv μ).integrableOn, IsROrC.im_eq_complex_im,
      ← withDensityᵥ_apply _ hi]
    · change (c.im.singularPart μ + μ.withDensityᵥ (c.im.rnDeriv μ)) i = _
      

Proof state:
case h.a
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ ↑(SignedMeasure.singularPart (im c) μ + Measure.withDensityᵥ μ (SignedMeasure.rnDeriv (im c) μ)) i =
    { re := ↑(re c) i, im := ↑(im c) i }.im

Next tactic:
rw [c.im.singularPart_add_withDensity_rnDeriv_eq μ]
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c := by
  conv_rhs => rw [← c.toComplexMeasure_to_signedMeasure]
  ext i hi : 1
  rw [VectorMeasure.add_apply, SignedMeasure.toComplexMeasure_apply]
  apply Complex.ext
  · rw [Complex.add_re, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.re_eq_complex_re,
      ← integral_re (c.integrable_rnDeriv μ).integrableOn, IsROrC.re_eq_complex_re,
      ← withDensityᵥ_apply _ hi]
    · change (c.re.singularPart μ + μ.withDensityᵥ (c.re.rnDeriv μ)) i = _
      rw [c.re.singularPart_add_withDensity_rnDeriv_eq μ]
    · exact SignedMeasure.integrable_rnDeriv _ _
  · rw [Complex.add_im, withDensityᵥ_apply (c.integrable_rnDeriv μ) hi, ← IsROrC.im_eq_complex_im,
      ← integral_im (c.integrable_rnDeriv μ).integrableOn, IsROrC.im_eq_complex_im,
      ← withDensityᵥ_apply _ hi]
    · change (c.im.singularPart μ + μ.withDensityᵥ (c.im.rnDeriv μ)) i = _
      rw [c.im.singularPart_add_withDensity_rnDeriv_eq μ]
    · 

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
c : ComplexMeasure α
inst✝ : HaveLebesgueDecomposition c μ
i : Set α
hi : MeasurableSet i
⊢ Integrable fun a => (rnDeriv c μ a).im

Next tactic:
exact SignedMeasure.integrable_rnDeriv _ _
theorem trivialization.coordChangeL (b : B) :
    (trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
      ContinuousLinearEquiv.refl 𝕜 F := by
  

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
b : B
⊢ Trivialization.coordChangeL 𝕜 (trivialization B F) (trivialization B F) b = ContinuousLinearEquiv.refl 𝕜 F

Next tactic:
ext v
theorem trivialization.coordChangeL (b : B) :
    (trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
      ContinuousLinearEquiv.refl 𝕜 F := by
  ext v
  

Proof state:
case h.h
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
b : B
v : F
⊢ (Trivialization.coordChangeL 𝕜 (trivialization B F) (trivialization B F) b) v = (ContinuousLinearEquiv.refl 𝕜 F) v

Next tactic:
rw [Trivialization.coordChangeL_apply']
theorem trivialization.coordChangeL (b : B) :
    (trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
      ContinuousLinearEquiv.refl 𝕜 F := by
  ext v
  rw [Trivialization.coordChangeL_apply']
  

Proof state:
case h.h
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
b : B
v : F
⊢ (↑(trivialization B F) (↑(PartialHomeomorph.symm (trivialization B F).toPartialHomeomorph) (b, v))).2 =
    (ContinuousLinearEquiv.refl 𝕜 F) v
case h.h.hb
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
b : B
v : F
⊢ b ∈ (trivialization B F).baseSet ∩ (trivialization B F).baseSet

Next tactic:
exacts [rfl, ⟨mem_univ _, mem_univ _⟩]
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
e : Trivialization F TotalSpace.proj
he : MemTrivializationAtlas e
⊢ Trivialization.IsLinear 𝕜 e

Next tactic:
rw [eq_trivialization B F e]
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    rw [eq_trivialization B F e]
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
e : Trivialization F TotalSpace.proj
he : MemTrivializationAtlas e
⊢ Trivialization.IsLinear 𝕜 (trivialization B F)

Next tactic:
infer_instance
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    rw [eq_trivialization B F e]
    infer_instance
  continuousOn_coordChange' e e' he he' := by
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
e e' : Trivialization F TotalSpace.proj
he : MemTrivializationAtlas e
he' : MemTrivializationAtlas e'
⊢ ContinuousOn (fun b => ↑(Trivialization.coordChangeL 𝕜 e e' b)) (e.baseSet ∩ e'.baseSet)

Next tactic:
obtain rfl := eq_trivialization B F e
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    rw [eq_trivialization B F e]
    infer_instance
  continuousOn_coordChange' e e' he he' := by
    obtain rfl := eq_trivialization B F e
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
e' : Trivialization F TotalSpace.proj
he' : MemTrivializationAtlas e'
he : MemTrivializationAtlas (trivialization B F)
⊢ ContinuousOn (fun b => ↑(Trivialization.coordChangeL 𝕜 (trivialization B F) e' b))
    ((trivialization B F).baseSet ∩ e'.baseSet)

Next tactic:
obtain rfl := eq_trivialization B F e'
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    rw [eq_trivialization B F e]
    infer_instance
  continuousOn_coordChange' e e' he he' := by
    obtain rfl := eq_trivialization B F e
    obtain rfl := eq_trivialization B F e'
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
he he' : MemTrivializationAtlas (trivialization B F)
⊢ ContinuousOn (fun b => ↑(Trivialization.coordChangeL 𝕜 (trivialization B F) (trivialization B F) b))
    ((trivialization B F).baseSet ∩ (trivialization B F).baseSet)

Next tactic:
simp only [trivialization.coordChangeL]
instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
  trivialization_linear' e he := by
    rw [eq_trivialization B F e]
    infer_instance
  continuousOn_coordChange' e e' he he' := by
    obtain rfl := eq_trivialization B F e
    obtain rfl := eq_trivialization B F e'
    simp only [trivialization.coordChangeL]
    

Proof state:
𝕜 : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
he he' : MemTrivializationAtlas (trivialization B F)
⊢ ContinuousOn (fun b => ↑(ContinuousLinearEquiv.refl 𝕜 F))
    ((trivialization B F).baseSet ∩ (trivialization B F).baseSet)

Next tactic:
exact continuous_const.continuousOn
@[simp]
theorem coordChangeL_prod [e₁.IsLinear 𝕜] [e₁'.IsLinear 𝕜] [e₂.IsLinear 𝕜] [e₂'.IsLinear 𝕜] ⦃b⦄
    (hb : b ∈ (e₁.prod e₂).baseSet ∩ (e₁'.prod e₂').baseSet) :
    ((e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b : F₁ × F₂ →L[𝕜] F₁ × F₂) =
      (e₁.coordChangeL 𝕜 e₁' b : F₁ →L[𝕜] F₁).prodMap (e₂.coordChangeL 𝕜 e₂' b) := by
  

Proof state:
𝕜 : Type u_1
B : Type u_2
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : TopologicalSpace B
F₁ : Type u_3
inst✝¹³ : NormedAddCommGroup F₁
inst✝¹² : NormedSpace 𝕜 F₁
E₁ : B → Type u_4
inst✝¹¹ : TopologicalSpace (TotalSpace F₁ E₁)
F₂ : Type u_5
inst✝¹⁰ : NormedAddCommGroup F₂
inst✝⁹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_6
inst✝⁸ : TopologicalSpace (TotalSpace F₂ E₂)
inst✝⁷ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁵ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁴ : (x : B) → Module 𝕜 (E₂ x)
e₁ e₁' : Trivialization F₁ TotalSpace.proj
e₂ e₂' : Trivialization F₂ TotalSpace.proj
inst✝³ : Trivialization.IsLinear 𝕜 e₁
inst✝² : Trivialization.IsLinear 𝕜 e₁'
inst✝¹ : Trivialization.IsLinear 𝕜 e₂
inst✝ : Trivialization.IsLinear 𝕜 e₂'
b : B
hb : b ∈ (prod e₁ e₂).baseSet ∩ (prod e₁' e₂').baseSet
⊢ ↑(coordChangeL 𝕜 (prod e₁ e₂) (prod e₁' e₂') b) =
    ContinuousLinearMap.prodMap ↑(coordChangeL 𝕜 e₁ e₁' b) ↑(coordChangeL 𝕜 e₂ e₂' b)

Next tactic:
rw [ContinuousLinearMap.ext_iff, ContinuousLinearMap.coe_prodMap']
@[simp]
theorem coordChangeL_prod [e₁.IsLinear 𝕜] [e₁'.IsLinear 𝕜] [e₂.IsLinear 𝕜] [e₂'.IsLinear 𝕜] ⦃b⦄
    (hb : b ∈ (e₁.prod e₂).baseSet ∩ (e₁'.prod e₂').baseSet) :
    ((e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b : F₁ × F₂ →L[𝕜] F₁ × F₂) =
      (e₁.coordChangeL 𝕜 e₁' b : F₁ →L[𝕜] F₁).prodMap (e₂.coordChangeL 𝕜 e₂' b) := by
  rw [ContinuousLinearMap.ext_iff, ContinuousLinearMap.coe_prodMap']
  

Proof state:
𝕜 : Type u_1
B : Type u_2
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : TopologicalSpace B
F₁ : Type u_3
inst✝¹³ : NormedAddCommGroup F₁
inst✝¹² : NormedSpace 𝕜 F₁
E₁ : B → Type u_4
inst✝¹¹ : TopologicalSpace (TotalSpace F₁ E₁)
F₂ : Type u_5
inst✝¹⁰ : NormedAddCommGroup F₂
inst✝⁹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_6
inst✝⁸ : TopologicalSpace (TotalSpace F₂ E₂)
inst✝⁷ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁵ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁴ : (x : B) → Module 𝕜 (E₂ x)
e₁ e₁' : Trivialization F₁ TotalSpace.proj
e₂ e₂' : Trivialization F₂ TotalSpace.proj
inst✝³ : Trivialization.IsLinear 𝕜 e₁
inst✝² : Trivialization.IsLinear 𝕜 e₁'
inst✝¹ : Trivialization.IsLinear 𝕜 e₂
inst✝ : Trivialization.IsLinear 𝕜 e₂'
b : B
hb : b ∈ (prod e₁ e₂).baseSet ∩ (prod e₁' e₂').baseSet
⊢ ∀ (x : F₁ × F₂),
    ↑(coordChangeL 𝕜 (prod e₁ e₂) (prod e₁' e₂') b) x =
      Prod.map (⇑↑(coordChangeL 𝕜 e₁ e₁' b)) (⇑↑(coordChangeL 𝕜 e₂ e₂' b)) x

Next tactic:
rintro ⟨v₁, v₂⟩