| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.Staggering |
| import Mathlib.Algebra.BigOperators.Group.Finset.Basic |
| import Mathlib.Data.Fintype.Perm |
|
|
| namespace OAI |
|
|
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ |
|
|
| open scoped BigOperators |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.PhysicalOrders |
|
|
| open Staggering |
|
|
| abbrev PhysicalOrder := Equiv.Perm (Fin 3) |
|
|
| theorem card_physical_orders : Fintype.card PhysicalOrder = 6 := by |
| norm_num [PhysicalOrder, Fintype.card_perm, Nat.factorial_succ] |
|
|
| def placementAmount (amount : ℝ) (_phi : PhysicalOrder) : ℝ := amount / 6 |
|
|
| theorem placementAmount_eq (amount : ℝ) (phi psi : PhysicalOrder) : |
| placementAmount amount phi = placementAmount amount psi := rfl |
|
|
| theorem sum_placementAmount (amount : ℝ) : |
| ∑ phi : PhysicalOrder, placementAmount amount phi = amount := by |
| simp only [placementAmount, Finset.sum_const, Finset.card_univ, |
| card_physical_orders, nsmul_eq_mul] |
| norm_num |
| ring |
|
|
| theorem placement_has_unique_order (rho phi : PhysicalOrder) : |
| ∃! sigma : PhysicalOrder, rho.trans phi = sigma := by |
| refine ⟨rho.trans phi, rfl, ?_⟩ |
| intro sigma hsigma |
| exact hsigma.symm |
|
|
| theorem sum_selected_placement (rho sigma : PhysicalOrder) (value : ℝ) : |
| (∑ phi : PhysicalOrder, if rho.trans phi = sigma then value else 0) = value := by |
| classical |
| obtain ⟨phi, hphi, hunique⟩ := physical_order_unique rho sigma |
| calc |
| _ = ∑ psi : PhysicalOrder, if psi = phi then value else 0 := by |
| apply Finset.sum_congr rfl |
| intro psi _ |
| have hiff : rho.trans psi = sigma ↔ psi = phi := by |
| constructor |
| · exact hunique psi |
| · rintro rfl |
| exact hphi |
| simp only [hiff] |
| _ = value := by simp |
|
|
| variable {History : Type*} [Fintype History] |
|
|
| def aggregateCapacity (amount : History → ℝ) (capacity : History → Capacity) : Capacity := |
| fun i => ∑ h, amount h * capacity h i |
|
|
| def perPhysicalOrderCapacity (amount : History → ℝ) (capacity : History → Capacity) |
| (priority : History → PhysicalOrder) (sigma : PhysicalOrder) : Capacity := by |
| classical |
| exact fun i => ∑ h, ∑ phi : PhysicalOrder, |
| if (priority h).trans phi = sigma then amount h / 6 * capacity h i else 0 |
|
|
| theorem perPhysicalOrderCapacity_apply (amount : History → ℝ) |
| (capacity : History → Capacity) (priority : History → PhysicalOrder) |
| (sigma : PhysicalOrder) (i : Fin 3) : |
| perPhysicalOrderCapacity amount capacity priority sigma i = |
| (1 / 6 : ℝ) * aggregateCapacity amount capacity i := by |
| classical |
| unfold perPhysicalOrderCapacity aggregateCapacity |
| simp only [sum_selected_placement] |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro h _ |
| ring |
|
|
| theorem perPhysicalOrderCapacity_eq (amount : History → ℝ) |
| (capacity : History → Capacity) (priority : History → PhysicalOrder) |
| (sigma : PhysicalOrder) : |
| perPhysicalOrderCapacity amount capacity priority sigma = |
| fun i => (1 / 6 : ℝ) * aggregateCapacity amount capacity i := by |
| funext i |
| exact perPhysicalOrderCapacity_apply amount capacity priority sigma i |
|
|
| theorem minCapacity_mul (a : Capacity) (r : ℝ) (hr : 0 ≤ r) : |
| minCapacity (fun i => r * a i) = r * minCapacity a := by |
| unfold minCapacity |
| rw [mul_min_of_nonneg _ _ hr, mul_min_of_nonneg _ _ hr] |
|
|
| theorem sum_physical_order_minima (amount : History → ℝ) |
| (capacity : History → Capacity) (priority : History → PhysicalOrder) : |
| (∑ sigma : PhysicalOrder, |
| minCapacity (perPhysicalOrderCapacity amount capacity priority sigma)) = |
| minCapacity (aggregateCapacity amount capacity) := by |
| simp_rw [perPhysicalOrderCapacity_eq, |
| minCapacity_mul _ (1 / 6 : ℝ) (by norm_num)] |
| simp only [Finset.sum_const, Finset.card_univ, card_physical_orders, nsmul_eq_mul] |
| norm_num |
| ring |
|
|
| end MatrixMultiplication.PhysicalOrders |
|
|
| end |
|
|
| end OAI |
|
|
