Theorem: integral_comp_polarCoord_symm
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

tactic: set B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ := fun p =>
  LinearMap.toContinuousLinearMap (Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ)
    !![cos p.2, -p.1 * sin p.2; sin p.2, p.1 * cos p.2])
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p

tactic: have A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt polarCoord.symm (B p) p := fun p _ =>
  hasFDerivAt_polarCoord_symm p
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p

tactic: have B_det : ∀ p, (B p).det = p.1 := by
  intro p
  conv_rhs => rw [← one_mul p.1, ← cos_sq_add_sin_sq p.2]
  simp only [B, neg_mul, LinearMap.det_toContinuousLinearMap, LinearMap.det_toLin,
    Matrix.det_fin_two_of, sub_neg_eq_add]
  ring
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p

tactic: symm
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p) = ∫ (p : ℝ × ℝ), f p
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ), f p = ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p)

tactic: calc
  ∫ p, f p = ∫ p in polarCoord.source, f p := by
    rw [← integral_univ]
    apply setIntegral_congr_set_ae
    exact polarCoord_source_ae_eq_univ.symm
  _ = ∫ p in polarCoord.target, abs (B p).det • f (polarCoord.symm p) := by
    apply integral_target_eq_integral_abs_det_fderiv_smul volume A
  _ = ∫ p in polarCoord.target, p.1 • f (polarCoord.symm p) := by
    apply setIntegral_congr polarCoord.open_target.measurableSet fun x hx => ?_
    rw [B_det, abs_of_pos]
    exact hx.1
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ), f p = ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p)
state_after: no goals

tactic: intro p
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
⊢ ∀ (p : ℝ × ℝ), (B p).det = p.1
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ (B p).det = p.1

tactic: conv_rhs => rw [← one_mul p.1, ← cos_sq_add_sin_sq p.2]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ (B p).det = p.1
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ (B p).det = (cos p.2 ^ 2 + sin p.2 ^ 2) * p.1

tactic: simp only [B, neg_mul, LinearMap.det_toContinuousLinearMap, LinearMap.det_toLin,
  Matrix.det_fin_two_of, sub_neg_eq_add]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ (B p).det = (cos p.2 ^ 2 + sin p.2 ^ 2) * p.1
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ cos p.2 * (p.1 * cos p.2) + p.1 * sin p.2 * sin p.2 = (cos p.2 ^ 2 + sin p.2 ^ 2) * p.1

tactic: ring
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
p : ℝ × ℝ
⊢ cos p.2 * (p.1 * cos p.2) + p.1 * sin p.2 * sin p.2 = (cos p.2 ^ 2 + sin p.2 ^ 2) * p.1
state_after: no goals

tactic: rw [← integral_univ]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ), f p = ∫ (p : ℝ × ℝ) in polarCoord.source, f p
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (x : ℝ × ℝ) in univ, f x = ∫ (p : ℝ × ℝ) in polarCoord.source, f p

tactic: apply setIntegral_congr_set_ae
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (x : ℝ × ℝ) in univ, f x = ∫ (p : ℝ × ℝ) in polarCoord.source, f p
state_after: case hst
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ univ =ᶠ[ae volume] polarCoord.source

tactic: exact polarCoord_source_ae_eq_univ.symm
state_before: case hst
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ univ =ᶠ[ae volume] polarCoord.source
state_after: no goals

tactic: apply integral_target_eq_integral_abs_det_fderiv_smul volume A
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ) in polarCoord.source, f p = ∫ (p : ℝ × ℝ) in polarCoord.target, |(B p).det| • f (↑polarCoord.symm p)
state_after: no goals

tactic: apply setIntegral_congr polarCoord.open_target.measurableSet fun x hx => ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
⊢ ∫ (p : ℝ × ℝ) in polarCoord.target, |(B p).det| • f (↑polarCoord.symm p) =
    ∫ (p : ℝ × ℝ) in polarCoord.target, p.1 • f (↑polarCoord.symm p)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
x : ℝ × ℝ
hx : x ∈ polarCoord.target
⊢ |(B x).det| • f (↑polarCoord.symm x) = x.1 • f (↑polarCoord.symm x)

tactic: rw [B_det, abs_of_pos]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
x : ℝ × ℝ
hx : x ∈ polarCoord.target
⊢ |(B x).det| • f (↑polarCoord.symm x) = x.1 • f (↑polarCoord.symm x)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
x : ℝ × ℝ
hx : x ∈ polarCoord.target
⊢ 0 < x.1

tactic: exact hx.1
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ × ℝ → E
B : ℝ × ℝ → ℝ × ℝ →L[ℝ] ℝ × ℝ :=
  fun p =>
    LinearMap.toContinuousLinearMap
      ((Matrix.toLin (Basis.finTwoProd ℝ) (Basis.finTwoProd ℝ))
        (Matrix.of ![![cos p.2, -p.1 * sin p.2], ![sin p.2, p.1 * cos p.2]]))
A : ∀ p ∈ polarCoord.symm.source, HasFDerivAt (↑polarCoord.symm) (B p) p
B_det : ∀ (p : ℝ × ℝ), (B p).det = p.1
x : ℝ × ℝ
hx : x ∈ polarCoord.target
⊢ 0 < x.1
state_after: no goals