Download data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchEncoding.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchEncoding.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchEncoding.lean
-
curl -L -o BlockSearchEncoding.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockSearchEncoding.lean
12.6 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearch | |
| namespace OAI.Algorithms | |
| /-! | |
| # Coordinate-major representation of a complete local basis table | |
| The encoded search enumerates one square table and a split position. Rows | |
| are ambient coordinates and columns are basis vectors. This module proves | |
| that this representation covers every successful kernel/complement pair. | |
| No transpose or basis search is performed by these definitions. | |
| -/ | |
| namespace SubexponentialSAT.Subexp.BlockSearchEncoding | |
| open BlockSearch | |
| open scoped BigOperators | |
| variable {K : Type*} {N : ℕ} | |
| /-- View a flat coordinate-major vector as a square table. -/ | |
| def unflattenTable (x : Fin (N * N) → K) (row col : Fin N) : K := | |
| x (finProdFinEquiv (row, col)) | |
| /-- Read the entries of a square table in coordinate-major order. -/ | |
| def flattenTable (T : Fin N → Fin N → K) (i : Fin (N * N)) : K := | |
| T (finProdFinEquiv.symm i).1 (finProdFinEquiv.symm i).2 | |
| @[simp] theorem unflattenTable_flattenTable (T : Fin N → Fin N → K) : | |
| unflattenTable (flattenTable T) = T := by | |
| funext row col | |
| simp [unflattenTable, flattenTable] | |
| @[simp] theorem flattenTable_unflattenTable (x : Fin (N * N) → K) : | |
| flattenTable (unflattenTable x) = x := by | |
| funext i | |
| change x (finProdFinEquiv (finProdFinEquiv.symm i)) = x i | |
| rw [Equiv.apply_symm_apply] | |
| @[simp] theorem flattenTable_product (T : Fin N → Fin N → K) (row col : Fin N) : | |
| flattenTable T (finProdFinEquiv (row, col)) = T row col := by | |
| simp [flattenTable] | |
| /-- An executable bijection; it uses quotient/remainder indexing only. -/ | |
| def flatTableEquiv : (Fin (N * N) → K) ≃ (Fin N → Fin N → K) where | |
| toFun := unflattenTable | |
| invFun := flattenTable | |
| left_inv := flattenTable_unflattenTable | |
| right_inv := unflattenTable_flattenTable | |
| /-- Coordinate-major rows, directly consumable by a matrix/vector scan. -/ | |
| def tableRows (T : Fin N → Fin N → K) : List (List K) := | |
| List.ofFn fun row => List.ofFn (T row) | |
| /-- Coordinate-major flat entries. -/ | |
| def tableEntries (T : Fin N → Fin N → K) : List K := | |
| List.ofFn (flattenTable T) | |
| @[simp] theorem tableRows_length (T : Fin N → Fin N → K) : | |
| (tableRows T).length = N := by simp [tableRows] | |
| theorem tableRows_row_length (T : Fin N → Fin N → K) (row : List K) | |
| (hrow : row ∈ tableRows T) : row.length = N := by | |
| obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hrow | |
| simp | |
| @[simp] theorem tableEntries_length (T : Fin N → Fin N → K) : | |
| (tableEntries T).length = N * N := by simp [tableEntries] | |
| /-- The flat index order is exactly the matrix scan's row concatenation. -/ | |
| theorem tableEntries_eq_flatten_rows (T : Fin N → Fin N → K) : | |
| tableEntries T = (tableRows T).flatten := by | |
| rw [tableEntries, List.ofFn_mul] | |
| unfold tableRows | |
| apply congrArg List.flatten | |
| apply congrArg List.ofFn | |
| funext row | |
| apply congrArg List.ofFn | |
| funext col | |
| have hi : (⟨row.val * N + col.val, by | |
| simpa [Nat.mul_comm, Nat.add_comm] using (finProdFinEquiv (row, col)).isLt⟩ : Fin (N * N)) = | |
| finProdFinEquiv (row, col) := by | |
| apply Fin.ext | |
| simp [finProdFinEquiv, Nat.mul_comm, Nat.add_comm] | |
| rw [hi] | |
| exact flattenTable_product T row col | |
| /-- Split a square coordinate-major table into its first `d` columns and | |
| its remaining columns. -/ | |
| def splitPair (d : Fin (N + 1)) (T : Fin N → Fin N → K) : | |
| Candidate K N × Candidate K N := | |
| (⟨d, fun i row => T row ⟨i.val, by have := d.isLt; omega⟩⟩, | |
| ⟨⟨N - d.val, Nat.lt_succ_of_le (Nat.sub_le N d.val)⟩, | |
| fun j row => T row ⟨d.val + j.val, by | |
| have hj : j.val < N - d.val := j.isLt | |
| have hd := d.isLt | |
| omega⟩⟩) | |
| @[simp] theorem splitPair_first_dimension (d : Fin (N + 1)) | |
| (T : Fin N → Fin N → K) : (splitPair d T).1.1 = d := rfl | |
| @[simp] theorem splitPair_second_dimension (d : Fin (N + 1)) | |
| (T : Fin N → Fin N → K) : (splitPair d T).2.1.val = N - d.val := rfl | |
| theorem splitPair_dimensions_add (d : Fin (N + 1)) (T : Fin N → Fin N → K) : | |
| (splitPair d T).1.1.val + (splitPair d T).2.1.val = N := by | |
| simp only [splitPair_first_dimension, splitPair_second_dimension] | |
| have := d.isLt | |
| omega | |
| @[simp] theorem splitPair_first_apply (d : Fin (N + 1)) | |
| (T : Fin N → Fin N → K) (i : Fin d.val) (row : Fin N) : | |
| (splitPair d T).1.2 i row = T row ⟨i.val, by have := d.isLt; omega⟩ := rfl | |
| @[simp] theorem splitPair_second_apply (d : Fin (N + 1)) | |
| (T : Fin N → Fin N → K) (j : Fin (N - d.val)) (row : Fin N) : | |
| (splitPair d T).2.2 j row = T row ⟨d.val + j.val, by have := j.isLt; omega⟩ := rfl | |
| /-- Read a successful pair as one coordinate-major square table. The | |
| dimension equality is used only to certify the second column index. -/ | |
| def tableOfPair (c : Candidate K N × Candidate K N) | |
| (h : c.1.1.val + c.2.1.val = N) (row col : Fin N) : K := | |
| if hc : col.val < c.1.1.val then c.1.2 ⟨col.val, hc⟩ row | |
| else c.2.2 ⟨col.val - c.1.1.val, by have := col.isLt; omega⟩ row | |
| @[simp] theorem tableOfPair_first (c : Candidate K N × Candidate K N) | |
| (h : c.1.1.val + c.2.1.val = N) (i : Fin c.1.1.val) (row : Fin N) : | |
| tableOfPair c h row ⟨i.val, by have := i.isLt; omega⟩ = c.1.2 i row := by | |
| simp [tableOfPair, i.isLt] | |
| @[simp] theorem tableOfPair_second (c : Candidate K N × Candidate K N) | |
| (h : c.1.1.val + c.2.1.val = N) (j : Fin c.2.1.val) (row : Fin N) : | |
| tableOfPair c h row ⟨c.1.1.val + j.val, by have := j.isLt; omega⟩ = | |
| c.2.2 j row := by | |
| simp [tableOfPair] | |
| /-- Joining a split table returns exactly its original entries. -/ | |
| @[simp] theorem tableOfPair_splitPair (d : Fin (N + 1)) | |
| (T : Fin N → Fin N → K) : | |
| tableOfPair (splitPair d T) (splitPair_dimensions_add d T) = T := by | |
| funext row col | |
| by_cases h : col.val < d.val | |
| · simp [tableOfPair, splitPair, h] | |
| · simp [tableOfPair, splitPair, h, Nat.add_sub_of_le (Nat.le_of_not_gt h)] | |
| /-- Splitting the table of a pair with the full ambient dimension returns | |
| the exact pair, including its dependent dimension indices. -/ | |
| @[simp] theorem splitPair_tableOfPair (c : Candidate K N × Candidate K N) | |
| (h : c.1.1.val + c.2.1.val = N) : | |
| splitPair c.1.1 (tableOfPair c h) = c := by | |
| rcases c with ⟨⟨d, v⟩, ⟨e, w⟩⟩ | |
| have he : e = ⟨N - d.val, Nat.lt_succ_of_le (Nat.sub_le N d.val)⟩ := by | |
| apply Fin.ext | |
| change e.val = N - d.val | |
| change d.val + e.val = N at h | |
| omega | |
| subst e | |
| apply Prod.ext | |
| · apply congrArg (fun f : Fin d.val → Vec K N => (⟨d, f⟩ : Candidate K N)) | |
| funext i row | |
| simp [ tableOfPair, i.isLt] | |
| · apply congrArg (fun f : Fin (N - d.val) → Vec K N => | |
| (⟨⟨N - d.val, Nat.lt_succ_of_le (Nat.sub_le N d.val)⟩, f⟩ : Candidate K N)) | |
| funext j row | |
| simp [ tableOfPair] | |
| /-- Restrict a full coefficient vector to the first group of columns. -/ | |
| def headCoefficients (d : Fin (N + 1)) (x : Fin N → K) : Fin d.val → K := | |
| fun i => x ⟨i.val, by have := d.isLt; omega⟩ | |
| /-- Restrict a full coefficient vector to the remaining columns. -/ | |
| def tailCoefficients (d : Fin (N + 1)) (x : Fin N → K) : Fin (N - d.val) → K := | |
| fun j => x ⟨d.val + j.val, by have := j.isLt; omega⟩ | |
| theorem sum_split {A : Type*} [AddCommMonoid A] (d : Fin (N + 1)) (f : Fin N → A) : | |
| (∑ i, f i) = | |
| (∑ i : Fin d.val, f ⟨i.val, by have := d.isLt; omega⟩) + | |
| ∑ j : Fin (N - d.val), f ⟨d.val + j.val, by have := j.isLt; omega⟩ := by | |
| have hN : d.val + (N - d.val) = N := by have := d.isLt; omega | |
| let e : Fin d.val ⊕ Fin (N - d.val) ≃ Fin N := | |
| finSumFinEquiv.trans (finCongr hN) | |
| have he₁ (i : Fin d.val) : e (.inl i) = ⟨i.val, by have := d.isLt; omega⟩ := by | |
| apply Fin.ext | |
| simp [e] | |
| have he₂ (j : Fin (N - d.val)) : | |
| e (.inr j) = ⟨d.val + j.val, by have := j.isLt; omega⟩ := by | |
| apply Fin.ext | |
| simp [e] | |
| calc | |
| (∑ i, f i) = ∑ j, f (e j) := (e.sum_comp f).symm | |
| _ = _ := by | |
| rw [Fintype.sum_sum_type] | |
| simp only [he₁, he₂] | |
| /-- Join coefficient vectors in the same column order used by `splitPair`. -/ | |
| def joinCoefficients (d : Fin (N + 1)) (a : Fin d.val → K) | |
| (b : Fin (N - d.val) → K) (i : Fin N) : K := | |
| if hi : i.val < d.val then a ⟨i.val, hi⟩ | |
| else b ⟨i.val - d.val, by have := i.isLt; have := d.isLt; omega⟩ | |
| @[simp] theorem headCoefficients_join (d : Fin (N + 1)) | |
| (a : Fin d.val → K) (b : Fin (N - d.val) → K) : | |
| headCoefficients d (joinCoefficients d a b) = a := by | |
| funext i | |
| simp [headCoefficients, joinCoefficients, i.isLt] | |
| @[simp] theorem tailCoefficients_join (d : Fin (N + 1)) | |
| (a : Fin d.val → K) (b : Fin (N - d.val) → K) : | |
| tailCoefficients d (joinCoefficients d a b) = b := by | |
| funext j | |
| simp [tailCoefficients, joinCoefficients] | |
| @[simp] theorem joinCoefficients_restrictions (d : Fin (N + 1)) (x : Fin N → K) : | |
| joinCoefficients d (headCoefficients d x) (tailCoefficients d x) = x := by | |
| funext i | |
| by_cases hi : i.val < d.val | |
| · simp [joinCoefficients, headCoefficients, hi] | |
| · simp [joinCoefficients, tailCoefficients, hi, Nat.add_sub_of_le (Nat.le_of_not_gt hi)] | |
| /-- Full coefficients are equivalent to the two restrictions. -/ | |
| def coefficientEquiv (d : Fin (N + 1)) : | |
| (Fin N → K) ≃ ((Fin d.val → K) × (Fin (N - d.val) → K)) where | |
| toFun x := (headCoefficients d x, tailCoefficients d x) | |
| invFun ab := joinCoefficients d ab.1 ab.2 | |
| left_inv := joinCoefficients_restrictions d | |
| right_inv ab := by simp | |
| theorem coefficients_zero_iff [Zero K] (d : Fin (N + 1)) (x : Fin N → K) : | |
| (headCoefficients d x = 0 ∧ tailCoefficients d x = 0) ↔ x = 0 := by | |
| constructor | |
| · rintro ⟨ha, hb⟩ | |
| have h := joinCoefficients_restrictions d x | |
| rw [ha, hb] at h | |
| have hz : joinCoefficients d (0 : Fin d.val → K) (0 : Fin (N - d.val) → K) = 0 := by | |
| funext i | |
| simp [joinCoefficients] | |
| exact h.symm.trans hz | |
| · rintro rfl | |
| exact ⟨rfl, rfl⟩ | |
| section Field | |
| variable [Field K] [DecidableEq K] | |
| omit [DecidableEq K] in | |
| /-- Multiplication of the coordinate-major table is exactly the sum of the | |
| kernel-tuple and complement-tuple linear combinations. -/ | |
| theorem matrixMap_eq_combine (d : Fin (N + 1)) (T : Fin N → Fin N → K) | |
| (x : Fin N → K) : | |
| matrixMap T x = | |
| combine (splitPair d T).1 (headCoefficients d x) + | |
| combine (splitPair d T).2 (tailCoefficients d x) := by | |
| ext row | |
| rw [show matrixMap T x row = ∑ j : Fin N, T row j * x j from rfl] | |
| simp only [Pi.add_apply, combine, Finset.sum_apply, Pi.smul_apply, | |
| headCoefficients, tailCoefficients, smul_eq_mul] | |
| rw [sum_split d (fun i => T row i * x i)] | |
| congr 1 <;> | |
| apply Finset.sum_congr rfl <;> | |
| intro i _ <;> | |
| rw [mul_comm] <;> | |
| rfl | |
| omit [DecidableEq K] in | |
| /-- Correct kernel and complement data necessarily contain exactly `N` | |
| basis vectors in total. -/ | |
| theorem dimensions_add {m : ℕ} {M : Fin m → Fin N → K} | |
| {c : Candidate K N × Candidate K N} (hc : GoodPair M c) : | |
| c.1.1.val + c.2.1.val = N := by | |
| have h := Submodule.finrank_add_eq_of_isCompl hc.isCompl | |
| rw [hc.1.finrank_kernel, hc.finrank_complement, Module.finrank_pi, | |
| Fintype.card_fin] at h | |
| exact h | |
| omit [DecidableEq K] in | |
| /-- The square-table search space covers every valid pair, independently | |
| of the order used to enumerate tables or split positions. -/ | |
| theorem goodPair_is_splitPair {m : ℕ} {M : Fin m → Fin N → K} | |
| {c : Candidate K N × Candidate K N} (hc : GoodPair M c) : | |
| ∃ (d : Fin (N + 1)) (T : Fin N → Fin N → K), splitPair d T = c := | |
| ⟨c.1.1, tableOfPair c (dimensions_add hc), splitPair_tableOfPair c _⟩ | |
| omit [DecidableEq K] in | |
| /-- Enumerating flat vectors of length `N²` and split positions covers every | |
| valid pair; no separately prepared matrix representation is assumed. -/ | |
| theorem goodPair_is_flat_splitPair {m : ℕ} {M : Fin m → Fin N → K} | |
| {c : Candidate K N × Candidate K N} (hc : GoodPair M c) : | |
| ∃ (d : Fin (N + 1)) (x : Fin (N * N) → K), | |
| splitPair d (unflattenTable x) = c := by | |
| obtain ⟨d, T, hT⟩ := goodPair_is_splitPair hc | |
| refine ⟨d, flattenTable T, ?_⟩ | |
| simpa using hT | |
| omit [DecidableEq K] in | |
| /-- At least one square table and split passes the actual pair specification. -/ | |
| theorem exists_good_splitPair {m : ℕ} (M : Fin m → Fin N → K) : | |
| ∃ (d : Fin (N + 1)) (T : Fin N → Fin N → K), GoodPair M (splitPair d T) := by | |
| obtain ⟨c, hc⟩ := exists_goodPair M | |
| obtain ⟨d, T, hT⟩ := goodPair_is_splitPair hc | |
| exact ⟨d, T, hT.symm ▸ hc⟩ | |
| end Field | |
| end SubexponentialSAT.Subexp.BlockSearchEncoding | |
| end OAI.Algorithms | |