import OAI.MathematicalPhysics.Elasticity.BoundaryEnergy

namespace OAI

section
/-! Strictly positive Gaussian-normal moments, without relying on a numerical
constant or an unproved nondegeneracy of the boundary limit. -/
noncomputable section
open Set MeasureTheory
open scoped BigOperators
namespace ElasticityBoundaryWeights

lemma weight_zero_of_nonpos (b : ℝ) {y : Y} (hy : y 2≤0) : weight b y=0 := by
  simp [weight,Fin.prod_univ_three,factor,not_lt.mpr hy]

lemma weight_pos (b : ℝ) {y : Y} (hy : 0<y 2) : 0<weight b y := by
  simp [weight,Fin.prod_univ_three,factor,hy,Real.exp_pos]

def normalMoment (n : ℕ) : ℝ := ∫ y : Y, (y 2)^n*weight 2 y

lemma normal_moment_integrable (n : ℕ) : Integrable (fun y : Y => (y 2)^n*weight 2 y) := by
  apply (integrable_coordinate_moment (by norm_num : (0:ℝ)<2) 2 n).congr
  exact Filter.Eventually.of_forall (fun y => by
    dsimp only
    by_cases hy : 0<y 2
    · rw [abs_of_pos hy]
    · rw [weight_zero_of_nonpos 2 (le_of_not_gt hy),mul_zero,mul_zero])

lemma normalMoment_pos (n : ℕ) : 0<normalMoment n := by
  have hn (y : Y) : 0≤(y 2)^n*weight 2 y := by
    by_cases hy : 0<y 2
    · exact mul_nonneg (pow_nonneg hy.le n) (weight_nonneg 2 y)
    · rw [weight_zero_of_nonpos 2 (le_of_not_gt hy),mul_zero]
  apply (integral_pos_iff_support_of_nonneg hn (normal_moment_integrable n)).mpr
  have ho : IsOpen ({y : Y | 0<y 2}) := isOpen_lt continuous_const (continuous_apply 2)
  have hne : ({y : Y | 0<y 2}).Nonempty := ⟨fun _ => 1,by norm_num⟩
  exact (ho.measure_pos volume hne).trans_le (measure_mono (fun y hy =>
    (mul_pos (pow_pos hy _) (weight_pos 2 hy)).ne'))

lemma normalMoment_complex (n : ℕ) :
    (∫ y : Y, weight 2 y • (y 2:ℂ)^n)=(normalMoment n:ℂ) := by
  simp only [Complex.real_smul,← Complex.ofReal_pow,← Complex.ofReal_mul]
  rw [integral_complex_ofReal]
  congr 1
  apply integral_congr_ae
  exact Filter.Eventually.of_forall (fun y => mul_comm _ _)

end ElasticityBoundaryWeights

end
end
section
/-! The finite leading packet pairing is precisely the integrated Hermitian
isotropic density, against a strictly positive normal Gaussian moment. -/
noncomputable section
open Set Filter MeasureTheory
open scoped Topology BigOperators
namespace ElasticityBoundaryPacket
open Elasticity ElasticityBoundaryMVNormal ElasticityBoundaryMVCalculus
  ElasticityBoundaryWeights ElasticityBoundaryOrderBound ElasticityBoundaryProfileBounds
  ElasticityBoundaryLimit ElasticityBoundaryParameter ElasticityBoundaryEnergyLimit
  ElasticityBoundaryCutoffBound

lemma polynomial_bound (p : MP) : OrderBound (fun _ y => value p y) 0 := by
  obtain ⟨A,hA,n,h⟩ := polynomialGrowth p
  exact ⟨A,hA,n,fun _ _ _ y => by simpa using h y⟩

lemma weighted_integrable {f : Y → ℂ} (hf : Continuous f)
    (hF : OrderBound (fun _ => f) 0) {b : ℝ} (hb : 0<b) :
    Integrable (fun y => weight b y • f y) := by
  obtain ⟨A,hA,n,hB⟩ := hF
  let g : Y → ℝ := fun y => (A*2^n)*(weight b y+‖y‖^n*weight b y)
  have hg : Integrable g := ((integrable_weight hb).add (integrable_norm_moment hb n)).const_mul _
  apply hg.mono' ((measurable_weight b).aestronglyMeasurable.smul hf.aestronglyMeasurable)
  exact Eventually.of_forall (fun y => by
    change ‖weight b y • f y‖≤g y
    rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg (weight_nonneg b y)]
    have h := hB 1 (by norm_num) le_rfl y
    simp only [pow_zero,mul_one] at h
    calc
      _ ≤ weight b y*(A*(1+‖y‖)^n) := mul_le_mul_of_nonneg_left h (weight_nonneg b y)
      _ ≤ weight b y*(A*(2^n*(1+‖y‖^n))) :=
        mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left (one_add_pow_le (norm_nonneg y) n) hA)
          (weight_nonneg b y)
      _ = g y := by dsimp [g]; ring)

lemma frozen_integrable (n : ℕ) (c : ℂ) (p q : MP) :
    Integrable (fun y : Y => weight 2 y • ((y 2:ℂ)^n*c*value p y*star (value q y))) := by
  apply weighted_integrable
  · exact ((((Complex.continuous_ofReal.comp (continuous_apply 2)).pow n).mul continuous_const).mul
      (smooth_value p).continuous).mul (smooth_value q).continuous.star
  · have hc : OrderBound (fun (_ : ℝ) (_ : Y) => c) 0 := by
      exact ⟨‖c‖,norm_nonneg _,0,fun _ _ _ _ => by simp⟩
    exact (((normal_power_bound n).mul hc).mul (polynomial_bound p)).mul (OrderBound.conj (polynomial_bound q))
  · norm_num

lemma frozenPair_integral (n : ℕ) (a : I → I → I → I → ℂ) (p q : W) :
    frozenPair n a p q=∫ y : Y, weight 2 y • ((y 2:ℂ)^n*
      tensorDensity a (fun i α => value (E₀ α (p i)) y) (fun j β => value (E₀ β (q j)) y)) := by
  have hi (i α j β : I) := frozen_integrable n (a i α j β) (E₀ α (p i)) (E₀ β (q j))
  have hfun (y : Y) : weight 2 y • ((y 2:ℂ)^n*
      tensorDensity a (fun i α => value (E₀ α (p i)) y) (fun j β => value (E₀ β (q j)) y))=
      ∑ i, ∑ α, ∑ j, ∑ β, weight 2 y • ((y 2:ℂ)^n*a i α j β*
        value (E₀ α (p i)) y*star (value (E₀ β (q j)) y)) := by
    simp only [tensorDensity,Finset.mul_sum,Finset.smul_sum,mul_assoc]
  simp_rw [hfun]
  unfold frozenPair
  symm
  rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun α _ =>
    integrable_finsetSum _ (fun j _ => integrable_finsetSum _ (fun β _ => hi i α j β))))]
  apply Finset.sum_congr rfl; intro i _
  rw [integral_finsetSum _ (fun α _ => integrable_finsetSum _ (fun j _ =>
    integrable_finsetSum _ (fun β _ => hi i α j β)))]
  apply Finset.sum_congr rfl; intro α _
  rw [integral_finsetSum _ (fun j _ => integrable_finsetSum _ (fun β _ => hi i α j β))]
  apply Finset.sum_congr rfl; intro j _
  exact integral_finsetSum _ (fun β _ => hi i α j β)

lemma frozenPair_constant (n : ℕ) (a : I → I → I → I → ℂ) (p q : W) (c : ℂ)
    (h : ∀ y : Y, tensorDensity a (fun i α => value (E₀ α (p i)) y)
      (fun j β => value (E₀ β (q j)) y)=c) :
    frozenPair n a p q=(normalMoment n:ℂ)*c := by
  rw [frozenPair_integral]
  simp only [h,Complex.real_smul,← mul_assoc]
  rw [integral_mul_const]
  congr 1
  exact normalMoment_complex n

end ElasticityBoundaryPacket

end
end
section
/-! Exact transverse and longitudinal frozen physical tests. Both are genuine
solutions of the normal isotropic elasticity equation. -/
noncomputable section
open scoped BigOperators Matrix
namespace ElasticityBoundaryLeading
open Elasticity ElasticityBoundarySymbol ElasticityBoundaryMVNormal
  ElasticityBoundaryMVCalculus ElasticityBoundaryParameter ElasticityBoundaryLayerOperator
abbrev I := Fin 3
abbrev Y := I → ℝ

def leading (l m : ℂ) (f : F) : W := fun i => lift (homogeneousPolynomial l m f i)

def grad (p : W) (y : Y) : CMatrix := fun i α => value (E₀ α (p i)) y

lemma leading_normal (l m : ℂ) (hp : l+3*m≠0) (f : F) : normal l m (leading l m f)=0 := by
  change normal l m (fun i => lift (homogeneousPolynomial l m f i))=0
  rw [normal_lift,homogeneousPolynomial_physical l m hp]
  ext i
  simp

lemma leading_apply (l m : ℂ) (f : F) (i : I) :
    leading l m f i=MvPolynomial.C (f i)+MvPolynomial.X 2*MvPolynomial.C (ElasticityBoundarySymbol.slope l m f i) := by
  simp only [leading,homogeneousPolynomial,map_add,map_mul,lift_C,lift_X]

lemma grad_leading (l m : ℂ) (f : F) (y : Y) (i α : I) :
    grad (leading l m f) y i α=
      if α=0 then Complex.I*(f i+(y 2:ℂ)*ElasticityBoundarySymbol.slope l m f i)
      else if α=1 then 0 else ElasticityBoundarySymbol.slope l m f i-f i-(y 2:ℂ)*ElasticityBoundarySymbol.slope l m f i := by
  rw [grad,leading_apply]
  fin_cases α <;> simp [E₀,value_smul] <;> ring

lemma tensorDensity_factor (D : ℂ) (a : I → I → I → I → ℂ) (P Q : CMatrix) :
    tensorDensity (fun i α j β => D*a i α j β) P Q=D*tensorDensity a P Q := by
  simp only [tensorDensity,Finset.mul_sum,mul_assoc]

lemma transverse_density (l₁ m₁ l₂ m₂ L M : ℂ) (y : Y) :
    tensorDensity (elasticityTensor L M)
      (grad (leading l₁ m₁ ![0,1,0]) y) (grad (leading l₂ m₂ ![0,1,0]) y)=2*M := by
  rw [tensorDensity_isotropic]
  simp only [sesquiDensity,Fin.sum_univ_three,grad_leading]
  simp [ElasticityBoundarySymbol.slope]
  ring

lemma longitudinal_trace (l m : ℂ) (hp : l+3*m≠0) (y : Y) :
    (∑ i, grad (leading l m ![1,0,0]) y i i)=Complex.I*(2*m/(l+3*m)) := by
  simp [Fin.sum_univ_three,grad_leading,ElasticityBoundarySymbol.slope]
  have hp' : l+m*3≠0 := by simpa only [mul_comm] using hp
  field_simp [hp,hp']
  ring

lemma longitudinal_density (l₁ m₁ l₂ m₂ : ℂ) (hp₁ : l₁+3*m₁≠0) (hp₂ : l₂+3*m₂≠0)
    (L : ℂ) (y : Y) :
    tensorDensity (elasticityTensor L 0)
      (grad (leading l₁ m₁ ![1,0,0]) y) (grad (leading l₂ m₂ ![1,0,0]) y)=
      L*(Complex.I*(2*m₁/(l₁+3*m₁)))*star (Complex.I*(2*m₂/(l₂+3*m₂))) := by
  rw [tensorDensity_isotropic]
  simp only [sesquiDensity,zero_div,zero_mul,add_zero,longitudinal_trace l₁ m₁ hp₁,
    longitudinal_trace l₂ m₂ hp₂]

lemma longitudinal_trace_ne (l m : ℂ) (hm : m≠0) (hp : l+3*m≠0) :
    Complex.I*(2*m/(l+3*m))≠0 :=
  mul_ne_zero Complex.I_ne_zero (div_ne_zero (mul_ne_zero (by norm_num) hm) hp)

end ElasticityBoundaryLeading

end
end
section
/-! Nondegenerate extraction of the two genuine isotropic scalar coefficients.
Tests are the actual frozen normal solutions, not arbitrary symbol data. -/
noncomputable section
open scoped Matrix BigOperators
namespace ElasticityBoundaryPacket
open Elasticity ElasticityBoundaryLeading ElasticityBoundaryWeights
  ElasticityBoundarySymbol ElasticityBoundaryMVNormal ElasticityBoundaryParameter ElasticityBoundaryLayerOperator

lemma pair_separates (n : ℕ) (l₁ m₁ l₂ m₂ D L M : ℂ)
    (hm₁ : m₁≠0) (hm₂ : m₂≠0) (hp₁ : l₁+3*m₁≠0) (hp₂ : l₂+3*m₂≠0)
    (hD : D≠0)
    (h : ∀ p q : W, normal l₁ m₁ p=0 → normal l₂ m₂ q=0 →
      frozenPair n (fun i α j β => D*elasticityTensor L M i α j β) p q=0) : L=0 ∧ M=0 := by
  have hmoment : (normalMoment n:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (normalMoment_pos n).ne'
  have hM : M=0 := by
    have hh := h (leading l₁ m₁ ![0,1,0]) (leading l₂ m₂ ![0,1,0])
      (leading_normal l₁ m₁ hp₁ _) (leading_normal l₂ m₂ hp₂ _)
    have he := frozenPair_constant n (fun i α j β => D*elasticityTensor L M i α j β)
      (leading l₁ m₁ ![0,1,0]) (leading l₂ m₂ ![0,1,0]) (D*(2*M)) (fun y => by
        change tensorDensity _ (grad _ y) (grad _ y)=_
        rw [tensorDensity_factor,transverse_density])
    rw [he] at hh
    exact (mul_eq_zero.mp ((mul_eq_zero.mp ((mul_eq_zero.mp hh).resolve_left hmoment)).resolve_left hD)).resolve_left
      (by norm_num)
  refine ⟨?_,hM⟩
  have hh := h (leading l₁ m₁ ![1,0,0]) (leading l₂ m₂ ![1,0,0])
    (leading_normal l₁ m₁ hp₁ _) (leading_normal l₂ m₂ hp₂ _)
  have he := frozenPair_constant n (fun i α j β => D*elasticityTensor L M i α j β)
    (leading l₁ m₁ ![1,0,0]) (leading l₂ m₂ ![1,0,0])
    (D*(L*(Complex.I*(2*m₁/(l₁+3*m₁)))*star (Complex.I*(2*m₂/(l₂+3*m₂))))) (fun y => by
      change tensorDensity _ (grad _ y) (grad _ y)=_
      rw [hM,tensorDensity_factor,longitudinal_density l₁ m₁ l₂ m₂ hp₁ hp₂])
  rw [he] at hh
  have ht₁ := longitudinal_trace_ne l₁ m₁ hm₁ hp₁
  have ht₂ : star (Complex.I*(2*m₂/(l₂+3*m₂)))≠0 := star_ne_zero.mpr
    (longitudinal_trace_ne l₂ m₂ hm₂ hp₂)
  exact (mul_eq_zero.mp ((mul_eq_zero.mp ((mul_eq_zero.mp
    ((mul_eq_zero.mp hh).resolve_left hmoment)).resolve_left hD)).resolve_right ht₂)).resolve_right ht₁

end ElasticityBoundaryPacket

end
end
section
/-! Boundary values of BOTH Lamé parameters from the literal physical DN map
on an arbitrary honest smooth domain. This is not a near-boundary assumption. -/
noncomputable section
open Set
open scoped Topology BigOperators
namespace ElasticityBoundaryPacket
open Elasticity ElasticityBoundaryLayerOperator
variable {Ω : Set X} {x : X}

lemma elasticityTensor_sub (l₁ m₁ l₂ m₂ : ℂ) (i α j β : I) :
    elasticityTensor l₁ m₁ i α j β-elasticityTensor l₂ m₂ i α j β=
      elasticityTensor (l₁-l₂) (m₁-m₂) i α j β := by
  unfold elasticityTensor
  ring

lemma admissible_frozen_ne {l m : X → ℝ} (ha : Admissible Ω l m) (hx : x∈closure Ω) :
    (m x:ℂ)≠0 ∧ (l x:ℂ)+3*(m x:ℂ)≠0 := by
  obtain ⟨hm,he⟩ := ha.2.2 x hx
  constructor
  · exact Complex.ofReal_ne_zero.mpr hm.ne'
  · have hp : 0<l x+3*m x := by linarith
    exact_mod_cast hp.ne'

lemma Setup.boundary_values (s : Setup Ω x) {l₁ m₁ l₂ m₂ : X → ℝ}
    (hl₁ : ContDiff ℝ (⊤ : ℕ∞) l₁) (hm₁ : ContDiff ℝ (⊤ : ℕ∞) m₁)
    (hl₂ : ContDiff ℝ (⊤ : ℕ∞) l₂) (hm₂ : ContDiff ℝ (⊤ : ℕ∞) m₂)
    (ha₁ : Admissible Ω l₁ m₁) (ha₂ : Admissible Ω l₂ m₂)
    (hO : IsOpen Ω) (hB : Bornology.IsBounded Ω) (hx : x∈closure Ω)
    (hDN : DN Ω l₁ m₁=DN Ω l₂ m₂) : l₁ x=l₂ x ∧ m₁ x=m₂ x := by
  obtain ⟨H₁,hH₁c,hH₁s,hH₁⟩ := s.compact_energy_coefficients
    (Complex.ofRealCLM.contDiff.comp hl₁) (Complex.ofRealCLM.contDiff.comp hm₁)
  obtain ⟨H₂,hH₂c,hH₂s,hH₂⟩ := s.compact_energy_coefficients
    (Complex.ofRealCLM.contDiff.comp hl₂) (Complex.ofRealCLM.contDiff.comp hm₂)
  let H := fun i α j β y => H₁ i α j β y-H₂ i α j β y
  have hHc : ∀ i α j β, Continuous (H i α j β) := fun i α j β =>
    (hH₁c i α j β).sub (hH₂c i α j β)
  have hHs : ∀ i α j β, HasCompactSupport (H i α j β) := fun i α j β =>
    (hH₁s i α j β).sub (hH₂s i α j β)
  have hH (i α j β : I) (y : Y) (hy : WithLp.toLp 2 y∈s.K) :
      s.rawCoeff (fun z => (l₁ z:ℂ)) (fun z => (m₁ z:ℂ)) i α j β y-
      s.rawCoeff (fun z => (l₂ z:ℂ)) (fun z => (m₂ z:ℂ)) i α j β y=(y 2:ℂ)^0*H i α j β y := by
    simp only [pow_zero,one_mul,H,hH₁ i α j β y hy,hH₂ i α j β y hy]
    rfl
  have hH0 : (fun i α j β => H i α j β 0)=
      (fun i α j β => (s.jacobian 0:ℂ)*elasticityTensor
        ((l₁ x:ℂ)-(l₂ x:ℂ)) ((m₁ x:ℂ)-(m₂ x:ℂ)) i α j β) := by
    funext i α j β
    have h0 := hH i α j β 0 (by simpa using s.zero_mem)
    simp only [pow_zero,one_mul] at h0
    rw [← h0]
    rw [s.rawCoeff_zero,s.rawCoeff_zero,← mul_sub,elasticityTensor_sub]
  have hpair := pair_separates 0 (l₁ x) (m₁ x) (l₂ x) (m₂ x) (s.jacobian 0)
    ((l₁ x:ℂ)-(l₂ x:ℂ)) ((m₁ x:ℂ)-(m₂ x:ℂ))
    (admissible_frozen_ne ha₁ hx).1 (admissible_frozen_ne ha₂ hx).1
    (admissible_frozen_ne ha₁ hx).2 (admissible_frozen_ne ha₂ hx).2
    (Complex.ofReal_ne_zero.mpr s.jacobian_pos.ne') (by
      intro p q hp hq
      rw [← hH0]
      exact s.extract_normal hl₁ hm₁ hl₂ hm₂ ha₁ ha₂ hO hB hx hDN 0 H hHc hHs hH p q hp hq)
  exact ⟨Complex.ofReal_injective (sub_eq_zero.mp hpair.1),
    Complex.ofReal_injective (sub_eq_zero.mp hpair.2)⟩

lemma boundary_values_global {l₁ m₁ l₂ m₂ : X → ℝ}
    (hS : SourceSmoothBoundary Ω) (hO : IsOpen Ω) (hB : Bornology.IsBounded Ω)
    (hl₁ : ContDiff ℝ (⊤ : ℕ∞) l₁) (hm₁ : ContDiff ℝ (⊤ : ℕ∞) m₁)
    (hl₂ : ContDiff ℝ (⊤ : ℕ∞) l₂) (hm₂ : ContDiff ℝ (⊤ : ℕ∞) m₂)
    (ha₁ : Admissible Ω l₁ m₁) (ha₂ : Admissible Ω l₂ m₂)
    (hDN : DN Ω l₁ m₁=DN Ω l₂ m₂) (hx : x∈frontier Ω) : l₁ x=l₂ x ∧ m₁ x=m₂ x := by
  obtain ⟨s⟩ := setup_exists hS hx
  exact s.boundary_values hl₁ hm₁ hl₂ hm₂ ha₁ ha₂ hO hB (frontier_subset_closure hx) hDN

end ElasticityBoundaryPacket

end
end
section
/-! Honest continuous normal Taylor quotients, obtained from the integral
remainder. These are actual functions of the coefficients, not assumed jets. -/
noncomputable section
open Set MeasureTheory
open scoped Topology BigOperators
namespace ElasticityBoundaryNormalTaylor
abbrev Y := Fin 3 → ℝ

def en : Y := Pi.single 2 1

def projection (y : Y) : Y := y-(y 2) • en

def travel (y : Y) (t : ℝ) : Y := projection y+t • ((y 2) • en)

@[simp] lemma en_apply_two : en 2=1 := by simp [en]
@[simp] lemma projection_two (y : Y) : projection y 2=0 := by simp [projection]
@[simp] lemma projection_zero : projection 0=0 := by simp [projection]
@[simp] lemma travel_zero (t : ℝ) : travel 0 t=0 := by simp [travel]
@[simp] lemma travel_one (y : Y) : travel y 1=y := by simp [travel,projection]

variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]

def normalJet (n : ℕ) (f : Y → F) (y : Y) : F :=
  iteratedFDeriv ℝ n f y (fun _ => en)

def quotient (n : ℕ) (f : Y → F) (y : Y) : F :=
  (n.factorial:ℝ)⁻¹ • ∫ t in (0:ℝ)..1, (1-t)^n • normalJet (n+1) f (travel y t)

omit [CompleteSpace F] in
lemma normalJet_continuous {f : Y → F} (hf : ContDiff ℝ (⊤ : ℕ∞) f) (n : ℕ) :
    Continuous (normalJet n f) :=
  (ContinuousMultilinearMap.apply ℝ (fun _ : Fin n => Y) F (fun _ => en)).continuous.comp
    (hf.continuous_iteratedFDeriv (by exact_mod_cast le_top))

lemma travel_continuous : Continuous (fun z : Y × ℝ => travel z.1 z.2) := by
  unfold travel projection
  fun_prop

omit [CompleteSpace F] in
lemma quotient_continuous {f : Y → F} (hf : ContDiff ℝ (⊤ : ℕ∞) f) (n : ℕ) :
    Continuous (quotient n f) := by
  have hc : Continuous (Function.uncurry (fun y (t:ℝ) => (1-t)^n • normalJet (n+1) f (travel y t))) :=
    ((continuous_const.sub continuous_snd).pow n).smul
      ((normalJet_continuous hf (n+1)).comp travel_continuous)
  have h := continuous_parametric_integral_of_continuous (μ := volume) hc (isCompact_Icc (a := (0:ℝ)) (b := 1))
  have he (y : Y) : (∫ t in (0:ℝ)..1, (1-t)^n • normalJet (n+1) f (travel y t))=
      ∫ t in Icc (0:ℝ) 1, (1-t)^n • normalJet (n+1) f (travel y t) := by
    rw [intervalIntegral.integral_of_le (by norm_num),integral_Icc_eq_integral_Ioc]
  change Continuous (fun y : Y => (n.factorial:ℝ)⁻¹ • ∫ t in (0:ℝ)..1, (1-t)^n • normalJet (n+1) f (travel y t))
  simp_rw [he]
  exact (continuous_const : Continuous (fun _ : Y => (n.factorial:ℝ)⁻¹)).smul h

lemma normal_factor {f : Y → F} (hf : ContDiff ℝ (⊤ : ℕ∞) f) (n : ℕ) (y : Y)
    (hz : ∀ k≤n, normalJet k f (projection y)=0) :
    f y=(y 2)^(n+1) • quotient n f y := by
  have h := map_add_eq_sum_add_integral_iteratedFDeriv
    (f := f) (x := projection y) (y := (y 2) • en) (n := n)
    (fun _ _ => hf.contDiffAt.of_le (by exact_mod_cast le_top))
  have hv (k : ℕ) (z : Y) :
      iteratedFDeriv ℝ k f z (fun _ => (y 2) • en)=(y 2)^k • normalJet k f z := by
    rw [ContinuousMultilinearMap.map_smul_univ]
    simp only [Finset.prod_const,Finset.card_univ,Fintype.card_fin,normalJet]
  rw [show projection y+y 2 • en=y by simp [projection]] at h
  rw [Finset.sum_eq_zero (fun k hk => by
    have hk' : k<n+1 := Finset.mem_range.mp hk
    rw [hv,hz k (by omega),smul_zero,smul_zero]),zero_add] at h
  simp_rw [hv] at h
  rw [show (fun t => (1-t)^n • ((y 2)^(n+1) • normalJet (n+1) f
    (projection y+t • (y 2 • en))))=
      (fun t => (y 2)^(n+1) • ((1-t)^n • normalJet (n+1) f (travel y t))) from by
        funext t; rw [smul_comm]; rfl] at h
  rw [intervalIntegral.integral_smul] at h
  simpa only [quotient,smul_comm (n.factorial:ℝ)⁻¹] using h

lemma quotient_zero (n : ℕ) (f : Y → F) :
    quotient n f 0=((n+1).factorial:ℝ)⁻¹ • normalJet (n+1) f 0 := by
  simp only [quotient,travel_zero]
  rw [intervalIntegral.integral_smul_const]
  have hi : (∫ t in (0:ℝ)..1, (1-t)^n)=(n+1:ℝ)⁻¹ := by
    rw [intervalIntegral.integral_comp_sub_left (fun t : ℝ => t^n) 1]
    simp [integral_pow]
  rw [hi,smul_smul]
  congr 1
  simp only [Nat.factorial_succ,Nat.cast_mul,Nat.cast_add,Nat.cast_one,mul_inv_rev]

end ElasticityBoundaryNormalTaylor

end
end

end OAI