| import OAI.Algebra.Finitistic.Bar.SignedBlockModel |
|
|
| namespace OAI |
| noncomputable section |
| namespace DerivedBar.Multibar |
|
|
| /-- The first X uniquely determines the length of the preceding D block. -/ |
| theorem base_run_injective (i j : ℕ) (p q : List Bool) |
| (h : List.replicate i false ++ true :: p = List.replicate j false ++ true :: q) : |
| i=j ∧ p=q := by |
| induction i generalizing j with |
| | zero => |
| cases j with |
| | zero => simpa using h |
| | succ j => simp [List.replicate_succ] at h |
| | succ i ih => |
| cases j with |
| | zero => simp [List.replicate_succ] at h |
| | succ j => |
| have ht : List.replicate i false ++ true :: p = List.replicate j false ++ true :: q := by |
| simpa only [List.replicate_succ, List.cons_append, List.cons.injEq, true_and] using h |
| obtain ⟨hij,hpq⟩ := ih j ht |
| exact ⟨congrArg Nat.succ hij,hpq⟩ |
|
|
| /-- Consecutive block lengths have a unique literal D/X word. -/ |
| theorem pattern_injective (r : ℕ) : Function.Injective (pattern r) := by |
| induction r with |
| | zero => |
| intro i j h |
| change List.replicate i false = List.replicate j false at h |
| exact List.length_replicate.symm.trans ((congrArg List.length h).trans List.length_replicate) |
| | succ r ih => |
| rintro ⟨i,p⟩ ⟨j,q⟩ h |
| obtain ⟨hij,hpq⟩ := base_run_injective i j (pattern r p) (pattern r q) h |
| exact Prod.ext hij (ih hpq) |
|
|
| /-- Parse a word of a specified count without changing its block data. -/ |
| def parseOfCount (r : ℕ) (p : List Bool) (h : count p=r) : Blocks r := h ▸ parse p |
|
|
| @[simp] theorem pattern_parseOfCount (r : ℕ) (p : List Bool) (h : count p=r) : |
| pattern r (parseOfCount r p h) = p := by |
| subst r |
| exact pattern_parse p |
|
|
| @[simp] theorem parseOfCount_pattern (r : ℕ) (b : Blocks r) : |
| parseOfCount r (pattern r b) (count_pattern r b) = b := by |
| apply pattern_injective r |
| simp |
|
|
| namespace Indexed |
|
|
| def shapeOfList : (p : List Bool) → Shape p.length (count p) |
| | [] => .nil |
| | false :: p => .base (shapeOfList p) |
| | true :: p => .ideal (shapeOfList p) |
|
|
| @[simp] theorem toList_shapeOfList (p : List Bool) : toList (shapeOfList p) = p := by |
| induction p with |
| | nil => rfl |
| | cons b p ih => |
| cases b with |
| | false => exact congrArg (false :: ·) ih |
| | true => exact congrArg (true :: ·) ih |
|
|
| def castShape {n m r s : ℕ} (hn : n=m) (hr : r=s) (p : Shape n r) : Shape m s := hn ▸ hr ▸ p |
|
|
| @[simp] theorem toList_castShape {n m r s : ℕ} (hn : n=m) (hr : r=s) (p : Shape n r) : |
| toList (castShape hn hr p) = toList p := by |
| subst m s |
| rfl |
|
|
| /-- Construct the degree-indexed tensor shape of a tuple of block lengths. -/ |
| def shapeOfBlocks (r : ℕ) (b : Blocks r) : Shape (r+total r b) r := |
| castShape (length_pattern r b) (count_pattern r b) (shapeOfList (pattern r b)) |
|
|
| @[simp] theorem toList_shapeOfBlocks (r : ℕ) (b : Blocks r) : |
| toList (shapeOfBlocks r b) = pattern r b := by |
| simp [shapeOfBlocks] |
|
|
| def blocksOfShape {n r : ℕ} (p : Shape n r) : Blocks r := |
| parseOfCount r (toList p) (count_toList p) |
|
|
| @[simp] theorem pattern_blocksOfShape {n r : ℕ} (p : Shape n r) : |
| pattern r (blocksOfShape p) = toList p := by simp [blocksOfShape] |
|
|
| theorem total_blocksOfShape {n r : ℕ} (p : Shape n r) : r+total r (blocksOfShape p)=n := by |
| have h := length_pattern r (blocksOfShape p) |
| rw [pattern_blocksOfShape, length_toList] at h |
| exact h.symm |
|
|
| /-- Reindex the finite block-length diagonal by the existing tensor shapes. |
| The shift by r occurs in the degree, not in a hidden tensor-power replacement. -/ |
| def blockDegreeEquiv (r m : ℕ) : {b : Blocks r // total r b=m} ≃ Shape (r+m) r where |
| toFun b := castShape (congrArg (r+·) b.property) rfl (shapeOfBlocks r b.val) |
| invFun p := ⟨blocksOfShape p, by have := total_blocksOfShape p; omega⟩ |
| left_inv b := by |
| apply Subtype.ext |
| apply pattern_injective r |
| simp |
| right_inv p := by |
| apply toList_injective |
| simp |
| end Indexed |
| end DerivedBar.Multibar |
|
|
| end |
|
|
| end OAI |
|
|
