Datasets:

roseking
/

openAI-math-dataset

import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Fintype.Sum
import Mathlib.Logic.Equiv.Set
import Mathlib.Logic.Equiv.Prod
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Tactic.FinCases

namespace OAI

universe uV uC uι uA uB

namespace PeriodicTilingThree

open scoped BigOperators Classical

section

variable {V : Type uV} {C : Type uC} [Fintype V] [Fintype C] {k : ℕ}

noncomputable def allBadAssignments
    (pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
    Finset (V → C) := by
  classical
  exact Finset.univ.filter fun f =>
    ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j

@[simp] theorem mem_allBadAssignments
    (pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) (f : V → C) :
    f ∈ allBadAssignments pair Good ↔
      ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j := by
  classical
  simp [allBadAssignments]

private abbrev Outside (pair : (Fin k × Fin 2) ↪ V) :=
  {v : V // v ∉ Set.range pair}

private noncomputable def vertexDecomposition (pair : (Fin k × Fin 2) ↪ V) :
    ((Fin k × Fin 2) ⊕ Outside pair) ≃ V := by
  classical
  exact (Equiv.sumCongr (Equiv.ofInjective pair pair.injective) (Equiv.refl _)).trans
    (Equiv.Set.sumCompl (Set.range pair))

private theorem vertexDecomposition_inl {V : Type uV} [Fintype V] (pair : (Fin k × Fin 2) ↪ V)
    (x : Fin k × Fin 2) : vertexDecomposition pair (Sum.inl x) = pair x := rfl

private theorem outside_card (pair : (Fin k × Fin 2) ↪ V) :
    Fintype.card (Outside pair) = Fintype.card V - 2 * k := by
  classical
  have h := Fintype.card_congr (vertexDecomposition pair)
  simp only [Fintype.card_sum, Fintype.card_prod, Fintype.card_fin] at h
  omega

private def edgeAssignmentEquiv : ((Fin k × Fin 2) → C) ≃ (Fin k → C × C) where
  toFun f j := (f (j, 0), f (j, 1))
  invFun f x := if x.2 = 0 then (f x.1).1 else (f x.1).2
  left_inv f := by
    funext x
    rcases x with ⟨j, b⟩
    fin_cases b <;> simp
  right_inv f := by
    funext j
    simp

private noncomputable def assignmentDecomposition (pair : (Fin k × Fin 2) ↪ V) :
    (V → C) ≃ (Fin k → C × C) × (Outside pair → C) :=
  ((Equiv.arrowCongr (vertexDecomposition pair).symm (Equiv.refl C)).trans
    (Equiv.sumArrowEquivProdArrow _ _ _)).trans
    (Equiv.prodCongr edgeAssignmentEquiv (Equiv.refl _))

private theorem assignmentDecomposition_apply
    {V : Type uV} {C : Type uC} [Fintype V] [Fintype C] (pair : (Fin k × Fin 2) ↪ V)
    (f : V → C) (j : Fin k) :
    (assignmentDecomposition pair f).1 j = (f (pair (j, 0)), f (pair (j, 1))) := rfl

private def constrainedProductEquiv {ι : Type uι} {A : Type uA} {B : Type uB} (p : ι → A → Prop) :
    {x : (ι → A) × B // ∀ i, p i (x.1 i)} ≃ (∀ i, {a : A // p i a}) × B where
  toFun x := (fun i => ⟨x.1.1 i, x.2 i⟩, x.1.2)
  invFun x := ⟨(fun i => (x.1 i).1, x.2), fun i => (x.1 i).2⟩
  left_inv x := by cases x; rfl
  right_inv x := by cases x; rfl

private noncomputable def badAssignmentEquiv
    (pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
    {f : V → C // ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j} ≃
      (∀ j : Fin k, {c : C × C // c ∉ Good j}) × (Outside pair → C) :=
  ((assignmentDecomposition pair).subtypeEquiv (fun _ => Iff.rfl)).trans
    (constrainedProductEquiv fun j c => c ∉ Good j)

theorem allBadAssignments_card
    (pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
    (allBadAssignments pair Good).card =
      (∏ j : Fin k, (Fintype.card C ^ 2 - (Good j).card)) *
        Fintype.card C ^ (Fintype.card V - 2 * k) := by
  classical
  have hbad : (allBadAssignments pair Good).card =
      Fintype.card {f : V → C // ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j} := by
    rw [Fintype.card_subtype]
    rfl
  have hcolor (j : Fin k) : Fintype.card {c : C × C // c ∉ Good j} =
      Fintype.card C ^ 2 - (Good j).card := by
    rw [Fintype.card_subtype_compl]
    simp [Fintype.card_prod, pow_two]
  rw [hbad, Fintype.card_congr (badAssignmentEquiv pair Good), Fintype.card_prod,
    Fintype.card_pi, Fintype.card_fun, outside_card]
  simp_rw [hcolor]

theorem allBadAssignments_card_le
    (pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) (g : ℕ)
    (hgood : ∀ j, g ≤ (Good j).card) :
    (allBadAssignments pair Good).card ≤
      (Fintype.card C ^ 2 - g) ^ k * Fintype.card C ^ (Fintype.card V - 2 * k) := by
  classical
  rw [allBadAssignments_card]
  apply Nat.mul_le_mul_right
  calc
    (∏ j : Fin k, (Fintype.card C ^ 2 - (Good j).card)) ≤
        ∏ _j : Fin k, (Fintype.card C ^ 2 - g) :=
      Finset.prod_le_prod (fun j _ => Nat.sub_le_sub_left (hgood j) _)
    _ = (Fintype.card C ^ 2 - g) ^ k := by simp

end

end PeriodicTilingThree

end OAI

	import Mathlib.Data.Fintype.BigOperators
	import Mathlib.Data.Fintype.Card
	import Mathlib.Data.Fintype.Sum
	import Mathlib.Logic.Equiv.Set
	import Mathlib.Logic.Equiv.Prod
	import Mathlib.Algebra.Order.BigOperators.Ring.Finset
	import Mathlib.Tactic.FinCases

	namespace OAI

	universe uV uC uι uA uB

	namespace PeriodicTilingThree

	open scoped BigOperators Classical

	section

	variable {V : Type uV} {C : Type uC} [Fintype V] [Fintype C] {k : ℕ}

	noncomputable def allBadAssignments
	(pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
	Finset (V → C) := by
	classical
	exact Finset.univ.filter fun f =>
	∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j

	@[simp] theorem mem_allBadAssignments
	(pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) (f : V → C) :
	f ∈ allBadAssignments pair Good ↔
	∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j := by
	classical
	simp [allBadAssignments]

	private abbrev Outside (pair : (Fin k × Fin 2) ↪ V) :=
	{v : V // v ∉ Set.range pair}

	private noncomputable def vertexDecomposition (pair : (Fin k × Fin 2) ↪ V) :
	((Fin k × Fin 2) ⊕ Outside pair) ≃ V := by
	classical
	exact (Equiv.sumCongr (Equiv.ofInjective pair pair.injective) (Equiv.refl _)).trans
	(Equiv.Set.sumCompl (Set.range pair))

	private theorem vertexDecomposition_inl {V : Type uV} [Fintype V] (pair : (Fin k × Fin 2) ↪ V)
	(x : Fin k × Fin 2) : vertexDecomposition pair (Sum.inl x) = pair x := rfl

	private theorem outside_card (pair : (Fin k × Fin 2) ↪ V) :
	Fintype.card (Outside pair) = Fintype.card V - 2 * k := by
	classical
	have h := Fintype.card_congr (vertexDecomposition pair)
	simp only [Fintype.card_sum, Fintype.card_prod, Fintype.card_fin] at h
	omega

	private def edgeAssignmentEquiv : ((Fin k × Fin 2) → C) ≃ (Fin k → C × C) where
	toFun f j := (f (j, 0), f (j, 1))
	invFun f x := if x.2 = 0 then (f x.1).1 else (f x.1).2
	left_inv f := by
	funext x
	rcases x with ⟨j, b⟩
	fin_cases b <;> simp
	right_inv f := by
	funext j
	simp

	private noncomputable def assignmentDecomposition (pair : (Fin k × Fin 2) ↪ V) :
	(V → C) ≃ (Fin k → C × C) × (Outside pair → C) :=
	((Equiv.arrowCongr (vertexDecomposition pair).symm (Equiv.refl C)).trans
	(Equiv.sumArrowEquivProdArrow _ _ _)).trans
	(Equiv.prodCongr edgeAssignmentEquiv (Equiv.refl _))

	private theorem assignmentDecomposition_apply
	{V : Type uV} {C : Type uC} [Fintype V] [Fintype C] (pair : (Fin k × Fin 2) ↪ V)
	(f : V → C) (j : Fin k) :
	(assignmentDecomposition pair f).1 j = (f (pair (j, 0)), f (pair (j, 1))) := rfl

	private def constrainedProductEquiv {ι : Type uι} {A : Type uA} {B : Type uB} (p : ι → A → Prop) :
	{x : (ι → A) × B // ∀ i, p i (x.1 i)} ≃ (∀ i, {a : A // p i a}) × B where
	toFun x := (fun i => ⟨x.1.1 i, x.2 i⟩, x.1.2)
	invFun x := ⟨(fun i => (x.1 i).1, x.2), fun i => (x.1 i).2⟩
	left_inv x := by cases x; rfl
	right_inv x := by cases x; rfl

	private noncomputable def badAssignmentEquiv
	(pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
	{f : V → C // ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j} ≃
	(∀ j : Fin k, {c : C × C // c ∉ Good j}) × (Outside pair → C) :=
	((assignmentDecomposition pair).subtypeEquiv (fun _ => Iff.rfl)).trans
	(constrainedProductEquiv fun j c => c ∉ Good j)

	theorem allBadAssignments_card
	(pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) :
	(allBadAssignments pair Good).card =
	(∏ j : Fin k, (Fintype.card C ^ 2 - (Good j).card)) *
	Fintype.card C ^ (Fintype.card V - 2 * k) := by
	classical
	have hbad : (allBadAssignments pair Good).card =
	Fintype.card {f : V → C // ∀ j, (f (pair (j, 0)), f (pair (j, 1))) ∉ Good j} := by
	rw [Fintype.card_subtype]
	rfl
	have hcolor (j : Fin k) : Fintype.card {c : C × C // c ∉ Good j} =
	Fintype.card C ^ 2 - (Good j).card := by
	rw [Fintype.card_subtype_compl]
	simp [Fintype.card_prod, pow_two]
	rw [hbad, Fintype.card_congr (badAssignmentEquiv pair Good), Fintype.card_prod,
	Fintype.card_pi, Fintype.card_fun, outside_card]
	simp_rw [hcolor]

	theorem allBadAssignments_card_le
	(pair : (Fin k × Fin 2) ↪ V) (Good : Fin k → Finset (C × C)) (g : ℕ)
	(hgood : ∀ j, g ≤ (Good j).card) :
	(allBadAssignments pair Good).card ≤
	(Fintype.card C ^ 2 - g) ^ k * Fintype.card C ^ (Fintype.card V - 2 * k) := by
	classical
	rw [allBadAssignments_card]
	apply Nat.mul_le_mul_right
	calc
	(∏ j : Fin k, (Fintype.card C ^ 2 - (Good j).card)) ≤
	∏ _j : Fin k, (Fintype.card C ^ 2 - g) :=
	Finset.prod_le_prod (fun j _ => Nat.sub_le_sub_left (hgood j) _)
	_ = (Fintype.card C ^ 2 - g) ^ k := by simp

	end

	end PeriodicTilingThree

	end OAI