Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Computability.VertexCover.Analysis.BaseReductionCoherent

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
namespace VertexCover.LabelCover
open UniqueGames.Foundations.Games
noncomputable section

def occurrenceLaw (Φ : LabelCover) : FiniteDistribution (Fin Φ.M) := by
  letI : Nonempty (Fin Φ.M) := ⟨⟨0, Φ.M_pos⟩⟩
  exact FiniteDistribution.uniform (Fin Φ.M)

def questionProjection (Φ : LabelCover) (x : Fin Φ.u) (y : Fin Φ.v) (a : Fin Φ.qU) : Fin Φ.qV :=
  if h : ∃ e, Φ.left e = x ∧ Φ.right e = y then Φ.projection h.choose a
  else ⟨0, Φ.qV_pos⟩

theorem questionProjection_at (Φ : LabelCover) (hc : Φ.ParallelCoherent)
    (e : Fin Φ.M) (a : Fin Φ.qU) :
    Φ.questionProjection (Φ.left e) (Φ.right e) a = Φ.projection e a := by
  unfold questionProjection
  split
  · rename_i h
    exact congrFun (hc h.choose e h.choose_spec.1 h.choose_spec.2) a
  · rename_i h
    exact False.elim (h ⟨e, rfl, rfl⟩)

def asGame (Φ : LabelCover) : Game (Fin Φ.u) (Fin Φ.v) (Fin Φ.qU) (Fin Φ.qV) :=
  { questions := Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))
    accepts := fun x y a b => decide (Φ.questionProjection x y a = b) }

theorem asGame_success (Φ : LabelCover) (hc : Φ.ParallelCoherent) (A : Φ.Labeling) :
    Φ.asGame.success A = (Φ.satisfiedCount A : ℝ) / Φ.M := by
  classical
  change (Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))).probability _ = _
  rw [FiniteDistribution.probability_pushforward]
  simp only [FiniteDistribution.probability, Game.wins, asGame, questionProjection_at Φ hc,
    decide_eq_true_eq]
  simp only [occurrenceLaw, FiniteDistribution.uniform, Fintype.card_fin]
  change (∑ e, if Φ.Satisfies A e then 1 / (Φ.M : ℝ) else 0) = _
  calc
    _ = (∑ e, (if Φ.Satisfies A e then 1 else 0 : ℝ)) / Φ.M := by
      rw [Finset.sum_div]
      apply Finset.sum_congr rfl
      intro e he
      split_ifs <;> simp
    _ = _ := by rw [Finset.sum_boole]; rfl

def asGameValue (Φ : LabelCover) : ℝ := by
  letI : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
  letI : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
  exact Φ.asGame.value

theorem asGameValue_eq (Φ : LabelCover) (hc : Φ.ParallelCoherent) : Φ.asGameValue = Φ.value := by
  classical
  let : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
  let : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
  change Φ.asGame.value = Φ.value
  apply le_antisymm
  · apply (Φ.asGame.value_le_iff _).mpr
    intro A
    rw [asGame_success Φ hc A]
    exact div_le_div_of_nonneg_right (Nat.cast_le.mpr (Φ.satisfiedCount_le_max A)) (by positivity)
  · apply value_le_of_counts
    intro A
    have hs := Φ.asGame.success_le_value A
    rw [asGame_success Φ hc A] at hs
    exact (div_le_iff₀ (Nat.cast_pos.mpr Φ.M_pos)).mp hs

def tupleEquiv (a n : ℕ) : (Fin n → Fin a) ≃ Fin (a ^ n) :=
  Fintype.equivFinOfCardEq (by simp)

def parallelPower (Φ : LabelCover) (n : ℕ) : LabelCover where
  u := Φ.u ^ n
  v := Φ.v ^ n
  qU := Φ.qU ^ n
  qV := Φ.qV ^ n
  M := Φ.M ^ n
  qU_pos := pow_pos Φ.qU_pos _
  qV_pos := pow_pos Φ.qV_pos _
  M_pos := pow_pos Φ.M_pos _
  left e := tupleEquiv Φ.u n (fun i => Φ.left ((tupleEquiv Φ.M n).symm e i))
  right e := tupleEquiv Φ.v n (fun i => Φ.right ((tupleEquiv Φ.M n).symm e i))
  projection e a := tupleEquiv Φ.qV n (fun i => Φ.projection ((tupleEquiv Φ.M n).symm e i)
    ((tupleEquiv Φ.qU n).symm a i))

def repeatLabeling (Φ : LabelCover) (n : ℕ) (A : Φ.Labeling) : (Φ.parallelPower n).Labeling :=
  (fun x => tupleEquiv Φ.qU n (fun i => A.1 ((tupleEquiv Φ.u n).symm x i)),
   fun y => tupleEquiv Φ.qV n (fun i => A.2 ((tupleEquiv Φ.v n).symm y i)))

theorem repeat_perfect (Φ : LabelCover) (n : ℕ) (A : Φ.Labeling) (hA : ∀ e, Φ.Satisfies A e) :
    ∀ e, (Φ.parallelPower n).Satisfies (Φ.repeatLabeling n A) e := by
  intro e
  change tupleEquiv Φ.qV n _ = tupleEquiv Φ.qV n _
  apply congrArg (tupleEquiv Φ.qV n)
  funext i
  simpa only [Satisfies, repeatLabeling, parallelPower, Equiv.symm_apply_apply] using hA ((tupleEquiv Φ.M n).symm e i)

def repeatedStrategy (Φ : LabelCover) (n : ℕ) (A : (Φ.parallelPower n).Labeling) :
    Strategy (Fin n → Fin Φ.u) (Fin n → Fin Φ.v) (Fin n → Fin Φ.qU) (Fin n → Fin Φ.qV) :=
  (fun x => (tupleEquiv Φ.qU n).symm (A.1 (tupleEquiv Φ.u n x)),
   fun y => (tupleEquiv Φ.qV n).symm (A.2 (tupleEquiv Φ.v n y)))

theorem repetition_success_probability (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ)
    (B : Strategy (Fin n → Fin Φ.u) (Fin n → Fin Φ.v)
      (Fin n → Fin Φ.qU) (Fin n → Fin Φ.qV)) :
    (Φ.asGame.repetition n).success B = (Φ.occurrenceLaw.iid n).probability
      (fun es => decide (∀ i, Φ.projection (es i)
        (B.1 (fun j => Φ.left (es j)) i) = B.2 (fun j => Φ.right (es j)) i)) := by
  classical
  unfold Game.success
  change (((Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))).iid n).transport
    (Game.tupleQuestionEquiv n)).probability _ = _
  rw [FiniteDistribution.probability_transport, FiniteDistribution.iid_pushforward,
    FiniteDistribution.probability_pushforward]
  congr 1
  funext es
  simp only [Game.wins, Game.repetition, Game.tupleQuestionEquiv, asGame,
    Equiv.coe_fn_mk, questionProjection_at Φ hc, decide_eq_true_eq]

theorem power_satisfies_iff (Φ : LabelCover) (n : ℕ) (A : (Φ.parallelPower n).Labeling)
    (es : Fin n → Fin Φ.M) :
    (Φ.parallelPower n).Satisfies A (tupleEquiv Φ.M n es) ↔
      ∀ i, Φ.projection (es i)
        ((Φ.repeatedStrategy n A).1 (fun j => Φ.left (es j)) i) =
        (Φ.repeatedStrategy n A).2 (fun j => Φ.right (es j)) i := by
  simp only [Satisfies, parallelPower, repeatedStrategy, Equiv.symm_apply_apply]
  rw [← Equiv.eq_symm_apply]
  exact funext_iff

theorem repetition_success (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ)
    (A : (Φ.parallelPower n).Labeling) :
    (Φ.asGame.repetition n).success (Φ.repeatedStrategy n A) =
      ((Φ.parallelPower n).satisfiedCount A : ℝ) / (Φ.M ^ n : ℕ) := by
  classical
  let : Nonempty (Fin Φ.M) := ⟨⟨0, Φ.M_pos⟩⟩
  rw [repetition_success_probability Φ hc]
  have hlaw : Φ.occurrenceLaw.iid n = FiniteDistribution.uniform (Fin n → Fin Φ.M) :=
    FiniteDistribution.iid_uniform n
  rw [hlaw]
  simp only [← power_satisfies_iff Φ n A, FiniteDistribution.probability,
    FiniteDistribution.uniform, Fintype.card_fun, Fintype.card_fin, decide_eq_true_eq]
  calc
    _ = ∑ e : Fin (Φ.M ^ n), if (Φ.parallelPower n).Satisfies A e then
        1 / ((Φ.M ^ n : ℕ) : ℝ) else 0 :=
      Fintype.sum_equiv (tupleEquiv Φ.M n) _ _ (fun _ => rfl)
    _ = (∑ e : Fin (Φ.M ^ n), (if (Φ.parallelPower n).Satisfies A e then 1 else 0 : ℝ)) /
        (Φ.M ^ n : ℕ) := by
      rw [Finset.sum_div]
      apply Finset.sum_congr rfl
      intro e he
      split_ifs <;> simp
    _ = _ := by
      have hsum : (∑ e : Fin (Φ.parallelPower n).M,
          (@ite ℝ ((Φ.parallelPower n).Satisfies A e) (Classical.propDecidable _) 1 0)) =
          ((Φ.parallelPower n).satisfiedCount A : ℝ) := by
        rw [satisfiedCount, Finset.card_filter, Nat.cast_sum]
        apply Finset.sum_congr rfl
        intro e he
        by_cases h : (Φ.parallelPower n).Satisfies A e <;> simp only [h, ite_true, ite_false, Nat.cast_zero, Nat.cast_one]
      exact congrArg (fun x : ℝ => x / ((Φ.M ^ n : ℕ) : ℝ)) hsum

theorem power_value_le_repetition (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ) :
    (Φ.parallelPower n).value ≤
      (letI : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩;
       letI : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩;
       (Φ.asGame.repetition n).value) := by
  classical
  let : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
  let : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
  apply value_le_of_counts
  intro A
  have hs := (Φ.asGame.repetition n).success_le_value (Φ.repeatedStrategy n A)
  rw [repetition_success Φ hc] at hs
  exact (div_le_iff₀ (Nat.cast_pos.mpr (pow_pos Φ.M_pos n))).mp hs

end
end VertexCover.LabelCover


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI

	import Mathlib
	import OAI.Computability.VertexCover.Analysis.BaseReductionCoherent

	namespace OAI

	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	namespace VertexCover.LabelCover
	open UniqueGames.Foundations.Games
	noncomputable section

	def occurrenceLaw (Φ : LabelCover) : FiniteDistribution (Fin Φ.M) := by
	letI : Nonempty (Fin Φ.M) := ⟨⟨0, Φ.M_pos⟩⟩
	exact FiniteDistribution.uniform (Fin Φ.M)

	def questionProjection (Φ : LabelCover) (x : Fin Φ.u) (y : Fin Φ.v) (a : Fin Φ.qU) : Fin Φ.qV :=
	if h : ∃ e, Φ.left e = x ∧ Φ.right e = y then Φ.projection h.choose a
	else ⟨0, Φ.qV_pos⟩

	theorem questionProjection_at (Φ : LabelCover) (hc : Φ.ParallelCoherent)
	(e : Fin Φ.M) (a : Fin Φ.qU) :
	Φ.questionProjection (Φ.left e) (Φ.right e) a = Φ.projection e a := by
	unfold questionProjection
	split
	· rename_i h
	exact congrFun (hc h.choose e h.choose_spec.1 h.choose_spec.2) a
	· rename_i h
	exact False.elim (h ⟨e, rfl, rfl⟩)

	def asGame (Φ : LabelCover) : Game (Fin Φ.u) (Fin Φ.v) (Fin Φ.qU) (Fin Φ.qV) :=
	{ questions := Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))
	accepts := fun x y a b => decide (Φ.questionProjection x y a = b) }

	theorem asGame_success (Φ : LabelCover) (hc : Φ.ParallelCoherent) (A : Φ.Labeling) :
	Φ.asGame.success A = (Φ.satisfiedCount A : ℝ) / Φ.M := by
	classical
	change (Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))).probability _ = _
	rw [FiniteDistribution.probability_pushforward]
	simp only [FiniteDistribution.probability, Game.wins, asGame, questionProjection_at Φ hc,
	decide_eq_true_eq]
	simp only [occurrenceLaw, FiniteDistribution.uniform, Fintype.card_fin]
	change (∑ e, if Φ.Satisfies A e then 1 / (Φ.M : ℝ) else 0) = _
	calc
	_ = (∑ e, (if Φ.Satisfies A e then 1 else 0 : ℝ)) / Φ.M := by
	rw [Finset.sum_div]
	apply Finset.sum_congr rfl
	intro e he
	split_ifs <;> simp
	_ = _ := by rw [Finset.sum_boole]; rfl

	def asGameValue (Φ : LabelCover) : ℝ := by
	letI : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
	letI : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
	exact Φ.asGame.value

	theorem asGameValue_eq (Φ : LabelCover) (hc : Φ.ParallelCoherent) : Φ.asGameValue = Φ.value := by
	classical
	let : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
	let : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
	change Φ.asGame.value = Φ.value
	apply le_antisymm
	· apply (Φ.asGame.value_le_iff _).mpr
	intro A
	rw [asGame_success Φ hc A]
	exact div_le_div_of_nonneg_right (Nat.cast_le.mpr (Φ.satisfiedCount_le_max A)) (by positivity)
	· apply value_le_of_counts
	intro A
	have hs := Φ.asGame.success_le_value A
	rw [asGame_success Φ hc A] at hs
	exact (div_le_iff₀ (Nat.cast_pos.mpr Φ.M_pos)).mp hs

	def tupleEquiv (a n : ℕ) : (Fin n → Fin a) ≃ Fin (a ^ n) :=
	Fintype.equivFinOfCardEq (by simp)

	def parallelPower (Φ : LabelCover) (n : ℕ) : LabelCover where
	u := Φ.u ^ n
	v := Φ.v ^ n
	qU := Φ.qU ^ n
	qV := Φ.qV ^ n
	M := Φ.M ^ n
	qU_pos := pow_pos Φ.qU_pos _
	qV_pos := pow_pos Φ.qV_pos _
	M_pos := pow_pos Φ.M_pos _
	left e := tupleEquiv Φ.u n (fun i => Φ.left ((tupleEquiv Φ.M n).symm e i))
	right e := tupleEquiv Φ.v n (fun i => Φ.right ((tupleEquiv Φ.M n).symm e i))
	projection e a := tupleEquiv Φ.qV n (fun i => Φ.projection ((tupleEquiv Φ.M n).symm e i)
	((tupleEquiv Φ.qU n).symm a i))

	def repeatLabeling (Φ : LabelCover) (n : ℕ) (A : Φ.Labeling) : (Φ.parallelPower n).Labeling :=
	(fun x => tupleEquiv Φ.qU n (fun i => A.1 ((tupleEquiv Φ.u n).symm x i)),
	fun y => tupleEquiv Φ.qV n (fun i => A.2 ((tupleEquiv Φ.v n).symm y i)))

	theorem repeat_perfect (Φ : LabelCover) (n : ℕ) (A : Φ.Labeling) (hA : ∀ e, Φ.Satisfies A e) :
	∀ e, (Φ.parallelPower n).Satisfies (Φ.repeatLabeling n A) e := by
	intro e
	change tupleEquiv Φ.qV n _ = tupleEquiv Φ.qV n _
	apply congrArg (tupleEquiv Φ.qV n)
	funext i
	simpa only [Satisfies, repeatLabeling, parallelPower, Equiv.symm_apply_apply] using hA ((tupleEquiv Φ.M n).symm e i)

	def repeatedStrategy (Φ : LabelCover) (n : ℕ) (A : (Φ.parallelPower n).Labeling) :
	Strategy (Fin n → Fin Φ.u) (Fin n → Fin Φ.v) (Fin n → Fin Φ.qU) (Fin n → Fin Φ.qV) :=
	(fun x => (tupleEquiv Φ.qU n).symm (A.1 (tupleEquiv Φ.u n x)),
	fun y => (tupleEquiv Φ.qV n).symm (A.2 (tupleEquiv Φ.v n y)))

	theorem repetition_success_probability (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ)
	(B : Strategy (Fin n → Fin Φ.u) (Fin n → Fin Φ.v)
	(Fin n → Fin Φ.qU) (Fin n → Fin Φ.qV)) :
	(Φ.asGame.repetition n).success B = (Φ.occurrenceLaw.iid n).probability
	(fun es => decide (∀ i, Φ.projection (es i)
	(B.1 (fun j => Φ.left (es j)) i) = B.2 (fun j => Φ.right (es j)) i)) := by
	classical
	unfold Game.success
	change (((Φ.occurrenceLaw.pushforward (fun e => (Φ.left e, Φ.right e))).iid n).transport
	(Game.tupleQuestionEquiv n)).probability _ = _
	rw [FiniteDistribution.probability_transport, FiniteDistribution.iid_pushforward,
	FiniteDistribution.probability_pushforward]
	congr 1
	funext es
	simp only [Game.wins, Game.repetition, Game.tupleQuestionEquiv, asGame,
	Equiv.coe_fn_mk, questionProjection_at Φ hc, decide_eq_true_eq]

	theorem power_satisfies_iff (Φ : LabelCover) (n : ℕ) (A : (Φ.parallelPower n).Labeling)
	(es : Fin n → Fin Φ.M) :
	(Φ.parallelPower n).Satisfies A (tupleEquiv Φ.M n es) ↔
	∀ i, Φ.projection (es i)
	((Φ.repeatedStrategy n A).1 (fun j => Φ.left (es j)) i) =
	(Φ.repeatedStrategy n A).2 (fun j => Φ.right (es j)) i := by
	simp only [Satisfies, parallelPower, repeatedStrategy, Equiv.symm_apply_apply]
	rw [← Equiv.eq_symm_apply]
	exact funext_iff

	theorem repetition_success (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ)
	(A : (Φ.parallelPower n).Labeling) :
	(Φ.asGame.repetition n).success (Φ.repeatedStrategy n A) =
	((Φ.parallelPower n).satisfiedCount A : ℝ) / (Φ.M ^ n : ℕ) := by
	classical
	let : Nonempty (Fin Φ.M) := ⟨⟨0, Φ.M_pos⟩⟩
	rw [repetition_success_probability Φ hc]
	have hlaw : Φ.occurrenceLaw.iid n = FiniteDistribution.uniform (Fin n → Fin Φ.M) :=
	FiniteDistribution.iid_uniform n
	rw [hlaw]
	simp only [← power_satisfies_iff Φ n A, FiniteDistribution.probability,
	FiniteDistribution.uniform, Fintype.card_fun, Fintype.card_fin, decide_eq_true_eq]
	calc
	_ = ∑ e : Fin (Φ.M ^ n), if (Φ.parallelPower n).Satisfies A e then
	1 / ((Φ.M ^ n : ℕ) : ℝ) else 0 :=
	Fintype.sum_equiv (tupleEquiv Φ.M n) _ _ (fun _ => rfl)
	_ = (∑ e : Fin (Φ.M ^ n), (if (Φ.parallelPower n).Satisfies A e then 1 else 0 : ℝ)) /
	(Φ.M ^ n : ℕ) := by
	rw [Finset.sum_div]
	apply Finset.sum_congr rfl
	intro e he
	split_ifs <;> simp
	_ = _ := by
	have hsum : (∑ e : Fin (Φ.parallelPower n).M,
	(@ite ℝ ((Φ.parallelPower n).Satisfies A e) (Classical.propDecidable _) 1 0)) =
	((Φ.parallelPower n).satisfiedCount A : ℝ) := by
	rw [satisfiedCount, Finset.card_filter, Nat.cast_sum]
	apply Finset.sum_congr rfl
	intro e he
	by_cases h : (Φ.parallelPower n).Satisfies A e <;> simp only [h, ite_true, ite_false, Nat.cast_zero, Nat.cast_one]
	exact congrArg (fun x : ℝ => x / ((Φ.M ^ n : ℕ) : ℝ)) hsum

	theorem power_value_le_repetition (Φ : LabelCover) (hc : Φ.ParallelCoherent) (n : ℕ) :
	(Φ.parallelPower n).value ≤
	(letI : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩;
	letI : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩;
	(Φ.asGame.repetition n).value) := by
	classical
	let : Nonempty (Fin Φ.qU) := ⟨⟨0, Φ.qU_pos⟩⟩
	let : Nonempty (Fin Φ.qV) := ⟨⟨0, Φ.qV_pos⟩⟩
	apply value_le_of_counts
	intro A
	have hs := (Φ.asGame.repetition n).success_le_value (Φ.repeatedStrategy n A)
	rw [repetition_success Φ hc] at hs
	exact (div_le_iff₀ (Nat.cast_pos.mpr (pow_pos Φ.M_pos n))).mp hs

	end
	end VertexCover.LabelCover


	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end

	end OAI