Datasets:

roseking
/

openAI-math-dataset

import OAI.Combinatorics.MatrixRemoval.Host
import OAI.Combinatorics.MatrixRemoval.DirectNonshattering

namespace OAI

/-!
# Nonshattering for the concrete canonical host

This is a direct application of the qualitative five-column obstruction to
`Problem348.Construction.host`. It needs no axis order and no injectivity
assumption on the five selected non-anchor columns.
-/

universe uR

namespace Problem348.Construction

open Finset

noncomputable section

/-- The two kinds of non-anchor positions, without their outer sum tag. -/
abbrev NonanchorPosition (h : ℕ) := VariablePosition h ⊕ Fin (2 ^ h)

/-- Column-class labels for the non-anchor induced submatrix. The dummy label
is irrelevant because dummy columns are treated separately. -/
def nonanchorClass {h : ℕ} : NonanchorPosition h → ℕ
  | Sum.inl v => v.1.val
  | Sum.inr _ => 0

def nonanchorKey {h : ℕ} : NonanchorPosition h → ℕ
  | Sum.inl v => node v
  | Sum.inr _ => 0

def nonanchorDummy {h : ℕ} : NonanchorPosition h → Prop
  | Sum.inl _ => False
  | Sum.inr _ => True

instance {h : ℕ} (x : NonanchorPosition h) : Decidable (nonanchorDummy x) := by
  cases x <;> simp only [nonanchorDummy] <;> infer_instance

/-- The three class labels that can contain ones in a variable row. -/
def variableSupportLabels {h : ℕ} (r : VariablePosition h) : Finset ℕ :=
  {r.1.val, 2 * (depth r - 1), 2 * (depth r - 1) + 1}

theorem variableSupportLabels_card_le {h : ℕ} (r : VariablePosition h) :
    (variableSupportLabels r).card ≤ 3 := by
  exact Finset.card_le_three

/-- The constant-class suffix property, stated for the actual host kernel. -/
theorem variableEntry_mono_class {h : ℕ} (r c d : VariablePosition h)
    (hclass : c.1.val = d.1.val) (hnode : node c ≤ node d)
    (hc : variableEntry r c = true) : variableEntry r d = true := by
  have hd : depth c = depth d := by simp only [depth, hclass]
  have hp : plus c = plus d := by simp only [plus, hclass]
  unfold variableEntry at hc ⊢
  simp only [hd, hp] at hc
  split_ifs at hc ⊢ <;> simp_all <;> omega

/-- A true variable entry has one of the three possible column-class labels. -/
theorem variableEntry_mem_support {h : ℕ} (r c : VariablePosition h)
    (hc : variableEntry r c = true) : c.1.val ∈ variableSupportLabels r := by
  have hr := r.1.isLt
  have hcv := c.1.isLt
  simp only [variableSupportLabels, Finset.mem_insert, Finset.mem_singleton]
  unfold variableEntry at hc
  simp only [depth, plus, decide_eq_true_eq] at hc ⊢
  split_ifs at hc <;> simp_all <;> omega

/-- The induced matrix on all non-anchor positions misses a five-bit word. -/
theorem nonanchor_host_not_surjective (h : ℕ)
    (selected : Fin 5 → NonanchorPosition h) :
    ¬ Function.Surjective
      (fun r : NonanchorPosition h =>
        fun i => host (Sum.inr r) (Sum.inr (selected i))) := by
  apply DirectNonshattering.not_surjective_selected_columns
    (fun r c : NonanchorPosition h => host (Sum.inr r) (Sum.inr c))
    nonanchorDummy nonanchorDummy nonanchorClass nonanchorKey
  · intro r hr c
    cases r with
    | inl r => exact False.elim hr
    | inr r => cases c <;> rfl
  · intro c hc r
    cases c with
    | inl c => exact False.elim hc
    | inr c => cases r <;> rfl
  · intro r hr c d hc hd hclass hnode he
    cases r with
    | inr r => exact False.elim (hr trivial)
    | inl r =>
      cases c with
      | inr c => exact False.elim (hc trivial)
      | inl c =>
        cases d with
        | inr d => exact False.elim (hd trivial)
        | inl d => exact variableEntry_mono_class r c d hclass hnode he
  · intro r hr
    cases r with
    | inr r => exact False.elim (hr trivial)
    | inl r =>
      apply (Finset.card_le_card ?_).trans (variableSupportLabels_card_le r)
      intro a ha
      obtain ⟨c, hc, rfl⟩ := Finset.mem_image.mp ha
      obtain ⟨_, hnd, he⟩ := Finset.mem_filter.mp hc
      cases c with
      | inr c => exact False.elim (hnd trivial)
      | inl c => exact variableEntry_mem_support r c he

/-- The actual host, stated using its outer position type. This avoids any
choice of a separate non-anchor enumeration in anchor-rigidity applications. -/
theorem host_nonanchor_missing_word {h : ℕ} (columns : Fin 5 → Position h)
    (hcolumns : ∀ i, ∃ c : NonanchorPosition h, columns i = Sum.inr c) :
    ∃ w : Fin 5 → Bool, ∀ r : Position h,
      (∃ a : NonanchorPosition h, r = Sum.inr a) →
      (fun i => host r (columns i)) ≠ w := by
  classical
  choose selected hselected using hcolumns
  obtain ⟨w, hw⟩ : ∃ w : Fin 5 → Bool, ∀ r : NonanchorPosition h,
      (fun i => host (Sum.inr r) (Sum.inr (selected i))) ≠ w := by
    simpa only [Function.Surjective, not_forall, not_exists] using
      nonanchor_host_not_surjective h selected
  refine ⟨w, ?_⟩
  rintro r ⟨a, rfl⟩
  simpa only [hselected] using hw a

/-- Restricting to any collection of non-anchor rows still misses a word.
This is the form used for the final 32 rows of an alleged anchor copy. -/
theorem host_nonanchor_submatrix_not_surjective {h : ℕ} {R : Type uR}
    (rows : R → Position h) (columns : Fin 5 → Position h)
    (hrows : ∀ r, ∃ a : NonanchorPosition h, rows r = Sum.inr a)
    (hcolumns : ∀ i, ∃ c : NonanchorPosition h, columns i = Sum.inr c) :
    ¬ Function.Surjective (fun r i => host (rows r) (columns i)) := by
  obtain ⟨w, hw⟩ := host_nonanchor_missing_word columns hcolumns
  intro hsurj
  obtain ⟨r, hr⟩ := hsurj w
  exact hw (rows r) (hrows r) hr

/-- The outer sum tag gives a convenient intrinsic non-anchor predicate. -/
@[simp] theorem exists_nonanchor_iff_not_isLeft {h : ℕ} (x : Position h) :
    (∃ a : NonanchorPosition h, x = Sum.inr a) ↔ ¬ x.isLeft := by
  cases x <;> simp

/-- Pointwise missing-word property for concrete anchor rigidity. -/
theorem host_nonanchor_missing_entry {h : ℕ} (columns : Fin 5 → Position h)
    (hcolumns : ∀ i, ¬ (columns i).isLeft) :
    ∃ w : Fin 5 → Bool, ∀ r : Position h, ¬ r.isLeft →
      ∃ i, host r (columns i) ≠ w i := by
  obtain ⟨w, hw⟩ := host_nonanchor_missing_word columns
    (fun i => (exists_nonanchor_iff_not_isLeft (columns i)).mpr (hcolumns i))
  refine ⟨w, ?_⟩
  intro r hr
  have hne := hw r ((exists_nonanchor_iff_not_isLeft r).mpr hr)
  exact not_forall.mp (fun he => hne (funext he))

/-- The subtype formulation also avoids making any non-anchor choices. -/
theorem host_nonanchor_subtype_not_surjective {h : ℕ}
    (columns : Fin 5 → Position h) (hcolumns : ∀ i, ¬ (columns i).isLeft) :
    ¬ Function.Surjective
      (fun r : {x : Position h // ¬ x.isLeft} => fun i => host r.val (columns i)) := by
  apply host_nonanchor_submatrix_not_surjective
    (fun r : {x : Position h // ¬ x.isLeft} => r.val) columns
  · intro r
    exact (exists_nonanchor_iff_not_isLeft r.val).mpr r.property
  · intro i
    exact (exists_nonanchor_iff_not_isLeft (columns i)).mpr (hcolumns i)

end
end Problem348.Construction

end OAI

	import OAI.Combinatorics.MatrixRemoval.Host
	import OAI.Combinatorics.MatrixRemoval.DirectNonshattering

	namespace OAI

	/-!
	# Nonshattering for the concrete canonical host

	This is a direct application of the qualitative five-column obstruction to
	`Problem348.Construction.host`. It needs no axis order and no injectivity
	assumption on the five selected non-anchor columns.
	-/

	universe uR

	namespace Problem348.Construction

	open Finset

	noncomputable section

	/-- The two kinds of non-anchor positions, without their outer sum tag. -/
	abbrev NonanchorPosition (h : ℕ) := VariablePosition h ⊕ Fin (2 ^ h)

	/-- Column-class labels for the non-anchor induced submatrix. The dummy label
	is irrelevant because dummy columns are treated separately. -/
	def nonanchorClass {h : ℕ} : NonanchorPosition h → ℕ
	\| Sum.inl v => v.1.val
	\| Sum.inr _ => 0

	def nonanchorKey {h : ℕ} : NonanchorPosition h → ℕ
	\| Sum.inl v => node v
	\| Sum.inr _ => 0

	def nonanchorDummy {h : ℕ} : NonanchorPosition h → Prop
	\| Sum.inl _ => False
	\| Sum.inr _ => True

	instance {h : ℕ} (x : NonanchorPosition h) : Decidable (nonanchorDummy x) := by
	cases x <;> simp only [nonanchorDummy] <;> infer_instance

	/-- The three class labels that can contain ones in a variable row. -/
	def variableSupportLabels {h : ℕ} (r : VariablePosition h) : Finset ℕ :=
	{r.1.val, 2 * (depth r - 1), 2 * (depth r - 1) + 1}

	theorem variableSupportLabels_card_le {h : ℕ} (r : VariablePosition h) :
	(variableSupportLabels r).card ≤ 3 := by
	exact Finset.card_le_three

	/-- The constant-class suffix property, stated for the actual host kernel. -/
	theorem variableEntry_mono_class {h : ℕ} (r c d : VariablePosition h)
	(hclass : c.1.val = d.1.val) (hnode : node c ≤ node d)
	(hc : variableEntry r c = true) : variableEntry r d = true := by
	have hd : depth c = depth d := by simp only [depth, hclass]
	have hp : plus c = plus d := by simp only [plus, hclass]
	unfold variableEntry at hc ⊢
	simp only [hd, hp] at hc
	split_ifs at hc ⊢ <;> simp_all <;> omega

	/-- A true variable entry has one of the three possible column-class labels. -/
	theorem variableEntry_mem_support {h : ℕ} (r c : VariablePosition h)
	(hc : variableEntry r c = true) : c.1.val ∈ variableSupportLabels r := by
	have hr := r.1.isLt
	have hcv := c.1.isLt
	simp only [variableSupportLabels, Finset.mem_insert, Finset.mem_singleton]
	unfold variableEntry at hc
	simp only [depth, plus, decide_eq_true_eq] at hc ⊢
	split_ifs at hc <;> simp_all <;> omega

	/-- The induced matrix on all non-anchor positions misses a five-bit word. -/
	theorem nonanchor_host_not_surjective (h : ℕ)
	(selected : Fin 5 → NonanchorPosition h) :
	¬ Function.Surjective
	(fun r : NonanchorPosition h =>
	fun i => host (Sum.inr r) (Sum.inr (selected i))) := by
	apply DirectNonshattering.not_surjective_selected_columns
	(fun r c : NonanchorPosition h => host (Sum.inr r) (Sum.inr c))
	nonanchorDummy nonanchorDummy nonanchorClass nonanchorKey
	· intro r hr c
	cases r with
	\| inl r => exact False.elim hr
	\| inr r => cases c <;> rfl
	· intro c hc r
	cases c with
	\| inl c => exact False.elim hc
	\| inr c => cases r <;> rfl
	· intro r hr c d hc hd hclass hnode he
	cases r with
	\| inr r => exact False.elim (hr trivial)
	\| inl r =>
	cases c with
	\| inr c => exact False.elim (hc trivial)
	\| inl c =>
	cases d with
	\| inr d => exact False.elim (hd trivial)
	\| inl d => exact variableEntry_mono_class r c d hclass hnode he
	· intro r hr
	cases r with
	\| inr r => exact False.elim (hr trivial)
	\| inl r =>
	apply (Finset.card_le_card ?_).trans (variableSupportLabels_card_le r)
	intro a ha
	obtain ⟨c, hc, rfl⟩ := Finset.mem_image.mp ha
	obtain ⟨_, hnd, he⟩ := Finset.mem_filter.mp hc
	cases c with
	\| inr c => exact False.elim (hnd trivial)
	\| inl c => exact variableEntry_mem_support r c he

	/-- The actual host, stated using its outer position type. This avoids any
	choice of a separate non-anchor enumeration in anchor-rigidity applications. -/
	theorem host_nonanchor_missing_word {h : ℕ} (columns : Fin 5 → Position h)
	(hcolumns : ∀ i, ∃ c : NonanchorPosition h, columns i = Sum.inr c) :
	∃ w : Fin 5 → Bool, ∀ r : Position h,
	(∃ a : NonanchorPosition h, r = Sum.inr a) →
	(fun i => host r (columns i)) ≠ w := by
	classical
	choose selected hselected using hcolumns
	obtain ⟨w, hw⟩ : ∃ w : Fin 5 → Bool, ∀ r : NonanchorPosition h,
	(fun i => host (Sum.inr r) (Sum.inr (selected i))) ≠ w := by
	simpa only [Function.Surjective, not_forall, not_exists] using
	nonanchor_host_not_surjective h selected
	refine ⟨w, ?_⟩
	rintro r ⟨a, rfl⟩
	simpa only [hselected] using hw a

	/-- Restricting to any collection of non-anchor rows still misses a word.
	This is the form used for the final 32 rows of an alleged anchor copy. -/
	theorem host_nonanchor_submatrix_not_surjective {h : ℕ} {R : Type uR}
	(rows : R → Position h) (columns : Fin 5 → Position h)
	(hrows : ∀ r, ∃ a : NonanchorPosition h, rows r = Sum.inr a)
	(hcolumns : ∀ i, ∃ c : NonanchorPosition h, columns i = Sum.inr c) :
	¬ Function.Surjective (fun r i => host (rows r) (columns i)) := by
	obtain ⟨w, hw⟩ := host_nonanchor_missing_word columns hcolumns
	intro hsurj
	obtain ⟨r, hr⟩ := hsurj w
	exact hw (rows r) (hrows r) hr

	/-- The outer sum tag gives a convenient intrinsic non-anchor predicate. -/
	@[simp] theorem exists_nonanchor_iff_not_isLeft {h : ℕ} (x : Position h) :
	(∃ a : NonanchorPosition h, x = Sum.inr a) ↔ ¬ x.isLeft := by
	cases x <;> simp

	/-- Pointwise missing-word property for concrete anchor rigidity. -/
	theorem host_nonanchor_missing_entry {h : ℕ} (columns : Fin 5 → Position h)
	(hcolumns : ∀ i, ¬ (columns i).isLeft) :
	∃ w : Fin 5 → Bool, ∀ r : Position h, ¬ r.isLeft →
	∃ i, host r (columns i) ≠ w i := by
	obtain ⟨w, hw⟩ := host_nonanchor_missing_word columns
	(fun i => (exists_nonanchor_iff_not_isLeft (columns i)).mpr (hcolumns i))
	refine ⟨w, ?_⟩
	intro r hr
	have hne := hw r ((exists_nonanchor_iff_not_isLeft r).mpr hr)
	exact not_forall.mp (fun he => hne (funext he))

	/-- The subtype formulation also avoids making any non-anchor choices. -/
	theorem host_nonanchor_subtype_not_surjective {h : ℕ}
	(columns : Fin 5 → Position h) (hcolumns : ∀ i, ¬ (columns i).isLeft) :
	¬ Function.Surjective
	(fun r : {x : Position h // ¬ x.isLeft} => fun i => host r.val (columns i)) := by
	apply host_nonanchor_submatrix_not_surjective
	(fun r : {x : Position h // ¬ x.isLeft} => r.val) columns
	· intro r
	exact (exists_nonanchor_iff_not_isLeft r.val).mpr r.property
	· intro i
	exact (exists_nonanchor_iff_not_isLeft (columns i)).mpr (hcolumns i)

	end
	end Problem348.Construction

	end OAI