openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Entropy /ComplexConditionalPrefixWords.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Separation.ComplexStageHierarchyResources | |
| namespace OAI | |
| /-! Finite entropy, rate estimates and ordered asymptotic limits. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation.ConditionalPrefixWords | |
| open LabelHierarchyCounts StageHierarchyResources | |
| open scoped BigOperators | |
| universe u v w | |
| local instance (priority := low) {B : Type*} : DecidableEq B := Classical.decEq B | |
| instance labelRecordZero_subsingleton {Label : ℕ → Type v} : | |
| Subsingleton (LabelRecord Label 0) := by | |
| change Subsingleton PUnit | |
| infer_instance | |
| private theorem population_fst {B C Position : Type*} | |
| [Fintype B] [Fintype C] [Fintype Position] | |
| (word : Position → B × C) (b : B) : | |
| wordPopulation (fun i => (word i).1) b = ∑ c, wordPopulation word (b, c) := by | |
| calc | |
| wordPopulation (fun i => (word i).1) b = | |
| ∑ c, wordPopulation (fun i : {i // (word i).1 = b} => (word i.val).2) c := | |
| (wordPopulation_sum _).symm | |
| _ = ∑ c, Fintype.card {i // (word i).1 = b ∧ (word i).2 = c} := by | |
| apply Finset.sum_congr rfl | |
| intro c hc | |
| exact wordPopulation_fiber (fun i => (word i).1) (fun i => (word i).2) b c | |
| _ = ∑ c, wordPopulation word (b, c) := by | |
| apply Finset.sum_congr rfl | |
| intro c hc | |
| simp only [wordPopulation, Prod.ext_iff] | |
| variable {A : Type u} [Fintype A] {Label : ℕ → Type v} | |
| [∀ n, Fintype (Label n)] | |
| abbrev ExactPrefix (counts : A → ℕ) (labels : ∀ n, A → Label n) (n t : ℕ) | |
| (Position : Type w) [Fintype Position] := | |
| PopulationWords Position (sourcePrefixCounts (fun a => t * counts a) labels n) | |
| variable {Position : Type w} [Fintype Position] | |
| variable {counts : A → ℕ} {labels : ∀ n, A → Label n} {n t : ℕ} | |
| abbrev conditionalPool (old : ExactPrefix counts labels n t Position) := | |
| ConditionalWords old.val | |
| (fun r s => sourcePrefixCounts (fun a => t * counts a) labels (n + 1) (r, s)) | |
| def conditionalFinset (old : ExactPrefix counts labels n t Position) : | |
| Finset (Position → Label n) := | |
| Finset.univ.filter (fun fine => ∀ r s, | |
| Fintype.card {i // old.val i = r ∧ fine i = s} = | |
| sourcePrefixCounts (fun a => t * counts a) labels (n + 1) (r, s)) | |
| @[simp] theorem mem_conditionalFinset (old : ExactPrefix counts labels n t Position) | |
| (fine : Position → Label n) : | |
| fine ∈ conditionalFinset old ↔ ∀ r s, | |
| Fintype.card {i // old.val i = r ∧ fine i = s} = | |
| sourcePrefixCounts (fun a => t * counts a) labels (n + 1) (r, s) := by | |
| simp only [conditionalFinset, Finset.mem_filter, Finset.mem_univ, true_and] | |
| def conditionalFinsetEquiv (old : ExactPrefix counts labels n t Position) : | |
| ↥(conditionalFinset old) ≃ conditionalPool old := | |
| Equiv.subtypeEquivRight (fun fine => mem_conditionalFinset old fine) | |
| theorem conditionalPool_card (old : ExactPrefix counts labels n t Position) : | |
| Fintype.card (conditionalPool old) = stageRefinementCount counts labels n t := | |
| stageConditionalWords_card counts labels n t old.val old.property | |
| theorem conditionalFinset_card (old : ExactPrefix counts labels n t Position) : | |
| (conditionalFinset old).card = stageRefinementCount counts labels n t := | |
| stageConditionalPool_card counts labels n t old.val old.property | |
| def conditionalFinsetEquivFin (old : ExactPrefix counts labels n t Position) : | |
| ↥(conditionalFinset old) ≃ Fin (stageRefinementCount counts labels n t) := | |
| LabelHierarchySeparation.poolEnumeration | |
| (fun previous : ExactPrefix counts labels n t Position => conditionalFinset previous) | |
| (stageRefinementCount counts labels n t) (fun previous => conditionalFinset_card previous) old | |
| def conditionalPoolEquivFin (old : ExactPrefix counts labels n t Position) : | |
| conditionalPool old ≃ Fin (stageRefinementCount counts labels n t) := | |
| (conditionalFinsetEquiv old).symm.trans (conditionalFinsetEquivFin old) | |
| @[simp] theorem decodedFine_eq_geometryDecode (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) : | |
| ((conditionalPoolEquivFin old).symm code).val = | |
| ((LabelHierarchySeparation.poolEnumeration | |
| (fun previous : ExactPrefix counts labels n t Position => conditionalFinset previous) | |
| (stageRefinementCount counts labels n t) | |
| (fun previous => conditionalFinset_card previous) old).symm code).val := rfl | |
| def appendPrefix (old : ExactPrefix counts labels n t Position) (fine : conditionalPool old) : | |
| ExactPrefix counts labels (n + 1) t Position := by | |
| classical | |
| refine ⟨fun i => (old.val i, fine.val i), ?_⟩ | |
| rintro ⟨r, s⟩ | |
| refine Eq.trans ?_ (fine.property r s) | |
| unfold wordPopulation | |
| apply Fintype.card_congr | |
| exact Equiv.subtypeEquivRight (fun i => Prod.ext_iff) | |
| omit [∀ n, Fintype (Label n)] in | |
| @[simp] theorem appendPrefix_val (old : ExactPrefix counts labels n t Position) | |
| (fine : conditionalPool old) (i : Position) : | |
| (appendPrefix old fine).val i = (old.val i, fine.val i) := rfl | |
| def oldPrefix (next : ExactPrefix counts labels (n + 1) t Position) : | |
| ExactPrefix counts labels n t Position := by | |
| classical | |
| refine ⟨fun i => (next.val i).1, ?_⟩ | |
| intro r | |
| calc | |
| wordPopulation (fun i => (next.val i).1) r = | |
| ∑ s : Label n, wordPopulation next.val (r, s) := by | |
| have h := population_fst next.val r | |
| refine h.trans ?_ | |
| apply Finset.sum_congr rfl | |
| intro s hs | |
| unfold wordPopulation | |
| exact congrArg (.card _) (Subsingleton.elim _ _) | |
| _ = ∑ s : Label n, | |
| sourcePrefixCounts (fun a => t * counts a) labels (n + 1) (r, s) := by | |
| apply Finset.sum_congr rfl | |
| intro s hs | |
| exact next.property (r, s) | |
| _ = sourcePrefixCounts (fun a => t * counts a) labels n r := | |
| (sourcePrefixCounts_compatible (fun a => t * counts a) labels n r).symm | |
| @[simp] theorem oldPrefix_val (next : ExactPrefix counts labels (n + 1) t Position) | |
| (i : Position) : (oldPrefix next).val i = (next.val i).1 := rfl | |
| def finePrefix (next : ExactPrefix counts labels (n + 1) t Position) : | |
| conditionalPool (oldPrefix next) := by | |
| classical | |
| refine ⟨fun i => (next.val i).2, ?_⟩ | |
| intro r s | |
| refine Eq.trans ?_ (next.property (r, s)) | |
| unfold wordPopulation | |
| apply Fintype.card_congr | |
| exact Equiv.subtypeEquivRight (fun i => by | |
| change ((next.val i).1 = r ∧ (next.val i).2 = s) ↔ next.val i = (r, s) | |
| constructor | |
| · rintro ⟨hfst, hsnd⟩ | |
| exact Prod.ext hfst hsnd | |
| · intro h | |
| exact ⟨congrArg Prod.fst h, congrArg Prod.snd h⟩) | |
| @[simp] theorem finePrefix_val (next : ExactPrefix counts labels (n + 1) t Position) | |
| (i : Position) : (finePrefix next).val i = (next.val i).2 := rfl | |
| @[simp] theorem oldPrefix_appendPrefix (old : ExactPrefix counts labels n t Position) | |
| (fine : conditionalPool old) : oldPrefix (appendPrefix old fine) = old := by | |
| apply Subtype.ext | |
| rfl | |
| def nextPrefixSigmaEquiv (counts : A → ℕ) (labels : ∀ n, A → Label n) (n t : ℕ) | |
| (Position : Type w) [Fintype Position] : | |
| ExactPrefix counts labels (n + 1) t Position ≃ | |
| Σ old : ExactPrefix counts labels n t Position, conditionalPool old where | |
| toFun next := ⟨oldPrefix next, finePrefix next⟩ | |
| invFun p := appendPrefix p.1 p.2 | |
| left_inv next := by | |
| apply Subtype.ext | |
| funext i | |
| rfl | |
| right_inv := by | |
| rintro ⟨⟨old, ho⟩, ⟨fine, hf⟩⟩ | |
| rfl | |
| def nextPrefixEquiv (counts : A → ℕ) (labels : ∀ n, A → Label n) (n t : ℕ) | |
| (Position : Type w) [Fintype Position] : | |
| ExactPrefix counts labels (n + 1) t Position ≃ | |
| ExactPrefix counts labels n t Position × Fin (stageRefinementCount counts labels n t) := | |
| (nextPrefixSigmaEquiv counts labels n t Position).trans | |
| (Equiv.sigmaEquivProdOfEquiv (fun old => conditionalPoolEquivFin old)) | |
| def appendCode (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) : | |
| ExactPrefix counts labels (n + 1) t Position := | |
| appendPrefix old ((conditionalPoolEquivFin old).symm code) | |
| @[simp] theorem appendCode_val (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) (i : Position) : | |
| (appendCode old code).val i = | |
| (old.val i, ((conditionalPoolEquivFin old).symm code).val i) := rfl | |
| @[simp] theorem nextPrefixEquiv_symm_apply | |
| (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) : | |
| (nextPrefixEquiv counts labels n t Position).symm (old, code) = appendCode old code := rfl | |
| @[simp] theorem nextPrefixEquiv_appendCode | |
| (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) : | |
| nextPrefixEquiv counts labels n t Position (appendCode old code) = (old, code) := | |
| (nextPrefixEquiv counts labels n t Position).apply_symm_apply (old, code) | |
| theorem appendCode_injective : Function.Injective | |
| (fun p : ExactPrefix counts labels n t Position × Fin (stageRefinementCount counts labels n t) => | |
| appendCode p.1 p.2) := | |
| (nextPrefixEquiv counts labels n t Position).symm.injective | |
| theorem appendCode_surjective : Function.Surjective | |
| (fun p : ExactPrefix counts labels n t Position × Fin (stageRefinementCount counts labels n t) => | |
| appendCode p.1 p.2) := | |
| (nextPrefixEquiv counts labels n t Position).symm.surjective | |
| theorem decodedFine_mem_conditionalFinset (old : ExactPrefix counts labels n t Position) | |
| (code : Fin (stageRefinementCount counts labels n t)) : | |
| ((conditionalPoolEquivFin old).symm code).val ∈ conditionalFinset old := | |
| (mem_conditionalFinset old _).2 ((conditionalPoolEquivFin old).symm code).property | |
| section Root | |
| omit [∀ n, Fintype (Label n)] | |
| private theorem rootPopulation (counts : A → ℕ) (labels : ∀ n, A → Label n) (t : ℕ) | |
| (r : LabelRecord Label 0) : | |
| sourcePrefixCounts (fun a => t * counts a) labels 0 r = ∑ a, t * counts a := by | |
| cases r | |
| unfold sourcePrefixCounts pushforwardCounts | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| exact ite_eq_left (Subsingleton.elim _ _) | |
| def rootPrefixWord (counts : A → ℕ) (labels : ∀ n, A → Label n) (t : ℕ) | |
| (Position : Type w) [Fintype Position] | |
| (hN : Fintype.card Position = ∑ a, t * counts a) : | |
| ExactPrefix counts labels 0 t Position := by | |
| classical | |
| refine ⟨fun _ => PUnit.unit, ?_⟩ | |
| intro r | |
| cases r | |
| calc | |
| _ = Fintype.card Position := by | |
| unfold wordPopulation | |
| exact Fintype.card_congr (Equiv.subtypeUnivEquiv (fun _ => rfl)) | |
| _ = ∑ a, t * counts a := hN | |
| _ = sourcePrefixCounts (fun a => t * counts a) labels 0 PUnit.unit := | |
| (rootPopulation counts labels t PUnit.unit).symm | |
| @[simp] theorem rootPrefixWord_val (counts : A → ℕ) (labels : ∀ n, A → Label n) (t : ℕ) | |
| (hN : Fintype.card Position = ∑ a, t * counts a) (i : Position) : | |
| (rootPrefixWord counts labels t Position hN).val i = PUnit.unit := rfl | |
| def rootPrefixEquiv (counts : A → ℕ) (labels : ∀ n, A → Label n) (t : ℕ) | |
| (Position : Type w) [Fintype Position] | |
| (hN : Fintype.card Position = ∑ a, t * counts a) : | |
| ExactPrefix counts labels 0 t Position ≃ PUnit where | |
| toFun _ := PUnit.unit | |
| invFun _ := rootPrefixWord counts labels t Position hN | |
| left_inv word := by | |
| apply Subtype.ext | |
| funext i | |
| exact Subsingleton.elim _ _ | |
| right_inv point := by cases point; rfl | |
| end Root | |
| section Terminal | |
| omit [∀ n, Fintype (Label n)] | |
| variable {depth : ℕ} | |
| theorem prefixSymbol_in_source_range (word : ExactPrefix counts labels depth t Position) | |
| (i : Position) : ∃ a : A, labelRecordOf labels depth a = word.val i := by | |
| by_contra hnone | |
| have hnot : ∀ a : A, labelRecordOf labels depth a ≠ word.val i := not_exists.mp hnone | |
| have hzero : sourcePrefixCounts (fun a => t * counts a) labels depth (word.val i) = 0 := by | |
| simp [sourcePrefixCounts, pushforwardCounts, hnot] | |
| have hpos : 0 < wordPopulation word.val (word.val i) := | |
| Fintype.card_pos_iff.mpr ⟨⟨i, rfl⟩⟩ | |
| rw [word.property (word.val i)] at hpos | |
| exact (Nat.ne_of_gt hpos) hzero | |
| def sourceSymbol (word : ExactPrefix counts labels depth t Position) (i : Position) : A := | |
| Classical.choose (prefixSymbol_in_source_range word i) | |
| @[simp] theorem sourceSymbol_record (word : ExactPrefix counts labels depth t Position) | |
| (i : Position) : labelRecordOf labels depth (sourceSymbol word i) = word.val i := | |
| Classical.choose_spec (prefixSymbol_in_source_range word i) | |
| theorem sourceSymbol_eq_iff | |
| (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : ExactPrefix counts labels depth t Position) (i : Position) (a : A) : | |
| sourceSymbol word i = a ↔ word.val i = labelRecordOf labels depth a := by | |
| constructor | |
| · intro h | |
| rw [← sourceSymbol_record word i, h] | |
| · intro h | |
| exact hinjective ((sourceSymbol_record word i).trans h) | |
| theorem sourceSymbol_grade {Grade : Type*} (grade : A → Grade) | |
| (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : ExactPrefix counts labels depth t Position) (i : Position) (a : A) | |
| (hrecord : labelRecordOf labels depth a = word.val i) : | |
| grade (sourceSymbol word i) = grade a := | |
| congrArg grade ((sourceSymbol_eq_iff hinjective word i a).2 hrecord.symm) | |
| def decodeSourceWord (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : ExactPrefix counts labels depth t Position) : | |
| PopulationWords Position (fun a => t * counts a) := by | |
| refine ⟨fun i => sourceSymbol word i, ?_⟩ | |
| intro a | |
| calc | |
| wordPopulation (fun i => sourceSymbol word i) a = | |
| wordPopulation word.val (labelRecordOf labels depth a) := | |
| Fintype.card_congr (Equiv.subtypeEquivRight | |
| (fun i => sourceSymbol_eq_iff hinjective word i a)) | |
| _ = sourcePrefixCounts (fun a => t * counts a) labels depth (labelRecordOf labels depth a) := | |
| word.property _ | |
| _ = t * counts a := pushforwardCounts_apply (fun a => t * counts a) | |
| (labelRecordOf labels depth) hinjective a | |
| def encodeSourceWord (counts : A → ℕ) (labels : ∀ n, A → Label n) (depth t : ℕ) | |
| (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : PopulationWords Position (fun a => t * counts a)) : | |
| ExactPrefix counts labels depth t Position := by | |
| refine ⟨fun i => labelRecordOf labels depth (word.val i), ?_⟩ | |
| intro r | |
| by_cases hr : ∃ a : A, labelRecordOf labels depth a = r | |
| · obtain ⟨a, rfl⟩ := hr | |
| calc | |
| wordPopulation (fun i => labelRecordOf labels depth (word.val i)) | |
| (labelRecordOf labels depth a) = wordPopulation word.val a := by | |
| simp only [wordPopulation, hinjective.eq_iff] | |
| _ = t * counts a := word.property a | |
| _ = sourcePrefixCounts (fun a => t * counts a) labels depth (labelRecordOf labels depth a) := | |
| (pushforwardCounts_apply (fun a => t * counts a) | |
| (labelRecordOf labels depth) hinjective a).symm | |
| · have hnot : ∀ a : A, labelRecordOf labels depth a ≠ r := not_exists.mp hr | |
| simp [wordPopulation, sourcePrefixCounts, pushforwardCounts, hnot] | |
| @[simp] theorem encodeSourceWord_val (counts : A → ℕ) (labels : ∀ n, A → Label n) | |
| (depth t : ℕ) (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : PopulationWords Position (fun a => t * counts a)) (i : Position) : | |
| (encodeSourceWord counts labels depth t hinjective word).val i = | |
| labelRecordOf labels depth (word.val i) := rfl | |
| @[simp] theorem sourceSymbol_encodeSourceWord (counts : A → ℕ) (labels : ∀ n, A → Label n) | |
| (depth t : ℕ) (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : PopulationWords Position (fun a => t * counts a)) (i : Position) : | |
| sourceSymbol (encodeSourceWord counts labels depth t hinjective word) i = word.val i := | |
| hinjective (sourceSymbol_record (encodeSourceWord counts labels depth t hinjective word) i) | |
| def sourcePrefixEquiv (counts : A → ℕ) (labels : ∀ n, A → Label n) (depth t : ℕ) | |
| (Position : Type w) [Fintype Position] | |
| (hinjective : Function.Injective (labelRecordOf labels depth)) : | |
| ExactPrefix counts labels depth t Position ≃ PopulationWords Position (fun a => t * counts a) where | |
| toFun word := decodeSourceWord hinjective word | |
| invFun word := encodeSourceWord counts labels depth t hinjective word | |
| left_inv word := by | |
| apply Subtype.ext | |
| funext i | |
| exact sourceSymbol_record word i | |
| right_inv word := by | |
| apply Subtype.ext | |
| funext i | |
| exact sourceSymbol_encodeSourceWord counts labels depth t hinjective word i | |
| @[simp] theorem sourcePrefixEquiv_apply_val (counts : A → ℕ) (labels : ∀ n, A → Label n) | |
| (depth t : ℕ) (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : ExactPrefix counts labels depth t Position) (i : Position) : | |
| (sourcePrefixEquiv counts labels depth t Position hinjective word).val i = | |
| sourceSymbol word i := rfl | |
| @[simp] theorem sourcePrefixEquiv_symm_val (counts : A → ℕ) (labels : ∀ n, A → Label n) | |
| (depth t : ℕ) (hinjective : Function.Injective (labelRecordOf labels depth)) | |
| (word : PopulationWords Position (fun a => t * counts a)) (i : Position) : | |
| ((sourcePrefixEquiv counts labels depth t Position hinjective).symm word).val i = | |
| labelRecordOf labels depth (word.val i) := rfl | |
| end Terminal | |
| end MatrixMultiplication.Foundation.ConditionalPrefixWords | |
| end | |
| end OAI | |