| import OAI.Combinatorics.MatrixRemoval.Host |
| import OAI.Combinatorics.MatrixRemoval.CopyBoundFixed |
|
|
| namespace OAI |
|
|
| /-! |
| |
|
|
| The row and column enumerations are independent. This adapter does not assume |
| that either enumeration preserves an ambient order on the sum type: the raw |
| localization hypothesis uses exactly the two induced finite orders. |
| -/ |
|
|
| noncomputable section |
| namespace Problem348.Construction |
|
|
| /-- The canonical host viewed through independent row/column enumerations. -/ |
| def hostMatrix {h n : ℕ} (er ec : Position h ≃ Fin n) : BinaryMatrix n := |
| fun i j => host (er.symm i) (ec.symm j) |
|
|
| /-- A raw leaf is shared by the plus and minus names on both axes. -/ |
| def countedLeaf {h : ℕ} (z : Fin (2 ^ h)) : Position h := |
| Sum.inr (Sum.inl (Fin.last (2 * h), z)) |
|
|
| /-- The depth/node conclusion of the mode analysis is exactly a leaf-diagonal |
| witness in the raw-position type, including the shared leaf class. -/ |
| theorem exists_countedLeaf_of_depth_node {h : ℕ} (r c : VariablePosition h) |
| (hr : depth r = h) (hc : depth c = h) (hnode : node r = node c) : |
| ∃ z, (Sum.inr (Sum.inl r) : Position h) = countedLeaf z ∧ |
| (Sum.inr (Sum.inl c) : Position h) = countedLeaf z := by |
| have hrclass : r.1 = Fin.last (2 * h) := by |
| apply Fin.ext |
| have hb := r.1.isLt |
| have hr' : r.1.val / 2 = h := hr |
| simp only [Fin.val_last] |
| omega |
| have hcclass : c.1 = Fin.last (2 * h) := by |
| apply Fin.ext |
| have hb := c.1.isLt |
| have hc' : c.1.val / 2 = h := hc |
| simp only [Fin.val_last] |
| omega |
| have hoffset : r.2 = c.2 := by |
| apply Fin.ext |
| simpa [node, hr, hc] using hnode |
| refine ⟨r.2, ?_, ?_⟩ |
| · simp only [countedLeaf, Sum.inr.injEq, Sum.inl.injEq] |
| exact Prod.ext hrclass rfl |
| · simp only [countedLeaf, Sum.inr.injEq, Sum.inl.injEq] |
| exact Prod.ext hcclass hoffset.symm |
|
|
| /-- Exact localization of a raw copy transports without any count-equivalence |
| machinery. The increasing-map hypotheses refer to the supplied enumerations. -/ |
| theorem localization_on_fin {h n : ℕ} (er ec : Position h ≃ Fin n) |
| (hloc : ∀ r c : Fin 66 → Position h, |
| StrictMono (fun i => er (r i)) → StrictMono (fun j => ec (c j)) → |
| (∀ i j, host (r i) (c j) = fixedH i j) → |
| ∃ z, r 64 = countedLeaf z ∧ c 64 = countedLeaf z) |
| (r c : IncreasingMap 66 n) |
| (hentries : ∀ i j, hostMatrix er ec (r.val i) (c.val j) = fixedH i j) : |
| ∃ z, r.val 64 = er (countedLeaf z) ∧ c.val 64 = ec (countedLeaf z) := by |
| obtain ⟨z, hr, hc⟩ := hloc (fun i => er.symm (r.val i)) |
| (fun j => ec.symm (c.val j)) (by simpa using r.property) |
| (by simpa using c.property) hentries |
| refine ⟨z, ?_, ?_⟩ |
| · simpa using congrArg er hr |
| · simpa using congrArg ec hc |
|
|
| /-- Integer bound used by the sequence assembly, from raw-host localization. -/ |
| theorem host_copyCount_le {h n : ℕ} (er ec : Position h ≃ Fin n) |
| (hloc : ∀ r c : Fin 66 → Position h, |
| StrictMono (fun i => er (r i)) → StrictMono (fun j => ec (c j)) → |
| (∀ i j, host (r i) (c j) = fixedH i j) → |
| ∃ z, r 64 = countedLeaf z ∧ c 64 = countedLeaf z) : |
| copyCount fixedH (hostMatrix er ec) ≤ 2 ^ h * n ^ 130 := by |
| classical |
| let L := Finset.univ.image (fun z : Fin (2 ^ h) => |
| (er (countedLeaf z), ec (countedLeaf z))) |
| have hcard : L.card ≤ 2 ^ h := Finset.card_image_le.trans (by simp) |
| apply (fixedCopyCount_le_of_body_cell_mem (hostMatrix er ec) L ?_).trans |
| (Nat.mul_le_mul_right _ hcard) |
| intro rc hrc |
| obtain ⟨z, hr, hc⟩ := localization_on_fin er ec hloc rc.1 rc.2 |
| (Finset.mem_filter.mp hrc).2 |
| exact Finset.mem_image.mpr ⟨z, Finset.mem_univ _, by simp [hr, hc]⟩ |
|
|
| /-- The exact density upper bound of counterexample_sequence for this raw host. -/ |
| theorem host_copyDensity_le (h : ℕ) |
| (er ec : Position h ≃ Fin ((386 * h + 2) * 2 ^ h)) |
| (hloc : ∀ r c : Fin 66 → Position h, |
| StrictMono (fun i => er (r i)) → StrictMono (fun j => ec (c j)) → |
| (∀ i j, host (r i) (c j) = fixedH i j) → |
| ∃ z, r 64 = countedLeaf z ∧ c 64 = countedLeaf z) : |
| (copyCount fixedH (hostMatrix er ec) : ℝ) / |
| ((((386 * h + 2) * 2 ^ h : ℕ) : ℝ) ^ 132) ≤ |
| (1 / (((386 * h + 2 : ℕ) : ℝ) ^ 2)) * (1 / ((2 : ℝ) ^ h)) := by |
| apply sequenceCopyDensity_le_of_leaf_witness h (hostMatrix er ec) |
| (fun z => er (countedLeaf z)) (fun z => ec (countedLeaf z)) |
| exact localization_on_fin er ec hloc |
|
|
| end Problem348.Construction |
|
|
| end |
|
|
| end OAI |
|
|
