openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Decoding /ChildBlockProjection.lean
| import OAI.Computability.PerfectCompleteness.Algebra.UniformLinearImage | |
| import OAI.Computability.PerfectCompleteness.Construction.SourceQuestionOrderLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.MultiplicationFormInjectiveLemmas | |
| import OAI.Computability.UniqueGames.Games.FinishBoundsLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.ChildBlockProjection | |
| open RecursiveSpaces TreeSourceSpaces HierarchicalArrays PointwiseSpaces | |
| open UniqueGamesTheorem.Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| variable {branch : Nat → Nat} {n t : Nat} | |
| {slots projected : Slots branch n → Fin t → MixedSupport.Slot} | |
| def nodeProjection | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (node : Nodes branch n) : | |
| ∀ s k, MixedSupport.Projection (nodeSlots slots node s k) (nodeSlots projected node s k) := | |
| fun s k => p ((Nodes.path node).slotEmbedding s) k | |
| theorem restrictNode_projection | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (node : Nodes branch n) (x : Domain slots) : | |
| sourceProjection (nodeProjection p node) (restrictNode slots node x) = | |
| restrictNode projected node (sourceProjection p x) := rfl | |
| def squarePullback | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| squareSpace (H projected) →ₗ[F2] squareSpace (H slots) where | |
| toFun f := ⟨PointwiseSpaces.pullback F2 (sourceProjection p) f.val, | |
| TreeSourceSpaces.squareSpace_pullback_le p (Submodule.mem_map_of_mem f.property)⟩ | |
| map_add' f g := by apply Subtype.ext; rfl | |
| map_smul' c f := by apply Subtype.ext; rfl | |
| @[simp] theorem squarePullback_apply | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (f : squareSpace (H projected)) (x : Domain slots) : | |
| (squarePullback p f).val x = f.val (sourceProjection p x) := rfl | |
| theorem squarePullback_injective | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| Function.Injective (squarePullback p) := by | |
| intro f g h | |
| apply Subtype.ext | |
| exact PointwiseSpaces.pullback_injective (sourceProjection p) (sourceProjection_surjective p) | |
| (congrArg (fun z : squareSpace (H slots) => z.val) h) | |
| def arraysPullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| Arrays projected rows →ₗ[F2] Arrays slots rows where | |
| toFun arrays node row := HPullback (nodeProjection p node) (arrays node row) | |
| map_add' a b := by | |
| funext node row | |
| exact map_add (HPullback (nodeProjection p node)) (a node row) (b node row) | |
| map_smul' c a := by | |
| funext node row | |
| exact map_smul (HPullback (nodeProjection p node)) c (a node row) | |
| @[simp] theorem arraysPullback_apply (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (arrays : Arrays projected rows) (node : Nodes branch n) | |
| (row : Fin (rows (Nodes.height node))) : | |
| arraysPullback rows p arrays node row = | |
| HPullback (nodeProjection p node) (arrays node row) := rfl | |
| theorem arraysPullback_injective (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| Function.Injective (arraysPullback rows p) := by | |
| intro a b h | |
| funext node row | |
| exact HPullback_injective (nodeProjection p node) | |
| (congrArg (fun z : Arrays slots rows => z node row) h) | |
| theorem fullJoint_pullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (arrays : Arrays projected rows) (x : Domain slots) : | |
| fullJoint (arraysPullback rows p arrays) x = fullJoint arrays (sourceProjection p x) := rfl | |
| def rawPullback (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| ChildBlockCardinality.Raw calls rows projected →ₗ[F2] | |
| ChildBlockCardinality.Raw calls rows slots where | |
| toFun block := (fun call => squarePullback p (block.1 call), arraysPullback rows p block.2) | |
| map_add' a b := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_add (squarePullback p) (a.1 call) (b.1 call) | |
| · exact map_add (arraysPullback rows p) a.2 b.2 | |
| map_smul' c a := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_smul (squarePullback p) c (a.1 call) | |
| · exact map_smul (arraysPullback rows p) c a.2 | |
| theorem rawPullback_injective (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| Function.Injective (rawPullback calls rows p) := by | |
| intro a b h | |
| apply Prod.ext | |
| · funext call | |
| exact squarePullback_injective p | |
| (congrArg (fun z : ChildBlockCardinality.Raw calls rows slots => z.1 call) h) | |
| · exact arraysPullback_injective rows p | |
| (congrArg (fun z : ChildBlockCardinality.Raw calls rows slots => z.2) h) | |
| def evaluate {calls : Nat} {rows : Nat → Nat} | |
| (block : ChildBlockCardinality.Raw calls rows slots) (x : Domain slots) : | |
| (Fin calls → F2) × Output branch n rows := | |
| (fun call => (block.1 call).val x, fullJoint block.2 x) | |
| theorem evaluate_pullback (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (block : ChildBlockCardinality.Raw calls rows projected) (x : Domain slots) : | |
| evaluate (rawPullback calls rows p block) x = evaluate block (sourceProjection p x) := rfl | |
| def liftedLaw (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| FiniteDistribution (ChildBlockCardinality.Raw calls rows slots) := | |
| (FiniteDistribution.uniform (ChildBlockCardinality.Raw calls rows projected)).pushforward | |
| (rawPullback calls rows p) | |
| instance liftedRangeFintype (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| Fintype (LinearMap.range (rawPullback calls rows p)) := Fintype.ofFinite _ | |
| theorem liftedLaw_eq_uniform_range (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| liftedLaw calls rows p = | |
| (FiniteDistribution.uniform (LinearMap.range (rawPullback calls rows p))).pushforward | |
| (LinearMap.range (rawPullback calls rows p)).subtype := by | |
| rw [← UniformLinearImage.uniform_pushforward_linearMap | |
| (rawPullback calls rows p).rangeRestrict | |
| (rawPullback calls rows p).surjective_rangeRestrict] | |
| rw [FiniteDistribution.pushforward_comp] | |
| rfl | |
| theorem liftedLaw_evaluate (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (x : Domain slots) : | |
| (liftedLaw calls rows p).pushforward (fun block => evaluate block x) = | |
| (FiniteDistribution.uniform (ChildBlockCardinality.Raw calls rows projected)).pushforward | |
| (fun block => evaluate block (sourceProjection p x)) := by | |
| rw [liftedLaw, FiniteDistribution.pushforward_comp] | |
| rfl | |
| def mixtureLaw {Z : Type*} [Fintype Z] (calls : Nat) (rows : Nat → Nat) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (projected : Z → Slots branch n → Fin t → MixedSupport.Slot) | |
| (p : ∀ z s k, MixedSupport.Projection (slots s k) (projected z s k)) | |
| (choiceLaw : FiniteDistribution Z) : | |
| FiniteDistribution (ChildBlockCardinality.Raw calls rows slots) := | |
| choiceLaw.mixture (fun z => liftedLaw calls rows (p z)) | |
| theorem mixtureLaw_weight {Z : Type*} [Fintype Z] (calls : Nat) (rows : Nat → Nat) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (projected : Z → Slots branch n → Fin t → MixedSupport.Slot) | |
| (p : ∀ z s k, MixedSupport.Projection (slots s k) (projected z s k)) | |
| (choiceLaw : FiniteDistribution Z) (block : ChildBlockCardinality.Raw calls rows slots) : | |
| (mixtureLaw calls rows slots projected p choiceLaw).weight block = | |
| ∑ z, choiceLaw.weight z * (liftedLaw calls rows (p z)).weight block := rfl | |
| variable {I : Type*} [Fintype I] [DecidableEq I] [Nonempty I] | |
| {Z : I → Type*} [∀ i, Fintype (Z i)] | |
| def replacementLaws (calls : Nat) (rows : Nat → Nat) | |
| (slots : I → Slots branch n → Fin t → MixedSupport.Slot) | |
| (projected : (i : I) → Z i → Slots branch n → Fin t → MixedSupport.Slot) | |
| (p : ∀ i z s k, MixedSupport.Projection (slots i s k) (projected i z s k)) | |
| (choiceLaw : (i : I) → FiniteDistribution (Z i)) : | |
| (i : I) → FiniteDistribution (ChildBlockCardinality.Raw calls rows (slots i)) := | |
| fun i => mixtureLaw calls rows (slots i) (projected i) (p i) (choiceLaw i) | |
| theorem observed_variation {Γ : Type*} [Fintype Γ] | |
| (calls : Nat) (rows : Nat → Nat) | |
| (slots : I → Slots branch n → Fin t → MixedSupport.Slot) | |
| (projected : (i : I) → Z i → Slots branch n → Fin t → MixedSupport.Slot) | |
| (p : ∀ i z s k, MixedSupport.Projection (slots i s k) (projected i z s k)) | |
| (choiceLaw : (i : I) → FiniteDistribution (Z i)) | |
| (β : ℝ) (hβ : 0 ≤ β) (hβ' : β ≤ 1) | |
| (observe : ((i : I) → ChildBlockCardinality.Raw calls rows (slots i)) → Γ) : | |
| ((SparseReplacement.law | |
| (fun i => FiniteDistribution.uniform (ChildBlockCardinality.Raw calls rows (slots i))) | |
| (replacementLaws calls rows slots projected p choiceLaw) β hβ hβ').pushforward | |
| observe).totalVariation | |
| ((FiniteProduct.law (fun i => | |
| FiniteDistribution.uniform (ChildBlockCardinality.Raw calls rows (slots i)))).pushforward | |
| observe) ≤ | |
| Real.sqrt ((1 + β ^ 2 * ((ChildBlockCardinality.bound branch n t calls rows : ℝ) - 1)) ^ | |
| Fintype.card I - 1) / 2 := by | |
| apply SparseReplacement.observed_uniform_variation | |
| intro i | |
| exact_mod_cast ChildBlockCardinality.fintype_card_le calls rows (slots i) | |
| theorem adaptive_selection | |
| (calls : Nat) (rows : Nat → Nat) | |
| (slots : I → Slots branch n → Fin t → MixedSupport.Slot) | |
| (projected : (i : I) → Z i → Slots branch n → Fin t → MixedSupport.Slot) | |
| (p : ∀ i z s k, MixedSupport.Projection (slots i s k) (projected i z s k)) | |
| (choiceLaw : (i : I) → FiniteDistribution (Z i)) | |
| (β : ℝ) (hβ : 0 ≤ β) (hβ' : β < 1) | |
| (select : ((i : I) → ChildBlockCardinality.Raw calls rows (slots i)) → Finset I) | |
| (budget : Nat) (size : ∀ x, (select x).card ≤ budget) : | |
| (SparseReplacement.markedLaw | |
| (fun i => FiniteDistribution.uniform (ChildBlockCardinality.Raw calls rows (slots i))) | |
| (replacementLaws calls rows slots projected p choiceLaw) β hβ hβ'.le).probability | |
| (fun z => decide (∃ i ∈ select z.2, z.1 i = true)) ≤ | |
| budget * (β * (ChildBlockCardinality.bound branch n t calls rows : ℝ) / (1 - β)) := by | |
| apply SparseReplacement.adaptive_uniform_selection _ β hβ hβ' | |
| (ChildBlockCardinality.bound branch n t calls rows : ℝ) ?_ select budget size | |
| intro i | |
| exact_mod_cast ChildBlockCardinality.fintype_card_le calls rows (slots i) | |
| end | |
| end PerfectCompleteness.ChildBlockProjection | |
| end OAI | |