Datasets:

roseking
/

openAI-math-dataset

import Mathlib

namespace OAI

/-!
# Ordered exhaustion of anchor groups

Once one mode is known, identical host rows within each group and distinct
pattern rows prevent repeated groups. The group order then forces the
selected group map to be the identity.
-/

universe uI uJ uR uC uG uL uT

namespace Problem348.AnchorGroups

/-- Distinct pattern rows force distinct selected group labels whenever equal
labels give identical rows against the selected columns. -/
theorem labels_injective {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {G : Type uG}
    (S : I → J → Bool) (A : R → C → Bool)
    (r : I → R) (c : J → C) (g : I → G)
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (htwin : ∀ i i', g i = g i' → ∀ j,
      A (r i) (c j) = A (r i') (c j)) :
    Function.Injective g := by
  intro i i' h
  apply hrows
  funext j
  rw [← hcopy i j, ← hcopy i' j]
  exact htwin i i' h j

/-- Equal host rows belonging to a fixed twin class cannot both be selected
by a pattern with distinct rows. This applies both to anchor groups and to the
dummy block, even before a common mode has been established. -/
theorem same_twin_class_index_eq {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC}
    (S : I → J → Bool) (A : R → C → Bool)
    (r : I → R) (c : J → C) (P : R → Prop)
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (htwin : ∀ x y, P x → P y → ∀ z, A x z = A y z)
    {i i' : I} (hi : P (r i)) (hi' : P (r i')) : i = i' := by
  apply hrows
  funext j
  rw [← hcopy i j, ← hcopy i' j]
  exact htwin (r i) (r i') hi hi' (c j)

/-- Before all selected positions are pinned, the partial anchor label is
already injective on the selected anchor positions. Nonanchor labels are not
required to be injective. -/
theorem partial_labels_injOn {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {L : Type uL}
    (S : I → J → Bool) (A : R → C → Bool)
    (r : I → R) (c : J → C) (label : R → Option L)
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (htwin : ∀ x y l, label x = some l → label y = some l →
      ∀ z, A x z = A y z) :
    Set.InjOn (fun i => label (r i)) {i | ∃ l, label (r i) = some l} := by
  intro i hi i' _ heq
  obtain ⟨l, hl⟩ := hi
  have hl' : label (r i') = some l := heq.symm.trans hl
  apply hrows
  funext j
  rw [← hcopy i j, ← hcopy i' j]
  exact htwin (r i) (r i') l hl hl' (c j)

/-- At most one selected position belongs to any host row twin class. -/
theorem selected_twin_class_card_le_one {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} [Fintype I]
    (S : I → J → Bool) (A : R → C → Bool)
    (r : I → R) (c : J → C) (P : R → Prop) [DecidablePred P]
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (htwin : ∀ x y, P x → P y → ∀ z, A x z = A y z) :
    (Finset.univ.filter (fun i => P (r i))).card ≤ 1 := by
  apply Finset.card_le_one.mpr
  intro i hi i' hi'
  exact same_twin_class_index_eq S A r c P hrows hcopy htwin
    (Finset.mem_filter.mp hi).2 (Finset.mem_filter.mp hi').2

/-- Unit-vector incidences contribute at most one true entry per participating
mode after selected anchor groups have been shown distinct. This is the
counting bridge from the concrete mode-support bound to rigidity's sparsity
hypothesis. -/
theorem true_entries_le_supported_modes {I : Type uI} {T : Type uT} {G : Type uG}
    (selected : Finset I) (mode : I → T) (group : I → G)
    (entry : I → Bool) (support : Finset T)
    (hgroups : Set.InjOn (fun i => (mode i, group i)) (↑selected : Set I))
    (hunit : ∀ i ∈ selected, ∀ j ∈ selected,
      entry i = true → entry j = true → mode i = mode j → group i = group j)
    (hsupport : ∀ i ∈ selected, entry i = true → mode i ∈ support) :
    (selected.filter (fun i => entry i = true)).card ≤ support.card := by
  classical
  apply Finset.card_le_card_of_injOn mode
  · intro i hi
    obtain ⟨his, hie⟩ := Finset.mem_filter.mp hi
    exact hsupport i his hie
  · intro i hi j hj hij
    obtain ⟨his, hie⟩ := Finset.mem_filter.mp hi
    obtain ⟨hjs, hje⟩ := Finset.mem_filter.mp hj
    apply hgroups his hjs
    exact Prod.ext hij (hunit i his j hjs hie hje hij)

/-- An increasing injective enumeration of a finite ordered set is its
prescribed enumeration. -/
theorem monotone_injective_eq_id {I : Type uI} [LinearOrder I] [Finite I]
    (g : I → I) (hmono : Monotone g) (hinj : Function.Injective g) :
    ∀ i, g i = i := by
  let f : I →o I := ⟨g, hmono⟩
  have hf : f = OrderHom.id := OrderHom.eq_id_of_injective f hinj
  intro i
  exact congrArg (fun q : I →o I => q i) hf

/-- Ordered group exhaustion for a copied pattern with distinct rows. -/
theorem group_eq_index {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} [LinearOrder I] [Finite I]
    (S : I → J → Bool) (A : R → C → Bool)
    (r : I → R) (c : J → C) (g : I → I)
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (htwin : ∀ i i', g i = g i' → ∀ j,
      A (r i) (c j) = A (r i') (c j))
    (hmono : Monotone g) : ∀ i, g i = i :=
  monotone_injective_eq_id g hmono
    (labels_injective S A r c g hrows hcopy htwin)

/-- Host-facing formulation: anchor labels record a mode and a group. Once
all selected rows are anchors of one mode, their group labels equal their
pattern indices. The column version follows by transposition. -/
theorem row_labels_eq {k : ℕ} {J : Type uJ} {R : Type uR} {C : Type uC} {T : Type uT} [LinearOrder R]
    (S : Fin k → J → Bool) (A : R → C → Bool)
    (label : R → Option (T × Fin k))
    (r : Fin k → R) (c : J → C) (t : T)
    (hr : StrictMono r)
    (hrows : Function.Injective S)
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (hmode : ∀ i, ∃ u, label (r i) = some (t, u))
    (htwin : ∀ x y u, label x = some (t, u) →
      label y = some (t, u) → ∀ z, A x z = A y z)
    (horder : ∀ x y u v, x < y → label x = some (t, u) →
      label y = some (t, v) → u ≤ v) :
    ∀ i, label (r i) = some (t, i) := by
  classical
  choose g hg using hmode
  have hmono : Monotone g := by
    intro i j hij
    rcases eq_or_lt_of_le hij with h | h
    · subst j
      exact le_rfl
    · exact horder (r i) (r j) (g i) (g j) (hr h) (hg i) (hg j)
  have heq : ∀ i, g i = i := group_eq_index S A r c g hrows hcopy
    (by
      intro i j hij z
      exact htwin (r i) (r j) (g i) (hg i) (hij ▸ hg j) (c z)) hmono
  intro i
  simpa only [heq i] using hg i

/-- Transposed host-facing formulation for the selected columns. -/
theorem column_labels_eq {k : ℕ} {I : Type uI} {R : Type uR} {C : Type uC} {T : Type uT} [LinearOrder C]
    (S : I → Fin k → Bool) (A : R → C → Bool)
    (label : C → Option (T × Fin k))
    (r : I → R) (c : Fin k → C) (t : T)
    (hc : StrictMono c)
    (hcols : Function.Injective (fun j i => S i j))
    (hcopy : ∀ i j, A (r i) (c j) = S i j)
    (hmode : ∀ j, ∃ v, label (c j) = some (t, v))
    (htwin : ∀ x y v, label x = some (t, v) →
      label y = some (t, v) → ∀ z, A z x = A z y)
    (horder : ∀ x y u v, x < y → label x = some (t, u) →
      label y = some (t, v) → u ≤ v) :
    ∀ j, label (c j) = some (t, j) := by
  exact row_labels_eq (fun j i => S i j) (fun y x => A x y)
    label c r t hc hcols (fun j i => hcopy i j) hmode htwin horder

end Problem348.AnchorGroups

end OAI

	import Mathlib

	namespace OAI

	/-!
	# Ordered exhaustion of anchor groups

	Once one mode is known, identical host rows within each group and distinct
	pattern rows prevent repeated groups. The group order then forces the
	selected group map to be the identity.
	-/

	universe uI uJ uR uC uG uL uT

	namespace Problem348.AnchorGroups

	/-- Distinct pattern rows force distinct selected group labels whenever equal
	labels give identical rows against the selected columns. -/
	theorem labels_injective {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {G : Type uG}
	(S : I → J → Bool) (A : R → C → Bool)
	(r : I → R) (c : J → C) (g : I → G)
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(htwin : ∀ i i', g i = g i' → ∀ j,
	A (r i) (c j) = A (r i') (c j)) :
	Function.Injective g := by
	intro i i' h
	apply hrows
	funext j
	rw [← hcopy i j, ← hcopy i' j]
	exact htwin i i' h j

	/-- Equal host rows belonging to a fixed twin class cannot both be selected
	by a pattern with distinct rows. This applies both to anchor groups and to the
	dummy block, even before a common mode has been established. -/
	theorem same_twin_class_index_eq {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC}
	(S : I → J → Bool) (A : R → C → Bool)
	(r : I → R) (c : J → C) (P : R → Prop)
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(htwin : ∀ x y, P x → P y → ∀ z, A x z = A y z)
	{i i' : I} (hi : P (r i)) (hi' : P (r i')) : i = i' := by
	apply hrows
	funext j
	rw [← hcopy i j, ← hcopy i' j]
	exact htwin (r i) (r i') hi hi' (c j)

	/-- Before all selected positions are pinned, the partial anchor label is
	already injective on the selected anchor positions. Nonanchor labels are not
	required to be injective. -/
	theorem partial_labels_injOn {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} {L : Type uL}
	(S : I → J → Bool) (A : R → C → Bool)
	(r : I → R) (c : J → C) (label : R → Option L)
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(htwin : ∀ x y l, label x = some l → label y = some l →
	∀ z, A x z = A y z) :
	Set.InjOn (fun i => label (r i)) {i \| ∃ l, label (r i) = some l} := by
	intro i hi i' _ heq
	obtain ⟨l, hl⟩ := hi
	have hl' : label (r i') = some l := heq.symm.trans hl
	apply hrows
	funext j
	rw [← hcopy i j, ← hcopy i' j]
	exact htwin (r i) (r i') l hl hl' (c j)

	/-- At most one selected position belongs to any host row twin class. -/
	theorem selected_twin_class_card_le_one {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} [Fintype I]
	(S : I → J → Bool) (A : R → C → Bool)
	(r : I → R) (c : J → C) (P : R → Prop) [DecidablePred P]
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(htwin : ∀ x y, P x → P y → ∀ z, A x z = A y z) :
	(Finset.univ.filter (fun i => P (r i))).card ≤ 1 := by
	apply Finset.card_le_one.mpr
	intro i hi i' hi'
	exact same_twin_class_index_eq S A r c P hrows hcopy htwin
	(Finset.mem_filter.mp hi).2 (Finset.mem_filter.mp hi').2

	/-- Unit-vector incidences contribute at most one true entry per participating
	mode after selected anchor groups have been shown distinct. This is the
	counting bridge from the concrete mode-support bound to rigidity's sparsity
	hypothesis. -/
	theorem true_entries_le_supported_modes {I : Type uI} {T : Type uT} {G : Type uG}
	(selected : Finset I) (mode : I → T) (group : I → G)
	(entry : I → Bool) (support : Finset T)
	(hgroups : Set.InjOn (fun i => (mode i, group i)) (↑selected : Set I))
	(hunit : ∀ i ∈ selected, ∀ j ∈ selected,
	entry i = true → entry j = true → mode i = mode j → group i = group j)
	(hsupport : ∀ i ∈ selected, entry i = true → mode i ∈ support) :
	(selected.filter (fun i => entry i = true)).card ≤ support.card := by
	classical
	apply Finset.card_le_card_of_injOn mode
	· intro i hi
	obtain ⟨his, hie⟩ := Finset.mem_filter.mp hi
	exact hsupport i his hie
	· intro i hi j hj hij
	obtain ⟨his, hie⟩ := Finset.mem_filter.mp hi
	obtain ⟨hjs, hje⟩ := Finset.mem_filter.mp hj
	apply hgroups his hjs
	exact Prod.ext hij (hunit i his j hjs hie hje hij)

	/-- An increasing injective enumeration of a finite ordered set is its
	prescribed enumeration. -/
	theorem monotone_injective_eq_id {I : Type uI} [LinearOrder I] [Finite I]
	(g : I → I) (hmono : Monotone g) (hinj : Function.Injective g) :
	∀ i, g i = i := by
	let f : I →o I := ⟨g, hmono⟩
	have hf : f = OrderHom.id := OrderHom.eq_id_of_injective f hinj
	intro i
	exact congrArg (fun q : I →o I => q i) hf

	/-- Ordered group exhaustion for a copied pattern with distinct rows. -/
	theorem group_eq_index {I : Type uI} {J : Type uJ} {R : Type uR} {C : Type uC} [LinearOrder I] [Finite I]
	(S : I → J → Bool) (A : R → C → Bool)
	(r : I → R) (c : J → C) (g : I → I)
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(htwin : ∀ i i', g i = g i' → ∀ j,
	A (r i) (c j) = A (r i') (c j))
	(hmono : Monotone g) : ∀ i, g i = i :=
	monotone_injective_eq_id g hmono
	(labels_injective S A r c g hrows hcopy htwin)

	/-- Host-facing formulation: anchor labels record a mode and a group. Once
	all selected rows are anchors of one mode, their group labels equal their
	pattern indices. The column version follows by transposition. -/
	theorem row_labels_eq {k : ℕ} {J : Type uJ} {R : Type uR} {C : Type uC} {T : Type uT} [LinearOrder R]
	(S : Fin k → J → Bool) (A : R → C → Bool)
	(label : R → Option (T × Fin k))
	(r : Fin k → R) (c : J → C) (t : T)
	(hr : StrictMono r)
	(hrows : Function.Injective S)
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(hmode : ∀ i, ∃ u, label (r i) = some (t, u))
	(htwin : ∀ x y u, label x = some (t, u) →
	label y = some (t, u) → ∀ z, A x z = A y z)
	(horder : ∀ x y u v, x < y → label x = some (t, u) →
	label y = some (t, v) → u ≤ v) :
	∀ i, label (r i) = some (t, i) := by
	classical
	choose g hg using hmode
	have hmono : Monotone g := by
	intro i j hij
	rcases eq_or_lt_of_le hij with h \| h
	· subst j
	exact le_rfl
	· exact horder (r i) (r j) (g i) (g j) (hr h) (hg i) (hg j)
	have heq : ∀ i, g i = i := group_eq_index S A r c g hrows hcopy
	(by
	intro i j hij z
	exact htwin (r i) (r j) (g i) (hg i) (hij ▸ hg j) (c z)) hmono
	intro i
	simpa only [heq i] using hg i

	/-- Transposed host-facing formulation for the selected columns. -/
	theorem column_labels_eq {k : ℕ} {I : Type uI} {R : Type uR} {C : Type uC} {T : Type uT} [LinearOrder C]
	(S : I → Fin k → Bool) (A : R → C → Bool)
	(label : C → Option (T × Fin k))
	(r : I → R) (c : Fin k → C) (t : T)
	(hc : StrictMono c)
	(hcols : Function.Injective (fun j i => S i j))
	(hcopy : ∀ i j, A (r i) (c j) = S i j)
	(hmode : ∀ j, ∃ v, label (c j) = some (t, v))
	(htwin : ∀ x y v, label x = some (t, v) →
	label y = some (t, v) → ∀ z, A z x = A z y)
	(horder : ∀ x y u v, x < y → label x = some (t, u) →
	label y = some (t, v) → u ≤ v) :
	∀ j, label (c j) = some (t, j) := by
	exact row_labels_eq (fun j i => S i j) (fun y x => A x y)
	label c r t hc hcols (fun j i => hcopy i j) hmode htwin horder

	end Problem348.AnchorGroups

	end OAI