Download data/lean/OAI/Computability/DirectedFeedback/Games/Explicit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 43.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/Explicit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/DirectedFeedback/Games/Explicit.lean
-
curl -L -o Explicit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/Explicit.lean
43.8 kB
import Mathlib
import OAI.Computability.DirectedFeedback.Games.ActualCanonical
namespace OAI
namespace DFVSGames.Reduction.Explicit
variable {Ξ± Ξ² : Type*}
def pairs (xs : List Ξ±) (ys : List Ξ²) : List (Ξ± Γ Ξ²) :=
xs.flatMap fun x => ys.map fun y => (x, y)
theorem length_pairs (xs : List Ξ±) (ys : List Ξ²) :
(pairs xs ys).length = xs.length * ys.length := by
induction xs with
| nil => simp [pairs]
| cons x xs ih =>
simp only [pairs, List.flatMap_cons, List.length_append, List.length_map,
List.length_cons] at *
rw [ih, Nat.add_mul, Nat.one_mul, Nat.add_comm]
theorem mem_pairs {xs : List Ξ±} {ys : List Ξ²} {x : Ξ±} {y : Ξ²} :
(x, y) β pairs xs ys β x β xs β§ y β ys := by
simp [pairs]
def words (alphabet : List Ξ±) : Nat β List (List Ξ±)
| 0 => [[]]
| k + 1 => (pairs alphabet (words alphabet k)).map fun p => p.1 :: p.2
theorem length_words (alphabet : List Ξ±) (k : Nat) :
(words alphabet k).length = alphabet.length ^ k := by
induction k with
| zero => simp [words]
| succ k ih =>
simp only [words, List.length_map, length_pairs, ih, Nat.pow_succ]
exact Nat.mul_comm _ _
theorem mem_words {alphabet : List Ξ±} {w : List Ξ±} {k : Nat} :
w β words alphabet k β w.length = k β§ β a β w, a β alphabet := by
induction k generalizing w with
| zero => cases w <;> simp [words]
| succ k ih =>
cases w with
| nil => simp [words, pairs]
| cons a w =>
simp only [words, List.mem_map]
constructor
Β· rintro β¨β¨b, vβ©, h, heqβ©
cases heq
obtain β¨ha, hwβ© := mem_pairs.mp h
obtain β¨hlen, hallβ© := ih.mp hw
constructor
Β· simp [hlen]
Β· intro x hx
rcases List.mem_cons.mp hx with hax | hxw
Β· simpa [hax] using ha
Β· exact hall x hxw
Β· rintro β¨hlen, hallβ©
refine β¨(a, w), mem_pairs.mpr β¨hall a (by simp), ?_β©, rflβ©
apply ih.mpr
constructor
Β· simpa using hlen
Β· intro x hx
exact hall x (List.mem_cons_of_mem a hx)
abbrev CoordinateOutcome := (List Nat Γ List Nat) Γ (Nat Γ List Nat)
def edgeOutcomes (m k dimR noiseCount : Nat) : List CoordinateOutcome :=
pairs
(pairs (words (List.range m) k) (words [0, 1] ((2*k + 1)*dimR)))
(pairs (List.range noiseCount) (words [0, 1] (2*k + 1)))
def edgeCount (m k dimR noiseCount : Nat) : Nat :=
m^k * 2^((2*k + 1)*(dimR + 1)) * noiseCount
theorem length_edgeOutcomes (m k dimR noiseCount : Nat) :
(edgeOutcomes m k dimR noiseCount).length = edgeCount m k dimR noiseCount := by
simp only [edgeOutcomes, length_pairs, length_words, List.length_range,
List.length_cons, List.length_nil, edgeCount]
simp only [Nat.mul_add, Nat.mul_one, Nat.pow_add]
norm_num only
ring
theorem edgeCount_pos {m noiseCount : Nat} (hm : 0 < m) (hv : 0 < noiseCount)
(k dimR : Nat) : 0 < edgeCount m k dimR noiseCount := by
exact Nat.mul_pos (Nat.mul_pos (Nat.pow_pos hm) (Nat.two_pow_pos _)) hv
theorem edgeOutcomes_nonempty {m noiseCount : Nat} (hm : 0 < m)
(hv : 0 < noiseCount) (k dimR : Nat) : edgeOutcomes m k dimR noiseCount β [] := by
intro h
have hp := edgeCount_pos hm hv k dimR
rw [β length_edgeOutcomes, h] at hp
exact Nat.not_lt_zero _ hp
theorem edgeCount_mono {m bound : Nat} (h : m β€ bound) (k dimR noiseCount : Nat) :
edgeCount m k dimR noiseCount β€ edgeCount bound k dimR noiseCount := by
exact Nat.mul_le_mul_right _
(Nat.mul_le_mul_right _ (Nat.pow_le_pow_left h k))
theorem product_pow (a b k : Nat) : (a*b)^k = a^k*b^k := by
induction k with
| zero => simp
| succ k ih =>
simp only [Nat.pow_succ, ih]
ring
theorem edgeCount_polynomial_bound {m n coefficient degree : Nat}
(h : m β€ coefficient * (n + 1)^degree) (k dimR noiseCount : Nat) :
edgeCount m k dimR noiseCount β€
(coefficient^k * 2^((2*k + 1)*(dimR + 1)) * noiseCount) *
(n + 1)^(degree*k) := by
calc
edgeCount m k dimR noiseCount β€
edgeCount (coefficient * (n + 1)^degree) k dimR noiseCount :=
edgeCount_mono h k dimR noiseCount
_ = _ := by
simp only [edgeCount, product_pow, β Nat.pow_mul]
ring
end DFVSGames.Reduction.Explicit
namespace DFVSGames.Reduction.ActualEnumeration
open Integration.BinaryLinear
open ActualHomogeneous
open _root_.OAI.DFVSGames.Reduction.Explicit
open scoped BigOperators
variable {Ξ± Ξ² N : Type*} {n m k s d noiseCount : Nat}
theorem nodup_pairs {xs : List Ξ±} {ys : List Ξ²} (hx : xs.Nodup) (hy : ys.Nodup) :
(pairs xs ys).Nodup := hx.product hy
def functions (values : List Ξ±) : (n : Nat) β List (Fin n β Ξ±)
| 0 => [Fin.elim0]
| n + 1 => (pairs values (functions values n)).map
(fun p => Fin.cons p.1 p.2)
theorem length_functions (values : List Ξ±) (n : Nat) :
(functions values n).length = values.length^n := by
induction n with
| zero => simp [functions]
| succ n ih => simp [functions, length_pairs, ih, pow_succ, Nat.mul_comm]
theorem mem_functions {values : List Ξ±} (full : β a, a β values)
(f : Fin n β Ξ±) : f β functions values n := by
induction n with
| zero =>
have : f = Fin.elim0 := by funext i; exact Fin.elim0 i
simp [functions, this]
| succ n ih =>
apply List.mem_map.mpr
exact β¨(f 0, Fin.tail f), mem_pairs.mpr β¨full _, ih _β©, Fin.cons_self_tail fβ©
theorem nodup_functions {values : List Ξ±} (distinct : values.Nodup) (n : Nat) :
(functions values n).Nodup := by
induction n with
| zero => simp [functions]
| succ n ih =>
apply (nodup_pairs distinct ih).map
intro x y h
apply Prod.ext
Β· exact congrFun h 0
Β· funext i
exact congrFun h i.succ
section Coefficients
variable (k : Nat) (R : Type*) [AddCommGroup R] [Module F2 R]
abbrev Coefficients := R Γ (Fin k β R Γ R)
def fromCoefficients (a : Coefficients k R) : E k ββ[F2] R where
toFun x := x.1 β’ a.1 + β j : Fin k,
((x.2 j).1 β’ (a.2 j).1 + (x.2 j).2 β’ (a.2 j).2)
map_add' x y := by
simp only [Prod.fst_add, Prod.snd_add, Pi.add_apply, add_smul]
simp only [add_add_add_comm, Finset.sum_add_distrib]
map_smul' c x := by
simp only [Prod.smul_fst, Prod.smul_snd, Pi.smul_apply, smul_eq_mul,
mul_smul, smul_add, Finset.smul_sum, RingHom.id_apply]
def toCoefficients (X : E k ββ[F2] R) : Coefficients k R :=
(X (hBasis k), fun j => (X (firstBasis j), X (secondBasis j)))
theorem to_fromCoefficients (a : Coefficients k R) :
toCoefficients k R (fromCoefficients k R a) = a := by
apply Prod.ext
Β· simp [toCoefficients, fromCoefficients, hBasis]
Β· funext j
apply Prod.ext <;>
simp [toCoefficients, fromCoefficients, firstBasis, secondBasis, Pi.single_apply,
apply_ite]
theorem from_toCoefficients (X : E k ββ[F2] R) :
fromCoefficients k R (toCoefficients k R X) = X := by
apply LinearMap.ext
intro x
exact (linearMap_expansion X x).symm
def coefficientEquiv : Coefficients k R β (E k ββ[F2] R) where
toFun := fromCoefficients k R
invFun := toCoefficients k R
left_inv := to_fromCoefficients k R
right_inv := from_toCoefficients k R
def allLinearMaps (values : List R) : List (E k ββ[F2] R) :=
(pairs values (functions (pairs values values) k)).map (coefficientEquiv k R)
theorem length_allLinearMaps (values : List R) :
(allLinearMaps k R values).length = values.length^(2*k+1) := by
simp only [allLinearMaps, List.length_map, length_pairs, length_functions]
rw [show values.length * values.length = values.length^2 by simp [pow_two],
β pow_mul, pow_succ]
exact Nat.mul_comm _ _
theorem mem_allLinearMaps {values : List R} (full : β a, a β values)
(X : E k ββ[F2] R) : X β allLinearMaps k R values := by
apply List.mem_map.mpr
refine β¨toCoefficients k R X, ?_, from_toCoefficients k R Xβ©
apply mem_pairs.mpr
exact β¨full _, mem_functions (fun a => mem_pairs.mpr β¨full _, full _β©) _β©
theorem nodup_allLinearMaps {values : List R} (distinct : values.Nodup) :
(allLinearMaps k R values).Nodup :=
(nodup_pairs distinct (nodup_functions (nodup_pairs distinct distinct) k)).map
(coefficientEquiv k R).injective
theorem cardinal_linearMaps [Fintype R] [Fintype (E k ββ[F2] R)] :
Fintype.card (E k ββ[F2] R) = (Fintype.card R)^(2*k+1) := by
rw [β Fintype.card_congr (coefficientEquiv k R)]
simp only [Coefficients, Fintype.card_prod, Fintype.card_fun, Fintype.card_fin]
rw [show Fintype.card R * Fintype.card R = (Fintype.card R)^2 by simp [pow_two],
β pow_mul, pow_succ]
exact Nat.mul_comm _ _
end Coefficients
def vectors (s : Nat) : List (Integration.BinaryLinear.Vector s) :=
(List.finRange (2^s)).map (Encoding.alphabetEquiv s).symm
theorem length_vectors (s : Nat) : (vectors s).length = 2^s := by
simp [vectors]
theorem mem_vectors (v : Integration.BinaryLinear.Vector s) : v β vectors s := by
exact List.mem_map.mpr β¨Encoding.alphabetEquiv s v, List.mem_finRange _,
(Encoding.alphabetEquiv s).symm_apply_apply vβ©
theorem nodup_vectors (s : Nat) : (vectors s).Nodup :=
(List.nodup_finRange _).map (Encoding.alphabetEquiv s).symm.injective
abbrev Ambient (s d : Nat) :=
Integration.BinaryLinear.Vector s Γ Integration.BinaryLinear.Vector d
def ambientVectors (s d : Nat) : List (Ambient s d) := pairs (vectors s) (vectors d)
theorem length_ambientVectors (s d : Nat) : (ambientVectors s d).length = 2^(s+d) := by
simp [ambientVectors, length_pairs, length_vectors, pow_add]
theorem mem_ambientVectors (v : Ambient s d) : v β ambientVectors s d :=
mem_pairs.mpr β¨mem_vectors v.1, mem_vectors v.2β©
theorem nodup_ambientVectors (s d : Nat) : (ambientVectors s d).Nodup :=
nodup_pairs (nodup_vectors s) (nodup_vectors d)
abbrev Query (m k s d : Nat) := (Fin k β Fin m) Γ (E k ββ[F2] Ambient s d)
def queries (m k s d : Nat) : List (Query m k s d) :=
pairs (functions (List.finRange m) k) (allLinearMaps k _ (ambientVectors s d))
theorem mem_queries (q : Query m k s d) : q β queries m k s d :=
mem_pairs.mpr β¨mem_functions (fun i => List.mem_finRange i) _,
mem_allLinearMaps k _ mem_ambientVectors _β©
theorem nodup_queries (m k s d : Nat) : (queries m k s d).Nodup :=
nodup_pairs (nodup_functions (List.nodup_finRange _) _)
(nodup_allLinearMaps k _ (nodup_ambientVectors s d))
theorem length_queries (m k s d : Nat) :
(queries m k s d).length = m^k * 2^((s+d)*(2*k+1)) := by
simp [queries, length_pairs, length_functions, length_allLinearMaps,
length_ambientVectors, β pow_mul]
abbrev Outcome (m k s d noiseCount : Nat) :=
Query m k s d Γ
(Fin noiseCount Γ (E k ββ[F2] F2))
def outcomes (m k s d noiseCount : Nat) : List (Outcome m k s d noiseCount) :=
pairs
(queries m k s d)
(pairs (List.finRange noiseCount) (allLinearMaps k F2 [0, 1]))
theorem length_outcomes (m k s d noiseCount : Nat) :
(outcomes m k s d noiseCount).length = edgeCount m k (s+d) noiseCount := by
simp only [outcomes, queries, length_pairs, length_functions, List.length_finRange,
length_allLinearMaps, length_ambientVectors, List.length_cons, List.length_nil,
edgeCount, β pow_mul]
change m^k * 2^((s+d)*(2*k+1)) * (noiseCount * 2^(2*k+1)) =
m^k * 2^((2*k+1)*(s+d+1)) * noiseCount
rw [show (2*k+1)*(s+d+1) = (s+d)*(2*k+1)+(2*k+1) by ring, pow_add]
ring
theorem mem_outcomes (Ο : Outcome m k s d noiseCount) :
Ο β outcomes m k s d noiseCount := by
apply mem_pairs.mpr
constructor
Β· exact mem_pairs.mpr β¨mem_functions (fun i => List.mem_finRange i) _,
mem_allLinearMaps k _ mem_ambientVectors _β©
Β· exact mem_pairs.mpr β¨List.mem_finRange _, mem_allLinearMaps k F2
(fun a => by rcases scalar_cases a with rfl | rfl <;> simp) _β©
theorem nodup_outcomes (m k s d noiseCount : Nat) :
(outcomes m k s d noiseCount).Nodup := by
apply nodup_pairs
Β· exact nodup_pairs (nodup_functions (List.nodup_finRange _) _)
(nodup_allLinearMaps k _ (nodup_ambientVectors s d))
Β· exact nodup_pairs (List.nodup_finRange _)
(nodup_allLinearMaps k F2 (by simp))
def indexedOutcomes (m k s d : Nat) (indices : List N) :
List (Query m k s d Γ (N Γ (E k ββ[F2] F2))) :=
pairs (queries m k s d) (pairs indices (allLinearMaps k F2 [0, 1]))
theorem length_indexedOutcomes (m k s d : Nat) (indices : List N) :
(indexedOutcomes m k s d indices).length = edgeCount m k (s+d) indices.length := by
rw [β length_outcomes m k s d indices.length]
simp only [indexedOutcomes, outcomes, length_pairs, List.length_finRange]
theorem mem_indexedOutcomes {indices : List N} (full : β i, i β indices)
(Ο : Query m k s d Γ (N Γ (E k ββ[F2] F2))) :
Ο β indexedOutcomes m k s d indices := by
apply mem_pairs.mpr
exact β¨mem_queries _, mem_pairs.mpr β¨full _, mem_allLinearMaps k F2
(fun a => by rcases scalar_cases a with rfl | rfl <;> simp) _β©β©
theorem nodup_indexedOutcomes {indices : List N} (distinct : indices.Nodup)
(m k s d : Nat) : (indexedOutcomes m k s d indices).Nodup :=
nodup_pairs (nodup_queries m k s d)
(nodup_pairs distinct (nodup_allLinearMaps k F2 (by simp)))
theorem indexedOutcomes_nonempty {m : Nat} (hm : 0 < m)
(k s d : Nat) {indices : List N} (nonempty : indices β []) :
indexedOutcomes m k s d indices β [] := by
apply List.length_pos_iff.mp
rw [length_indexedOutcomes]
exact edgeCount_pos hm (List.length_pos_iff.mpr nonempty) k (s+d)
theorem length_indexedOutcomes_polynomial_bound {m n coefficient degree : Nat}
(h : m β€ coefficient * (n+1)^degree) (k s d : Nat) (indices : List N) :
(indexedOutcomes m k s d indices).length β€
(coefficient^k * 2^((2*k+1)*(s+d+1)) * indices.length) *
(n+1)^(degree*k) := by
rw [length_indexedOutcomes]
exact edgeCount_polynomial_bound h k (s+d) indices.length
end DFVSGames.Reduction.ActualEnumeration
namespace DFVSGames.Decoder.PaddedLaw
open scoped BigOperators
open DFVSGames.Integration.BinaryLinear
open DFVSGames.Reduction
open DFVSGames.Soundness
open ConditionalIncidences PartnerProjection RawPartnerTarget RawMapLaw
open ActualCanonicalPullback
open SparseLaw
noncomputable section
attribute [local instance] Classical.propDecidable
section FinitePushforward
variable {Ξ± B : Type*} [Fintype Ξ±]
def pushforwardWeight (p : Ξ± β β) (f : Ξ± β B) (y : B) : β :=
β x, if f x = y then p x else 0
theorem pushforwardWeight_pi (p : Ξ± β β) (f : Ξ± β B) (k : β)
(ys : Fin k β B) :
pushforwardWeight (independentWeights p k) (fun xs i => f (xs i)) ys =
independentWeights (pushforwardWeight p f) k ys := by
classical
simp only [pushforwardWeight, independentWeights]
rw [Fintype.prod_sum]
apply Finset.sum_congr rfl
intro xs _
simp only [Fintype.prod_ite_zero, funext_iff]
split_ifs <;> rfl
theorem pushforwardWeight_joint_uniform_intercept {W : Type*} [Fintype W] [AddGroup W]
(p : Ξ± β β) (f : Ξ± β B) (shift : Ξ± β W) (z : W) (b : B) :
pushforwardWeight (fun az : Ξ± Γ W => p az.1 * uniformWeights W az.2)
(fun az => (az.2 + shift az.1, f az.1)) (z, b) =
uniformWeights W z * pushforwardWeight p f b := by
classical
simp only [pushforwardWeight, Fintype.sum_prod_type]
calc
(β a : Ξ±, β t : W,
if (t + shift a, f a) = (z, b) then p a * uniformWeights W t else 0) =
β a : Ξ±, if f a = b then p a * uniformWeights W z else 0 := by
apply Finset.sum_congr rfl
intro a _
by_cases h : f a = b
Β· simp only [Prod.mk.injEq, h, and_true, ite_true]
exact joint_intercept_pushforward p shift a z
Β· simp [Prod.mk.injEq, h]
_ = uniformWeights W z * (β a : Ξ±, if f a = b then p a else 0) := by
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
by_cases h : f a = b <;> simp [h, mul_comm]
end FinitePushforward
variable {k : β} {V : Type} [AddCommGroup V] [Module F2 V]
abbrev BlockDraw (V : Type) := (V Γ V) β (Fin 3 Γ V)
def decodeSlot (i : Fin 3) : Slot :=
if i = 0 then .first else if i = 1 then .second else .third
theorem slotIndex_decodeSlot (i : Fin 3) : ConcreteExtraction.slotIndex (decodeSlot i) = i := by
fin_cases i <;> rfl
def blockAmbient : BlockDraw V β Fin 3 β V
| .inl ab => ![ab.1, ab.2, 0]
| .inr ia => Pi.single ia.1 ia.2
def blockSlopes (d : BlockDraw V) : V Γ V :=
(blockAmbient d 0 + blockAmbient d 2, blockAmbient d 1 + blockAmbient d 2)
def blockThird (d : BlockDraw V) : V := blockAmbient d 2
omit [Module F2 V] in
@[simp] theorem blockSlopes_full (ab : V Γ V) : blockSlopes (.inl ab) = ab := by
simp [blockSlopes, blockAmbient]
omit [Module F2 V] in
@[simp] theorem blockSlopes_first (a : V) :
blockSlopes (.inr ((0 : Fin 3), a)) = (a, 0) := by
simp [blockSlopes, blockAmbient]
omit [Module F2 V] in
@[simp] theorem blockSlopes_second (a : V) :
blockSlopes (.inr ((1 : Fin 3), a)) = (0, a) := by
simp [blockSlopes, blockAmbient]
omit [Module F2 V] in
@[simp] theorem blockSlopes_third (a : V) :
blockSlopes (.inr ((2 : Fin 3), a)) = (a, a) := by
simp [blockSlopes, blockAmbient]
def singletonPositions (d : Fin k β BlockDraw V) : Finset (Fin k) :=
Finset.univ.filter fun j => (d j).isRight
def drawSlots (d : Fin k β BlockDraw V) (j : Fin k) : Slot :=
match d j with
| .inl _ => .first
| .inr ia => decodeSlot ia.1
def drawCoefficients (d : Fin k β BlockDraw V) (z : V) :
RawCoefficients (singletonPositions d) V
| none => z
| some (.inl (j, i)) =>
match d j.val with
| .inl ab => if i = 0 then ab.1 else ab.2
| .inr _ => 0
| some (.inr j) =>
match d j.val with
| .inl _ => 0
| .inr ia => ia.2
def paddedMap (rhs : Fin k β Bool) (d : Fin k β BlockDraw V) (z : V) :
ActualHomogeneous.E k ββ[F2] V :=
(rawMap (singletonPositions d) V (drawCoefficients d z)).comp
(rawProjection rhs (singletonPositions d) (drawSlots d))
omit [Module F2 V] in
theorem ambientCoefficients_draw (d : Fin k β BlockDraw V) (z : V) :
ambientCoefficients (singletonPositions d) V (drawCoefficients d z) (drawSlots d) =
fun j => blockAmbient (d j) := by
funext j i
cases hd : d j with
| inl ab =>
fin_cases i <;>
simp [ambientCoefficients, singletonPositions, drawCoefficients, blockAmbient, hd]
| inr ia =>
simp [ambientCoefficients, singletonPositions, drawCoefficients, drawSlots,
blockAmbient, hd, slotIndex_decodeSlot, Pi.single_apply]
def interceptShift (rhs : Fin k β Bool) (d : Fin k β BlockDraw V) : V :=
β j, ofBit (rhs j) β’ blockThird (d j)
theorem paddedMap_toCoefficients (rhs : Fin k β Bool) (d : Fin k β BlockDraw V)
(z : V) :
ActualEnumeration.toCoefficients k V (paddedMap rhs d z) =
(z + interceptShift rhs d, fun j => blockSlopes (d j)) := by
have hrep := raw_represents rhs (singletonPositions d) V (drawCoefficients d z) (drawSlots d)
rw [ambientCoefficients_draw] at hrep
have hc := ActualCanonical.extension_coefficients _ _ _ _ hrep
have hmap : paddedMap rhs d z =
freePullback rhs (singletonPositions d) V (drawCoefficients d z) (drawSlots d) := by
unfold paddedMap
rw [rawMap_pullback, coefficients_rawMap]
rw [hmap]
apply Prod.ext
Β· exact hc.1
Β· funext j
exact Prod.ext (hc.2 j).1 (hc.2 j).2
theorem uniform_rawMaps [Fintype V] (J : Finset (Fin k))
(H : (RawPoint J ββ[F2] V) β β) :
(πΌ gamma : RawCoefficients J V, H (rawMap J V gamma)) = πΌ Y, H Y := by
exact Fintype.expect_equiv (rawMapEquiv J V) _ H (fun _ => rfl)
abbrev RawTuple (J : Finset (Fin k)) (V : Type) :=
V Γ ((PositionOutside J β V Γ V) Γ (PositionInside J β V))
def rawTupleEquiv (J : Finset (Fin k)) : RawTuple J V β RawCoefficients J V where
toFun a
| none => a.1
| some (.inl (j, i)) => if i = 0 then (a.2.1 j).1 else (a.2.1 j).2
| some (.inr j) => a.2.2 j
invFun gamma := β¨gamma none,
β¨(fun j => (gamma (some (.inl (j, 0))), gamma (some (.inl (j, 1))))),
(fun j => gamma (some (.inr j)))β©β©
left_inv a := by
apply Prod.ext rfl
apply Prod.ext
Β· funext j
rfl
Β· rfl
right_inv gamma := by
funext s
rcases s with _ | (β¨j, iβ© | j)
Β· rfl
Β· fin_cases i <;> rfl
Β· rfl
def tupleDraw (J : Finset (Fin k)) (slot : Fin k β Slot) (a : RawTuple J V)
(j : Fin k) : BlockDraw V :=
if hj : j β J then .inr (ConcreteExtraction.slotIndex (slot j), a.2.2 β¨j, hjβ©)
else .inl (a.2.1 β¨j, hjβ©)
omit [Module F2 V] in
theorem tupleDraw_ambient (J : Finset (Fin k)) (slot : Fin k β Slot)
(a : RawTuple J V) :
(fun j => blockAmbient (tupleDraw J slot a j)) =
ambientCoefficients J V (rawTupleEquiv J a) slot := by
funext j i
by_cases hj : j β J
Β· simp [tupleDraw, hj, blockAmbient, ambientCoefficients, rawTupleEquiv, Pi.single_apply]
Β· fin_cases i <;>
simp [tupleDraw, hj, blockAmbient, ambientCoefficients, rawTupleEquiv]
theorem paddedMap_tupleDraw (rhs : Fin k β Bool) (J : Finset (Fin k))
(slot : Fin k β Slot) (a : RawTuple J V) :
paddedMap rhs (tupleDraw J slot a) a.1 =
(rawMap J V (rawTupleEquiv J a)).comp (rawProjection rhs J slot) := by
have hr := raw_represents rhs J V (rawTupleEquiv J a) slot
rw [β tupleDraw_ambient] at hr
have hc := ActualCanonical.extension_coefficients _ _ _ _ hr
apply (ActualEnumeration.coefficientEquiv k V).symm.injective
change ActualEnumeration.toCoefficients k V _ = ActualEnumeration.toCoefficients k V _
rw [paddedMap_toCoefficients, rawMap_pullback, coefficients_rawMap]
apply Prod.ext
Β· exact hc.1.symm
Β· funext j
exact Prod.ext (hc.2 j).1.symm (hc.2 j).2.symm
theorem uniform_fixed_projection_tuple [Fintype V] (rhs : Fin k β Bool)
(J : Finset (Fin k)) (slot : Fin k β Slot)
(H : (ActualHomogeneous.E k ββ[F2] V) β β) :
(πΌ a : RawTuple J V, H (paddedMap rhs (tupleDraw J slot a) a.1)) =
πΌ Y : RawPoint J ββ[F2] V, H (Y.comp (rawProjection rhs J slot)) := by
simp_rw [paddedMap_tupleDraw]
exact Fintype.expect_equiv ((rawTupleEquiv J).trans (rawMapEquiv J V)) _ _ (fun _ => rfl)
variable [Fintype V]
def blockWeights (Ξ² : β) : BlockDraw V β β
| .inl ab => (1 - Ξ²) * uniformWeights (V Γ V) ab
| .inr ia => (Ξ² / 3) * uniformWeights V ia.2
omit [Module F2 V] in
theorem blockWeights_isProbability (Ξ² : β) (hΞ² : 0 β€ Ξ²) (hΞ²' : Ξ² β€ 1) :
DFVSGames.Foundations.Information.IsProbability (blockWeights (V := V) Ξ²) := by
constructor
Β· intro d
cases d with
| inl ab => exact mul_nonneg (sub_nonneg.mpr hΞ²') (uniformWeights_pos ab).le
| inr ia => exact mul_nonneg (div_nonneg hΞ² (by norm_num)) (uniformWeights_pos ia.2).le
Β· rw [Fintype.sum_sum_type]
simp only [blockWeights, β Finset.mul_sum,
(uniformWeights_isProbability (Ξ± := V Γ V)).2, mul_one, Fintype.sum_prod_type,
(uniformWeights_isProbability (Ξ± := V)).2]
simp
omit [Module F2 V] in
theorem blockWeights_slopes (Ξ² : β) (ab : V Γ V) :
pushforwardWeight (blockWeights (V := V) Ξ²) blockSlopes ab =
mixture Ξ² (singletonPairWeights V) ab := by
have hfull : (β x : V Γ V, if blockSlopes (.inl x) = ab then
blockWeights Ξ² (.inl x) else 0) = (1 - Ξ²) * uniformWeights (V Γ V) ab := by
simp [blockWeights]
have hsingle : (β ia : Fin 3 Γ V, if blockSlopes (.inr ia) = ab then
blockWeights Ξ² (.inr ia) else 0) = Ξ² * singletonSamplerWeights V ab := by
rw [Fintype.sum_prod_type, Fin.sum_univ_three]
simp only [blockSlopes_first, blockSlopes_second,
blockSlopes_third, blockWeights]
have hfactor (f : V β V Γ V) :
(β a : V, if f a = ab then Ξ² / 3 * uniformWeights V a else 0) =
(Ξ² / 3) * β a : V, if f a = ab then uniformWeights V a else 0 := by
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
split <;> simp_all
simp only [hfactor, singletonSamplerWeights]
ring
unfold pushforwardWeight
rw [Fintype.sum_sum_type]
calc
_ = (β x : V Γ V, if blockSlopes (.inl x) = ab then blockWeights Ξ² (.inl x) else 0) +
(β ia : Fin 3 Γ V, if blockSlopes (.inr ia) = ab then blockWeights Ξ² (.inr ia) else 0) := by
congr 1 <;> apply Finset.sum_congr rfl <;> intro x _ <;> split_ifs <;> rfl
_ = _ := by rw [hfull, hsingle, singletonSamplerWeights_eq]; rfl
def drawWeights (Ξ² : β) (k : β) : ((Fin k β BlockDraw V) Γ V) β β :=
fun dz => independentWeights (blockWeights Ξ²) k dz.1 * uniformWeights V dz.2
def paddedWeights (rhs : Fin k β Bool) (Ξ² : β) : ActualEnumeration.Coefficients k V β β :=
pushforwardWeight (drawWeights Ξ² k)
(fun dz => ActualEnumeration.toCoefficients k V (paddedMap rhs dz.1 dz.2))
theorem paddedWeights_eq (rhs : Fin k β Bool) (Ξ² : β)
(a : ActualEnumeration.Coefficients k V) :
paddedWeights rhs Ξ² a = uniformWeights V a.1 *
independentWeights (mixture Ξ² (singletonPairWeights V)) k a.2 := by
rcases a with β¨z, slopesβ©
unfold paddedWeights
simp_rw [paddedMap_toCoefficients]
unfold drawWeights
have hj := pushforwardWeight_joint_uniform_intercept
(independentWeights (blockWeights (V := V) Ξ²) k)
(fun d j => blockSlopes (d j)) (interceptShift rhs) z slopes
calc
_ = uniformWeights V z * pushforwardWeight
(independentWeights (blockWeights (V := V) Ξ²) k)
(fun d j => blockSlopes (d j)) slopes := by
convert hj using 1
_ = _ := by
rw [pushforwardWeight_pi]
congr 1
apply Finset.prod_congr rfl
intro j _
exact blockWeights_slopes Ξ² (slopes j)
theorem uniformWeights_prod {A B : Type*} [Fintype A] [Fintype B] (ab : A Γ B) :
uniformWeights (A Γ B) ab = uniformWeights A ab.1 * uniformWeights B ab.2 := by
simp [uniformWeights, Fintype.card_prod, Nat.cast_mul, one_div, mul_comm]
theorem totalVariation_uniform_front {A B : Type*} [Fintype A] [Nonempty A] [Fintype B]
(p q : B β β) :
DFVSGames.Foundations.Information.totalVariation
(fun ab : A Γ B => uniformWeights A ab.1 * p ab.2)
(fun ab : A Γ B => uniformWeights A ab.1 * q ab.2) =
DFVSGames.Foundations.Information.totalVariation p q := by
unfold DFVSGames.Foundations.Information.totalVariation
rw [Fintype.sum_prod_type]
simp only [β mul_sub, abs_mul, abs_of_nonneg (uniformWeights_pos _).le,
β Finset.mul_sum, β Finset.sum_mul, (uniformWeights_isProbability (Ξ± := A)).2, one_mul]
theorem paddedWeights_totalVariation_eq_slope (rhs : Fin k β Bool) (Ξ² : β) :
DFVSGames.Foundations.Information.totalVariation (paddedWeights (V := V) rhs Ξ²)
(uniformWeights (ActualEnumeration.Coefficients k V)) =
DFVSGames.Foundations.Information.totalVariation
(independentWeights (mixture Ξ² (singletonPairWeights V)) k)
(uniformWeights (Fin k β V Γ V)) := by
have hp : paddedWeights (V := V) rhs Ξ² = fun a => uniformWeights V a.1 *
independentWeights (mixture Ξ² (singletonPairWeights V)) k a.2 := by
funext a
exact paddedWeights_eq rhs Ξ² a
have hu : uniformWeights (ActualEnumeration.Coefficients k V) =
fun a => uniformWeights V a.1 * uniformWeights (Fin k β V Γ V) a.2 := by
funext a
exact uniformWeights_prod a
rw [hp, hu, totalVariation_uniform_front]
theorem paddedWeights_totalVariation (rhs : Fin k β Bool) (Ξ² : β)
(hΞ² : 0 β€ Ξ²) (hΞ²' : Ξ² β€ 1) :
DFVSGames.Foundations.Information.totalVariation (paddedWeights (V := V) rhs Ξ²)
(uniformWeights (ActualEnumeration.Coefficients k V)) β€
Real.sqrt ((1 + Ξ² ^ 2 * ((Fintype.card V : β) - 1) / 3) ^ k - 1) / 2 := by
rw [paddedWeights_totalVariation_eq_slope]
exact paddedSlope_totalVariation V Ξ² hΞ² hΞ²' k
abbrev ProjectionChoice := Option (Fin 3)
def choiceWeight (Ξ² : β) : ProjectionChoice β β
| none => 1 - Ξ²
| some _ => Ξ² / 3
theorem choiceWeight_isProbability (Ξ² : β) (hΞ² : 0 β€ Ξ²) (hΞ²' : Ξ² β€ 1) :
DFVSGames.Foundations.Information.IsProbability (choiceWeight Ξ²) := by
constructor
Β· intro c
cases c with
| none => exact sub_nonneg.mpr hΞ²'
| some i => exact div_nonneg hΞ² (by norm_num)
Β· rw [Fintype.sum_option]
simp [choiceWeight]
ring
def blockKernel : ProjectionChoice β BlockDraw V β β
| none, .inl ab => uniformWeights (V Γ V) ab
| some i, .inr ja => if i = ja.1 then uniformWeights V ja.2 else 0
| _, _ => 0
def choiceTupleWeight (Ξ² : β) (c : Fin k β ProjectionChoice) : β :=
β j, choiceWeight Ξ² (c j)
theorem choiceTupleWeight_isProbability (Ξ² : β) (hΞ² : 0 β€ Ξ²) (hΞ²' : Ξ² β€ 1) :
DFVSGames.Foundations.Information.IsProbability (choiceTupleWeight (k := k) Ξ²) := by
exact independentWeights_isProbability (choiceWeight Ξ²)
(choiceWeight_isProbability Ξ² hΞ² hΞ²') k
def kernelTupleWeight (c : Fin k β ProjectionChoice) (d : Fin k β BlockDraw V) : β :=
β j, blockKernel (c j) (d j)
omit [AddCommGroup V] [Module F2 V] in
theorem blockWeights_choice_mixture (Ξ² : β) (d : BlockDraw V) :
blockWeights Ξ² d = β c : ProjectionChoice, choiceWeight Ξ² c * blockKernel c d := by
cases d <;>
simp [Fintype.sum_option, choiceWeight, blockKernel, blockWeights, mul_ite]
omit [AddCommGroup V] [Module F2 V] in
theorem independent_blockWeights_mixture (Ξ² : β) (d : Fin k β BlockDraw V) :
independentWeights (blockWeights Ξ²) k d =
β c : Fin k β ProjectionChoice, choiceTupleWeight Ξ² c * kernelTupleWeight c d := by
unfold independentWeights choiceTupleWeight kernelTupleWeight
simp_rw [blockWeights_choice_mixture]
rw [Fintype.prod_sum]
apply Finset.sum_congr rfl
intro c _
exact Finset.prod_mul_distrib
omit [AddCommGroup V] [Module F2 V] in
theorem drawWeights_choice_mixture (Ξ² : β) (dz : (Fin k β BlockDraw V) Γ V) :
drawWeights Ξ² k dz = β c : Fin k β ProjectionChoice,
choiceTupleWeight Ξ² c * (kernelTupleWeight c dz.1 * uniformWeights V dz.2) := by
rw [drawWeights, independent_blockWeights_mixture, Finset.sum_mul]
apply Finset.sum_congr rfl
intro c _
ring
omit [AddCommGroup V] [Module F2 V] in
theorem draw_expectation_choice_mixture (Ξ² : β)
(H : ((Fin k β BlockDraw V) Γ V) β β) :
(β dz, drawWeights Ξ² k dz * H dz) =
β c : Fin k β ProjectionChoice, choiceTupleWeight Ξ² c *
β dz, (kernelTupleWeight c dz.1 * uniformWeights V dz.2) * H dz := by
simp_rw [drawWeights_choice_mixture, Finset.sum_mul]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro c _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro dz _
ring
def ChoiceValue (V : Type) : ProjectionChoice β Type
| none => V Γ V
| some _ => V
instance choiceValueFintype (c : ProjectionChoice) : Fintype (ChoiceValue V c) := by
cases c <;> dsimp [ChoiceValue] <;> infer_instance
def choiceEmbed : (c : ProjectionChoice) β ChoiceValue V c β BlockDraw V
| none, ab => .inl ab
| some i, a => .inr (i, a)
omit [AddCommGroup V] [Module F2 V] in
theorem blockKernel_uniform_pushforward (c : ProjectionChoice) (d : BlockDraw V) :
blockKernel c d =
pushforwardWeight (uniformWeights (ChoiceValue V c)) (choiceEmbed c) d := by
cases c with
| none =>
cases d <;> simp [blockKernel, pushforwardWeight, choiceEmbed, ChoiceValue]
exact fun h => False.elim (h (Finset.mem_univ _))
| some i =>
cases d with
| inl ab => simp [blockKernel, pushforwardWeight, choiceEmbed, ChoiceValue]
| inr ja =>
rcases ja with β¨j, aβ©
by_cases h : i = j <;>
simp [blockKernel, pushforwardWeight, choiceEmbed, ChoiceValue,
Prod.mk.injEq, h]
exact fun h => False.elim (h (Finset.mem_univ _))
theorem pushforwardWeight_pi_dep {I B : Type*} [Fintype I]
{A : I β Type*} [β i, Fintype (A i)]
(p : (i : I) β A i β β) (f : (i : I) β A i β B) (ys : I β B) :
pushforwardWeight (fun xs : β i, A i => β i, p i (xs i))
(fun xs : β i, A i => fun i => f i (xs i)) ys =
β i, pushforwardWeight (p i) (f i) (ys i) := by
classical
simp only [pushforwardWeight]
rw [Fintype.prod_sum]
apply Finset.sum_congr rfl
intro xs _
simp only [Fintype.prod_ite_zero, funext_iff]
theorem uniformWeights_pi {I : Type*} [Fintype I] {A : I β Type*}
[β i, Fintype (A i)] (x : β i, A i) :
uniformWeights (β i, A i) x = β i, uniformWeights (A i) (x i) := by
simp [uniformWeights, Fintype.card_pi, Nat.cast_prod, one_div,
Finset.prod_inv_distrib]
omit [AddCommGroup V] [Module F2 V] in
theorem kernelTuple_uniform_pushforward (c : Fin k β ProjectionChoice)
(d : Fin k β BlockDraw V) :
kernelTupleWeight c d =
pushforwardWeight (uniformWeights (β j, ChoiceValue V (c j)))
(fun f j => choiceEmbed (c j) (f j)) d := by
unfold kernelTupleWeight
simp_rw [blockKernel_uniform_pushforward]
rw [β pushforwardWeight_pi_dep]
have hp : (fun f : β j, ChoiceValue V (c j) =>
β j, uniformWeights (ChoiceValue V (c j)) (f j)) =
uniformWeights (β j, ChoiceValue V (c j)) := by
funext f
simp [uniformWeights, Fintype.card_pi, Nat.cast_prod, one_div,
Finset.prod_inv_distrib]
rw [hp]
congr 1 ; exact Subsingleton.elim _ _
theorem sum_pushforwardWeight_mul {A B : Type*} [Fintype A] [Fintype B]
(p : A β β) (f : A β B) (H : B β β) :
(β b, pushforwardWeight p f b * H b) = β a, p a * H (f a) := by
classical
simp only [pushforwardWeight, Finset.sum_mul]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro a _
simp [ite_mul]
theorem sum_uniformWeights_mul {A : Type*} [Fintype A] (H : A β β) :
(β a, uniformWeights A a * H a) = πΌ a, H a := by
rw [Fintype.expect_eq_sum_div_card]
simp only [uniformWeights, β Finset.mul_sum]
ring
def choiceMask (c : Fin k β ProjectionChoice) : Finset (Fin k) :=
Finset.univ.filter fun j => (c j).isSome
def choiceSlot : ProjectionChoice β Slot
| none => .first
| some i => decodeSlot i
def choiceSlots (c : Fin k β ProjectionChoice) (j : Fin k) : Slot :=
choiceSlot (c j)
theorem not_mem_choiceMask (c : Fin k β ProjectionChoice) (j : Fin k) :
j β choiceMask c β c j = none := by
cases h : c j <;> simp [choiceMask, h]
def fullChoiceValue : (c : ProjectionChoice) β ChoiceValue V c β V Γ V
| none, x => x
| some _, _ => (0, 0)
def singleChoiceValue : (c : ProjectionChoice) β ChoiceValue V c β V
| none, _ => 0
| some _, x => x
def readChoiceValue (q : ProjectionChoice) (full : q = none β V Γ V)
(single : q.isSome = true β V) : ChoiceValue V q := by
cases q with
| none => exact full rfl
| some i => exact single rfl
omit [Module F2 V] [Fintype V] in
theorem readChoiceValue_roundtrip (q : ProjectionChoice) (v : ChoiceValue V q) :
readChoiceValue q (fun _ => fullChoiceValue q v)
(fun _ => singleChoiceValue q v) = v := by
cases q <;> rfl
omit [Module F2 V] [Fintype V] in
theorem readChoiceValue_full (q : ProjectionChoice) (full : q = none β V Γ V)
(single : q.isSome = true β V) (h : q = none) :
fullChoiceValue q (readChoiceValue q full single) = full h := by
subst q
rfl
omit [Module F2 V] [Fintype V] in
theorem readChoiceValue_single (q : ProjectionChoice) (full : q = none β V Γ V)
(single : q.isSome = true β V) (h : q.isSome = true) :
singleChoiceValue q (readChoiceValue q full single) = single h := by
cases q with
| none => simp at h
| some i => rfl
def choiceValuesToRawTuple (c : Fin k β ProjectionChoice)
(fz : (β j, ChoiceValue V (c j)) Γ V) : RawTuple (choiceMask c) V :=
(fz.2,
(fun j => fullChoiceValue (c j.val) (fz.1 j.val)),
fun j => singleChoiceValue (c j.val) (fz.1 j.val))
def rawTupleToChoiceValues (c : Fin k β ProjectionChoice)
(a : RawTuple (choiceMask c) V) (j : Fin k) : ChoiceValue V (c j) :=
readChoiceValue (c j)
(fun h => a.2.1 β¨j, (not_mem_choiceMask c j).mpr hβ©)
(fun h => a.2.2 β¨j, by simpa [choiceMask] using hβ©)
def choiceValuesRawTupleEquiv (c : Fin k β ProjectionChoice) :
((β j, ChoiceValue V (c j)) Γ V) β RawTuple (choiceMask c) V where
toFun := choiceValuesToRawTuple c
invFun a := (rawTupleToChoiceValues c a, a.1)
left_inv fz := by
apply Prod.ext
Β· funext j
exact readChoiceValue_roundtrip (c j) (fz.1 j)
Β· rfl
right_inv a := by
apply Prod.ext
Β· rfl
Β· apply Prod.ext
Β· funext j
have hc : c j.val = none := (not_mem_choiceMask c j.val).mp j.property
exact readChoiceValue_full (c j.val) _ _ hc
Β· funext j
have hc : (c j.val).isSome = true := by
simpa [choiceMask] using j.property
exact readChoiceValue_single (c j.val) _ _ hc
omit [Module F2 V] [Fintype V] in
theorem restoreChoiceDraw (q : ProjectionChoice) (v : ChoiceValue V q) :
(if q.isSome then
Sum.inr (ConcreteExtraction.slotIndex (choiceSlot q),
singleChoiceValue q v)
else Sum.inl (fullChoiceValue q v)) = choiceEmbed q v := by
cases q <;> simp [fullChoiceValue, singleChoiceValue, choiceEmbed, choiceSlot,
slotIndex_decodeSlot]
omit [Module F2 V] [Fintype V] in
theorem tupleDraw_choiceValues (c : Fin k β ProjectionChoice)
(fz : (β j, ChoiceValue V (c j)) Γ V) :
tupleDraw (choiceMask c) (choiceSlots c) (choiceValuesRawTupleEquiv c fz) =
fun j => choiceEmbed (c j) (fz.1 j) := by
funext j
change (if j β choiceMask c then
Sum.inr (ConcreteExtraction.slotIndex (choiceSlot (c j)),
singleChoiceValue (c j) (fz.1 j))
else Sum.inl (fullChoiceValue (c j) (fz.1 j))) = choiceEmbed (c j) (fz.1 j)
simpa only [choiceMask, Finset.mem_filter,
Finset.mem_univ, true_and] using restoreChoiceDraw (c j) (fz.1 j)
theorem fixed_choice_kernel_map_expectation
(rhs : Fin k β Bool) (c : Fin k β ProjectionChoice)
(H : (ActualHomogeneous.E k ββ[F2] V) β β) :
(β dz : (Fin k β BlockDraw V) Γ V,
(kernelTupleWeight c dz.1 * uniformWeights V dz.2) *
H (paddedMap rhs dz.1 dz.2)) =
πΌ Y : RawPoint (choiceMask c) ββ[F2] V,
H (Y.comp (rawProjection rhs (choiceMask c) (choiceSlots c))) := by
calc
_ = β d : Fin k β BlockDraw V, kernelTupleWeight c d *
β z : V, uniformWeights V z * H (paddedMap rhs d z) := by
rw [Fintype.sum_prod_type]
apply Finset.sum_congr rfl
intro d _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro z _
ring
_ = β f : β j, ChoiceValue V (c j), uniformWeights _ f *
β z : V, uniformWeights V z *
H (paddedMap rhs (fun j => choiceEmbed (c j) (f j)) z) := by
simp_rw [kernelTuple_uniform_pushforward]
exact sum_pushforwardWeight_mul _ _ _
_ = πΌ fz : (β j, ChoiceValue V (c j)) Γ V,
H (paddedMap rhs (fun j => choiceEmbed (c j) (fz.1 j)) fz.2) := by
rw [β sum_uniformWeights_mul, Fintype.sum_prod_type]
apply Finset.sum_congr rfl
intro f _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro z _
rw [uniformWeights_prod]
ring
_ = πΌ a : RawTuple (choiceMask c) V,
H (paddedMap rhs (tupleDraw (choiceMask c) (choiceSlots c) a) a.1) := by
apply Fintype.expect_equiv (choiceValuesRawTupleEquiv c)
intro fz
rw [tupleDraw_choiceValues]
rfl
_ = _ := uniform_fixed_projection_tuple rhs (choiceMask c) (choiceSlots c) H
theorem actual_projection_mixture_expectation
(rhs : Fin k β Bool) (Ξ² : β)
(H : (ActualHomogeneous.E k ββ[F2] V) β β) :
(β dz : (Fin k β BlockDraw V) Γ V,
drawWeights Ξ² k dz * H (paddedMap rhs dz.1 dz.2)) =
β c : Fin k β ProjectionChoice, choiceTupleWeight Ξ² c *
(πΌ Y : RawPoint (choiceMask c) ββ[F2] V,
H (Y.comp (rawProjection rhs (choiceMask c) (choiceSlots c)))) := by
rw [draw_expectation_choice_mixture]
apply Finset.sum_congr rfl
intro c _
rw [fixed_choice_kernel_map_expectation]
theorem uniform_rawMap_pair {K W : Type}
[AddCommGroup K] [Module F2 K] [Fintype K]
[AddCommGroup W] [Module F2 W] [Fintype W]
(J : Finset (Fin k)) (H : (RawPoint J ββ[F2] K Γ W) β β) :
(πΌ MT : (RawPoint J ββ[F2] K) Γ (RawPoint J ββ[F2] W),
H (MT.1.prod MT.2)) = πΌ Y : RawPoint J ββ[F2] K Γ W, H Y := by
exact Fintype.expect_equiv (LinearMap.prodEquiv F2).toEquiv _ H (fun _ => rfl)
variable [Fintype (ActualHomogeneous.E k ββ[F2] V)]
def paddedMapWeights (rhs : Fin k β Bool) (Ξ² : β) :
(ActualHomogeneous.E k ββ[F2] V) β β :=
pushforwardWeight (drawWeights Ξ² k) (fun dz => paddedMap rhs dz.1 dz.2)
omit [Fintype (ActualHomogeneous.E k ββ[F2] V)] in
theorem paddedMapWeights_eq (rhs : Fin k β Bool) (Ξ² : β)
(X : ActualHomogeneous.E k ββ[F2] V) :
paddedMapWeights rhs Ξ² X =
paddedWeights rhs Ξ² (ActualEnumeration.toCoefficients k V X) := by
unfold paddedMapWeights paddedWeights pushforwardWeight
apply Finset.sum_congr rfl
intro dz _
have he : paddedMap rhs dz.1 dz.2 = X β
ActualEnumeration.toCoefficients k V (paddedMap rhs dz.1 dz.2) =
ActualEnumeration.toCoefficients k V X :=
(ActualEnumeration.coefficientEquiv k V).symm.injective.eq_iff.symm
simp only [he]
split_ifs <;> rfl
theorem uniform_sourceMap_coordinates (a : ActualEnumeration.Coefficients k V) :
uniformWeights (ActualHomogeneous.E k ββ[F2] V)
(ActualEnumeration.coefficientEquiv k V a) =
uniformWeights (ActualEnumeration.Coefficients k V) a := by
simp only [uniformWeights]
rw [Fintype.card_congr (ActualEnumeration.coefficientEquiv k V)]
theorem paddedMapWeights_totalVariation_eq_slope (rhs : Fin k β Bool) (Ξ² : β) :
DFVSGames.Foundations.Information.totalVariation (paddedMapWeights (V := V) rhs Ξ²)
(uniformWeights (ActualHomogeneous.E k ββ[F2] V)) =
DFVSGames.Foundations.Information.totalVariation
(independentWeights (mixture Ξ² (singletonPairWeights V)) k)
(uniformWeights (Fin k β V Γ V)) := by
have heq : DFVSGames.Foundations.Information.totalVariation
(paddedMapWeights (V := V) rhs Ξ²)
(uniformWeights (ActualHomogeneous.E k ββ[F2] V)) =
DFVSGames.Foundations.Information.totalVariation
(paddedWeights (V := V) rhs Ξ²)
(uniformWeights (ActualEnumeration.Coefficients k V)) := by
unfold DFVSGames.Foundations.Information.totalVariation
rw [β (ActualEnumeration.coefficientEquiv k V).sum_comp]
simp only [paddedMapWeights_eq,
ActualEnumeration.coefficientEquiv, Equiv.coe_fn_mk,
ActualEnumeration.to_fromCoefficients]
congr 1
apply Finset.sum_congr rfl
intro a _
rw [show uniformWeights (ActualHomogeneous.E k ββ[F2] V)
(ActualEnumeration.fromCoefficients k V a) =
uniformWeights (ActualEnumeration.Coefficients k V) a from
uniform_sourceMap_coordinates a]
rw [heq]
exact paddedWeights_totalVariation_eq_slope rhs Ξ²
theorem paddedMapWeights_totalVariation (rhs : Fin k β Bool) (Ξ² : β)
(hΞ² : 0 β€ Ξ²) (hΞ²' : Ξ² β€ 1) :
DFVSGames.Foundations.Information.totalVariation (paddedMapWeights (V := V) rhs Ξ²)
(uniformWeights (ActualHomogeneous.E k ββ[F2] V)) β€
Real.sqrt ((1 + Ξ² ^ 2 * ((Fintype.card V : β) - 1) / 3) ^ k - 1) / 2 := by
rw [paddedMapWeights_totalVariation_eq_slope]
exact paddedSlope_totalVariation V Ξ² hΞ² hΞ²' k
end
end DFVSGames.Decoder.PaddedLaw
end OAI
import Mathlib
import OAI.Computability.DirectedFeedback.Games.ActualCanonical
namespace OAI
namespace DFVSGames.Reduction.Explicit
variable {Ξ± Ξ² : Type*}
def pairs (xs : List Ξ±) (ys : List Ξ²) : List (Ξ± Γ Ξ²) :=
xs.flatMap fun x => ys.map fun y => (x, y)
theorem length_pairs (xs : List Ξ±) (ys : List Ξ²) :
(pairs xs ys).length = xs.length * ys.length := by
induction xs with
| nil => simp [pairs]
| cons x xs ih =>
simp only [pairs, List.flatMap_cons, List.length_append, List.length_map,
List.length_cons] at *
rw [ih, Nat.add_mul, Nat.one_mul, Nat.add_comm]
theorem mem_pairs {xs : List Ξ±} {ys : List Ξ²} {x : Ξ±} {y : Ξ²} :
(x, y) β pairs xs ys β x β xs β§ y β ys := by
simp [pairs]
def words (alphabet : List Ξ±) : Nat β List (List Ξ±)
| 0 => [[]]
| k + 1 => (pairs alphabet (words alphabet k)).map fun p => p.1 :: p.2
theorem length_words (alphabet : List Ξ±) (k : Nat) :
(words alphabet k).length = alphabet.length ^ k := by
induction k with
| zero => simp [words]
| succ k ih =>
simp only [words, List.length_map, length_pairs, ih, Nat.pow_succ]
exact Nat.mul_comm _ _
theorem mem_words {alphabet : List Ξ±} {w : List Ξ±} {k : Nat} :
w β words alphabet k β w.length = k β§ β a β w, a β alphabet := by
induction k generalizing w with
| zero => cases w <;> simp [words]
| succ k ih =>
cases w with
| nil => simp [words, pairs]
| cons a w =>
simp only [words, List.mem_map]
constructor
Β· rintro β¨β¨b, vβ©, h, heqβ©
cases heq
obtain β¨ha, hwβ© := mem_pairs.mp h
obtain β¨hlen, hallβ© := ih.mp hw
constructor
Β· simp [hlen]
Β· intro x hx
rcases List.mem_cons.mp hx with hax | hxw
Β· simpa [hax] using ha
Β· exact hall x hxw
Β· rintro β¨hlen, hallβ©
refine β¨(a, w), mem_pairs.mpr β¨hall a (by simp), ?_β©, rflβ©
apply ih.mpr
constructor
Β· simpa using hlen
Β· intro x hx
exact hall x (List.mem_cons_of_mem a hx)
abbrev CoordinateOutcome := (List Nat Γ List Nat) Γ (Nat Γ List Nat)
def edgeOutcomes (m k dimR noiseCount : Nat) : List CoordinateOutcome :=
pairs
(pairs (words (List.range m) k) (words [0, 1] ((2*k + 1)*dimR)))
(pairs (List.range noiseCount) (words [0, 1] (2*k + 1)))
def edgeCount (m k dimR noiseCount : Nat) : Nat :=
m^k * 2^((2*k + 1)*(dimR + 1)) * noiseCount
theorem length_edgeOutcomes (m k dimR noiseCount : Nat) :
(edgeOutcomes m k dimR noiseCount).length = edgeCount m k dimR noiseCount := by
simp only [edgeOutcomes, length_pairs, length_words, List.length_range,
List.length_cons, List.length_nil, edgeCount]
simp only [Nat.mul_add, Nat.mul_one, Nat.pow_add]
norm_num only
ring
theorem edgeCount_pos {m noiseCount : Nat} (hm : 0 < m) (hv : 0 < noiseCount)
(k dimR : Nat) : 0 < edgeCount m k dimR noiseCount := by
exact Nat.mul_pos (Nat.mul_pos (Nat.pow_pos hm) (Nat.two_pow_pos _)) hv
theorem edgeOutcomes_nonempty {m noiseCount : Nat} (hm : 0 < m)
(hv : 0 < noiseCount) (k dimR : Nat) : edgeOutcomes m k dimR noiseCount β [] := by
intro h
have hp := edgeCount_pos hm hv k dimR
rw [β length_edgeOutcomes, h] at hp
exact Nat.not_lt_zero _ hp
theorem edgeCount_mono {m bound : Nat} (h : m β€ bound) (k dimR noiseCount : Nat) :
edgeCount m k dimR noiseCount β€ edgeCount bound k dimR noiseCount := by
exact Nat.mul_le_mul_right _
(Nat.mul_le_mul_right _ (Nat.pow_le_pow_left h k))