File size: 5,648 Bytes
97c3405 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | import OAI.Combinatorics.ContingencyTables.Machines.InitialFactorialBits
import OAI.Combinatorics.ContingencyTables.Transport.RealKernelApproximation
namespace OAI
/-! # Actual bounded-word initialization of the companion trace
The output is in the literal `PlainIndex` used by the trace chain. Its
ideal rational law is exactly the source's phase-zero law; the bounded
word implementation is within 2^(-h), with an explicit word length.
-/
namespace ContingencyTables.CompanionInitialDraw
open CommonBasesFPRAS ResidualMixture FirstSuccess TwoLiftStates
open CompanionFactorialApplication InitialFactorialLaw InitialFactorialBits
open RealKernelApproximation
open scoped BigOperators Classical
noncomputable section
variable {I J : Type*} [Fintype I] [Fintype J]
def cellEnum (A : Instance I J) : SmallCell A ≃ Fin (Fintype.card (SmallCell A)) :=
Fintype.equivFin (SmallCell A)
def cellCapacity (A : Instance I J) (i : Fin (Fintype.card (SmallCell A))) : ℕ :=
A.b ((cellEnum A).symm i).val.1 ((cellEnum A).symm i).val.2
def indexEquiv (A : Instance I J) :
{S : Set (Labels A×Bool) // PlainState pairs S} ≃
PlainIndex (pairs : List ((Labels A×Bool)×(Labels A×Bool))) where
toFun S := ⟨⟨S.val,Or.inl S.property⟩,S.property⟩
invFun S := ⟨S.val.val,S.property⟩
left_inv _ := rfl
right_inv _ := rfl
def idealLaw (A : Instance I J) :
RationalLaw (PlainIndex (pairs : List ((Labels A×Bool)×(Labels A×Bool)))) :=
equivLaw (indexEquiv A) (companionLaw A)
theorem idealLaw_mass (A : Instance I J)
(S : PlainIndex (pairs : List ((Labels A×Bool)×(Labels A×Bool)))) :
((idealLaw A).mass S:ℝ)=CompanionWarmStart.law A 0 S.val.val :=
companionLaw_mass A ((indexEquiv A).symm S)
def initialBits (A : Instance I J) (B : ℕ) : ℕ := bitCount (cellCapacity A) B
def draw (A : Instance I J) (B : ℕ) (bits : Fin (initialBits A B) → Bool) :
PlainIndex (pairs : List ((Labels A×Bool)×(Labels A×Bool))) :=
indexEquiv A (transversalDraw (fun s : SmallCell A => A.b s.val.1 s.val.2)
(cellEnum A) B bits)
lemma cellCount_bound (A : Instance I J) : Fintype.card (SmallCell A)≤A.d := by
exact (Fintype.card_le_of_injective (fun s : SmallCell A => s.val) Subtype.val_injective).trans
(by simpa only [Fintype.card_prod] using A.hcard)
lemma cellCapacity_bound (A : Instance I J) (i : Fin (Fintype.card (SmallCell A))) :
cellCapacity A i≤A.W :=
(A.hsmall _ _ ((cellEnum A).symm i).property).le
theorem initialBits_bound (A : Instance I J) (B : ℕ) :
initialBits A B≤A.d*(A.W+1)*B := by
have hh := bitCount_bound (cellCapacity A) B A.W (cellCapacity_bound A)
exact hh.trans (Nat.mul_le_mul_right B
(Nat.mul_le_mul_right (A.W+1) (cellCount_bound A)))
theorem draw_error (A : Instance I J) (B : ℕ) :
variation (mapLaw (uniformLaw (α := Fin (initialBits A B) → Bool)) (draw A B))
(idealLaw A)≤(A.d:ℚ)*(3*A.W+1)/(2*(2:ℚ)^B) := by
unfold draw initialBits cellCapacity
have he := mapLaw_equiv_output (indexEquiv A)
(uniformLaw (α := Fin (bitCount
(fun i => A.b ((cellEnum A).symm i).val.1 ((cellEnum A).symm i).val.2) B) → Bool))
(transversalDraw (fun s : SmallCell A => A.b s.val.1 s.val.2) (cellEnum A) B)
rw [he,idealLaw,variation_equiv]
have ht := transversalDraw_error (fun s : SmallCell A => A.b s.val.1 s.val.2)
(cellEnum A) B A.W (fun s => (A.hsmall _ _ s.property).le)
apply ht.trans
apply div_le_div_of_nonneg_right _ (by positivity)
apply mul_le_mul_of_nonneg_right _ (by positivity)
exact_mod_cast cellCount_bound A
def precision (A : Instance I J) (h : ℕ) : ℕ :=
Nat.clog 2 (A.d*(3*A.W+1)+1)+h
lemma precision_error (A : Instance I J) (h : ℕ) :
(A.d:ℚ)*(3*A.W+1)/(2*(2:ℚ)^precision A h)≤1/(2:ℚ)^h := by
have hc : A.d*(3*A.W+1)≤2^Nat.clog 2 (A.d*(3*A.W+1)+1) :=
(Nat.le_succ _).trans (Nat.le_pow_clog (by decide) _)
have hcr : (A.d:ℚ)*(3*A.W+1)≤(2:ℚ)^Nat.clog 2 (A.d*(3*A.W+1)+1) := by
exact_mod_cast hc
unfold precision
rw [pow_add]
apply (div_le_div_iff₀ (by positivity) (by positivity)).mpr
have hp := mul_le_mul_of_nonneg_right hcr (show 0≤(2:ℚ)^h by positivity)
have hp0 : 0≤(2:ℚ)^Nat.clog 2 (A.d*(3*A.W+1)+1)*(2:ℚ)^h := by positivity
nlinarith [pow_pos (by norm_num : (0:ℚ)<2) h]
/-- The implemented initial word is compared directly to the literal
phase-zero law, so later restart estimates need no initializer oracle. -/
theorem initial_distance (A : Instance I J) (h : ℕ) :
distance (fun S => ((mapLaw (uniformLaw (α := Fin (initialBits A (precision A h)) → Bool))
(draw A (precision A h))).mass S:ℝ))
(fun S => CompanionWarmStart.law A 0 S.val.val)≤1/(2:ℝ)^h := by
have hh := (draw_error A (precision A h)).trans (precision_error A h)
have he : distance
(fun S => ((mapLaw (uniformLaw (α := Fin (initialBits A (precision A h)) → Bool))
(draw A (precision A h))).mass S:ℝ))
(fun S => CompanionWarmStart.law A 0 S.val.val)=
(variation (mapLaw (uniformLaw (α := Fin (initialBits A (precision A h)) → Bool))
(draw A (precision A h))) (idealLaw A):ℝ) := by
simp_rw [←idealLaw_mass A]
simp only [distance,variation,Rat.cast_div,Rat.cast_sum,Rat.cast_abs,Rat.cast_sub,Rat.cast_ofNat]
rw [he]
have hc : (variation (mapLaw (uniformLaw (α := Fin (initialBits A (precision A h)) → Bool))
(draw A (precision A h))) (idealLaw A):ℝ)≤((1/(2:ℚ)^h:ℚ):ℝ) := Rat.cast_le.mpr hh
simpa only [Rat.cast_div,Rat.cast_one,Rat.cast_pow,Rat.cast_ofNat] using hc
end
end ContingencyTables.CompanionInitialDraw
end OAI
|