| import Mathlib.Data.List.OfFn |
| import OAI.NumberTheory.Ostmann.Conclusion.BulkPermutation |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace Ostmann.Conclusion |
| open Construction |
|
|
| def initialBulkSlots (m : ℕ) : List SourceSlot := |
| List.ofFn (fun i : Fin m => ⟨.bulk,i.val⟩) |
|
|
| @[simp] theorem initialBulkSlots_length (m : ℕ) : (initialBulkSlots m).length=m := by |
| simp [initialBulkSlots] |
|
|
| @[simp] theorem initial_bulk_role_iff (m k : ℕ) (i : Fin (Template.initial m k).length) : |
| (Template.initial m k)[i.val].role=.bulk ↔ i.val < m := by |
| simpa [Template.initial] using InitialCoordinatesTemplate.initialRoles_bulk_iff m k |
| ⟨i.val,by simpa [Template.initial] using i.isLt⟩ |
|
|
| @[simp] theorem initial_bulk_origin (m k : ℕ) (i : Fin (Template.initial m k).length) : |
| (Template.initial m k)[i.val].origin=i.val := by simp [Template.initial] |
|
|
| theorem initial_take_bulk (m k : ℕ) : (Template.initial m k).take m=initialBulkSlots m := by |
| apply List.ext_getElem |
| · simp [InitialCoordinatesTemplate.initial_length] |
| omega |
| · intro i hi hj |
| have him : i < m := by simpa using hj |
| have hiT : i<(Template.initial m k).length := by |
| rw [InitialCoordinatesTemplate.initial_length] |
| omega |
| have hr := (initial_bulk_role_iff m k ⟨i,hiT⟩).mpr him |
| simpa [initialBulkSlots,List.getElem_take,Template.initial] using hr |
|
|
| def bulkLeafTail (m k : ℕ) : ℕ → List SourceSlot |
| | 0 => (Template.initial m k).drop m |
| | l+1 => Template.remainder (l+1) (bulkLeafTail m k l) |
|
|
| def bulkLeafTemplate (m k l : ℕ) : List SourceSlot := |
| initialBulkSlots m ++ bulkLeafTail m k l |
|
|
| @[simp] theorem bulkLeafTemplate_zero (m k : ℕ) : bulkLeafTemplate m k 0=Template.initial m k := by |
| rw [bulkLeafTemplate,bulkLeafTail,← initial_take_bulk,List.take_append_drop] |
|
|
| @[simp] theorem bulkLeafTemplate_succ (m k l : ℕ) : |
| bulkLeafTemplate m k (l+1)=Template.remainder (l+1) (bulkLeafTemplate m k l) := by |
| have hp : (initialBulkSlots m).filter |
| (fun q => decide (q.role ≠ SlotRole.compensation (l+1)))=initialBulkSlots m := by |
| apply List.filter_eq_self.mpr |
| intro q hq |
| obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hq |
| simp |
| simp only [bulkLeafTemplate,bulkLeafTail,Template.remainder,List.filter_append,hp] |
|
|
| theorem bulkLeafTail_not_bulk (m k l : ℕ) : ∀q∈bulkLeafTail m k l,q.role≠.bulk := by |
| induction l with |
| | zero => |
| intro q hq hr |
| obtain ⟨i,hi,rfl⟩ := List.mem_iff_getElem.mp hq |
| have hiT : m+i<(Template.initial m k).length := by |
| simp only [bulkLeafTail,List.length_drop] at hi |
| omega |
| have hri : (Template.initial m k)[m+i].role=.bulk := by |
| simpa only [bulkLeafTail,List.getElem_drop] using hr |
| have hh := (initial_bulk_role_iff m k ⟨m+i,hiT⟩).mp hri |
| change m+i < m at hh |
| omega |
| | succ l ih => |
| intro q hq |
| exact ih q (List.mem_filter.mp hq).1 |
|
|
| @[simp] theorem bulkLeafTemplate_bulk_iff (m k l : ℕ) |
| (i : Fin (bulkLeafTemplate m k l).length) : |
| (bulkLeafTemplate m k l)[i.val].role=.bulk ↔ i.val < m := by |
| by_cases hi : i.val < m |
| · have hh : i.val<(initialBulkSlots m).length := by simpa using hi |
| simp only [bulkLeafTemplate,List.getElem_append_left hh] |
| simp [initialBulkSlots,hi] |
| · have hh : (initialBulkSlots m).length ≤ i.val := by simpa using Nat.le_of_not_gt hi |
| have hr := bulkLeafTail_not_bulk m k l _ (List.getElem_mem |
| (show i.val-(initialBulkSlots m).length<(bulkLeafTail m k l).length by |
| have := i.isLt |
| simp only [bulkLeafTemplate,List.length_append,initialBulkSlots_length] at * |
| omega)) |
| simp only [bulkLeafTemplate,List.getElem_append_right hh] |
| exact iff_of_false hr hi |
|
|
| @[simp] theorem bulkLeafTemplate_bulk_origin (m k l : ℕ) |
| (i : Fin (bulkLeafTemplate m k l).length) (hi : i.val < m) : |
| (bulkLeafTemplate m k l)[i.val].origin=i.val := by |
| simp only [bulkLeafTemplate] |
| rw [List.getElem_append_left (by simpa using hi)] |
| simp [initialBulkSlots] |
|
|
| theorem current_eq_bulkLeafBlocks (m k l : ℕ) : |
| Template.current (Template.initial m k) l= |
| (List.replicate (2^l) (bulkLeafTemplate m k l)).flatten := by |
| induction l with |
| | zero => simp [Template.current] |
| | succ l ih => |
| simp only [Template.current,ih,Template.remainder,List.filter_flatten,List.map_replicate] |
| have he := (bulkLeafTemplate_succ m k l).symm |
| unfold Template.remainder at he |
| rw [he] |
| rw [← List.flatten_append,← List.replicate_add] |
| congr 2 |
| simp [pow_succ] |
| omega |
|
|
| @[simp] theorem current_bulk_block_length (m k l : ℕ) : |
| (Template.current (Template.initial m k) l).length= |
| 2^l*(bulkLeafTemplate m k l).length := by |
| rw [current_eq_bulkLeafBlocks] |
| simp [List.length_flatten,List.map_replicate] |
|
|
| end Ostmann.Conclusion |
|
|
| end |
|
|
| end OAI |
|
|
