| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! |
| Full row and column orders extending the variable order. |
| The raw carrier is the anchor / variable / dummy sum. |
| -/ |
|
|
| universe uM uV uO |
|
|
| namespace Problem348.AnchorFrames |
|
|
| abbrev Raw (M : Type uM) (V : Type uV) (O : Type uO) := (M × Fin 64 × O) ⊕ (V ⊕ O) |
| abbrev AnchorOrder (M : Type uM) (O : Type uO) := M ×ₗ Fin 64 ×ₗ O |
| abbrev RowOrder (M : Type uM) (V : Type uV) (O : Type uO) := AnchorOrder M O ⊕ₗ (V ⊕ₗ O) |
| abbrev ColOrder (M : Type uM) (V : Type uV) (O : Type uO) := AnchorOrder M O ⊕ₗ (O ⊕ₗ V) |
|
|
| /-- Coordinates for the row order: anchors, variables, dummy. -/ |
| def rowKey {M : Type uM} {V : Type uV} {O : Type uO} : Raw M V O → RowOrder M V O |
| | .inl (t, u, x) => .inlₗ (toLex (t, toLex (u, x))) |
| | .inr (.inl v) => .inrₗ (.inlₗ v) |
| | .inr (.inr x) => .inrₗ (.inrₗ x) |
|
|
| /-- Coordinates for the column order: anchors, dummy, variables. -/ |
| def colKey {M : Type uM} {V : Type uV} {O : Type uO} : Raw M V O → ColOrder M V O |
| | .inl (t, u, x) => .inlₗ (toLex (t, toLex (u, x))) |
| | .inr (.inl v) => .inrₗ (.inrₗ v) |
| | .inr (.inr x) => .inrₗ (.inlₗ x) |
|
|
| def rowEquiv (M : Type uM) (V : Type uV) (O : Type uO) : Raw M V O ≃ RowOrder M V O where |
| toFun := rowKey |
| invFun x := match ofLex x with |
| | .inl a => .inl ((ofLex a).1, (ofLex (ofLex a).2).1, (ofLex (ofLex a).2).2) |
| | .inr b => .inr (ofLex b) |
| left_inv := by rintro (⟨t,u,x⟩ | (v | x)) <;> rfl |
| right_inv := by rintro (⟨t,u,x⟩ | (v | x)) <;> rfl |
|
|
| def colEquiv (M : Type uM) (V : Type uV) (O : Type uO) : Raw M V O ≃ ColOrder M V O where |
| toFun := colKey |
| invFun x := match ofLex x with |
| | .inl a => .inl ((ofLex a).1, (ofLex (ofLex a).2).1, (ofLex (ofLex a).2).2) |
| | .inr b => match ofLex b with |
| | .inl x => .inr (.inr x) |
| | .inr v => .inr (.inl v) |
| left_inv := by rintro (⟨t,u,x⟩ | (v | x)) <;> rfl |
| right_inv := by rintro (⟨t,u,x⟩ | (x | v)) <;> rfl |
|
|
| section Orders |
| variable {M : Type uM} {V : Type uV} {O : Type uO} [LinearOrder M] [LinearOrder V] [LinearOrder O] |
|
|
| /-- The full raw row order, suitable for local instance installation. -/ |
| abbrev rowOrder : LinearOrder (Raw M V O) := LinearOrder.lift' rowKey (rowEquiv M V O).injective |
|
|
| /-- The full raw column order, suitable for local instance installation. -/ |
| abbrev colOrder : LinearOrder (Raw M V O) := LinearOrder.lift' colKey (colEquiv M V O).injective |
|
|
| /-- Arbitrary offsets in successive groups give increasing selected anchors. -/ |
| theorem row_anchor_strictMono (t : M) (a : Fin 64 → O) : |
| StrictMono (fun u => rowKey (M := M) (V := V) (.inl (t, u, a u))) := by |
| intro u v huv |
| change Sum.Lex _ _ _ _ |
| apply Sum.Lex.inl |
| apply Prod.Lex.right |
| exact Prod.Lex.left _ _ huv |
|
|
| theorem col_anchor_strictMono (t : M) (a : Fin 64 → O) : |
| StrictMono (fun u => colKey (M := M) (V := V) (.inl (t, u, a u))) := by |
| intro u v huv |
| change Sum.Lex _ _ _ _ |
| apply Sum.Lex.inl |
| apply Prod.Lex.right |
| exact Prod.Lex.left _ _ huv |
|
|
| theorem row_anchor_lt_nonanchor (t : M) (u : Fin 64) (a : O) (x : V ⊕ O) : |
| rowKey (.inl (t,u,a)) < rowKey (.inr x) := by |
| cases x <;> exact Sum.Lex.sep _ _ |
|
|
| theorem col_anchor_lt_nonanchor (t : M) (u : Fin 64) (a : O) (x : V ⊕ O) : |
| colKey (.inl (t,u,a)) < colKey (.inr x) := by |
| cases x <;> exact Sum.Lex.sep _ _ |
|
|
| theorem row_variable_lt_dummy (v : V) (x : O) : |
| rowKey (M := M) (.inr (.inl v)) < rowKey (.inr (.inr x)) := |
| Sum.Lex.inr (Sum.Lex.sep _ _) |
|
|
| theorem col_dummy_lt_variable (v : V) (x : O) : |
| colKey (M := M) (.inr (.inr x)) < colKey (.inr (.inl v)) := |
| Sum.Lex.inr (Sum.Lex.sep _ _) |
|
|
| @[simp] theorem row_variable_lt_variable (v w : V) : |
| rowKey (M := M) (O := O) (.inr (.inl v)) < rowKey (.inr (.inl w)) ↔ v < w := by |
| simp [rowKey] |
|
|
| @[simp] theorem col_variable_lt_variable (v w : V) : |
| colKey (M := M) (O := O) (.inr (.inl v)) < colKey (.inr (.inl w)) ↔ v < w := by |
| simp [colKey] |
|
|
| /-- The anchor region is an initial segment of the complete row axis. -/ |
| theorem row_not_nonanchor_lt_anchor (t : M) (u : Fin 64) (a : O) (x : V ⊕ O) : |
| ¬ rowKey (.inr x) < rowKey (.inl (t,u,a)) := |
| not_lt_of_gt (row_anchor_lt_nonanchor t u a x) |
|
|
| /-- The anchor region is also an initial segment of the complete column axis. -/ |
| theorem col_not_nonanchor_lt_anchor (t : M) (u : Fin 64) (a : O) (x : V ⊕ O) : |
| ¬ colKey (.inr x) < colKey (.inl (t,u,a)) := |
| not_lt_of_gt (col_anchor_lt_nonanchor t u a x) |
|
|
| /-- Within one mode, increasing selected anchors have nondecreasing group labels. -/ |
| theorem row_group_le_of_lt (t : M) (u v : Fin 64) (a b : O) |
| (hab : rowKey (V := V) (.inl (t,u,a)) < rowKey (.inl (t,v,b))) : u ≤ v := by |
| have h : toLex (u,a) < toLex (v,b) := by |
| simpa [rowKey, Prod.Lex.lt_iff] using hab |
| exact (Prod.Lex.monotone_fst_ofLex h.le) |
|
|
| theorem col_group_le_of_lt (t : M) (u v : Fin 64) (a b : O) |
| (hab : colKey (V := V) (.inl (t,u,a)) < colKey (.inl (t,v,b))) : u ≤ v := by |
| have h : toLex (u,a) < toLex (v,b) := by |
| simpa [colKey, Prod.Lex.lt_iff] using hab |
| exact (Prod.Lex.monotone_fst_ofLex h.le) |
|
|
| /-- Selected anchor rows after the full axis has been enumerated by `Fin n`. -/ |
| def selectedRows {n : ℕ} (e : Fin n ≃o RowOrder M V O) |
| (t : M) (a : Fin 64 → O) : Fin 64 → Fin n := |
| fun u => e.symm (rowKey (.inl (t, u, a u))) |
|
|
| /-- Selected anchor columns after the full axis has been enumerated by `Fin n`. -/ |
| def selectedCols {n : ℕ} (e : Fin n ≃o ColOrder M V O) |
| (t : M) (a : Fin 64 → O) : Fin 64 → Fin n := |
| fun u => e.symm (colKey (.inl (t, u, a u))) |
|
|
| theorem selectedRows_strictMono {n : ℕ} (e : Fin n ≃o RowOrder M V O) |
| (t : M) (a : Fin 64 → O) : StrictMono (selectedRows e t a) := |
| e.symm.strictMono.comp (row_anchor_strictMono t a) |
|
|
| theorem selectedCols_strictMono {n : ℕ} (e : Fin n ≃o ColOrder M V O) |
| (t : M) (a : Fin 64 → O) : StrictMono (selectedCols e t a) := |
| e.symm.strictMono.comp (col_anchor_strictMono t a) |
|
|
| theorem selectedRows_lt_nonanchor {n : ℕ} (e : Fin n ≃o RowOrder M V O) |
| (t : M) (a : Fin 64 → O) (u : Fin 64) (x : V ⊕ O) : |
| selectedRows e t a u < e.symm (rowKey (.inr x)) := |
| e.symm.strictMono (row_anchor_lt_nonanchor t u (a u) x) |
|
|
| theorem selectedCols_lt_nonanchor {n : ℕ} (e : Fin n ≃o ColOrder M V O) |
| (t : M) (a : Fin 64 → O) (u : Fin 64) (x : V ⊕ O) : |
| selectedCols e t a u < e.symm (colKey (.inr x)) := |
| e.symm.strictMono (col_anchor_lt_nonanchor t u (a u) x) |
|
|
| end Orders |
| end Problem348.AnchorFrames |
|
|
| end OAI |
|
|
