| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! |
| Finite combinatorial anchor rigidity under explicit density, sparsity, |
| and mode-incidence hypotheses. |
| -/ |
|
|
| universe uI uJ uT |
|
|
| namespace Problem348.AnchorRigidity |
|
|
| /-- At most one zero leaves all but at most one position equal to one. -/ |
| theorem card_le_true_card_add_one {I : Type uI} [DecidableEq I] |
| (s : Finset I) (f : I → Bool) |
| (hz : (s.filter fun i => f i = false).card ≤ 1) : |
| s.card ≤ (s.filter fun i => f i = true).card + 1 := by |
| classical |
| have hp := Finset.card_filter_add_card_filter_not (s := s) |
| (p := fun i => f i = true) |
| have hn : (s.filter fun i => ¬ f i = true).card ≤ 1 := by |
| simpa only [Bool.not_eq_true] using hz |
| omega |
|
|
| /-- Two columns with at most one zero share a one on any core of size at least three. -/ |
| theorem exists_common_true {I : Type uI} [DecidableEq I] |
| (s : Finset I) (f g : I → Bool) (hs : 3 ≤ s.card) |
| (hf : (s.filter fun i => f i = false).card ≤ 1) |
| (hg : (s.filter fun i => g i = false).card ≤ 1) : |
| ∃ i ∈ s, f i = true ∧ g i = true := by |
| classical |
| by_contra h |
| have hsub : (s.filter fun i => f i = true) ⊆ |
| (s.filter fun i => g i = false) := by |
| intro i hi |
| obtain ⟨his, hif⟩ := Finset.mem_filter.mp hi |
| apply Finset.mem_filter.mpr |
| refine ⟨his, ?_⟩ |
| cases hgi : g i with |
| | false => rfl |
| | true => exact False.elim (h ⟨i, his, hif, hgi⟩) |
| have hcard := Finset.card_le_card hsub |
| have hpos := card_le_true_card_add_one s f hf |
| omega |
|
|
| /-- One-sided rigidity. A dense anchor core on the row axis forces both axes |
| into one mode. The dummy predicate is only needed to permit one exceptional |
| non-anchor column before the common mode has been identified. -/ |
| theorem one_sided |
| {I : Type uI} {J : Type uJ} {T : Type uT} [Fintype I] [Fintype J] |
| (B : I → J → Bool) (rowMode : I → Option T) (colMode : J → Option T) |
| (dummyCol : J → Prop) (core : Finset I) |
| (hcore : 6 ≤ core.card) |
| (core_anchor : ∀ i ∈ core, ∃ t, rowMode i = some t) |
| (core_zeros : ∀ j, (core.filter fun i => B i j = false).card ≤ 1) |
| (variable_sparse : ∀ j, colMode j = none → ¬ dummyCol j → |
| (core.filter fun i => B i j = true).card ≤ 4) |
| (dummy_unique : ∀ j k, dummyCol j → dummyCol k → j = k) |
| (cross_mode : ∀ i j t u, rowMode i = some t → colMode j = some u → |
| B i j = true → t = u) |
| (nonanchor_row_unit : ∀ i, rowMode i = none → ∀ j k t, |
| colMode j = some t → colMode k = some t → |
| B i j = true → B i k = true → j = k) |
| (nonanchor_col_unit : ∀ j, colMode j = none → ∀ i k t, |
| rowMode i = some t → rowMode k = some t → |
| B i j = true → B k j = true → i = k) |
| (row_dense : ∀ i, 2 ≤ (Finset.univ.filter fun j => B i j = true).card) : |
| ∃ t, (∀ i, rowMode i = some t) ∧ (∀ j, colMode j = some t) := by |
| classical |
| have core_positive (j : J) : 5 ≤ (core.filter fun i => B i j = true).card := by |
| have h := card_le_true_card_add_one core (fun i => B i j) (core_zeros j) |
| omega |
| have nonanchor_dummy (j : J) (hj : colMode j = none) : dummyCol j := by |
| by_contra hd |
| have hs := variable_sparse j hj hd |
| have hp := core_positive j |
| omega |
| have nonanchor_unique (j k : J) (hj : colMode j = none) |
| (hk : colMode k = none) : j = k := |
| dummy_unique j k (nonanchor_dummy j hj) (nonanchor_dummy k hk) |
| have two_ones (i : I) : ∃ j k, B i j = true ∧ B i k = true ∧ j ≠ k := by |
| have hd := row_dense i |
| obtain ⟨j, hj, k, hk, hne⟩ := Finset.one_lt_card.mp (show |
| 1 < (Finset.univ.filter fun j => B i j = true).card by omega) |
| exact ⟨j, k, (Finset.mem_filter.mp hj).2, (Finset.mem_filter.mp hk).2, hne⟩ |
| have row_anchor_one (i : I) : ∃ j t, colMode j = some t ∧ B i j = true := by |
| obtain ⟨j, k, hj, hk, hne⟩ := two_ones i |
| cases hmj : colMode j with |
| | some t => exact ⟨j, t, hmj, hj⟩ |
| | none => |
| cases hmk : colMode k with |
| | some t => exact ⟨k, t, hmk, hk⟩ |
| | none => exact False.elim (hne (nonanchor_unique j k hmj hmk)) |
| obtain ⟨i₀, hi₀⟩ := Finset.card_pos.mp (show 0 < core.card by omega) |
| obtain ⟨j₀, t, hj₀, _⟩ := row_anchor_one i₀ |
| have anchor_columns (j : J) (u : T) (hj : colMode j = some u) : u = t := by |
| obtain ⟨i, hi, hij, hij₀⟩ := exists_common_true core |
| (fun i => B i j) (fun i => B i j₀) (by omega) (core_zeros j) (core_zeros j₀) |
| obtain ⟨v, hiv⟩ := core_anchor i hi |
| exact (cross_mode i j v u hiv hj hij).symm.trans |
| (cross_mode i j₀ v t hiv hj₀ hij₀) |
| have anchor_rows (i : I) (u : T) (hi : rowMode i = some u) : u = t := by |
| obtain ⟨j, v, hj, hij⟩ := row_anchor_one i |
| exact (cross_mode i j u v hi hj hij).trans (anchor_columns j v hj) |
| have core_same (i : I) (hi : i ∈ core) : rowMode i = some t := by |
| obtain ⟨u, hu⟩ := core_anchor i hi |
| simpa only [anchor_rows i u hu] using hu |
| have all_columns (j : J) : colMode j = some t := by |
| cases hj : colMode j with |
| | some u => simp only [anchor_columns j u hj] |
| | none => |
| have hs : (core.filter fun i => B i j = true).card ≤ 1 := by |
| apply Finset.card_le_one.mpr |
| intro i hi k hk |
| obtain ⟨hic, hij⟩ := Finset.mem_filter.mp hi |
| obtain ⟨hkc, hkj⟩ := Finset.mem_filter.mp hk |
| exact nonanchor_col_unit j hj i k t (core_same i hic) (core_same k hkc) hij hkj |
| have hp := core_positive j |
| omega |
| refine ⟨t, ?_, all_columns⟩ |
| intro i |
| cases hi : rowMode i with |
| | some u => simp only [anchor_rows i u hi] |
| | none => |
| obtain ⟨j, k, hj, hk, hne⟩ := two_ones i |
| exact False.elim (hne (nonanchor_row_unit i hi j k t |
| (all_columns j) (all_columns k) hj hk)) |
|
|
| /-- A dense core consists of at least six selected anchor positions. Every |
| opposite position has at most one zero on it, while a variable opposite |
| position would have at most four ones. -/ |
| def DenseAnchorCore {I : Type uI} {J : Type uJ} {T : Type uT} |
| (B : I → J → Bool) (rowMode : I → Option T) (colMode : J → Option T) |
| (dummyCol : J → Prop) : Prop := |
| ∃ core : Finset I, 6 ≤ core.card ∧ |
| (∀ i ∈ core, ∃ t, rowMode i = some t) ∧ |
| (∀ j, (core.filter fun i => B i j = false).card ≤ 1) ∧ |
| (∀ j, colMode j = none → ¬ dummyCol j → |
| (core.filter fun i => B i j = true).card ≤ 4) |
|
|
| /-- Symmetric form of anchor rigidity: a dense anchor core on either axis |
| suffices. The no-shattering/order argument supplies this disjunction in the |
| application to the 64 by 64 pattern. -/ |
| theorem rigidity |
| {I : Type uI} {J : Type uJ} {T : Type uT} [Fintype I] [Fintype J] |
| (B : I → J → Bool) (rowMode : I → Option T) (colMode : J → Option T) |
| (dummyRow : I → Prop) (dummyCol : J → Prop) |
| (hcore : DenseAnchorCore B rowMode colMode dummyCol ∨ |
| DenseAnchorCore (fun j i => B i j) colMode rowMode dummyRow) |
| (dummy_row_unique : ∀ i k, dummyRow i → dummyRow k → i = k) |
| (dummy_col_unique : ∀ j k, dummyCol j → dummyCol k → j = k) |
| (cross_mode : ∀ i j t u, rowMode i = some t → colMode j = some u → |
| B i j = true → t = u) |
| (nonanchor_row_unit : ∀ i, rowMode i = none → ∀ j k t, |
| colMode j = some t → colMode k = some t → |
| B i j = true → B i k = true → j = k) |
| (nonanchor_col_unit : ∀ j, colMode j = none → ∀ i k t, |
| rowMode i = some t → rowMode k = some t → |
| B i j = true → B k j = true → i = k) |
| (row_dense : ∀ i, 2 ≤ (Finset.univ.filter fun j => B i j = true).card) |
| (col_dense : ∀ j, 2 ≤ (Finset.univ.filter fun i => B i j = true).card) : |
| ∃ t, (∀ i, rowMode i = some t) ∧ (∀ j, colMode j = some t) := by |
| rcases hcore with hcore | hcore |
| · obtain ⟨core, hc, ha, hz, hs⟩ := hcore |
| exact one_sided B rowMode colMode dummyCol core hc ha hz hs |
| dummy_col_unique cross_mode nonanchor_row_unit nonanchor_col_unit row_dense |
| · obtain ⟨core, hc, ha, hz, hs⟩ := hcore |
| obtain ⟨t, hcol, hrow⟩ := one_sided (fun j i => B i j) colMode rowMode |
| dummyRow core hc ha hz hs dummy_row_unique |
| (fun j i u t hj hi hb => (cross_mode i j t u hi hj hb).symm) |
| nonanchor_col_unit nonanchor_row_unit col_dense |
| exact ⟨t, hrow, hcol⟩ |
|
|
| end Problem348.AnchorRigidity |
|
|
| end OAI |
|
|
