openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Foundations /GeometricPathLemmas.lean
| import Mathlib.Data.Fin.Tuple.Basic | |
| import OAI.Computability.PerfectCompleteness.Algebra.HierarchicalMatrixTable | |
| import OAI.Computability.PerfectCompleteness.Algebra.MatrixTriangularFoldingLemmas | |
| import OAI.Computability.PerfectCompleteness.Construction.FactoredFunctionsLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.HierarchicalArrays | |
| import OAI.Computability.UniqueGames.Foundations.SamplingLemmas | |
| import OAI.Computability.UniqueGames.Foundations.ValueLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.GeometricPath | |
| open RecursiveSpaces DescendantSpaces HierarchicalArrays | |
| open UniqueGamesTheorem.Foundations.Games | |
| variable {branch : Nat → Nat} | |
| def leafPath : {n : Nat} → Slots branch n → Path branch n 0 | |
| | 0, _ => .refl 0 | |
| | _ + 1, leaf => .step leaf.1 (leafPath leaf.2) | |
| theorem leafPath_endpoint : ∀ {n : Nat} (leaf : Slots branch n), | |
| (leafPath leaf).slotEmbedding () = leaf := by | |
| intro n | |
| induction n with | |
| | zero => intro leaf; cases leaf; rfl | |
| | succ n ih => | |
| intro leaf | |
| exact Prod.ext rfl (ih leaf.2) | |
| def nodeAtLevel : {n : Nat} → Slots branch n → Fin n → Nodes branch n | |
| | 0, _, level => Fin.elim0 level | |
| | _ + 1, leaf, level => | |
| Fin.lastCases (.inl ()) (fun lower => .inr (leaf.1, nodeAtLevel leaf.2 lower)) level | |
| @[simp] theorem nodeAtLevel_last {n : Nat} (leaf : Slots branch (n + 1)) : | |
| nodeAtLevel leaf (Fin.last n) = (.inl () : Nodes branch (n + 1)) := by | |
| exact Fin.lastCases_last (n := n) (motive := fun _ => Nodes branch (n + 1)) | |
| (last := (.inl () : Nodes branch (n + 1))) | |
| (cast := fun lower : Fin n => (.inr (leaf.1, nodeAtLevel leaf.2 lower) : Nodes branch (n + 1))) | |
| @[simp] theorem nodeAtLevel_castSucc {n : Nat} (leaf : Slots branch (n + 1)) | |
| (lower : Fin n) : | |
| nodeAtLevel leaf lower.castSucc = | |
| (.inr (leaf.1, nodeAtLevel leaf.2 lower) : Nodes branch (n + 1)) := by | |
| exact Fin.lastCases_castSucc (n := n) (motive := fun _ => Nodes branch (n + 1)) | |
| (last := (.inl () : Nodes branch (n + 1))) | |
| (cast := fun j : Fin n => (.inr (leaf.1, nodeAtLevel leaf.2 j) : Nodes branch (n + 1))) lower | |
| theorem nodeAtLevel_height : ∀ {n : Nat} (leaf : Slots branch n) (level : Fin n), | |
| Nodes.height (nodeAtLevel leaf level) = level.val + 1 := by | |
| intro n | |
| induction n with | |
| | zero => intro leaf level; exact Fin.elim0 level | |
| | succ n ih => | |
| intro leaf level | |
| refine Fin.lastCases ?_ (fun lower => ?_) level | |
| · simp only [nodeAtLevel_last, Nodes.height, Fin.val_last] | |
| · simpa only [nodeAtLevel_castSucc, Nodes.height, Fin.val_castSucc] | |
| using ih leaf.2 lower | |
| theorem nodeAtLevel_injective {n : Nat} (leaf : Slots branch n) : | |
| Function.Injective (nodeAtLevel leaf) := by | |
| intro i j h | |
| apply Fin.ext | |
| have hh := congrArg Nodes.height h | |
| rw [nodeAtLevel_height, nodeAtLevel_height] at hh | |
| exact Nat.add_right_cancel hh | |
| theorem slots_nonempty : ∀ (n : Nat), (∀ k < n, 0 < branch k) → Nonempty (Slots branch n) := by | |
| intro n | |
| induction n with | |
| | zero => intro _; exact ⟨()⟩ | |
| | succ n ih => | |
| intro hbranch | |
| obtain ⟨leaf⟩ := ih (fun k hk => hbranch k (Nat.lt_trans hk (Nat.lt_succ_self n))) | |
| exact ⟨(⟨0, hbranch n (Nat.lt_succ_self n)⟩, leaf)⟩ | |
| noncomputable def law (n : Nat) (hbranch : ∀ k < n, 0 < branch k) : | |
| FiniteDistribution (Slots branch n) := by | |
| letI := slots_nonempty n hbranch | |
| exact FiniteDistribution.uniform (Slots branch n) | |
| theorem law_step (n : Nat) (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| law (n + 1) hbranch = | |
| (by | |
| letI : Nonempty (Fin (branch n)) := ⟨⟨0, hbranch n (Nat.lt_succ_self n)⟩⟩ | |
| exact (FiniteDistribution.uniform (Fin (branch n))).product | |
| (law n (fun k hk => hbranch k (Nat.lt_trans hk (Nat.lt_succ_self n))))) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro leaf | |
| change (1 : ℝ) / (Fintype.card (Fin (branch n) × Slots branch n) : ℝ) = | |
| ((1 : ℝ) / (Fintype.card (Fin (branch n)) : ℝ)) * | |
| ((1 : ℝ) / (Fintype.card (Slots branch n) : ℝ)) | |
| simp [Fintype.card_prod, Nat.cast_mul, one_div, mul_inv_rev, mul_comm] | |
| end PerfectCompleteness.GeometricPath | |
| namespace PerfectCompleteness.HierarchicalKnownRows | |
| noncomputable section | |
| open TreeSourceSpaces HierarchicalArrays | |
| variable {branch rows : Nat → Nat} {n t : Nat} {D : Type*} | |
| (slots : RecursiveSpaces.Slots branch n → Fin t → MixedSupport.Slot) | |
| (upper : Nodes branch n) | |
| (background : HierarchicalMatrixTable.Background (rows := rows) slots upper) | |
| (descendant : D → {j : Nodes branch n // j ≠ upper}) | |
| def lower (x : NodeEmbedding.NumberedDomain slots) (d : D) : | |
| Fin (rows (Nodes.height (descendant d).val)) → F2 := | |
| (HierarchicalMatrixTable.other slots upper background x).1 (descendant d) | |
| @[simp] theorem lower_apply (x : NodeEmbedding.NumberedDomain slots) | |
| (d : D) (i : Fin (rows (Nodes.height (descendant d).val))) : | |
| lower slots upper background descendant x d i = | |
| (background (descendant d) i).val | |
| (NodeEmbedding.numberedRestriction slots (descendant d).val x) := rfl | |
| def knownSpace : Submodule F2 (NodeEmbedding.NumberedDomain slots → F2) := | |
| FactoredFunctionsDependent.dependentQuadraticSpan (lower slots upper background descendant) | |
| theorem one_mem_knownSpace : | |
| (1 : NodeEmbedding.NumberedDomain slots → F2) ∈ knownSpace slots upper background descendant := | |
| FactoredFunctionsDependent.one_mem_dependentQuadraticSpan _ | |
| theorem product_mem_knownSpace (d : D) | |
| (i j : Fin (rows (Nodes.height (descendant d).val))) : | |
| (fun x => lower slots upper background descendant x d i * | |
| lower slots upper background descendant x d j) ∈ knownSpace slots upper background descendant := | |
| FactoredFunctionsDependent.product_mem_dependentQuadraticSpan | |
| (𝕜 := F2) (Ω := NodeEmbedding.NumberedDomain slots) (I := D) | |
| (J := fun d => Fin (rows (Nodes.height (descendant d).val))) | |
| (lower slots upper background descendant) d i j | |
| theorem knownSpace_le_factoringSpace : | |
| knownSpace slots upper background descendant ≤ | |
| FactoredFunctions.factoringSpace (HierarchicalMatrixTable.other slots upper background) := by | |
| intro f hf x y hxy | |
| apply FactoredFunctionsDependent.dependentQuadraticSpan_le_factoringSpace | |
| (lower slots upper background descendant) hf x y | |
| funext d i | |
| exact congrArg (fun z : HierarchicalMatrixTable.SideOutput (rows := rows) upper => | |
| z.1 (descendant d) i) hxy | |
| theorem determined : | |
| RepresentativeMatrixTable.Determined (TreeCanonical.numberedSlots slots) | |
| (NodeEmbedding.RowSpace slots upper) (HierarchicalMatrixTable.other slots upper background) | |
| ((knownSpace slots upper background descendant).comap | |
| (NodeEmbedding.RowSpace slots upper).subtype) := | |
| RepresentativeMatrixTable.determined_comap (TreeCanonical.numberedSlots slots) | |
| (NodeEmbedding.RowSpace slots upper) (HierarchicalMatrixTable.other slots upper background) | |
| (knownSpace slots upper background descendant) | |
| (knownSpace_le_factoringSpace slots upper background descendant) | |
| end | |
| end PerfectCompleteness.HierarchicalKnownRows | |
| end OAI | |