Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/FiniteSchedule.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.82 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/FiniteSchedule.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/FiniteSchedule.lean
-
curl -L -o FiniteSchedule.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/FiniteSchedule.lean
5.82 kB
| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.Staggering | |
| import Mathlib.Algebra.BigOperators.Group.Finset.Basic | |
| namespace OAI | |
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ | |
| open scoped BigOperators | |
| noncomputable section | |
| namespace MatrixMultiplication.FiniteSchedule | |
| open Staggering | |
| def lotTick {K : β} (j : Fin K) (stage : Fin 3) : β := j.val + stage.val | |
| theorem lotTick_lt {K : β} (j : Fin K) (stage : Fin 3) : | |
| lotTick j stage < K + 2 := by | |
| have hj := j.isLt | |
| have hs := stage.isLt | |
| dsimp [lotTick] | |
| omega | |
| def stageActive (K tick : β) (stage : Fin 3) : Prop := | |
| stage.val β€ tick β§ tick < K + stage.val | |
| instance (K tick : β) (stage : Fin 3) : Decidable (stageActive K tick stage) := | |
| inferInstanceAs (Decidable (stage.val β€ tick β§ tick < K + stage.val)) | |
| theorem stageActive_iff_unique_lot (K tick : β) (stage : Fin 3) : | |
| stageActive K tick stage β β! j : Fin K, lotTick j stage = tick := by | |
| constructor | |
| Β· rintro β¨hle, hltβ© | |
| refine β¨β¨tick - stage.val, by omegaβ©, ?_, ?_β© | |
| Β· dsimp [lotTick] | |
| omega | |
| Β· intro j hj | |
| apply Fin.ext | |
| dsimp [lotTick] at hj β’ | |
| omega | |
| Β· rintro β¨j, hj, _β© | |
| have hjlt := j.isLt | |
| dsimp [stageActive, lotTick] at * | |
| omega | |
| theorem lot_active_at_its_tick {K : β} (j : Fin K) (stage : Fin 3) : | |
| stageActive K (lotTick j stage) stage := by | |
| have hj := j.isLt | |
| dsimp [stageActive, lotTick] | |
| omega | |
| def tickCapacity (K : β) (a b c : Capacity) (tick : β) : Capacity := fun i => | |
| (if stageActive K tick 0 then a i else 0) + | |
| (if stageActive K tick 1 then b i else 0) + | |
| (if stageActive K tick 2 then c i else 0) | |
| theorem tickCapacity_first (K : β) (hK : 2 β€ K) (a b c : Capacity) : | |
| tickCapacity K a b c 0 = a := by | |
| funext i | |
| have h0 : 0 < K := by omega | |
| simp [tickCapacity, stageActive, h0] | |
| theorem tickCapacity_second (K : β) (hK : 2 β€ K) (a b c : Capacity) : | |
| tickCapacity K a b c 1 = fun i => a i + b i := by | |
| funext i | |
| have h1 : 1 < K := by omega | |
| have h2 : 1 < K + 1 := by omega | |
| simp [tickCapacity, stageActive, h1, h2] | |
| theorem tickCapacity_interior (K tick : β) (ht : 2 β€ tick) (htK : tick < K) | |
| (a b c : Capacity) : | |
| tickCapacity K a b c tick = fun i => a i + b i + c i := by | |
| funext i | |
| have h1 : 1 β€ tick := by omega | |
| have ht1 : tick < K + 1 := by omega | |
| have ht2 : tick < K + 2 := by omega | |
| simp [tickCapacity, stageActive, ht, htK, h1, ht1, ht2] | |
| theorem tickCapacity_penultimate (K : β) (hK : 2 β€ K) (a b c : Capacity) : | |
| tickCapacity K a b c K = fun i => b i + c i := by | |
| funext i | |
| have h1 : 1 β€ K := by omega | |
| simp [tickCapacity, stageActive, hK, h1] | |
| theorem tickCapacity_last (K : β) (hK : 2 β€ K) (a b c : Capacity) : | |
| tickCapacity K a b c (K + 1) = c := by | |
| funext i | |
| have h1 : 2 β€ K + 1 := by omega | |
| simp [tickCapacity, stageActive, h1] | |
| theorem sum_tick_minima (K : β) (hK : 2 β€ K) (a b c : Capacity) (full : β) | |
| (hfull : β i, a i + b i + c i = full) : | |
| (β tick β Finset.range (K + 2), minCapacity (tickCapacity K a b c tick)) = | |
| (K - 2 : β) * full + minCapacity a + minCapacity (fun i => a i + b i) + | |
| minCapacity (fun i => b i + c i) + minCapacity c := by | |
| let f : β β β := fun tick => minCapacity (tickCapacity K a b c tick) | |
| have hhead : β tick β Finset.range 2, f tick = | |
| minCapacity a + minCapacity (fun i => a i + b i) := by | |
| simp [f, Finset.sum_range_succ, tickCapacity_first K hK, | |
| tickCapacity_second K hK] | |
| have hinterior : (β tick β Finset.range (K - 2), f (2 + tick)) = | |
| (K - 2 : β) * full := by | |
| calc | |
| _ = β _tick β Finset.range (K - 2), full := by | |
| apply Finset.sum_congr rfl | |
| intro tick htick | |
| have hlt := Finset.mem_range.mp htick | |
| dsimp [f] | |
| rw [tickCapacity_interior K (2 + tick) (by omega) (by omega)] | |
| simp [minCapacity, hfull] | |
| _ = _ := by simp | |
| have htail : (β tick β Finset.range 2, f (K + tick)) = | |
| minCapacity (fun i => b i + c i) + minCapacity c := by | |
| simp [f, Finset.sum_range_succ, tickCapacity_penultimate K hK, | |
| tickCapacity_last K hK] | |
| change (β tick β Finset.range (K + 2), f tick) = _ | |
| rw [Finset.sum_range_add f K 2, htail] | |
| have hsplit : (β tick β Finset.range K, f tick) = | |
| (β tick β Finset.range 2, f tick) + | |
| β tick β Finset.range (K - 2), f (2 + tick) := by | |
| have hKsum : 2 + (K - 2) = K := by omega | |
| simpa only [hKsum] using Finset.sum_range_add f 2 (K - 2) | |
| rw [hsplit, hhead, hinterior] | |
| ring | |
| theorem finite_schedule_yield (K : β) (hK : 2 β€ K) (a b c : Capacity) (full : β) | |
| (hfull : β i, a i + b i + c i = full) : | |
| (β tick β Finset.range (K + 2), minCapacity (tickCapacity K a b c tick)) = | |
| (K : β) * full - boundaryDeficit a b c full := by | |
| rw [sum_tick_minima K hK a b c full hfull] | |
| exact Staggering.finite_schedule_yield a b c full K hK | |
| theorem fixed_lot_boundary_limit {Y beta w S R : β} | |
| (hfixed : β K : β, 2 β€ K β Y - beta / (K : β) + w * S / 3 β€ R) : | |
| Y + w * S / 3 β€ R := by | |
| by_contra hnot | |
| have hgap : 0 < Y + w * S / 3 - R := by linarith | |
| obtain β¨K, hKβ© := exists_nat_gt (max (beta / (Y + w * S / 3 - R)) (2 : β)) | |
| have hKtwo : (2 : β) < (K : β) := lt_of_le_of_lt (le_max_right _ _) hK | |
| have hKnat : 2 β€ K := Nat.ofNat_le_cast.mp hKtwo.le | |
| have hKpos : (0 : β) < (K : β) := by linarith | |
| have hsmall : beta / (K : β) < Y + w * S / 3 - R := by | |
| apply (div_lt_iffβ hKpos).2 | |
| have hquot : beta / (Y + w * S / 3 - R) < (K : β) := | |
| lt_of_le_of_lt (le_max_left _ _) hK | |
| simpa only [mul_comm] using (div_lt_iffβ hgap).1 hquot | |
| have hbound := hfixed K hKnat | |
| linarith | |
| end MatrixMultiplication.FiniteSchedule | |
| end | |
| end OAI | |