openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /FieldConstruction /ActiveSums.lean
| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.Priority | |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.Sums | |
| namespace OAI | |
| /-! Tensor extraction over arbitrary fields and its asymptotic rate. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.AllFieldHistory | |
| open AllFieldParameters | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| private def aRelot {K L : ℕ} (lot : Fin L) (h : AfterA K) : AfterA L := | |
| ⟨⟨(lot, h.1.val.2), h.1.property⟩, h.2⟩ | |
| private def bRelot {K L : ℕ} (lot : Fin L) (h : AfterB K) : AfterB L := | |
| ⟨⟨aRelot lot h.1.val, h.1.property⟩, h.2⟩ | |
| private def partRelot {K L : ℕ} (lot : Fin L) (h : PartC K) : PartC L := | |
| (⟨bRelot lot h.1.val, h.1.property⟩, h.2) | |
| def workRelot {K L : ℕ} (lot : Fin L) : Work K → Work L | |
| | .stageA h => .stageA ⟨(lot, h.val.2), h.property⟩ | |
| | .stageB h => .stageB ⟨aRelot lot h.val, h.property⟩ | |
| | .stageC h => .stageC (partRelot lot h) | |
| @[simp] theorem workRelot_lot {K L : ℕ} (lot : Fin L) (w : Work K) : | |
| (workRelot lot w).lot = lot := by cases w <;> rfl | |
| @[simp] theorem workRelot_stage {K L : ℕ} (lot : Fin L) (w : Work K) : | |
| (workRelot lot w).stage = w.stage := by cases w <;> rfl | |
| @[simp] theorem workRelot_self {K : ℕ} (w : Work K) : workRelot w.lot w = w := by | |
| cases w <;> rfl | |
| @[simp] theorem workRelot_relot {K L M : ℕ} (first : Fin L) (last : Fin M) | |
| (w : Work K) : workRelot last (workRelot first w) = workRelot last w := by | |
| cases w <;> rfl | |
| @[simp] theorem workAmount_relot {K L : ℕ} (allocation : Allocation) | |
| (lot : Fin L) (w : Work K) : | |
| workAmount allocation (workRelot lot w) = workAmount allocation w := by | |
| cases w <;> rfl | |
| def workLotEquiv (K : ℕ) : Work K ≃ Fin K × Work 1 where | |
| toFun w := (w.lot, workRelot 0 w) | |
| invFun h := workRelot h.1 h.2 | |
| left_inv w := by simp only [workRelot_relot, workRelot_self] | |
| right_inv h := by | |
| rcases h with ⟨lot, w⟩ | |
| apply Prod.ext | |
| · exact workRelot_lot lot w | |
| · simp only [workRelot_relot] | |
| have hzero : (0 : Fin 1) = w.lot := Subsingleton.elim _ _ | |
| rw [hzero, workRelot_self] | |
| @[simp] theorem workLotEquiv_symm_apply (K : ℕ) (lot : Fin K) (w : Work 1) : | |
| (workLotEquiv K).symm (lot, w) = workRelot lot w := rfl | |
| private def workStagesEquiv (K : ℕ) : | |
| Work K ≃ InitialPositive K ⊕ APositive K ⊕ PartC K where | |
| toFun | |
| | .stageA h => .inl h | |
| | .stageB h => .inr (.inl h) | |
| | .stageC h => .inr (.inr h) | |
| invFun | |
| | .inl h => .stageA h | |
| | .inr (.inl h) => .stageB h | |
| | .inr (.inr h) => .stageC h | |
| left_inv w := by cases w <;> rfl | |
| right_inv h := by rcases h with h | h | h <;> rfl | |
| private theorem work_sum {K : ℕ} (f : Work K → ℝ) : | |
| (∑ w, f w) = (∑ h : InitialPositive K, f (.stageA h)) + | |
| (∑ h : APositive K, f (.stageB h)) + (∑ h : PartC K, f (.stageC h)) := by | |
| calc | |
| _ = ∑ h : InitialPositive K ⊕ APositive K ⊕ PartC K, | |
| f ((workStagesEquiv K).symm h) := | |
| ((workStagesEquiv K).symm.sum_comp f).symm | |
| _ = _ := by | |
| simp only [Fintype.sum_sum_type] | |
| exact (add_assoc _ _ _).symm | |
| theorem sum_lot_tick (K tick : ℕ) (stage : Fin 3) (value : ℝ) : | |
| (∑ lot : Fin K, if FiniteSchedule.lotTick lot stage = tick then value else 0) = | |
| if FiniteSchedule.stageActive K tick stage then value else 0 := by | |
| by_cases active : FiniteSchedule.stageActive K tick stage | |
| · obtain ⟨lot, hlot, unique⟩ := | |
| (FiniteSchedule.stageActive_iff_unique_lot K tick stage).mp active | |
| have he (j : Fin K) : FiniteSchedule.lotTick j stage = tick ↔ j = lot := | |
| ⟨unique j, fun h => by simpa only [h] using hlot⟩ | |
| simp only [he, ite_eq_left active] | |
| simp | |
| · have hn (lot : Fin K) : FiniteSchedule.lotTick lot stage ≠ tick := by | |
| intro h | |
| exact active (h ▸ FiniteSchedule.lot_active_at_its_tick lot stage) | |
| simp only [hn, ite_eq_right active, ite_false, Finset.sum_const_zero] | |
| def shapeValue {K : ℕ} (fA fB : Shape → ℝ) | |
| (fC : Shape → Shape → Fin 3 → ℝ) : Work K → ℝ | |
| | .stageA h => fA (initialShape h.val) | |
| | .stageB h => fB (aShape h.val) | |
| | .stageC h => fC (cParameterParent h) (cShapeParent h) h.2 | |
| @[simp] theorem shapeValue_relot {K L : ℕ} (fA fB : Shape → ℝ) | |
| (fC : Shape → Shape → Fin 3 → ℝ) (lot : Fin L) (w : Work K) : | |
| shapeValue fA fB fC (workRelot lot w) = shapeValue fA fB fC w := by | |
| cases w <;> rfl | |
| def stageASourceSum (fA : Shape → ℝ) : ℝ := | |
| (positiveInitial.map (fun g => (initialLaw g : ℝ) * fA g)).sum | |
| def stageBSourceSum (fB : Shape → ℝ) : ℝ := | |
| (positiveSecond.map (fun t => (secondMass t : ℝ) * fB t)).sum | |
| def stageCSourceSum (allocation : Allocation) (fC : Shape → Shape → Fin 3 → ℝ) : ℝ := | |
| (positiveSecond.map (fun t => (((below t).filter positive).map (fun u => | |
| (littleMass t u : ℝ) * ∑ part : Fin 3, (allocation.mass part : ℝ) * fC t u part)).sum)).sum | |
| theorem stageA_one_lot_sum (fA : Shape → ℝ) : | |
| (∑ h : InitialPositive 1, (initialAmount h.val : ℝ) * fA (initialShape h.val)) = | |
| stageASourceSum fA := by | |
| simpa only [Nat.cast_one, one_mul, initialAmount, stageASourceSum] using | |
| initial_positive_sum 1 (fun g => (initialLaw g : ℝ) * fA g) | |
| theorem stageB_one_lot_sum (fB : Shape → ℝ) : | |
| (∑ h : APositive 1, (aAmount h.val : ℝ) * fB (aShape h.val)) = | |
| stageBSourceSum fB := by | |
| simpa only [Nat.cast_one, one_mul, stageBSourceSum] using a_positive_history_sum 1 fB | |
| theorem stageC_one_lot_sum (allocation : Allocation) (fC : Shape → Shape → Fin 3 → ℝ) : | |
| (∑ h : PartC 1, (partAmount allocation h : ℝ) * | |
| fC (cParameterParent h) (cShapeParent h) h.2) = stageCSourceSum allocation fC := by | |
| simp only [Fintype.sum_prod_type, partAmount, Rat.cast_mul, | |
| cParameterParent, cShapeParent, mul_assoc, ← Finset.mul_sum] | |
| simpa only [Nat.cast_one, one_mul, stageCSourceSum] using | |
| b_positive_history_sum 1 (fun t u => ∑ part : Fin 3, | |
| (allocation.mass part : ℝ) * fC t u part) | |
| private theorem subtype_sum_indicator {A : Type*} [Fintype A] | |
| (P : A → Prop) [DecidablePred P] [Fintype {a // P a}] (f : A → ℝ) : | |
| (∑ a : {a // P a}, f a.val) = ∑ a, if P a then f a else 0 := by | |
| rw [← Finset.sum_filter] | |
| exact (Finset.sum_subtype _ (by simp) f).symm | |
| theorem active_shape_sum (K tick : ℕ) (allocation : Allocation) | |
| (fA fB : Shape → ℝ) (fC : Shape → Shape → Fin 3 → ℝ) : | |
| (∑ w : CanonicalActive K tick, | |
| workAmount allocation w.val * shapeValue fA fB fC w.val) = | |
| (if FiniteSchedule.stageActive K tick 0 then stageASourceSum fA else 0) + | |
| (if FiniteSchedule.stageActive K tick 1 then stageBSourceSum fB else 0) + | |
| (if FiniteSchedule.stageActive K tick 2 then stageCSourceSum allocation fC else 0) := by | |
| rw [subtype_sum_indicator | |
| (fun w : Work K => FiniteSchedule.lotTick w.lot w.stage = tick) | |
| (fun w => workAmount allocation w * shapeValue fA fB fC w)] | |
| rw [← (workLotEquiv K).symm.sum_comp | |
| (fun w => if FiniteSchedule.lotTick w.lot w.stage = tick then | |
| workAmount allocation w * shapeValue fA fB fC w else 0)] | |
| simp only [Fintype.sum_prod_type, workLotEquiv_symm_apply, workRelot_lot, | |
| workRelot_stage, workAmount_relot, shapeValue_relot] | |
| rw [Finset.sum_comm] | |
| simp only [sum_lot_tick] | |
| rw [work_sum] | |
| change | |
| (∑ h : InitialPositive 1, if FiniteSchedule.stageActive K tick 0 then | |
| (initialAmount h.val : ℝ) * fA (initialShape h.val) else 0) + | |
| (∑ h : APositive 1, if FiniteSchedule.stageActive K tick 1 then | |
| (aAmount h.val : ℝ) * fB (aShape h.val) else 0) + | |
| (∑ h : PartC 1, if FiniteSchedule.stageActive K tick 2 then | |
| (partAmount allocation h : ℝ) * fC (cParameterParent h) (cShapeParent h) h.2 else 0) = _ | |
| simp only [Finset.sum_ite_irrel, Finset.sum_const_zero] | |
| rw [stageA_one_lot_sum, stageB_one_lot_sum, stageC_one_lot_sum] | |
| def shapeCapacity {K : ℕ} (fA fB : Shape → Staggering.Capacity) | |
| (fC : Shape → Shape → Fin 3 → Staggering.Capacity) (w : Work K) : Staggering.Capacity := | |
| fun i => shapeValue (fun g => fA g i) (fun t => fB t i) (fun t u part => fC t u part i) w | |
| def stageASourceCapacity (fA : Shape → Staggering.Capacity) : Staggering.Capacity := | |
| fun i => stageASourceSum (fun g => fA g i) | |
| def stageBSourceCapacity (fB : Shape → Staggering.Capacity) : Staggering.Capacity := | |
| fun i => stageBSourceSum (fun t => fB t i) | |
| def stageCSourceCapacity (allocation : Allocation) | |
| (fC : Shape → Shape → Fin 3 → Staggering.Capacity) : Staggering.Capacity := | |
| fun i => stageCSourceSum allocation (fun t u part => fC t u part i) | |
| theorem activeAggregateCapacity_shapeCapacity (K tick : ℕ) (allocation : Allocation) | |
| (fA fB : Shape → Staggering.Capacity) | |
| (fC : Shape → Shape → Fin 3 → Staggering.Capacity) : | |
| activeAggregateCapacity allocation tick (shapeCapacity (K := K) fA fB fC) = | |
| FiniteSchedule.tickCapacity K (stageASourceCapacity fA) (stageBSourceCapacity fB) | |
| (stageCSourceCapacity allocation fC) tick := by | |
| funext i | |
| exact active_shape_sum K tick allocation (fun g => fA g i) (fun t => fB t i) | |
| (fun t u part => fC t u part i) | |
| end MatrixMultiplication.AllFieldHistory | |
| end | |
| end OAI | |