File size: 6,001 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 | import Mathlib
namespace OAI
/-!
# Structural bridges for anchor pinning
Group uniqueness and no-shattering give pinning criteria independent of
the host construction.
-/
universe uI uJ uR uC uG
namespace Problem348.AnchorBridge
/-- Distinct pattern rows prevent a copy from repeating any host row class
whose members have identical entries. -/
theorem row_labels_injective {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {G : Type uG}
(H : I → J → Bool) (A : R → C → Bool)
(row : I → R) (col : J → C) (label : R → G)
(hcopy : ∀ i j, A (row i) (col j) = H i j)
(hrows : Function.Injective H)
(hlabel : ∀ r s, label r = label s → A r = A s) :
Function.Injective (fun i => label (row i)) := by
intro i j hij
apply hrows
funext c
rw [← hcopy, ← hcopy]
exact congrFun (hlabel (row i) (row j) hij) (col c)
/-- The column version of `row_labels_injective`. -/
theorem col_labels_injective {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {G : Type uG}
(H : I → J → Bool) (A : R → C → Bool)
(row : I → R) (col : J → C) (label : C → G)
(hcopy : ∀ i j, A (row i) (col j) = H i j)
(hcols : Function.Injective (fun j => fun i => H i j))
(hlabel : ∀ c d, label c = label d → ∀ r, A r c = A r d) :
Function.Injective (fun j => label (col j)) := by
intro i j hij
apply hcols
funext r
change H r i = H r j
rw [← hcopy, ← hcopy]
exact hlabel (col i) (col j) hij (row r)
/-- The 32 rows carrying all binary words in the fixed anchor. -/
def wordRow (a : Fin 32) : Fin 64 := ⟨32 + a.val, by omega⟩
/-- The five columns carrying the word coordinates in the fixed anchor. -/
def wordCol (b : Fin 5) : Fin 64 := ⟨59 + b.val, by omega⟩
@[simp] theorem wordCol_injective : Function.Injective wordCol := by
intro a b hab
apply Fin.ext
have := congrArg Fin.val hab
simp only [wordCol] at this
omega
/-- If both axes had at most 32 initial anchor positions, the complete-word
submatrix would shatter five non-anchor columns. Thus the position at index
32 is an anchor on at least one axis. -/
theorem anchor_at_32_or_anchor_at_32 {R : Type uR} {C : Type uC}
(H : Fin 64 → Fin 64 → Bool) (A : R → C → Bool)
(row : Fin 64 → R) (col : Fin 64 → C)
(anchorR : R → Prop) (anchorC : C → Prop)
(hcopy : ∀ i j, A (row i) (col j) = H i j)
(hcol : Function.Injective col)
(hprefixR : ∀ i j, i ≤ j → anchorR (row j) → anchorR (row i))
(hprefixC : ∀ i j, i ≤ j → anchorC (col j) → anchorC (col i))
(hwords : ∀ w : Fin 5 → Bool, ∃ a : Fin 32,
∀ b : Fin 5, H (wordRow a) (wordCol b) = w b)
(hnoshatter : ∀ cs : Fin 5 → C, Function.Injective cs →
(∀ b, ¬ anchorC (cs b)) → ∃ w : Fin 5 → Bool,
∀ r, ¬ anchorR r → ∃ b, A r (cs b) ≠ w b) :
anchorR (row ⟨32, by decide⟩) ∨ anchorC (col ⟨32, by decide⟩) := by
classical
by_contra h
push Not at h
have hr : ∀ a : Fin 32, ¬ anchorR (row (wordRow a)) := by
intro a ha
apply h.1
exact hprefixR _ _ (by simp only [wordRow, Fin.le_iff_val_le_val]; omega) ha
have hc : ∀ b : Fin 5, ¬ anchorC (col (wordCol b)) := by
intro b hb
apply h.2
exact hprefixC _ _ (by simp only [wordCol, Fin.le_iff_val_le_val]; omega) hb
obtain ⟨w, hw⟩ := hnoshatter (fun b => col (wordCol b))
(hcol.comp wordCol_injective) hc
obtain ⟨a, ha⟩ := hwords w
obtain ⟨b, hb⟩ := hw (row (wordRow a)) (hr a)
exact hb ((hcopy _ _).trans (ha b))
/-- A downward-closed predicate holding at index `m` holds at at least
`m+1` indices. -/
theorem prefix_card_lower_bound {n : ℕ} (P : Fin n → Prop) [DecidablePred P]
(m : Fin n) (hprefix : ∀ i j, i ≤ j → P j → P i) (hm : P m) :
m.val + 1 ≤ (Finset.univ.filter P).card := by
classical
calc
m.val + 1 = (Finset.Iic m).card := by simp
_ ≤ (Finset.univ.filter P).card := by
apply Finset.card_le_card
intro i hi
exact Finset.mem_filter.mpr ⟨Finset.mem_univ i,
hprefix i m (Finset.mem_Iic.mp hi) hm⟩
/-- An increasing self-map of a finite ordered interval uses every label
in the prescribed order. -/
theorem increasing_labels_eq_id {n : ℕ} (f : Fin n → Fin n)
(hf : StrictMono f) : f = id := by
funext i
exact le_antisymm (hf.le_id i) (hf.id_le i)
/-- Any class of host rows with identical entries is used at most once
in a copy with distinct pattern rows. In particular this applies to the
dummy row class. -/
theorem card_selected_row_class_le_one {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC}
[Fintype I] (H : I → J → Bool) (A : R → C → Bool)
(row : I → R) (col : J → C) (P : R → Prop) [DecidablePred P]
(hcopy : ∀ i j, A (row i) (col j) = H i j)
(hrows : Function.Injective H)
(hclass : ∀ r s, P r → P s → A r = A s) :
(Finset.univ.filter (fun i => P (row i))).card ≤ 1 := by
classical
apply Finset.card_le_one.mpr
intro i hi j hj
apply hrows
funext c
rw [← hcopy, ← hcopy]
exact congrFun (hclass (row i) (row j)
(Finset.mem_filter.mp hi).2 (Finset.mem_filter.mp hj).2) (col c)
/-- Column version of the single-use class bound. -/
theorem card_selected_col_class_le_one {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC}
[Fintype J] (H : I → J → Bool) (A : R → C → Bool)
(row : I → R) (col : J → C) (P : C → Prop) [DecidablePred P]
(hcopy : ∀ i j, A (row i) (col j) = H i j)
(hcols : Function.Injective (fun j => fun i => H i j))
(hclass : ∀ c d, P c → P d → ∀ r, A r c = A r d) :
(Finset.univ.filter (fun j => P (col j))).card ≤ 1 := by
classical
apply Finset.card_le_one.mpr
intro i hi j hj
apply hcols
funext r
change H r i = H r j
rw [← hcopy, ← hcopy]
exact hclass (col i) (col j)
(Finset.mem_filter.mp hi).2 (Finset.mem_filter.mp hj).2 (row r)
end Problem348.AnchorBridge
end OAI
|