openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Entropy /ComplexOrientationRates.lean
| import Mathlib.Data.Fintype.Perm | |
| import Mathlib.Data.Fintype.BigOperators | |
| import Mathlib.Algebra.BigOperators.Field | |
| import Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | |
| import Mathlib.Analysis.SpecialFunctions.Log.Basic | |
| import Mathlib.Tactic.FieldSimp | |
| import Mathlib.Tactic.NormNum | |
| import Mathlib.Tactic.Ring | |
| namespace OAI | |
| /-! Finite entropy, rate estimates and ordered asymptotic limits. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation | |
| namespace OrientationRates | |
| open scoped BigOperators | |
| abbrev Orientation := Equiv.Perm (Fin 3) | |
| @[simp] theorem orientation_card : Fintype.card Orientation = 6 := by | |
| rw [Fintype.card_perm] | |
| decide | |
| def relativeOrientation (relative : Orientation) : Orientation ≃ Orientation where | |
| toFun outer := outer * relative | |
| invFun original := original * relative⁻¹ | |
| left_inv outer := by simp [mul_assoc] | |
| right_inv original := by simp [mul_assoc] | |
| @[simp] theorem relativeOrientation_apply (relative outer : Orientation) : | |
| relativeOrientation relative outer = outer * relative := rfl | |
| theorem unique_outer_orientation (relative original : Orientation) : | |
| ∃! outer : Orientation, outer * relative = original := | |
| (relativeOrientation relative).bijective.existsUnique original | |
| theorem sum_relative_orientation {M : Type*} [AddCommMonoid M] | |
| (relative : Orientation) (value : Orientation → M) : | |
| (∑ outer, value (outer * relative)) = ∑ original, value original := | |
| (relativeOrientation relative).sum_comp value | |
| theorem prod_relative_orientation {M : Type*} [CommMonoid M] | |
| (relative : Orientation) (value : Orientation → M) : | |
| (∏ outer, value (outer * relative)) = ∏ original, value original := | |
| (relativeOrientation relative).prod_comp value | |
| theorem site_population_in_orientation {M : Type*} [AddCommMonoid M] | |
| (relative original : Orientation) (population : M) : | |
| (∑ outer : Orientation, | |
| if outer * relative = original then population else 0) = population := by | |
| classical | |
| rw [sum_relative_orientation relative | |
| (fun orientation => if orientation = original then population else 0)] | |
| simp | |
| theorem histogram_in_original_orientation {Site M : Type*} | |
| [Fintype Site] [AddCommMonoid M] | |
| (relative : Site → Orientation) (population : Site → M) | |
| (original : Orientation) : | |
| (∑ site, ∑ outer : Orientation, | |
| if outer * relative site = original then population site else 0) = | |
| ∑ site, population site := by | |
| classical | |
| apply Finset.sum_congr rfl | |
| intro site _ | |
| exact site_population_in_orientation (relative site) original (population site) | |
| theorem target_multiplicity (targetCount : ℕ) : | |
| (∏ _ : Orientation, targetCount) = targetCount ^ 6 := by | |
| simp | |
| section FiniteRates | |
| variable {Node Grade : Type*} [Fintype Node] [Fintype Grade] | |
| def outputLaw (n : ℕ) (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (grade : Grade) : ℝ := | |
| (∑ node, population node * law node grade) / n | |
| def affineScore (offset : ℝ) (coefficient law : Grade → ℝ) : ℝ := | |
| offset + ∑ grade, coefficient grade * law grade | |
| def totalNodeUtility (population utility : Node → ℝ) : ℝ := | |
| ∑ node, population node * utility node | |
| def totalCost (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (offset : ℝ) (coefficient : Grade → ℝ) (utility : Node → ℝ) : ℝ := | |
| ∑ node, population node * (affineScore offset coefficient (law node) - utility node) | |
| omit [Fintype Grade] in | |
| theorem outputLaw_nonnegative (n : ℕ) (population : Node → ℝ) | |
| (law : Node → Grade → ℝ) | |
| (hp : ∀ node, 0 ≤ population node) (hq : ∀ node grade, 0 ≤ law node grade) | |
| (grade : Grade) : 0 ≤ outputLaw n population law grade := by | |
| apply div_nonneg | |
| · exact Finset.sum_nonneg fun node _ => mul_nonneg (hp node) (hq node grade) | |
| · exact Nat.cast_nonneg n | |
| theorem outputLaw_total (n : ℕ) (hn : n ≠ 0) (population : Node → ℝ) | |
| (law : Node → Grade → ℝ) | |
| (hp : ∑ node, population node = (n : ℝ)) | |
| (hq : ∀ node, ∑ grade, law node grade = 1) : | |
| ∑ grade, outputLaw n population law grade = 1 := by | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn | |
| simp only [outputLaw, ← Finset.sum_div] | |
| rw [Finset.sum_comm] | |
| simp only [← Finset.mul_sum, hq, mul_one, hp, div_self hn'] | |
| theorem weighted_affineScore (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (offset : ℝ) (coefficient : Grade → ℝ) : | |
| (∑ node, population node * affineScore offset coefficient (law node)) = | |
| (∑ node, population node) * offset + | |
| ∑ grade, coefficient grade * (∑ node, population node * law node grade) := by | |
| simp only [affineScore, mul_add, Finset.sum_add_distrib, ← Finset.sum_mul] | |
| congr 1 | |
| calc | |
| (∑ node, population node * ∑ grade, coefficient grade * law node grade) = | |
| ∑ node, ∑ grade, coefficient grade * (population node * law node grade) := by | |
| apply Finset.sum_congr rfl | |
| intro node _ | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro grade _ | |
| ring | |
| _ = ∑ grade, coefficient grade * ∑ node, population node * law node grade := by | |
| rw [Finset.sum_comm] | |
| simp only [Finset.mul_sum] | |
| theorem weighted_affineScore_eq (n : ℕ) (hn : n ≠ 0) | |
| (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (hp : ∑ node, population node = (n : ℝ)) | |
| (offset : ℝ) (coefficient : Grade → ℝ) : | |
| (∑ node, population node * affineScore offset coefficient (law node)) = | |
| (n : ℝ) * affineScore offset coefficient (outputLaw n population law) := by | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn | |
| rw [weighted_affineScore, hp] | |
| simp only [affineScore, outputLaw] | |
| conv_rhs => rw [mul_add, Finset.mul_sum] | |
| congr 1 | |
| apply Finset.sum_congr rfl | |
| intro grade _ | |
| field_simp [hn'] | |
| theorem totalCost_eq (n : ℕ) (hn : n ≠ 0) | |
| (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (hp : ∑ node, population node = (n : ℝ)) | |
| (offset : ℝ) (coefficient : Grade → ℝ) (utility : Node → ℝ) : | |
| totalCost population law offset coefficient utility = | |
| (n : ℝ) * affineScore offset coefficient (outputLaw n population law) - | |
| totalNodeUtility population utility := by | |
| simp only [totalCost, mul_sub, Finset.sum_sub_distrib, totalNodeUtility] | |
| rw [weighted_affineScore_eq n hn population law hp] | |
| theorem utility_rate_identity (n : ℕ) (hn : n ≠ 0) | |
| (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (hp : ∑ node, population node = (n : ℝ)) | |
| (offset targetRate : ℝ) (coefficient : Grade → ℝ) (utility : Node → ℝ) : | |
| (targetRate + totalNodeUtility population utility) / n = | |
| affineScore offset coefficient (outputLaw n population law) + | |
| (targetRate - totalCost population law offset coefficient utility) / n := by | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn | |
| rw [totalCost_eq n hn population law hp] | |
| field_simp [hn'] | |
| ring | |
| theorem finite_utility_bound (n : ℕ) (hn : n ≠ 0) | |
| (population : Node → ℝ) (law : Node → Grade → ℝ) | |
| (hp : ∑ node, population node = (n : ℝ)) | |
| (offset targetRate error actualUtility : ℝ) | |
| (coefficient : Grade → ℝ) (utility : Node → ℝ) | |
| (construction : (targetRate + totalNodeUtility population utility) / n - error ≤ | |
| actualUtility) : | |
| affineScore offset coefficient (outputLaw n population law) + | |
| (targetRate - totalCost population law offset coefficient utility) / n - error ≤ | |
| actualUtility := by | |
| rwa [utility_rate_identity n hn population law hp offset targetRate coefficient utility] | |
| at construction | |
| end FiniteRates | |
| section PhysicalNormalization | |
| variable {Node : Type*} [Fintype Node] | |
| theorem log_resource_product (copies : Node → ℕ) (resource : Node → ℝ) | |
| (hresource : ∀ node, resource node ≠ 0) : | |
| Real.log (∏ node, resource node ^ copies node) = | |
| ∑ node, (copies node : ℝ) * Real.log (resource node) := by | |
| rw [Real.log_prod (s := Finset.univ) (f := fun node => resource node ^ copies node) | |
| (fun node _ => pow_ne_zero _ (hresource node))] | |
| simp only [Real.log_pow] | |
| theorem log_direct_multiplicity (targetCount : ℝ) (htarget : targetCount ≠ 0) | |
| (copies : Node → ℕ) (labels : Node → ℝ) (hlabels : ∀ node, labels node ≠ 0) : | |
| Real.log (targetCount ^ 6 * ∏ node, labels node ^ copies node) = | |
| 6 * Real.log targetCount + ∑ node, (copies node : ℝ) * Real.log (labels node) := by | |
| have hprod : (∏ node, labels node ^ copies node) ≠ 0 := | |
| Finset.prod_ne_zero_iff.mpr (fun node _ => pow_ne_zero _ (hlabels node)) | |
| rw [Real.log_mul (pow_ne_zero _ htarget) hprod, Real.log_pow, | |
| log_resource_product copies labels hlabels] | |
| norm_num | |
| theorem raw_utility_accounting (targetCount : ℝ) (htarget : targetCount ≠ 0) | |
| (copies : Node → ℕ) (labels rank volume : Node → ℝ) | |
| (hlabels : ∀ node, labels node ≠ 0) (hrank : ∀ node, rank node ≠ 0) | |
| (hvolume : ∀ node, volume node ≠ 0) (volumeWeight : ℝ) : | |
| Real.log (targetCount ^ 6 * ∏ node, labels node ^ copies node) - | |
| Real.log (∏ node, rank node ^ copies node) + | |
| volumeWeight * Real.log (∏ node, volume node ^ copies node) = | |
| 6 * Real.log targetCount + | |
| ∑ node, (copies node : ℝ) * | |
| (Real.log (labels node) - Real.log (rank node) + | |
| volumeWeight * Real.log (volume node)) := by | |
| rw [log_direct_multiplicity targetCount htarget copies labels hlabels, | |
| log_resource_product copies rank hrank, log_resource_product copies volume hvolume] | |
| simp only [mul_add, mul_sub, Finset.sum_add_distrib, Finset.sum_sub_distrib] | |
| rw [Finset.mul_sum] | |
| have hvolumeSum : | |
| (∑ node, volumeWeight * ((copies node : ℝ) * Real.log (volume node))) = | |
| ∑ node, (copies node : ℝ) * (volumeWeight * Real.log (volume node)) := by | |
| apply Finset.sum_congr rfl | |
| intro node _ | |
| ring | |
| rw [hvolumeSum] | |
| ring | |
| theorem physical_rate_normalization (bank horizon : ℕ) | |
| (hbank : bank ≠ 0) (hhorizon : horizon ≠ 0) | |
| (blockSize copies : Node → ℕ) (hsize : ∀ node, blockSize node ≠ 0) | |
| (population rawNodeUtility : Node → ℝ) (targetLog : ℝ) | |
| (tiling : ∀ node, (bank : ℝ) * population node = | |
| (copies node : ℝ) * blockSize node) : | |
| (6 * targetLog + ∑ node, (copies node : ℝ) * rawNodeUtility node) / | |
| (6 * bank * horizon) = | |
| (targetLog / bank + totalNodeUtility population | |
| (fun node => rawNodeUtility node / (6 * blockSize node))) / horizon := by | |
| have hbank' : (bank : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hbank | |
| have hhorizon' : (horizon : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hhorizon | |
| have hnode (node : Node) : | |
| population node * (rawNodeUtility node / (6 * blockSize node)) = | |
| (copies node : ℝ) * rawNodeUtility node / (6 * bank) := by | |
| have hsize' : (blockSize node : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (hsize node) | |
| have hp : population node = (copies node : ℝ) * blockSize node / bank := by | |
| apply (eq_div_iff hbank').mpr | |
| simpa only [mul_comm] using tiling node | |
| rw [hp] | |
| field_simp [hbank', hsize'] | |
| simp only [totalNodeUtility, hnode, ← Finset.sum_div] | |
| field_simp [hbank', hhorizon'] | |
| theorem physical_cost_rate_identity {Grade : Type*} [Fintype Grade] | |
| (bank horizon : ℕ) (hbank : bank ≠ 0) (hhorizon : horizon ≠ 0) | |
| (blockSize copies : Node → ℕ) (hsize : ∀ node, blockSize node ≠ 0) | |
| (population rawNodeUtility : Node → ℝ) (law : Node → Grade → ℝ) | |
| (targetLog offset : ℝ) (coefficient : Grade → ℝ) | |
| (tiling : ∀ node, (bank : ℝ) * population node = | |
| (copies node : ℝ) * blockSize node) | |
| (total : ∑ node, population node = (horizon : ℝ)) : | |
| (6 * targetLog + ∑ node, (copies node : ℝ) * rawNodeUtility node) / | |
| (6 * bank * horizon) = | |
| affineScore offset coefficient (outputLaw horizon population law) + | |
| (targetLog / bank - totalCost population law offset coefficient | |
| (fun node => rawNodeUtility node / (6 * blockSize node))) / horizon := by | |
| rw [physical_rate_normalization bank horizon hbank hhorizon blockSize copies | |
| hsize population rawNodeUtility targetLog tiling] | |
| exact utility_rate_identity horizon hhorizon population law total offset | |
| (targetLog / bank) coefficient (fun node => rawNodeUtility node / (6 * blockSize node)) | |
| end PhysicalNormalization | |
| end OrientationRates | |
| end MatrixMultiplication.Foundation | |
| end | |
| end OAI | |