openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Decoding /ChildAssemblyProjection.lean
| import OAI.Computability.PerfectCompleteness.Construction.CutChildGrouping | |
| import OAI.Computability.PerfectCompleteness.Decoding.ChildBlockProjection | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.ChildAssemblyProjection | |
| 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 + 1) → Fin t → MixedSupport.Slot} | |
| def childProjection | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (i : Fin (branch n)) : | |
| ∀ s k, MixedSupport.Projection (childSlots slots i s k) (childSlots projected i s k) := | |
| fun s k => p (i, s) k | |
| theorem restrictChild_projection | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (i : Fin (branch n)) (x : Domain slots) : | |
| sourceProjection (childProjection p i) (restrictChild slots i x) = | |
| restrictChild projected i (sourceProjection p x) := rfl | |
| theorem recursiveSum_pullback | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (f : (i : Fin (branch n)) → squareSpace (H (childSlots projected i))) : | |
| UniformChildSum.recursiveSum (LeafDomain slots) | |
| (fun i => ChildBlockProjection.squarePullback (childProjection p i) (f i)) = | |
| HPullback p (UniformChildSum.recursiveSum (LeafDomain projected) f) := by | |
| apply Subtype.ext | |
| change (∑ i, PointwiseSpaces.pullback F2 (childRestriction (LeafDomain slots) i) | |
| (ChildBlockProjection.squarePullback (childProjection p i) (f i)).val) = | |
| PointwiseSpaces.pullback F2 (sourceProjection p) | |
| (∑ i, PointwiseSpaces.pullback F2 (childRestriction (LeafDomain projected) i) (f i).val) | |
| rw [map_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rfl | |
| variable {C : Type*} [Fintype C] | |
| def childPullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (i : Fin (branch n)) : | |
| CutChildGrouping.Child (C := C) projected rows i →ₗ[F2] | |
| CutChildGrouping.Child (C := C) slots rows i where | |
| toFun block := | |
| (fun call => ChildBlockProjection.squarePullback (childProjection p i) (block.1 call), | |
| ChildBlockProjection.arraysPullback rows (childProjection p i) block.2) | |
| map_add' a b := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_add (ChildBlockProjection.squarePullback (childProjection p i)) | |
| (a.1 call) (b.1 call) | |
| · exact map_add (ChildBlockProjection.arraysPullback rows (childProjection p i)) a.2 b.2 | |
| map_smul' c a := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_smul (ChildBlockProjection.squarePullback (childProjection p i)) c (a.1 call) | |
| · exact map_smul (ChildBlockProjection.arraysPullback rows (childProjection p i)) c a.2 | |
| theorem childPullback_fin (calls : Nat) (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (i : Fin (branch n)) : | |
| childPullback (C := Fin calls) rows p i = | |
| ChildBlockProjection.rawPullback calls rows (childProjection p i) := rfl | |
| def rawPullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| CutChildGrouping.Raw (C := C) projected rows →ₗ[F2] | |
| CutChildGrouping.Raw (C := C) slots rows where | |
| toFun block i := childPullback rows p i (block i) | |
| map_add' a b := by | |
| funext i | |
| exact map_add (childPullback rows p i) (a i) (b i) | |
| map_smul' c a := by | |
| funext i | |
| exact map_smul (childPullback rows p i) c (a i) | |
| def assembledPullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| CutChildGrouping.Assembled (C := C) projected rows →ₗ[F2] | |
| CutChildGrouping.Assembled (C := C) slots rows where | |
| toFun z := (fun call => HPullback p (z.1 call), | |
| fun i => ChildBlockProjection.arraysPullback rows (childProjection p i) (z.2 i)) | |
| map_add' a b := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_add (HPullback p) (a.1 call) (b.1 call) | |
| · funext i | |
| exact map_add (ChildBlockProjection.arraysPullback rows (childProjection p i)) (a.2 i) (b.2 i) | |
| map_smul' c a := by | |
| apply Prod.ext | |
| · funext call | |
| exact map_smul (HPullback p) c (a.1 call) | |
| · funext i | |
| exact map_smul (ChildBlockProjection.arraysPullback rows (childProjection p i)) c (a.2 i) | |
| omit [Fintype C] in | |
| theorem assemble_pullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (block : CutChildGrouping.Raw (C := C) projected rows) : | |
| CutChildGrouping.assemble slots rows (rawPullback rows p block) = | |
| assembledPullback rows p (CutChildGrouping.assemble projected rows block) := by | |
| apply Prod.ext | |
| · funext call | |
| exact recursiveSum_pullback p (fun i => (block i).1 call) | |
| · rfl | |
| omit [Fintype C] in | |
| theorem assemble_comp_pullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| (CutChildGrouping.assemble (C := C) slots rows).comp (rawPullback rows p) = | |
| (assembledPullback rows p).comp (CutChildGrouping.assemble projected rows) := by | |
| apply LinearMap.ext | |
| intro block | |
| exact assemble_pullback rows p block | |
| def evaluate {rows : Nat → Nat} | |
| (z : CutChildGrouping.Assembled (C := C) slots rows) (x : Domain slots) : | |
| (C → F2) × (Fin (branch n) → Output branch n rows) := | |
| (fun call => (z.1 call).val x, | |
| fun i => fullJoint (z.2 i) (restrictChild slots i x)) | |
| omit [Fintype C] in | |
| theorem evaluate_pullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (z : CutChildGrouping.Assembled (C := C) projected rows) (x : Domain slots) : | |
| evaluate (assembledPullback rows p z) x = evaluate z (sourceProjection p x) := rfl | |
| omit [Fintype C] in | |
| theorem evaluate_assemble_pullback (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (block : CutChildGrouping.Raw (C := C) projected rows) (x : Domain slots) : | |
| evaluate (CutChildGrouping.assemble slots rows (rawPullback rows p block)) x = | |
| evaluate (CutChildGrouping.assemble projected rows block) (sourceProjection p x) := by | |
| rw [assemble_pullback] | |
| exact evaluate_pullback rows p _ x | |
| theorem pushforward_assemble (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) | |
| (μ : FiniteDistribution (CutChildGrouping.Raw (C := C) projected rows)) : | |
| (μ.pushforward (rawPullback rows p)).pushforward (CutChildGrouping.assemble slots rows) = | |
| (μ.pushforward (CutChildGrouping.assemble projected rows)).pushforward | |
| (assembledPullback rows p) := by | |
| rw [FiniteDistribution.pushforward_comp, FiniteDistribution.pushforward_comp] | |
| congr 1 | |
| funext block | |
| exact assemble_pullback rows p block | |
| theorem uniform_projected_assembly (rows : Nat → Nat) | |
| (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k)) : | |
| ((CutChildGrouping.rawLaw (C := C) projected rows).pushforward | |
| (rawPullback rows p)).pushforward (CutChildGrouping.assemble slots rows) = | |
| (FiniteDistribution.uniform (CutChildGrouping.Assembled (C := C) projected rows)).pushforward | |
| (assembledPullback rows p) := by | |
| rw [pushforward_assemble, CutChildGrouping.assemble_law] | |
| end | |
| end PerfectCompleteness.ChildAssemblyProjection | |
| end | |
| end OAI | |