Datasets:

roseking
/

openAI-math-dataset

import OAI.Combinatorics.LowSpaceSubsetSum.Counting.Model
import Mathlib.Data.Finset.Card
import Mathlib.Data.Finset.Powerset

namespace OAI

/-!
# Equal-weight records and exact dictionary capacities

An additional prime can distinguish unequal weights, but cannot distinguish
different masks of equal weight. These deterministic bounds handle that case,
including the full-mask endpoint of the right-prefix refinement.
-/

namespace LowSpaceSubsetSum

variable {ι : Type*} [DecidableEq ι]
instance : DecidableEq (Entry ι) := fun a b =>
  if h : a.value = b.value ∧ a.mask = b.mask then
    isTrue (by cases a; cases b; simp_all)
  else isFalse (by intro hab; exact h (hab ▸ ⟨rfl, rfl⟩))
/-- Equal-weight records are uniquely identified by their top masks. -/
theorem same_weight_card_le_masks (U : Finset (Entry ι)) (x : ℤ) :
    (U.filter fun e => e.value = x).card ≤ (U.image Entry.mask).card := by
  classical
  have hinj : Set.InjOn Entry.mask (↑(U.filter fun e => e.value = x) : Set (Entry ι)) := by
    intro e he f hf hmask
    have heq := (Finset.mem_filter.mp he).2
    have hfq := (Finset.mem_filter.mp hf).2
    cases e
    cases f
    simp_all
  calc
    _ = ((U.filter fun e => e.value = x).image Entry.mask).card :=
      (Finset.card_image_iff.mpr hinj).symm
    _ ≤ (U.image Entry.mask).card :=
      Finset.card_le_card (Finset.image_subset_image (Finset.filter_subset _ _))
/-- Prescribed mask size bounds all equal-weight records by a binomial count. -/
theorem same_weight_card_le_choose (U : Finset (Entry ι)) (top : Finset ι)
    (k : ℕ) (hmask : ∀ e ∈ U, e.mask ⊆ top ∧ e.mask.card = k) (x : ℤ) :
    (U.filter fun e => e.value = x).card ≤ top.card.choose k := by
  apply (same_weight_card_le_masks U x).trans
  calc
    _ ≤ (top.powersetCard k).card := by
      apply Finset.card_le_card
      intro D hD
      obtain ⟨e, he, rfl⟩ := Finset.mem_image.mp hD
      exact Finset.mem_powersetCard.mpr (hmask e he)
    _ = _ := Finset.card_powersetCard _ _
/-- Fixing both the exact weight and the entire mask leaves at most one key. -/
theorem full_mask_same_weight_card_le_one (U : Finset (Entry ι))
    (x : ℤ) (D : Finset ι) :
    (U.filter fun e => e.value = x ∧ e.mask = D).card ≤ 1 := by
  apply Finset.card_le_one.mpr
  intro e he f hf
  obtain ⟨he0, he1⟩ := (Finset.mem_filter.mp he).2
  obtain ⟨hf0, hf1⟩ := (Finset.mem_filter.mp hf).2
  cases e
  cases f
  simp_all
omit [DecidableEq ι] in
/-- The complete bucket fits when both its equal- and unequal-weight parts fit.
This counts keys, rather than raw tuples producing those keys. -/
theorem bucket_card_le_of_parts (U : Finset (Entry ι)) (x : ℤ) (C A B : ℕ)
    (hneq : (U.filter fun e => e.value ≠ x).card ≤ A)
    (heq : (U.filter fun e => e.value = x).card ≤ B) (hcap : A + B ≤ C) :
    U.card ≤ C := by
  have h := Finset.card_filter_add_card_filter_not (s := U) (p := fun e => e.value = x)
  have hcard : (U.filter fun e => e.value = x).card +
      (U.filter fun e => e.value ≠ x).card = U.card := by
    simpa only [ne_eq] using h
  omega
end LowSpaceSubsetSum
end OAI

	import OAI.Combinatorics.LowSpaceSubsetSum.Counting.Model
	import Mathlib.Data.Finset.Card
	import Mathlib.Data.Finset.Powerset

	namespace OAI

	/-!
	# Equal-weight records and exact dictionary capacities

	An additional prime can distinguish unequal weights, but cannot distinguish
	different masks of equal weight. These deterministic bounds handle that case,
	including the full-mask endpoint of the right-prefix refinement.
	-/

	namespace LowSpaceSubsetSum

	variable {ι : Type*} [DecidableEq ι]

	instance : DecidableEq (Entry ι) := fun a b =>
	if h : a.value = b.value ∧ a.mask = b.mask then
	isTrue (by cases a; cases b; simp_all)
	else isFalse (by intro hab; exact h (hab ▸ ⟨rfl, rfl⟩))

	/-- Equal-weight records are uniquely identified by their top masks. -/
	theorem same_weight_card_le_masks (U : Finset (Entry ι)) (x : ℤ) :
	(U.filter fun e => e.value = x).card ≤ (U.image Entry.mask).card := by
	classical
	have hinj : Set.InjOn Entry.mask (↑(U.filter fun e => e.value = x) : Set (Entry ι)) := by
	intro e he f hf hmask
	have heq := (Finset.mem_filter.mp he).2
	have hfq := (Finset.mem_filter.mp hf).2
	cases e
	cases f
	simp_all
	calc
	_ = ((U.filter fun e => e.value = x).image Entry.mask).card :=
	(Finset.card_image_iff.mpr hinj).symm
	_ ≤ (U.image Entry.mask).card :=
	Finset.card_le_card (Finset.image_subset_image (Finset.filter_subset _ _))

	/-- Prescribed mask size bounds all equal-weight records by a binomial count. -/
	theorem same_weight_card_le_choose (U : Finset (Entry ι)) (top : Finset ι)
	(k : ℕ) (hmask : ∀ e ∈ U, e.mask ⊆ top ∧ e.mask.card = k) (x : ℤ) :
	(U.filter fun e => e.value = x).card ≤ top.card.choose k := by
	apply (same_weight_card_le_masks U x).trans
	calc
	_ ≤ (top.powersetCard k).card := by
	apply Finset.card_le_card
	intro D hD
	obtain ⟨e, he, rfl⟩ := Finset.mem_image.mp hD
	exact Finset.mem_powersetCard.mpr (hmask e he)
	_ = _ := Finset.card_powersetCard _ _

	/-- Fixing both the exact weight and the entire mask leaves at most one key. -/
	theorem full_mask_same_weight_card_le_one (U : Finset (Entry ι))
	(x : ℤ) (D : Finset ι) :
	(U.filter fun e => e.value = x ∧ e.mask = D).card ≤ 1 := by
	apply Finset.card_le_one.mpr
	intro e he f hf
	obtain ⟨he0, he1⟩ := (Finset.mem_filter.mp he).2
	obtain ⟨hf0, hf1⟩ := (Finset.mem_filter.mp hf).2
	cases e
	cases f
	simp_all

	omit [DecidableEq ι] in
	/-- The complete bucket fits when both its equal- and unequal-weight parts fit.
	This counts keys, rather than raw tuples producing those keys. -/
	theorem bucket_card_le_of_parts (U : Finset (Entry ι)) (x : ℤ) (C A B : ℕ)
	(hneq : (U.filter fun e => e.value ≠ x).card ≤ A)
	(heq : (U.filter fun e => e.value = x).card ≤ B) (hcap : A + B ≤ C) :
	U.card ≤ C := by
	have h := Finset.card_filter_add_card_filter_not (s := U) (p := fun e => e.value = x)
	have hcard : (U.filter fun e => e.value = x).card +
	(U.filter fun e => e.value ≠ x).card = U.card := by
	simpa only [ne_eq] using h
	omega

	end LowSpaceSubsetSum

	end OAI