openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /FieldConstruction /ActiveGibbs.lean
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.ActiveLaws | |
| import Mathlib.Data.Rat.BigOperators | |
| namespace OAI | |
| /-! Tensor extraction over arbitrary fields and its asymptotic rate. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.AllFieldActiveGibbs | |
| open AllFieldParameters AllFieldHistory AllFieldActiveLaws MatrixMultiplication.Foundation | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| def splitCoordinateWeight (parents : List Shape) (data : List ℤ) | |
| (s : Shape) (i : Fin 3) (k : ℕ) : ℝ := | |
| (weight (assigned (splitKeys parents) data (s, i, min k (s i - k))) : ℝ) | |
| def splitPotential (parents : List Shape) (data : List ℤ) | |
| (s : Shape) (i : Fin 3) (k : ℕ) : ℝ := | |
| Real.log (splitCoordinateWeight parents data s i k) | |
| def splitNormalizer (parents : List Shape) (data : List ℤ) (s : Shape) : ℝ := | |
| (((below s).map (splitWeight parents data s)).sum : ℚ) | |
| def splitLogNormalizer (parents : List Shape) (data : List ℤ) (s : Shape) : ℝ := | |
| Real.log (splitNormalizer parents data s) | |
| theorem splitCoordinateWeight_pos (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s : Shape) (i : Fin 3) (k : ℕ) : | |
| 0 < splitCoordinateWeight parents data s i k := by | |
| apply Rat.cast_pos.mpr | |
| exact weight_positive_of_argument_bound _ (assigned_argument_bound _ data hd _) | |
| theorem splitNormalizer_pos (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s : Shape) (hne : below s ≠ []) : | |
| 0 < splitNormalizer parents data s := by | |
| apply Rat.cast_pos.mpr | |
| exact list_sum_map_positive _ _ hne (fun u _ => splitWeight_positive parents data hd s u) | |
| theorem splitWeight_log (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) : | |
| Real.log (splitWeight parents data s u : ℝ) = | |
| ∑ i : Fin 3, splitPotential parents data s i (u i) := by | |
| have hweight (i : Fin 3) : (weight (splitSignature parents data s u i) : ℝ) ≠ 0 := | |
| ne_of_gt (splitCoordinateWeight_pos parents data hd s i (u i)) | |
| rw [splitWeight, Rat.cast_prod, Real.log_prod (s := Finset.univ) (fun i _ => hweight i)] | |
| rfl | |
| theorem splitLaw_log (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) (hu : u ∈ below s) : | |
| Real.log (splitLaw parents data s u : ℝ) = | |
| (∑ i : Fin 3, splitPotential parents data s i (u i)) - | |
| splitLogNormalizer parents data s := by | |
| have hweight : (splitWeight parents data s u : ℝ) ≠ 0 := by | |
| exact_mod_cast ne_of_gt (splitWeight_positive parents data hd s u) | |
| have hne : below s ≠ [] := by | |
| intro he | |
| simp only [he, List.not_mem_nil] at hu | |
| have hnormal := ne_of_gt (splitNormalizer_pos parents data hd s hne) | |
| rw [splitLaw, ite_eq_left hu, Rat.cast_div] | |
| change Real.log ((splitWeight parents data s u : ℝ) / splitNormalizer parents data s) = _ | |
| rw [Real.log_div hweight hnormal, splitWeight_log parents data hd] | |
| rfl | |
| theorem splitLaw_positive_iff (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) : | |
| 0 < (splitLaw parents data s u : ℝ) ↔ u ∈ below s := by | |
| constructor | |
| · intro hp | |
| by_contra hu | |
| rw [splitLaw_outside_support parents data s u hu] at hp | |
| norm_num at hp | |
| · intro hu | |
| exact_mod_cast splitLaw_positive parents data hd s u hu | |
| def physicalPotential (parents : List Shape) (data : List ℤ) (s : Shape) | |
| (phi : Placement) (i : Fin 3) (k : Fin 17) : ℝ := | |
| splitPotential parents data s (phi.symm i) k.val | |
| theorem splitLaw_log_physical (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) (hu : u ∈ below s) | |
| (hb : ShapeBounded u) (phi : Placement) : | |
| Real.log (splitLaw parents data s u : ℝ) = | |
| physicalPotential parents data s phi 0 (JointPopulation.shapeSide 0 (encodePhysicalShape phi u hb)) + | |
| physicalPotential parents data s phi 1 (JointPopulation.shapeSide 1 (encodePhysicalShape phi u hb)) + | |
| physicalPotential parents data s phi 2 (JointPopulation.shapeSide 2 (encodePhysicalShape phi u hb)) - | |
| splitLogNormalizer parents data s := by | |
| rw [splitLaw_log parents data hd s u hu] | |
| have hsum : (∑ i : Fin 3, splitPotential parents data s i (u i)) = | |
| ∑ i : Fin 3, physicalPotential parents data s phi i | |
| (JointPopulation.shapeSide i (encodePhysicalShape phi u hb)) := by | |
| simp only [physicalPotential, encodePhysicalShape_side] | |
| exact (phi.symm.sum_comp (fun i => splitPotential parents data s i (u i))).symm | |
| rw [hsum, Fin.sum_univ_three] | |
| theorem placedLaw_positive_has_branch {K : ℕ} (w : PlacedWork K) | |
| (u : JointPopulation.Shape) (hu : 0 < (placedLaw w).mass u) : | |
| ∃ b : w.1.Branch, branchShape w b = u := by | |
| by_contra hn | |
| have hz : (placedLaw w).mass u = 0 := by | |
| rw [placedLaw_mass] | |
| apply Finset.sum_eq_zero | |
| intro b _ | |
| exact ite_eq_right (fun hb => hn ⟨b, hb⟩) | |
| rw [hz] at hu | |
| exact lt_irrefl 0 hu | |
| theorem placedLaw_stageA_branch_log {K : ℕ} (h : InitialPositive K) | |
| (phi : Placement) (b : ASplit h) : | |
| Real.log ((placedLaw (Work.stageA h, phi)).mass (branchShape (Work.stageA h, phi) b)) = | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 0 | |
| (JointPopulation.shapeSide 0 (branchShape (Work.stageA h, phi) b)) + | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 1 | |
| (JointPopulation.shapeSide 1 (branchShape (Work.stageA h, phi) b)) + | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 2 | |
| (JointPopulation.shapeSide 2 (branchShape (Work.stageA h, phi) b)) - | |
| splitLogNormalizer positiveInitial tableP (initialShape h.val) := by | |
| change (Work.stageA h).Branch at b | |
| rw [placedLaw_mass_branch] | |
| exact splitLaw_log_physical positiveInitial tableP stageA_table_arguments_bounded | |
| (initialShape h.val) (aSplit ⟨h, b, false⟩) (aSplit_mem ⟨h, b, false⟩) | |
| ((Work.stageA h).splitShape_spec b).1 phi | |
| theorem placedLaw_stageB_branch_log {K : ℕ} (h : APositive K) | |
| (phi : Placement) (b : BSplit h) : | |
| Real.log ((placedLaw (Work.stageB h, phi)).mass (branchShape (Work.stageB h, phi) b)) = | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 0 | |
| (JointPopulation.shapeSide 0 (branchShape (Work.stageB h, phi) b)) + | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 1 | |
| (JointPopulation.shapeSide 1 (branchShape (Work.stageB h, phi) b)) + | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 2 | |
| (JointPopulation.shapeSide 2 (branchShape (Work.stageB h, phi) b)) - | |
| splitLogNormalizer positiveSecond tablep (aShape h.val) := by | |
| change (Work.stageB h).Branch at b | |
| rw [placedLaw_mass_branch] | |
| exact splitLaw_log_physical positiveSecond tablep stageB_table_arguments_bounded | |
| (aShape h.val) (bSplit ⟨h, b, false⟩) (bSplit_mem ⟨h, b, false⟩) | |
| ((Work.stageB h).splitShape_spec b).1 phi | |
| theorem placedLaw_stageA_log {K : ℕ} (h : InitialPositive K) (phi : Placement) | |
| (u : JointPopulation.Shape) (hu : 0 < (placedLaw (Work.stageA h, phi)).mass u) : | |
| Real.log ((placedLaw (Work.stageA h, phi)).mass u) = | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 0 (JointPopulation.shapeSide 0 u) + | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 1 (JointPopulation.shapeSide 1 u) + | |
| physicalPotential positiveInitial tableP (initialShape h.val) phi 2 (JointPopulation.shapeSide 2 u) - | |
| splitLogNormalizer positiveInitial tableP (initialShape h.val) := by | |
| obtain ⟨b, rfl⟩ := placedLaw_positive_has_branch (Work.stageA h, phi) u hu | |
| exact placedLaw_stageA_branch_log h phi b | |
| theorem placedLaw_stageB_log {K : ℕ} (h : APositive K) (phi : Placement) | |
| (u : JointPopulation.Shape) (hu : 0 < (placedLaw (Work.stageB h, phi)).mass u) : | |
| Real.log ((placedLaw (Work.stageB h, phi)).mass u) = | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 0 (JointPopulation.shapeSide 0 u) + | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 1 (JointPopulation.shapeSide 1 u) + | |
| physicalPotential positiveSecond tablep (aShape h.val) phi 2 (JointPopulation.shapeSide 2 u) - | |
| splitLogNormalizer positiveSecond tablep (aShape h.val) := by | |
| obtain ⟨b, rfl⟩ := placedLaw_positive_has_branch (Work.stageB h, phi) u hu | |
| exact placedLaw_stageB_branch_log h phi b | |
| theorem mem_shapes_of_total (u : Shape) (n : ℕ) | |
| (h : shapeTotal u = n) : u ∈ shapes n := by | |
| dsimp [shapeTotal] at h | |
| simp only [shapes, List.mem_flatMap, List.mem_map, List.mem_range] | |
| refine ⟨u 0, by omega, u 1, by omega, ?_⟩ | |
| funext i | |
| fin_cases i | |
| · rfl | |
| · rfl | |
| · change n - u 0 - u 1 = u 2 | |
| omega | |
| theorem mem_below_iff (s u : Shape) : | |
| u ∈ below s ↔ shapeTotal u = shapeTotal s / 2 ∧ ∀ i, u i ≤ s i := by | |
| constructor | |
| · intro hu | |
| exact ⟨below_total hu, below_le hu⟩ | |
| · rintro ⟨ht, hle⟩ | |
| apply List.mem_filter.mpr | |
| refine ⟨mem_shapes_of_total u _ ht, ?_⟩ | |
| simpa only [Bool.and_eq_true, decide_eq_true_eq, and_assoc] using | |
| And.intro (hle 0) (And.intro (hle 1) (hle 2)) | |
| theorem splitShape_exhaustive {K : ℕ} (w : Work K) | |
| (u : Shape) (hu : u ∈ below w.parentShape) : | |
| ∃ b : w.Branch, w.splitShape b = u := by | |
| cases w with | |
| | stageA h => | |
| change u ∈ below (initialShape h.val) at hu | |
| obtain ⟨b, hb⟩ := List.mem_iff_get.mp hu | |
| exact ⟨b, hb⟩ | |
| | stageB h => | |
| change u ∈ below (aShape h.val) at hu | |
| obtain ⟨b, hb⟩ := List.mem_iff_get.mp hu | |
| exact ⟨b, hb⟩ | |
| | stageC h => | |
| exact stageCAtom_exhaustive _ (bShape_size h.1.val) h.1.property u hu | |
| theorem branchShape_exhaustive {K : ℕ} (w : PlacedWork K) | |
| (u : JointPopulation.Shape) | |
| (ht : u.1.val + u.2.1.val + u.2.2.val = 2 * w.1.halfLength) | |
| (hle : ∀ i, (JointPopulation.shapeSide i u).val ≤ | |
| physicalShape w.2 w.1.parentShape i) : | |
| ∃ b : w.1.Branch, branchShape w b = u := by | |
| let v : Shape := physicalShape w.2.symm (decodeShape u) | |
| have hvt : shapeTotal v = 2 * w.1.halfLength := by | |
| dsimp [v] | |
| rw [physicalShape_total] | |
| exact ht | |
| have hvl : ∀ i, v i ≤ w.1.parentShape i := by | |
| intro i | |
| simpa only [v, physicalShape, decodeShape, Equiv.symm_symm, | |
| Equiv.symm_apply_apply] using hle (w.2 i) | |
| have hv : v ∈ below w.1.parentShape := by | |
| apply (mem_below_iff _ _).2 | |
| refine ⟨?_, hvl⟩ | |
| rw [hvt, (w.1.parentShape_spec).2] | |
| omega | |
| obtain ⟨b, hb⟩ := splitShape_exhaustive w.1 v hv | |
| refine ⟨b, ?_⟩ | |
| have hd : decodeShape (branchShape w b) = decodeShape u := by | |
| rw [branchShape, decode_encodePhysicalShape, hb] | |
| funext i | |
| simp only [v, physicalShape, Equiv.symm_symm, Equiv.apply_symm_apply] | |
| apply Prod.ext | |
| · exact Fin.ext (congrFun hd 0) | |
| · apply Prod.ext | |
| · exact Fin.ext (congrFun hd 1) | |
| · exact Fin.ext (congrFun hd 2) | |
| theorem placedLaw_stageA_positive {K : ℕ} (h : InitialPositive K) (phi : Placement) | |
| (u : JointPopulation.Shape) (ht : u.1.val + u.2.1.val + u.2.2.val = 8) | |
| (hle : ∀ i, (JointPopulation.shapeSide i u).val ≤ | |
| physicalShape phi (initialShape h.val) i) : | |
| 0 < (placedLaw (Work.stageA h, phi)).mass u := by | |
| obtain ⟨b, rfl⟩ := branchShape_exhaustive (Work.stageA h, phi) u ht hle | |
| rw [placedLaw_mass_branch] | |
| exact_mod_cast stageALaw_positive (initialShape h.val) (aSplit ⟨h, b, false⟩) | |
| (aSplit_mem ⟨h, b, false⟩) | |
| theorem placedLaw_stageB_positive {K : ℕ} (h : APositive K) (phi : Placement) | |
| (u : JointPopulation.Shape) (ht : u.1.val + u.2.1.val + u.2.2.val = 4) | |
| (hle : ∀ i, (JointPopulation.shapeSide i u).val ≤ | |
| physicalShape phi (aShape h.val) i) : | |
| 0 < (placedLaw (Work.stageB h, phi)).mass u := by | |
| obtain ⟨b, rfl⟩ := branchShape_exhaustive (Work.stageB h, phi) u ht hle | |
| rw [placedLaw_mass_branch] | |
| exact_mod_cast stageBLaw_positive (aShape h.val) (bSplit ⟨h, b, false⟩) | |
| (bSplit_mem ⟨h, b, false⟩) | |
| end MatrixMultiplication.AllFieldActiveGibbs | |
| end | |
| end OAI | |