/-- Riemann-Lebesgue lemma for functions on a finite-dimensional real vector space, formulated via
dual space. -/
theorem tendsto_integral_exp_smul_cocompact (μ : Measure V) [μ.IsAddHaarMeasure] :
    Tendsto (fun w : V →L[ℝ] ℝ => ∫ v, e[-w v] • f v ∂μ) (cocompact (V →L[ℝ] ℝ)) (𝓝 0) := by
  -- We have already proved the result for inner-product spaces, formulated in a way which doesn't
  -- refer to the inner product. So we choose an arbitrary inner-product space isomorphic to V
  -- and port the result over from there.
  let V' := EuclideanSpace ℝ (Fin (finrank ℝ V))
  have A : V ≃L[ℝ] V' := toEuclidean
  borelize V'
  -- various equivs derived from A
  let Aₘ : MeasurableEquiv V V' := A.toHomeomorph.toMeasurableEquiv
  -- isomorphism between duals derived from A -- need to do continuity as a separate step in order
  -- to apply `LinearMap.continuous_of_finiteDimensional`.
  let Adualₗ : (V →L[ℝ] ℝ) ≃ₗ[ℝ] V' →L[ℝ] ℝ :=
    { toFun := fun t => t.comp A.symm.toContinuousLinearMap
      invFun := fun t => t.comp A.toContinuousLinearMap
      map_add' := by
        intro t s
        ext1 v
        simp only [ContinuousLinearMap.coe_comp', Function.comp_apply,
          ContinuousLinearMap.add_apply]
      map_smul' := by
        intro x f
        ext1 v
        simp only [RingHom.id_apply, ContinuousLinearMap.coe_comp', Function.comp_apply,
          ContinuousLinearMap.smul_apply]
      left_inv := by
        intro w
        ext1 v
        simp only [ContinuousLinearMap.coe_comp',
          ContinuousLinearEquiv.coe_coe, Function.comp_apply,
          ContinuousLinearEquiv.symm_apply_apply]
      right_inv := by
        intro w
        ext1 v
        simp only [ContinuousLinearMap.coe_comp',
          ContinuousLinearEquiv.coe_coe, Function.comp_apply,
          ContinuousLinearEquiv.apply_symm_apply] }
  let Adual : (V →L[ℝ] ℝ) ≃L[ℝ] V' →L[ℝ] ℝ :=
    { Adualₗ with
      continuous_toFun := Adualₗ.toLinearMap.continuous_of_finiteDimensional
      continuous_invFun := Adualₗ.symm.toLinearMap.continuous_of_finiteDimensional }
  have : (μ.map Aₘ).IsAddHaarMeasure := Measure.MapContinuousLinearEquiv.isAddHaarMeasure _ A
  convert
    (tendsto_integral_exp_smul_cocompact_of_inner_product (f ∘ A.symm) (μ.map Aₘ)).comp
      Adual.toHomeomorph.toCocompactMap.cocompact_tendsto' with w
  rw [Function.comp_apply, integral_map_equiv]
  congr 1 with v : 1
  congr
  · -- Porting note: added `congr_arg`
    apply congr_arg w
    exact (ContinuousLinearEquiv.symm_apply_apply A v).symm
  · 

Proof state:
case h.e'_3.h.e_f.h.e_a.e_a
E : Type u_1
V : Type u_2
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℂ E
f : V → E
inst✝¹⁰ : AddCommGroup V
inst✝⁹ : TopologicalSpace V
inst✝⁸ : TopologicalAddGroup V
inst✝⁷ : T2Space V
inst✝⁶ : MeasurableSpace V
inst✝⁵ : BorelSpace V
inst✝⁴ : Module ℝ V
inst✝³ : ContinuousSMul ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : CompleteSpace E
μ : Measure V
inst✝ : Measure.IsAddHaarMeasure μ
V' : Type := EuclideanSpace ℝ (Fin (finrank ℝ V))
A : V ≃L[ℝ] V'
this✝¹ : MeasurableSpace V' := borel V'
this✝ : BorelSpace V'
Aₘ : V ≃ᵐ V' := Homeomorph.toMeasurableEquiv (ContinuousLinearEquiv.toHomeomorph A)
Adualₗ : (V →L[ℝ] ℝ) ≃ₗ[ℝ] V' →L[ℝ] ℝ :=
  {
    toLinearMap :=
      {
        toAddHom :=
          { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
            map_add' :=
              (_ :
                ∀ (t s : V →L[ℝ] ℝ),
                  (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                    (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                      (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) },
        map_smul' :=
          (_ :
            ∀ (x : ℝ) (f : V →L[ℝ] ℝ),
              AddHom.toFun
                  { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                    map_add' :=
                      (_ :
                        ∀ (t s : V →L[ℝ] ℝ),
                          (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                            (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                              (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                  (x • f) =
                (RingHom.id ℝ) x •
                  AddHom.toFun
                    { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                      map_add' :=
                        (_ :
                          ∀ (t s : V →L[ℝ] ℝ),
                            (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                              (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                    f) },
    invFun := fun t => ContinuousLinearMap.comp t ↑A,
    left_inv :=
      (_ :
        ∀ (w : V →L[ℝ] ℝ),
          (fun t => ContinuousLinearMap.comp t ↑A)
              (AddHom.toFun
                {
                    toAddHom :=
                      { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                        map_add' :=
                          (_ :
                            ∀ (t s : V →L[ℝ] ℝ),
                              (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                                (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                  (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) },
                    map_smul' :=
                      (_ :
                        ∀ (x : ℝ) (f : V →L[ℝ] ℝ),
                          AddHom.toFun
                              { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                                map_add' :=
                                  (_ :
                                    ∀ (t s : V →L[ℝ] ℝ),
                                      (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                                        (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                          (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                              (x • f) =
                            (RingHom.id ℝ) x •
                              AddHom.toFun
                                { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                                  map_add' :=
                                    (_ :
                                      ∀ (t s : V →L[ℝ] ℝ),
                                        (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                                          (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                            (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                                f) }.toAddHom
                w) =
            w),
    right_inv :=
      (_ :
        ∀ (w : V' →L[ℝ] ℝ),
          AddHom.toFun
              {
                  toAddHom :=
                    { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                      map_add' :=
                        (_ :
                          ∀ (t s : V →L[ℝ] ℝ),
                            (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                              (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) },
                  map_smul' :=
                    (_ :
                      ∀ (x : ℝ) (f : V →L[ℝ] ℝ),
                        AddHom.toFun
                            { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                              map_add' :=
                                (_ :
                                  ∀ (t s : V →L[ℝ] ℝ),
                                    (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                                      (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                        (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                            (x • f) =
                          (RingHom.id ℝ) x •
                            AddHom.toFun
                              { toFun := fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A),
                                map_add' :=
                                  (_ :
                                    ∀ (t s : V →L[ℝ] ℝ),
                                      (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) (t + s) =
                                        (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) t +
                                          (fun t => ContinuousLinearMap.comp t ↑(ContinuousLinearEquiv.symm A)) s) }
                              f) }.toAddHom
              ((fun t => ContinuousLinearMap.comp t ↑A) w) =
            w) }
Adual : (V →L[ℝ] ℝ) ≃L[ℝ] V' →L[ℝ] ℝ :=
  ContinuousLinearEquiv.mk
    { toLinearMap := ↑Adualₗ, invFun := Adualₗ.invFun,
      left_inv := (_ : Function.LeftInverse Adualₗ.invFun Adualₗ.toFun),
      right_inv := (_ : Function.RightInverse Adualₗ.invFun Adualₗ.toFun) }
this : Measure.IsAddHaarMeasure (Measure.map (⇑Aₘ) μ)
w : V →L[ℝ] ℝ
v : V
⊢ v = (ContinuousLinearEquiv.symm A) (Aₘ v)

Next tactic:
exact (ContinuousLinearEquiv.symm_apply_apply A v).symm