openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /FieldConstruction /NativeGroupedRates.lean
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.GroupedEntropyPartition | |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.PairConditionalEntropy | |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.ComplementSums | |
| import Mathlib.Data.List.NodupEquivFin | |
| namespace OAI | |
| /-! Tensor extraction over arbitrary fields and its asymptotic rate. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.AllFieldNativeGroupedRates | |
| open MatrixMultiplication.Foundation AllFieldParameters AllFieldHistory | |
| open JointNativeGroupedEntropy JointGroupedEntropyPartition | |
| open AllFieldNativeCapacity AllFieldPairConditionalEntropy | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| section Reindex | |
| variable {U K A : Type*} [Fintype U] [Fintype K] [Fintype A] | |
| omit [Fintype U] [Fintype K] in | |
| theorem singletonResidualGroup_transport (e : U ≃ U) (c : K ≃ K) | |
| (d : U → Prop) (weight : U → K) | |
| (hw : ∀ u, c (weight u) = weight (e u)) : | |
| (Equiv.sumCongr e c) ∘ singletonResidualGroup (d ∘ e) weight = | |
| singletonResidualGroup d weight ∘ e := by | |
| funext u | |
| by_cases hu : d (e u) <;> | |
| simp [singletonResidualGroup, Function.comp_apply, hu, hw] | |
| theorem singletonResidual_groupedEntropy_reindex (e : U ≃ U) (c : K ≃ K) | |
| (p : U → ℝ) (d : U → Prop) (weight : U → K) (q : U → A → ℝ) | |
| (hp : ∀ u, p (e u) = p u) (hw : ∀ u, c (weight u) = weight (e u)) : | |
| JointCompatibilityIncidence.groupedEntropy p | |
| (singletonResidualGroup (d ∘ e) weight) (q ∘ e) = | |
| JointCompatibilityIncidence.groupedEntropy p (singletonResidualGroup d weight) q := by | |
| calc | |
| _ = JointCompatibilityIncidence.groupedEntropy p | |
| ((Equiv.sumCongr e c) ∘ singletonResidualGroup (d ∘ e) weight) (q ∘ e) := | |
| (JointCompatibilityIncidence.groupedEntropy_relabel (Equiv.sumCongr e c) p _ _).symm | |
| _ = JointCompatibilityIncidence.groupedEntropy p | |
| (singletonResidualGroup d weight ∘ e) (q ∘ e) := by | |
| rw [singletonResidualGroup_transport e c d weight hw] | |
| _ = _ := JointCompatibilityIncidence.groupedEntropy_reindex e p _ q hp | |
| theorem right_conditional_sum_eq (e : U ≃ U) (c : K ≃ K) | |
| (p : FiniteLaw U) (d : U → Prop) (weight : U → K) (q : U → A → ℝ) | |
| (hp : ∀ u, p.mass (e u) = p.mass u) | |
| (hw : ∀ u, c (weight u) = weight (e u)) (hq : ∀ u, ∑ a, q u a = 1) : | |
| (∑ k, (p.map weight).mass k * | |
| JointCompatibilityIncidence.groupedEntropy (p.conditional weight k).mass | |
| (JointCompatibilityIncidence.designatedGroup (d ∘ e)) (q ∘ e)) = | |
| JointCompatibilityIncidence.groupedEntropy p.mass (singletonResidualGroup d weight) q := by | |
| rw [← groupedEntropy_conditional_partition p (d ∘ e) weight (q ∘ e) | |
| (fun u => hq (e u))] | |
| exact singletonResidual_groupedEntropy_reindex e c p.mass d weight q hp hw | |
| end Reindex | |
| def supportSubtypeEquiv {α : Type*} (xs : List α) (f : α → α) | |
| (hm : ∀ x ∈ xs, f x ∈ xs) (hi : ∀ x ∈ xs, f (f x) = x) : | |
| Equiv.Perm {x // x ∈ xs} where | |
| toFun x := ⟨f x.val, hm x.val x.property⟩ | |
| invFun x := ⟨f x.val, hm x.val x.property⟩ | |
| left_inv x := Subtype.ext (hi x.val x.property) | |
| right_inv x := Subtype.ext (hi x.val x.property) | |
| def supportIndexEquiv {α : Type*} [DecidableEq α] (xs : List α) (hn : xs.Nodup) | |
| (f : α → α) (hm : ∀ x ∈ xs, f x ∈ xs) (hi : ∀ x ∈ xs, f (f x) = x) : | |
| Equiv.Perm (Fin xs.length) := | |
| ((hn.getEquiv xs).trans (supportSubtypeEquiv xs f hm hi)).trans (hn.getEquiv xs).symm | |
| theorem supportIndexEquiv_get {α : Type*} [DecidableEq α] (xs : List α) | |
| (hn : xs.Nodup) (f : α → α) (hm : ∀ x ∈ xs, f x ∈ xs) | |
| (hi : ∀ x ∈ xs, f (f x) = x) (i : Fin xs.length) : | |
| xs.get (supportIndexEquiv xs hn f hm hi i) = f (xs.get i) := by | |
| exact congrArg Subtype.val ((hn.getEquiv xs).apply_symm_apply | |
| ((supportSubtypeEquiv xs f hm hi) ((hn.getEquiv xs) i))) | |
| def boundedComplement (s : ℕ) (hs : s < 17) (k : Fin 17) : Fin 17 := | |
| ⟨if k.val ≤ s then s - k.val else k.val, by | |
| split_ifs | |
| · exact lt_of_le_of_lt (Nat.sub_le _ _) hs | |
| · exact k.isLt⟩ | |
| theorem boundedComplement_involutive (s : ℕ) (hs : s < 17) : | |
| Function.Involutive (boundedComplement s hs) := by | |
| intro k | |
| apply Fin.ext | |
| dsimp only [boundedComplement] | |
| split_ifs <;> omega | |
| def boundedComplementEquiv (s : ℕ) (hs : s < 17) : Equiv.Perm (Fin 17) where | |
| toFun := boundedComplement s hs | |
| invFun := boundedComplement s hs | |
| left_inv := boundedComplement_involutive s hs | |
| right_inv := boundedComplement_involutive s hs | |
| section NativeSupport | |
| variable {A : Type*} [Fintype A] | |
| theorem native_right_conditional_sum_eq (support : List Shape) (s : Shape) | |
| (p : Shape → ℝ) (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ) | |
| (hn : support.Nodup) (hm : ∀ u ∈ support, complement s u ∈ support) | |
| (hsupp : ∀ u ∈ support, ∀ side, u side ≤ s side) | |
| (hs : s (priority position) < 17) | |
| (hbound : ∀ i : SupportIndex support, support[i.val] (priority position) < 17) | |
| (law : FiniteLaw (SupportIndex support)) | |
| (hlaw : ∀ i : SupportIndex support, law.mass i = p support[i.val]) | |
| (hp : ∀ u ∈ support, p (complement s u) = p u) | |
| (hq : ∀ i : SupportIndex support, ∑ a, q support[i.val] a = 1) : | |
| (∑ k : Fin 17, (law.map (ownWeight support priority position hbound)).mass k * | |
| JointCompatibilityIncidence.groupedEntropy | |
| (law.conditional (ownWeight support priority position hbound) k).mass | |
| (JointCompatibilityIncidence.designatedGroup (fun i => | |
| AllFieldNativeCapacity.designated priority position (complement s support[i.val]))) | |
| (fun i => q (complement s support[i.val]))) = | |
| AllFieldNativeCapacity.groupedEntropy support p priority position q := by | |
| let hi : ∀ u ∈ support, complement s (complement s u) = u := | |
| fun u hu => complement_involution_of_le s u (hsupp u hu) | |
| let e := supportIndexEquiv support hn (complement s) hm hi | |
| let c := boundedComplementEquiv (s (priority position)) hs | |
| let weight := ownWeight support priority position hbound | |
| let d : SupportIndex support → Prop := | |
| fun i => AllFieldNativeCapacity.designated priority position support[i.val] | |
| let q₀ : SupportIndex support → A → ℝ := fun i => q support[i.val] | |
| have he (i : SupportIndex support) : | |
| support[(e i).val] = complement s support[i.val] := by | |
| simpa only [List.get_eq_getElem] using | |
| supportIndexEquiv_get support hn (complement s) hm hi i | |
| have hmass (i : SupportIndex support) : law.mass (e i) = law.mass i := by | |
| simp only [hlaw, he] | |
| exact hp _ (List.getElem_mem i.isLt) | |
| have hw (i : SupportIndex support) : c (weight i) = weight (e i) := by | |
| apply Fin.ext | |
| change (if support[i.val] (priority position) ≤ s (priority position) | |
| then s (priority position) - support[i.val] (priority position) | |
| else support[i.val] (priority position)) = support[(e i).val] (priority position) | |
| rw [ite_eq_left (hsupp _ (List.getElem_mem i.isLt) _), he] | |
| rfl | |
| have hright := right_conditional_sum_eq e c law d weight q₀ hmass hw hq | |
| have hd : d ∘ e = fun i => | |
| AllFieldNativeCapacity.designated priority position (complement s support[i.val]) := by | |
| funext i | |
| dsimp only [d, Function.comp_apply] | |
| rw [he] | |
| have hqr : q₀ ∘ e = fun i => q (complement s support[i.val]) := by | |
| funext i | |
| dsimp only [q₀, Function.comp_apply] | |
| rw [he] | |
| rw [hd, hqr] at hright | |
| have hnonneg (i : SupportIndex support) : 0 ≤ p support[i.val] := by | |
| rw [← hlaw i] | |
| exact law.nonneg i | |
| have hmassfun : law.mass = fun i : SupportIndex support => p support[i.val] := funext hlaw | |
| calc | |
| _ = JointCompatibilityIncidence.groupedEntropy law.mass | |
| (nativeGroup support priority position hbound) (fun i => q support[i.val]) := by | |
| simpa only [d, q₀, weight, nativeGroup] using hright | |
| _ = _ := by | |
| rw [hmassfun] | |
| exact groupedEntropy_eq_native support p priority position q hbound hnonneg hq | |
| theorem native_two_conditional_sums_eq (support : List Shape) (s : Shape) | |
| (p : Shape → ℝ) (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ) | |
| (hn : support.Nodup) (hm : ∀ u ∈ support, complement s u ∈ support) | |
| (hsupp : ∀ u ∈ support, ∀ side, u side ≤ s side) | |
| (hs : s (priority position) < 17) | |
| (hbound : ∀ i : SupportIndex support, support[i.val] (priority position) < 17) | |
| (law : FiniteLaw (SupportIndex support)) | |
| (hlaw : ∀ i : SupportIndex support, law.mass i = p support[i.val]) | |
| (hp : ∀ u ∈ support, p (complement s u) = p u) | |
| (hq : ∀ i : SupportIndex support, ∑ a, q support[i.val] a = 1) : | |
| (∑ k : Fin 17, (law.map (ownWeight support priority position hbound)).mass k * | |
| (JointCompatibilityIncidence.groupedEntropy | |
| (law.conditional (ownWeight support priority position hbound) k).mass | |
| (JointCompatibilityIncidence.designatedGroup (fun i => | |
| AllFieldNativeCapacity.designated priority position support[i.val])) | |
| (fun i => q support[i.val]) + | |
| JointCompatibilityIncidence.groupedEntropy | |
| (law.conditional (ownWeight support priority position hbound) k).mass | |
| (JointCompatibilityIncidence.designatedGroup (fun i => | |
| AllFieldNativeCapacity.designated priority position (complement s support[i.val]))) | |
| (fun i => q (complement s support[i.val])))) = | |
| 2 * AllFieldNativeCapacity.groupedEntropy support p priority position q := by | |
| simp only [mul_add, Finset.sum_add_distrib] | |
| rw [← native_groupedEntropy_eq_sum_conditional support p priority position q hbound law hlaw hq, | |
| native_right_conditional_sum_eq support s p priority position q hn hm hsupp hs | |
| hbound law hlaw hp hq] | |
| ring | |
| end NativeSupport | |
| def twoHalfConditionalCost {A : Type*} [Fintype A] | |
| (support : List Shape) (s : Shape) (priority : Placement) (position : Fin 3) | |
| (q : Shape → A → ℝ) (law : FiniteLaw (SupportIndex support)) | |
| (weight : SupportIndex support → Fin 17) : ℝ := | |
| ∑ k : Fin 17, (law.map weight).mass k * | |
| (JointCompatibilityIncidence.groupedEntropy (law.conditional weight k).mass | |
| (JointCompatibilityIncidence.designatedGroup (fun i => | |
| AllFieldNativeCapacity.designated priority position support[i.val])) | |
| (fun i => q support[i.val]) + | |
| JointCompatibilityIncidence.groupedEntropy (law.conditional weight k).mass | |
| (JointCompatibilityIncidence.designatedGroup (fun i => | |
| AllFieldNativeCapacity.designated priority position (complement s support[i.val]))) | |
| (fun i => q (complement s support[i.val]))) | |
| theorem stageA_twoHalfConditionalCost_eq (g : Shape) (hg : g ∈ positiveInitial) | |
| (priority : Placement) (position : Fin 3) : | |
| twoHalfConditionalCost (below g) g priority position | |
| (fun u a => (halfLaw u (priority position) a : ℝ)) (stageASplitLaw g hg) | |
| (stageASplitWeight g hg (priority position)) = | |
| 2 * AllFieldNativeCapacity.groupedEntropy (below g) | |
| (fun u => (stageALaw g u : ℝ)) priority position | |
| (fun u a => (halfLaw u (priority position) a : ℝ)) := by | |
| have hs : g (priority position) < 17 := | |
| Nat.lt_succ_of_le ((positiveInitial_shape_spec g hg).1 (priority position)) | |
| let hb : ∀ i : SupportIndex (below g), (below g)[i.val] (priority position) < 17 := | |
| fun i => lt_of_le_of_lt (below_le (List.getElem_mem i.isLt) _) hs | |
| have hq (i : SupportIndex (below g)) : | |
| ∑ a, (halfLaw (below g)[i.val] (priority position) a : ℝ) = 1 := | |
| (halfFiniteLaw _ (stageA_children_size g hg _ (List.getElem_mem i.isLt)) | |
| (priority position)).total | |
| have hh := native_two_conditional_sums_eq (below g) g | |
| (fun u => (stageALaw g u : ℝ)) priority position | |
| (fun u a => (halfLaw u (priority position) a : ℝ)) | |
| (stageA_below_nodup g hg) (fun u hu => (stageA_support_complement g hg u hu).1) | |
| (fun _ hu => below_le hu) hs hb (stageASplitLaw g hg) (fun _ => rfl) | |
| (fun u hu => by rw [stageALaw_complement g u hg hu]) hq | |
| have hw : ownWeight (below g) priority position hb = | |
| stageASplitWeight g hg (priority position) := by | |
| funext i | |
| apply Fin.ext | |
| simp only [ownWeight, stageASplitWeight, List.get_eq_getElem] | |
| rw [hw] at hh | |
| simpa only [twoHalfConditionalCost] using hh | |
| theorem stageB_twoHalfConditionalCost_eq (t : Shape) (ht : t ∈ positiveSecond) | |
| (priority : Placement) (position : Fin 3) : | |
| twoHalfConditionalCost (below t) t priority position | |
| (fun u a => (littleLaw t u (priority position) a : ℝ)) (stageBSplitLaw t ht) | |
| (stageBSplitWeight t ht (priority position)) = | |
| 2 * AllFieldNativeCapacity.groupedEntropy (below t) | |
| (fun u => (stageBLaw t u : ℝ)) priority position | |
| (fun u a => (littleLaw t u (priority position) a : ℝ)) := by | |
| have hs : t (priority position) < 17 := | |
| Nat.lt_succ_of_le ((positiveSecond_shape_spec t ht).1 (priority position)) | |
| let hb : ∀ i : SupportIndex (below t), (below t)[i.val] (priority position) < 17 := | |
| fun i => lt_of_le_of_lt (below_le (List.getElem_mem i.isLt) _) hs | |
| have hq (i : SupportIndex (below t)) : | |
| ∑ a, (littleLaw t (below t)[i.val] (priority position) a : ℝ) = 1 := | |
| (littleFiniteLaw t _ (priority position)).total | |
| have hh := native_two_conditional_sums_eq (below t) t | |
| (fun u => (stageBLaw t u : ℝ)) priority position | |
| (fun u a => (littleLaw t u (priority position) a : ℝ)) | |
| (stageB_below_nodup t ht) (fun u hu => (stageB_support_complement t ht u hu).1) | |
| (fun _ hu => below_le hu) hs hb (stageBSplitLaw t ht) (fun _ => rfl) | |
| (fun u hu => by rw [stageBLaw_complement t u ht hu]) hq | |
| have hw : ownWeight (below t) priority position hb = | |
| stageBSplitWeight t ht (priority position) := by | |
| funext i | |
| apply Fin.ext | |
| simp only [ownWeight, stageBSplitWeight, List.get_eq_getElem] | |
| rw [hw] at hh | |
| simpa only [twoHalfConditionalCost] using hh | |
| theorem stageA_twoHalfConditionalCost_eq_entropy_sub_capacity | |
| (g : Shape) (hg : g ∈ positiveInitial) (side : Fin 3) (hside : side ≠ 0) : | |
| twoHalfConditionalCost (below g) g (Equiv.refl (Fin 3)) side | |
| (fun u a => (halfLaw u side a : ℝ)) (stageASplitLaw g hg) | |
| (stageASplitWeight g hg side) = | |
| finiteEntropy (stageAPairLaw g hg side).mass - stageACapacity g side := by | |
| rw [stageACapacity_sharing g hg side hside] | |
| have hh := stageA_twoHalfConditionalCost_eq g hg (Equiv.refl (Fin 3)) side | |
| simpa only [Equiv.refl_apply, sub_sub_cancel] using hh | |
| theorem stageB_twoHalfConditionalCost_eq_entropy_sub_capacity | |
| (t : Shape) (ht : t ∈ positiveSecond) (side : Fin 3) (hside : side ≠ 0) : | |
| twoHalfConditionalCost (below t) t (stageBPriority t) side | |
| (fun u a => (littleLaw t u (stageBPriority t side) a : ℝ)) (stageBSplitLaw t ht) | |
| (stageBSplitWeight t ht (stageBPriority t side)) = | |
| finiteEntropy (stageBPairLaw t ht (stageBPriority t side)).mass - | |
| stageBCapacity t side := by | |
| rw [stageBCapacity_sharing t ht side hside] | |
| have hh := stageB_twoHalfConditionalCost_eq t ht (stageBPriority t) side | |
| simpa only [sub_sub_cancel] using hh | |
| end MatrixMultiplication.AllFieldNativeGroupedRates | |
| end | |
| end OAI | |