| import Mathlib |
| import OAI.Computability.MinUncut.Games.TripleKernel |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Composition |
| open BinaryFourier OuterSmoothness |
| attribute [local instance] Classical.propDecidable BinaryFourier.dualFintype |
|
|
| abbrev TripleIndex (J : Type*) := Option (Option (Option J)) |
|
|
| def tripleTupleEquiv {J A : Type*} : |
| (TripleIndex J → A) ≃ ((J → A) × (A × A × A)) where |
| toFun L := (fun j => L (some (some (some j))), L none,L (some none),L (some (some none))) |
| invFun z |
| | none => z.2.1 |
| | some none => z.2.2.1 |
| | some (some none) => z.2.2.2 |
| | some (some (some j)) => z.1 j |
| left_inv L := by funext j; cases j with |
| | none => rfl |
| | some j => cases j with |
| | none => rfl |
| | some j => cases j <;> rfl |
| right_inv _ := rfl |
|
|
| lemma TripleIndex.card (J : Type*) [Fintype J] : |
| Fintype.card (TripleIndex J)=Fintype.card J+3 := by simp [TripleIndex] |
|
|
| variable {J V W : Type*} [Fintype J] [DecidableEq J] |
| [AddCommGroup V] [Module F₂ V] [Fintype V] |
| [AddCommGroup W] [Module F₂ W] [Fintype W] |
|
|
| def adaptiveKernel (f : (J → V) → V → ℝ) (u : ℝ) (L : TripleIndex J → V) : ℝ := |
| tripleKernel (remainder (f (tripleTupleEquiv L).1) u) (tripleTupleEquiv L).2 |
|
|
| omit [Fintype J] [DecidableEq J] in |
| lemma adaptiveKernel_abs (f : (J → V) → V → ℝ) {M u : ℝ} |
| (hM : 0≤M) (hu : 0<u) (hf : ∀ D z, |f D z|≤M) (L : TripleIndex J → V) : |
| |adaptiveKernel f u L|≤(M+M^2/u)^4 := |
| tripleKernel_abs _ (by positivity) (remainder_abs_bound _ hM hu (hf _)) _ |
|
|
| lemma adaptiveKernel_uniform (f : (J → V) → V → ℝ) {M u : ℝ} |
| (hM : 0≤M) (hu : 0<u) (hf : ∀ D z, |f D z|≤M) : |
| (𝔼 L : TripleIndex J → V, adaptiveKernel f u L)≤u^2*M^2 := by |
| have he : (𝔼 L : TripleIndex J → V, adaptiveKernel f u L) = |
| 𝔼 z : (J → V) × (V × V × V), tripleKernel (remainder (f z.1) u) z.2 := |
| Fintype.expect_equiv tripleTupleEquiv _ _ (fun _ => rfl) |
| rw [he,expect_pair] |
| simp_rw [tripleKernel_mean] |
| exact (Finset.expect_le_expect (fun D _ => remainder_fourth_bound (f D) hM hu (hf D))).trans_eq |
| (Fintype.expect_const _) |
|
|
| omit [Fintype J] [DecidableEq J] [Fintype W] in |
| lemma adaptiveKernel_pullback (π : W →ₗ[F₂] V) (f : (J → V) → V → ℝ) (u : ℝ) |
| (L : TripleIndex J → W) : |
| adaptiveKernel f u (fun j => π (L j)) = |
| tripleKernel (fun z => remainder (f (fun j => π ((tripleTupleEquiv L).1 j))) u (π z)) |
| (tripleTupleEquiv L).2 := by |
| simp only [adaptiveKernel,tripleKernel,tripleTupleEquiv,Equiv.coe_fn_mk,map_add] |
|
|
| lemma adaptiveKernel_pullback_mean (π : W →ₗ[F₂] V) (f : (J → V) → V → ℝ) (u : ℝ) : |
| (𝔼 L : TripleIndex J → W, adaptiveKernel f u (fun j => π (L j))) = |
| 𝔼 D : J → W, ∑ β : Module.Dual F₂ W, |
| coefficient (fun z => remainder (f (fun j => π (D j))) u (π z)) β ^4 := by |
| simp_rw [adaptiveKernel_pullback] |
| have he := Fintype.expect_equiv (tripleTupleEquiv (J := J) (A := W)) |
| (fun L => tripleKernel (fun z => remainder (f (fun j => π ((tripleTupleEquiv L).1 j))) u (π z)) |
| (tripleTupleEquiv L).2) |
| (fun z => tripleKernel (fun w => remainder (f (fun j => π (z.1 j))) u (π w)) z.2) |
| (fun _ => rfl) |
| rw [he,expect_pair] |
| simp_rw [tripleKernel_mean] |
|
|
| end MinUncut.Composition |
|
|
| end |
| end |
|
|
| end OAI |
|
|
