Datasets:

roseking
/

openAI-math-dataset

import Mathlib

namespace OAI

/-!
Mode-incidence bounds. Active modes have levels 1 through h, while
variable positions have levels 0 through h. At level h the plus and minus
blocks coincide.
-/

universe uAlpha

namespace Problem348.ModeIncidence

inductive Kind where
  | vertical (sign : Bool)
  | horizontal (sign parity : Bool)
  deriving DecidableEq, Fintype

abbrev Mode := ℕ × Kind

/-- Leaf positions have both sign names; other positions have their own sign. -/
def hasSign (h depth : ℕ) (own requested : Bool) : Prop :=
  depth = h ∨ own = requested

/-- Incidence with either row role of a mode. -/
def rowIncident (h depth : ℕ) (sign parity : Bool) (t : Mode) : Prop :=
  1 ≤ t.1 ∧ t.1 ≤ h ∧
    match t.2 with
    | .vertical s => (depth = t.1 ∨ depth + 1 = t.1) ∧ hasSign h depth sign s
    | .horizontal s p => depth = t.1 ∧ hasSign h depth sign s ∧ parity = p

/-- Incidence with either column role of a mode. -/
def colIncident (h depth : ℕ) (sign parity : Bool) (t : Mode) : Prop :=
  1 ≤ t.1 ∧ t.1 ≤ h ∧
    match t.2 with
    | .vertical s => depth + 1 = t.1 ∧ hasSign h depth sign s
    | .horizontal s p => hasSign h depth sign s ∧
        (depth + 1 = t.1 ∨ (depth = t.1 ∧ parity = p))

/-- Three possible modes for an internal variable row. Boundary levels may
remove some of these modes. -/
def internalRowModes (depth : ℕ) (sign parity : Bool) : Finset Mode :=
  {(depth, .vertical sign), (depth + 1, .vertical sign),
    (depth, .horizontal sign parity)}

/-- The four possible modes for a shared leaf row. -/
def leafRowModes (h : ℕ) (parity : Bool) : Finset Mode :=
  {(h, .vertical false), (h, .vertical true),
    (h, .horizontal false parity), (h, .horizontal true parity)}

/-- Four possible modes for an internal variable column. -/
def internalColModes (depth : ℕ) (sign parity : Bool) : Finset Mode :=
  {(depth + 1, .vertical sign), (depth + 1, .horizontal sign false),
    (depth + 1, .horizontal sign true), (depth, .horizontal sign parity)}

/-- The two possible modes for a shared leaf column. -/
def leafColModes (h : ℕ) (parity : Bool) : Finset Mode :=
  {(h, .horizontal false parity), (h, .horizontal true parity)}

theorem rowIncident_internal {h depth : ℕ} {sign parity : Bool} {t : Mode}
    (hd : depth < h) (ht : rowIncident h depth sign parity t) :
    t ∈ internalRowModes depth sign parity := by
  rcases t with ⟨level, kind⟩
  rcases kind with s | ⟨s, p⟩ <;> dsimp [rowIncident] at ht
  · rcases ht with ⟨_, _, hlevel, hsign⟩
    have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
    subst s
    rcases hlevel with rfl | rfl <;> simp [internalRowModes]
  · rcases ht with ⟨_, _, hlevel, hsign, hp⟩
    have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
    subst s
    subst p
    subst level
    simp [internalRowModes]

theorem rowIncident_leaf {h : ℕ} {sign parity : Bool} {t : Mode}
    (ht : rowIncident h h sign parity t) : t ∈ leafRowModes h parity := by
  rcases t with ⟨level, kind⟩
  rcases kind with s | ⟨s, p⟩ <;> dsimp [rowIncident] at ht
  · rcases ht with ⟨_, hbound, hlevel, _⟩
    have heq : level = h := by omega
    subst level
    cases s <;> simp [leafRowModes]
  · rcases ht with ⟨_, _, hlevel, _, hp⟩
    subst level
    subst p
    cases s <;> simp [leafRowModes]

theorem colIncident_internal {h depth : ℕ} {sign parity : Bool} {t : Mode}
    (hd : depth < h) (ht : colIncident h depth sign parity t) :
    t ∈ internalColModes depth sign parity := by
  rcases t with ⟨level, kind⟩
  rcases kind with s | ⟨s, p⟩ <;> dsimp [colIncident] at ht
  · rcases ht with ⟨_, _, hlevel, hsign⟩
    have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
    subst s
    subst level
    simp [internalColModes]
  · rcases ht with ⟨_, _, hsign, hlevel⟩
    have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
    subst s
    rcases hlevel with hlevel | ⟨hlevel, hp⟩
    · subst level
      cases p <;> simp [internalColModes]
    · subst level
      subst p
      simp [internalColModes]

theorem colIncident_leaf {h : ℕ} {sign parity : Bool} {t : Mode}
    (ht : colIncident h h sign parity t) : t ∈ leafColModes h parity := by
  rcases t with ⟨level, kind⟩
  rcases kind with s | ⟨s, p⟩ <;> dsimp [colIncident] at ht
  · rcases ht with ⟨_, hbound, hlevel, _⟩
    omega
  · rcases ht with ⟨_, hbound, _, hlevel⟩
    rcases hlevel with hbad | ⟨heq, hp⟩
    · omega
    · subst level
      subst p
      cases s <;> simp [leafColModes]

/-- An internal row participates in at most three modes. -/
theorem card_internalRowModes_le (depth : ℕ) (sign parity : Bool) :
    (internalRowModes depth sign parity).card ≤ 3 := by
  simp only [internalRowModes]
  exact Finset.card_insert_le _ _ |>.trans (Nat.succ_le_succ
    (Finset.card_insert_le _ _ |>.trans (by simp)))

/-- A leaf row participates in at most four modes. -/
theorem card_leafRowModes_le (h : ℕ) (parity : Bool) :
    (leafRowModes h parity).card ≤ 4 := by
  simp [leafRowModes]

/-- A variable column below the leaf level participates in at most four modes. -/
theorem card_internalColModes_le (depth : ℕ) (sign parity : Bool) :
    (internalColModes depth sign parity).card ≤ 4 := by
  unfold internalColModes
  exact Finset.card_insert_le _ _ |>.trans (Nat.succ_le_succ
    (Finset.card_insert_le _ _ |>.trans (Nat.succ_le_succ
      (Finset.card_insert_le _ _ |>.trans (by simp)))))

/-- A leaf column participates in at most two modes. -/
theorem card_leafColModes_le (h : ℕ) (parity : Bool) :
    (leafColModes h parity).card ≤ 2 := by
  simp [leafColModes]

/-- Formulation independent of the particular finite enumeration of valid modes. -/
theorem card_row_incident_le_four {h depth : ℕ} {sign parity : Bool}
    (hd : depth ≤ h) (modes : Finset Mode)
    (hmodes : ∀ t ∈ modes, rowIncident h depth sign parity t) :
    modes.card ≤ 4 := by
  rcases lt_or_eq_of_le hd with hd | rfl
  · have hsub : modes ⊆ internalRowModes depth sign parity := by
      intro t ht
      exact rowIncident_internal hd (hmodes t ht)
    exact (Finset.card_le_card hsub).trans
      ((card_internalRowModes_le depth sign parity).trans (by decide))
  · have hsub : modes ⊆ leafRowModes depth parity := by
      intro t ht
      exact rowIncident_leaf (hmodes t ht)
    exact (Finset.card_le_card hsub).trans (card_leafRowModes_le depth parity)

/-- Formulation independent of the particular finite enumeration of valid modes. -/
theorem card_col_incident_le_four {h depth : ℕ} {sign parity : Bool}
    (hd : depth ≤ h) (modes : Finset Mode)
    (hmodes : ∀ t ∈ modes, colIncident h depth sign parity t) :
    modes.card ≤ 4 := by
  rcases lt_or_eq_of_le hd with hd | rfl
  · have hsub : modes ⊆ internalColModes depth sign parity := by
      intro t ht
      exact colIncident_internal hd (hmodes t ht)
    exact (Finset.card_le_card hsub).trans (card_internalColModes_le depth sign parity)
  · have hsub : modes ⊆ leafColModes depth parity := by
      intro t ht
      exact colIncident_leaf (hmodes t ht)
    exact (Finset.card_le_card hsub).trans
      ((card_leafColModes_le depth parity).trans (by decide))

/-- A generic sparse-trace transfer: at most one chosen one-entry per mode. -/
theorem card_ones_le_of_mode_bound {α : Type uAlpha} [DecidableEq α]
    (positions : Finset α) (mode : α → Mode) (entry : α → Bool)
    (incident : Mode → Prop) (bound : ℕ)
    (hbound : ∀ modes : Finset Mode,
      (∀ t ∈ modes, incident t) → modes.card ≤ bound)
    (hincident : ∀ x ∈ positions, entry x = true → incident (mode x))
    (hunique : ∀ x ∈ positions, ∀ y ∈ positions,
      entry x = true → entry y = true → mode x = mode y → x = y) :
    (positions.filter (fun x => entry x = true)).card ≤ bound := by
  have hinjective : Set.InjOn mode
      (↑(positions.filter (fun x => entry x = true)) : Set α) := by
    intro x hx y hy heq
    obtain ⟨hx, hxe⟩ := Finset.mem_filter.mp hx
    obtain ⟨hy, hye⟩ := Finset.mem_filter.mp hy
    exact hunique x hx y hy hxe hye heq
  rw [← Finset.card_image_of_injOn hinjective]
  apply hbound
  intro t ht
  obtain ⟨x, hx, rfl⟩ := Finset.mem_image.mp ht
  obtain ⟨hx, hxe⟩ := Finset.mem_filter.mp hx
  exact hincident x hx hxe

/-- Against anchor representatives, a variable row has at most four ones,
provided one-entries in the same mode use the same representative. -/
theorem card_row_ones_le_four {α : Type uAlpha} [DecidableEq α]
    {h depth : ℕ} {sign parity : Bool} (hd : depth ≤ h)
    (positions : Finset α) (mode : α → Mode) (entry : α → Bool)
    (hincident : ∀ x ∈ positions, entry x = true →
      rowIncident h depth sign parity (mode x))
    (hunique : ∀ x ∈ positions, ∀ y ∈ positions,
      entry x = true → entry y = true → mode x = mode y → x = y) :
    (positions.filter (fun x => entry x = true)).card ≤ 4 :=
  card_ones_le_of_mode_bound positions mode entry
    (rowIncident h depth sign parity) 4
    (card_row_incident_le_four hd) hincident hunique

/-- The symmetric sparse-trace statement for variable columns. -/
theorem card_col_ones_le_four {α : Type uAlpha} [DecidableEq α]
    {h depth : ℕ} {sign parity : Bool} (hd : depth ≤ h)
    (positions : Finset α) (mode : α → Mode) (entry : α → Bool)
    (hincident : ∀ x ∈ positions, entry x = true →
      colIncident h depth sign parity (mode x))
    (hunique : ∀ x ∈ positions, ∀ y ∈ positions,
      entry x = true → entry y = true → mode x = mode y → x = y) :
    (positions.filter (fun x => entry x = true)).card ≤ 4 :=
  card_ones_le_of_mode_bound positions mode entry
    (colIncident h depth sign parity) 4
    (card_col_incident_le_four hd) hincident hunique

end Problem348.ModeIncidence

end OAI

	import Mathlib

	namespace OAI

	/-!
	Mode-incidence bounds. Active modes have levels 1 through h, while
	variable positions have levels 0 through h. At level h the plus and minus
	blocks coincide.
	-/

	universe uAlpha

	namespace Problem348.ModeIncidence

	inductive Kind where
	\| vertical (sign : Bool)
	\| horizontal (sign parity : Bool)
	deriving DecidableEq, Fintype

	abbrev Mode := ℕ × Kind

	/-- Leaf positions have both sign names; other positions have their own sign. -/
	def hasSign (h depth : ℕ) (own requested : Bool) : Prop :=
	depth = h ∨ own = requested

	/-- Incidence with either row role of a mode. -/
	def rowIncident (h depth : ℕ) (sign parity : Bool) (t : Mode) : Prop :=
	1 ≤ t.1 ∧ t.1 ≤ h ∧
	match t.2 with
	\| .vertical s => (depth = t.1 ∨ depth + 1 = t.1) ∧ hasSign h depth sign s
	\| .horizontal s p => depth = t.1 ∧ hasSign h depth sign s ∧ parity = p

	/-- Incidence with either column role of a mode. -/
	def colIncident (h depth : ℕ) (sign parity : Bool) (t : Mode) : Prop :=
	1 ≤ t.1 ∧ t.1 ≤ h ∧
	match t.2 with
	\| .vertical s => depth + 1 = t.1 ∧ hasSign h depth sign s
	\| .horizontal s p => hasSign h depth sign s ∧
	(depth + 1 = t.1 ∨ (depth = t.1 ∧ parity = p))

	/-- Three possible modes for an internal variable row. Boundary levels may
	remove some of these modes. -/
	def internalRowModes (depth : ℕ) (sign parity : Bool) : Finset Mode :=
	{(depth, .vertical sign), (depth + 1, .vertical sign),
	(depth, .horizontal sign parity)}

	/-- The four possible modes for a shared leaf row. -/
	def leafRowModes (h : ℕ) (parity : Bool) : Finset Mode :=
	{(h, .vertical false), (h, .vertical true),
	(h, .horizontal false parity), (h, .horizontal true parity)}

	/-- Four possible modes for an internal variable column. -/
	def internalColModes (depth : ℕ) (sign parity : Bool) : Finset Mode :=
	{(depth + 1, .vertical sign), (depth + 1, .horizontal sign false),
	(depth + 1, .horizontal sign true), (depth, .horizontal sign parity)}

	/-- The two possible modes for a shared leaf column. -/
	def leafColModes (h : ℕ) (parity : Bool) : Finset Mode :=
	{(h, .horizontal false parity), (h, .horizontal true parity)}

	theorem rowIncident_internal {h depth : ℕ} {sign parity : Bool} {t : Mode}
	(hd : depth < h) (ht : rowIncident h depth sign parity t) :
	t ∈ internalRowModes depth sign parity := by
	rcases t with ⟨level, kind⟩
	rcases kind with s \| ⟨s, p⟩ <;> dsimp [rowIncident] at ht
	· rcases ht with ⟨_, _, hlevel, hsign⟩
	have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
	subst s
	rcases hlevel with rfl \| rfl <;> simp [internalRowModes]
	· rcases ht with ⟨_, _, hlevel, hsign, hp⟩
	have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
	subst s
	subst p
	subst level
	simp [internalRowModes]

	theorem rowIncident_leaf {h : ℕ} {sign parity : Bool} {t : Mode}
	(ht : rowIncident h h sign parity t) : t ∈ leafRowModes h parity := by
	rcases t with ⟨level, kind⟩
	rcases kind with s \| ⟨s, p⟩ <;> dsimp [rowIncident] at ht
	· rcases ht with ⟨_, hbound, hlevel, _⟩
	have heq : level = h := by omega
	subst level
	cases s <;> simp [leafRowModes]
	· rcases ht with ⟨_, _, hlevel, _, hp⟩
	subst level
	subst p
	cases s <;> simp [leafRowModes]

	theorem colIncident_internal {h depth : ℕ} {sign parity : Bool} {t : Mode}
	(hd : depth < h) (ht : colIncident h depth sign parity t) :
	t ∈ internalColModes depth sign parity := by
	rcases t with ⟨level, kind⟩
	rcases kind with s \| ⟨s, p⟩ <;> dsimp [colIncident] at ht
	· rcases ht with ⟨_, _, hlevel, hsign⟩
	have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
	subst s
	subst level
	simp [internalColModes]
	· rcases ht with ⟨_, _, hsign, hlevel⟩
	have hs : sign = s := hsign.resolve_left (Nat.ne_of_lt hd)
	subst s
	rcases hlevel with hlevel \| ⟨hlevel, hp⟩
	· subst level
	cases p <;> simp [internalColModes]
	· subst level
	subst p
	simp [internalColModes]

	theorem colIncident_leaf {h : ℕ} {sign parity : Bool} {t : Mode}
	(ht : colIncident h h sign parity t) : t ∈ leafColModes h parity := by
	rcases t with ⟨level, kind⟩
	rcases kind with s \| ⟨s, p⟩ <;> dsimp [colIncident] at ht
	· rcases ht with ⟨_, hbound, hlevel, _⟩
	omega
	· rcases ht with ⟨_, hbound, _, hlevel⟩
	rcases hlevel with hbad \| ⟨heq, hp⟩
	· omega
	· subst level
	subst p
	cases s <;> simp [leafColModes]

	/-- An internal row participates in at most three modes. -/
	theorem card_internalRowModes_le (depth : ℕ) (sign parity : Bool) :
	(internalRowModes depth sign parity).card ≤ 3 := by
	simp only [internalRowModes]
	exact Finset.card_insert_le _ _ \|>.trans (Nat.succ_le_succ
	(Finset.card_insert_le _ _ \|>.trans (by simp)))

	/-- A leaf row participates in at most four modes. -/
	theorem card_leafRowModes_le (h : ℕ) (parity : Bool) :
	(leafRowModes h parity).card ≤ 4 := by
	simp [leafRowModes]

	/-- A variable column below the leaf level participates in at most four modes. -/
	theorem card_internalColModes_le (depth : ℕ) (sign parity : Bool) :
	(internalColModes depth sign parity).card ≤ 4 := by
	unfold internalColModes
	exact Finset.card_insert_le _ _ \|>.trans (Nat.succ_le_succ
	(Finset.card_insert_le _ _ \|>.trans (Nat.succ_le_succ
	(Finset.card_insert_le _ _ \|>.trans (by simp)))))

	/-- A leaf column participates in at most two modes. -/
	theorem card_leafColModes_le (h : ℕ) (parity : Bool) :
	(leafColModes h parity).card ≤ 2 := by
	simp [leafColModes]

	/-- Formulation independent of the particular finite enumeration of valid modes. -/
	theorem card_row_incident_le_four {h depth : ℕ} {sign parity : Bool}
	(hd : depth ≤ h) (modes : Finset Mode)
	(hmodes : ∀ t ∈ modes, rowIncident h depth sign parity t) :
	modes.card ≤ 4 := by
	rcases lt_or_eq_of_le hd with hd \| rfl
	· have hsub : modes ⊆ internalRowModes depth sign parity := by
	intro t ht
	exact rowIncident_internal hd (hmodes t ht)
	exact (Finset.card_le_card hsub).trans
	((card_internalRowModes_le depth sign parity).trans (by decide))
	· have hsub : modes ⊆ leafRowModes depth parity := by
	intro t ht
	exact rowIncident_leaf (hmodes t ht)
	exact (Finset.card_le_card hsub).trans (card_leafRowModes_le depth parity)

	/-- Formulation independent of the particular finite enumeration of valid modes. -/
	theorem card_col_incident_le_four {h depth : ℕ} {sign parity : Bool}
	(hd : depth ≤ h) (modes : Finset Mode)
	(hmodes : ∀ t ∈ modes, colIncident h depth sign parity t) :
	modes.card ≤ 4 := by
	rcases lt_or_eq_of_le hd with hd \| rfl
	· have hsub : modes ⊆ internalColModes depth sign parity := by
	intro t ht
	exact colIncident_internal hd (hmodes t ht)
	exact (Finset.card_le_card hsub).trans (card_internalColModes_le depth sign parity)
	· have hsub : modes ⊆ leafColModes depth parity := by
	intro t ht
	exact colIncident_leaf (hmodes t ht)
	exact (Finset.card_le_card hsub).trans
	((card_leafColModes_le depth parity).trans (by decide))

	/-- A generic sparse-trace transfer: at most one chosen one-entry per mode. -/
	theorem card_ones_le_of_mode_bound {α : Type uAlpha} [DecidableEq α]
	(positions : Finset α) (mode : α → Mode) (entry : α → Bool)
	(incident : Mode → Prop) (bound : ℕ)
	(hbound : ∀ modes : Finset Mode,
	(∀ t ∈ modes, incident t) → modes.card ≤ bound)
	(hincident : ∀ x ∈ positions, entry x = true → incident (mode x))
	(hunique : ∀ x ∈ positions, ∀ y ∈ positions,
	entry x = true → entry y = true → mode x = mode y → x = y) :
	(positions.filter (fun x => entry x = true)).card ≤ bound := by
	have hinjective : Set.InjOn mode
	(↑(positions.filter (fun x => entry x = true)) : Set α) := by
	intro x hx y hy heq
	obtain ⟨hx, hxe⟩ := Finset.mem_filter.mp hx
	obtain ⟨hy, hye⟩ := Finset.mem_filter.mp hy
	exact hunique x hx y hy hxe hye heq
	rw [← Finset.card_image_of_injOn hinjective]
	apply hbound
	intro t ht
	obtain ⟨x, hx, rfl⟩ := Finset.mem_image.mp ht
	obtain ⟨hx, hxe⟩ := Finset.mem_filter.mp hx
	exact hincident x hx hxe

	/-- Against anchor representatives, a variable row has at most four ones,
	provided one-entries in the same mode use the same representative. -/
	theorem card_row_ones_le_four {α : Type uAlpha} [DecidableEq α]
	{h depth : ℕ} {sign parity : Bool} (hd : depth ≤ h)
	(positions : Finset α) (mode : α → Mode) (entry : α → Bool)
	(hincident : ∀ x ∈ positions, entry x = true →
	rowIncident h depth sign parity (mode x))
	(hunique : ∀ x ∈ positions, ∀ y ∈ positions,
	entry x = true → entry y = true → mode x = mode y → x = y) :
	(positions.filter (fun x => entry x = true)).card ≤ 4 :=
	card_ones_le_of_mode_bound positions mode entry
	(rowIncident h depth sign parity) 4
	(card_row_incident_le_four hd) hincident hunique

	/-- The symmetric sparse-trace statement for variable columns. -/
	theorem card_col_ones_le_four {α : Type uAlpha} [DecidableEq α]
	{h depth : ℕ} {sign parity : Bool} (hd : depth ≤ h)
	(positions : Finset α) (mode : α → Mode) (entry : α → Bool)
	(hincident : ∀ x ∈ positions, entry x = true →
	colIncident h depth sign parity (mode x))
	(hunique : ∀ x ∈ positions, ∀ y ∈ positions,
	entry x = true → entry y = true → mode x = mode y → x = y) :
	(positions.filter (fun x => entry x = true)).card ≤ 4 :=
	card_ones_le_of_mode_bound positions mode entry
	(colIncident h depth sign parity) 4
	(card_col_incident_le_four hd) hincident hunique

	end Problem348.ModeIncidence

	end OAI