openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /FieldConstruction /InitialGibbs.lean
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.InitialOrbit | |
| import Mathlib.Data.Rat.BigOperators | |
| namespace OAI | |
| /-! Tensor extraction over arbitrary fields and its asymptotic rate. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.AllFieldInitialGibbs | |
| open AllFieldParameters AllFieldHistory AllFieldInitialEntropy AllFieldInitialOrbit | |
| open MatrixMultiplication.Foundation | |
| open scoped BigOperators | |
| def coordinateWeight (k : Fin 17) : ℝ := | |
| (weight (initialInteger k.val) : ℝ) | |
| def orderedWeight (u : JointPopulation.Shape) : ℝ := | |
| ∏ s : Fin 3, coordinateWeight (JointPopulation.shapeSide s u) | |
| def initialNormalizer : ℝ := ((sortedInitial.map initialWeight).sum : ℚ) | |
| def initialPotential (k : Fin 17) : ℝ := Real.log (coordinateWeight k) | |
| def initialLogNormalizer : ℝ := Real.log initialNormalizer | |
| theorem coordinateWeight_pos (k : Fin 17) : 0 < coordinateWeight k := by | |
| apply Rat.cast_pos.mpr | |
| apply weight_positive_of_argument_bound | |
| exact assigned_argument_bound _ tablea initial_table_arguments_bounded _ | |
| theorem orderedWeight_pos (u : JointPopulation.Shape) : 0 < orderedWeight u := | |
| Finset.prod_pos (fun _ _ => coordinateWeight_pos _) | |
| theorem initialNormalizer_pos : 0 < initialNormalizer := by | |
| apply Rat.cast_pos.mpr | |
| exact list_sum_map_positive _ _ (by decide +kernel) | |
| (fun s _ => initialWeight_positive s) | |
| theorem orderedWeight_source (p : PlacedInitial) : | |
| orderedWeight (initialShapeCode p) = | |
| ∏ s : Fin 3, (weight (initialInteger (sortedInitial.get p.1 s)) : ℝ) := by | |
| simp only [orderedWeight, coordinateWeight, initialShapeCode_side] | |
| exact p.2.symm.prod_comp | |
| (fun s : Fin 3 => (weight (initialInteger (sortedInitial.get p.1 s)) : ℝ)) | |
| theorem initialWeight_source (p : PlacedInitial) : | |
| (initialWeight (sortedInitial.get p.1) : ℝ) = | |
| (initialMultiplicity (sortedInitial.get p.1) : ℝ) * | |
| orderedWeight (initialShapeCode p) := by | |
| rw [orderedWeight_source] | |
| simp only [initialWeight] | |
| push_cast | |
| rfl | |
| theorem placedInitialLaw_mass (p : PlacedInitial) : | |
| placedInitialLaw.mass p = | |
| (initialMultiplicity (sortedInitial.get p.1) : ℝ) * | |
| orderedWeight (initialShapeCode p) / initialNormalizer / 6 := by | |
| change (initialLaw (sortedInitial.get p.1) : ℝ) / 6 = _ | |
| rw [initialLaw, ite_eq_left (List.get_mem _ _), Rat.cast_div, initialWeight_source p] | |
| rfl | |
| theorem orderedInitialLaw_mass (u : JointPopulation.Shape) | |
| (hu : u.1.val + u.2.1.val + u.2.2.val = 16) : | |
| orderedInitialLaw.mass u = orderedWeight u / initialNormalizer := by | |
| classical | |
| have hcount : (∑ p : PlacedInitial, | |
| if initialShapeCode p = u then | |
| (initialMultiplicity (sortedInitial.get p.1) : ℝ) else 0) = 6 := by | |
| exact_mod_cast weighted_fiber_count u hu | |
| simp only [orderedInitialLaw, FiniteLaw.map_mass, placedInitialLaw_mass] | |
| calc | |
| _ = (∑ p : PlacedInitial, if initialShapeCode p = u then | |
| (initialMultiplicity (sortedInitial.get p.1) : ℝ) else 0) * | |
| (orderedWeight u / initialNormalizer / 6) := by | |
| rw [Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro p _ | |
| by_cases hp : initialShapeCode p = u | |
| · simp only [hp, ite_true] | |
| ring | |
| · simp only [hp, ite_false, zero_mul] | |
| _ = _ := by rw [hcount]; ring | |
| theorem orderedInitialLaw_zero (u : JointPopulation.Shape) | |
| (hu : u.1.val + u.2.1.val + u.2.2.val ≠ 16) : | |
| orderedInitialLaw.mass u = 0 := by | |
| classical | |
| simp only [orderedInitialLaw, FiniteLaw.map_mass] | |
| apply Finset.sum_eq_zero | |
| intro p _ | |
| apply ite_eq_right | |
| intro hp | |
| have ht := source_total p | |
| rw [hp] at ht | |
| exact hu ht | |
| theorem orderedInitialLaw_mass_eq (u : JointPopulation.Shape) : | |
| orderedInitialLaw.mass u = | |
| if u.1.val + u.2.1.val + u.2.2.val = 16 | |
| then orderedWeight u / initialNormalizer else 0 := by | |
| split_ifs with hu | |
| · exact orderedInitialLaw_mass u hu | |
| · exact orderedInitialLaw_zero u hu | |
| theorem orderedInitialLaw_positive (u : JointPopulation.Shape) | |
| (hu : u.1.val + u.2.1.val + u.2.2.val = 16) : | |
| 0 < orderedInitialLaw.mass u := by | |
| rw [orderedInitialLaw_mass u hu] | |
| exact div_pos (orderedWeight_pos u) initialNormalizer_pos | |
| theorem orderedInitialLaw_support (u : JointPopulation.Shape) | |
| (hu : 0 < orderedInitialLaw.mass u) : | |
| u.1.val + u.2.1.val + u.2.2.val = 16 := by | |
| by_contra hn | |
| rw [orderedInitialLaw_zero u hn] at hu | |
| exact lt_irrefl _ hu | |
| theorem log_orderedWeight (u : JointPopulation.Shape) : | |
| Real.log (orderedWeight u) = | |
| initialPotential (JointPopulation.shapeSide 0 u) + | |
| initialPotential (JointPopulation.shapeSide 1 u) + | |
| initialPotential (JointPopulation.shapeSide 2 u) := by | |
| rw [orderedWeight, Real.log_prod | |
| (fun s _ => ne_of_gt (coordinateWeight_pos (JointPopulation.shapeSide s u)))] | |
| simp only [Fin.sum_univ_three, initialPotential] | |
| theorem orderedInitialLaw_log (u : JointPopulation.Shape) | |
| (hu : 0 < orderedInitialLaw.mass u) : | |
| Real.log (orderedInitialLaw.mass u) = | |
| initialPotential (JointPopulation.shapeSide 0 u) + | |
| initialPotential (JointPopulation.shapeSide 1 u) + | |
| initialPotential (JointPopulation.shapeSide 2 u) - initialLogNormalizer := by | |
| rw [orderedInitialLaw_mass u (orderedInitialLaw_support u hu), | |
| Real.log_div (ne_of_gt (orderedWeight_pos u)) (ne_of_gt initialNormalizer_pos), | |
| log_orderedWeight] | |
| rfl | |
| end MatrixMultiplication.AllFieldInitialGibbs | |
| end | |
| end OAI | |