| import OAI.LinearAlgebra.MatrixMultiplication.Completion.Scripts |
| import Mathlib.Data.Fintype.Card |
| import Mathlib.Tactic.FieldSimp |
|
|
| namespace OAI |
|
|
| /-! Readable tensor completion and its finite arithmetic realization. -/ |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.CompletionPartitions |
|
|
| open MatrixMultiplication.Foundation RecursiveCompletion |
| attribute [local instance 10000] Classical.propDecidable Classical.decEq |
| attribute [local instance 11000] instDecidableEqFin |
|
|
| variable {X Y Z : Type*} [Fintype X] |
|
|
| def activeCount (S : FlaggedTensor X Y Z) : ℕ := Fintype.card {x |
| def inactiveCount (S : FlaggedTensor X Y Z) : ℕ := Fintype.card {x |
|
|
| theorem partition_count (S : FlaggedTensor X Y Z) : |
| activeCount S + inactiveCount S = Fintype.card X := by |
| rw [activeCount, inactiveCount, Fintype.card_subtype_compl] |
| exact Nat.add_sub_of_le (Fintype.card_subtype_le S.flagB) |
|
|
| theorem card_all (p : X → Prop) (m : ℕ) : |
| Fintype.card {x : Fin m → X |
| calc |
| _ = Fintype.card (Fin m → {x |
| Fintype.card_congr Equiv.subtypePiEquivPi |
| _ = _ := by simp |
|
|
| theorem activeCount_minus (S : FlaggedTensor X Y Z) (m : ℕ) : |
| activeCount (complete S .B m) = activeCount S ^ m := by |
| simpa [activeCount, complete, flagB, raisedFlag] using card_all S.flagB m |
|
|
| theorem inactiveCount_plus (S : FlaggedTensor X Y Z) (center : Color) |
| (hc : center ≠ .B) (m : ℕ) : |
| inactiveCount (complete S center m) = inactiveCount S ^ m := by |
| change Fintype.card {x : Fin m → X |
| calc |
| _ = Fintype.card {x : Fin m → X |
| Fintype.card_congr (Equiv.subtypeEquivRight fun x => by simp [raisedFlag, hc]) |
| _ = Fintype.card (Fin m → {x |
| Fintype.card_congr |
| { toFun := fun w i => ⟨w.val i, w.property i⟩ |
| invFun := fun w => ⟨fun i => (w i).val, fun i => (w i).property⟩ |
| left_inv := fun _ => rfl |
| right_inv := fun _ => rfl } |
| _ = _ := by simp [inactiveCount] |
|
|
| def activeFraction (S : FlaggedTensor X Y Z) : ℝ := |
| (activeCount S : ℝ) / Fintype.card X |
|
|
| def inactiveFraction (S : FlaggedTensor X Y Z) : ℝ := |
| (inactiveCount S : ℝ) / Fintype.card X |
|
|
| theorem fraction_sum [Nonempty X] (S : FlaggedTensor X Y Z) : |
| activeFraction S + inactiveFraction S = 1 := by |
| have hc : (Fintype.card X : ℝ) ≠ 0 := (Nat.cast_pos.mpr Fintype.card_pos).ne' |
| rw [activeFraction, inactiveFraction, ← add_div, ← Nat.cast_add, partition_count] |
| exact div_self hc |
| |
| theorem activeFraction_minus (S : FlaggedTensor X Y Z) (m : ℕ) : |
| activeFraction (complete S .B m) = activeFraction S ^ m := by |
| simp only [activeFraction, activeCount_minus, Fintype.card_fun, |
| Fintype.card_fin, Nat.cast_pow, div_pow] |
| |
| theorem inactiveFraction_plus (S : FlaggedTensor X Y Z) (center : Color) |
| (hc : center ≠ .B) (m : ℕ) : |
| inactiveFraction (complete S center m) = inactiveFraction S ^ m := by |
| simp only [inactiveFraction, inactiveCount_plus S center hc m, |
| Fintype.card_fun, Fintype.card_fin, Nat.cast_pow, div_pow] |
| |
| theorem activeFraction_plus [Nonempty X] (S : FlaggedTensor X Y Z) |
| (center : Color) (hc : center ≠ .B) (m : ℕ) : |
| activeFraction (complete S center m) = 1 - (1 - activeFraction S) ^ m := by |
| have h := fraction_sum (complete S center m) |
| rw [inactiveFraction_plus S center hc m] at h |
| have hold : inactiveFraction S = 1 - activeFraction S := by |
| linarith [fraction_sum S] |
| rw [hold] at h |
| linarith |
| |
| end MatrixMultiplication.CompletionPartitions |
| |
| end |
| |
| end OAI |
| |
