File size: 6,940 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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | import OAI.Combinatorics.ContingencyTables.Counting.CompanionOracleJointLaw
import OAI.Combinatorics.ContingencyTables.Transport.FiniteScaledDraw
import OAI.Combinatorics.ContingencyTables.Transport.RationalMapProducts
namespace OAI
/-! # Explicit integer intervals inside the companion evaluator bins -/
namespace ContingencyTables.CompanionOracleDensity
open CompanionFactorialApplication ForestAssignmentSplit GridBoundary ResidualMixture FirstSuccess
open scoped BigOperators Classical
noncomputable section
variable {I J : Type*} [Fintype I] [Fintype J]
def intervalSize (K N beta : ℕ) : ℕ :=
FairBits.endpoint K N (beta+1)-FairBits.endpoint K N beta
/-- Each offset is sent to its integer by adding the exact lower ceiling
endpoint. This is the actual source interval, not a cardinality-only choice. -/
def intervalEquiv (K N beta : ℕ) (hK : 0 < K) (hN : 0 < N) (hb : beta < K) :
Fin (intervalSize K N beta) ≃ {z : ℕ // z∈FairBits.fiber K N beta} where
toFun x := ⟨FairBits.endpoint K N beta+x.val,by
rw [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico]
have hh := x.isLt
unfold intervalSize at hh
omega⟩
invFun x := ⟨x.val-FairBits.endpoint K N beta,by
have hx : FairBits.endpoint K N beta ≤ x.val ∧
x.val < FairBits.endpoint K N (beta+1) := by
simpa only [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] using x.property
unfold intervalSize
omega⟩
left_inv x := by apply Fin.ext; simp
right_inv x := by
apply Subtype.ext
have hx : FairBits.endpoint K N beta ≤ x.val ∧
x.val < FairBits.endpoint K N (beta+1) := by
simpa only [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] using x.property
dsimp only
omega
def binSize (A : Instance I J) (K : ℕ) (v : Grid (I := Fin (dimension A)) K)
(i : Fin (dimension A)) : ℕ :=
intervalSize K (freeRange A (index A i)) (naturalBin A v (index A i))
theorem binSize_positive (A : Instance I J) (K : ℕ) (hK : 0 < K)
(hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) (i : Fin (dimension A)) :
0 < binSize A K v i := by
have hp := CompanionBinPopulation.coordinate_nonempty K (freeRange A (index A i)) A.d
(naturalBin A v (index A i)) hK A.hd (by
have hb := (A.hlarge (index A i).val.1 (index A i).val.2 (index A i).property.1).1
unfold freeRange
omega) (naturalBin_lt A v (index A i))
have hc := Finset.card_pos.mpr hp
have hN : 0 < freeRange A (index A i) := Nat.succ_pos _
rw [FairBits.fiber_card hK hN (naturalBin_lt A v (index A i))] at hc
exact hc
def binOffsetsEquiv (A : Instance I J) (K : ℕ) (hK : 0 < K)
(v : Grid (I := Fin (dimension A)) K) :
((i : Fin (dimension A)) → Fin (binSize A K v i)) ≃ {f // f∈integerFiber A K hK v} :=
(Equiv.piCongrRight (fun i => intervalEquiv K (freeRange A (index A i))
(naturalBin A v (index A i)) hK (Nat.succ_pos _) (naturalBin_lt A v (index A i)))).trans
((Equiv.piCongrLeft (fun t : FreeCell A.small A.T =>
{z : ℕ // z∈FairBits.fiber K (freeRange A t) (naturalBin A v t)}) (index A)).trans
(integerFiberEquiv A K hK v).symm)
def binOffsetValue (A : Instance I J) (K : ℕ) (hK : 0 < K)
(v : Grid (I := Fin (dimension A)) K)
(x : (i : Fin (dimension A)) → Fin (binSize A K v i)) : FreeIndex A.small A.T A.b :=
(binOffsetsEquiv A K hK v x).val
lemma binOffsetValue_mem (A : Instance I J) (K : ℕ) (hK : 0 < K)
(v : Grid (I := Fin (dimension A)) K)
(x : (i : Fin (dimension A)) → Fin (binSize A K v i)) :
binOffsetValue A K hK v x∈integerFiber A K hK v := (binOffsetsEquiv A K hK v x).property
def exactBinLaw (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W)
(v : Grid (I := Fin (dimension A)) K) : RationalLaw (FreeIndex A.small A.T A.b) :=
mapLaw (piLaw (fun i => FairBits.uniformIntLaw (binSize A K v i) (binSize_positive A K hK hW v i)))
(binOffsetValue A K hK v)
def approximateBinLaw (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W)
(v : Grid (I := Fin (dimension A)) K) (h : ℕ) : RationalLaw (FreeIndex A.small A.T A.b) :=
mapLaw (piLaw (fun i => FairBits.scaledLaw (binSize A K v i)
(FairBits.offsetBitLength (binSize A K v i) h A.d) (binSize_positive A K hK hW v i)))
(binOffsetValue A K hK v)
theorem exactBinLaw_mass (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W)
(v : Grid (I := Fin (dimension A)) K) (f : FreeIndex A.small A.T A.b) :
(exactBinLaw A K hK hW v).mass f=
if integerBin A K hK f=v then 1/((integerFiber A K hK v).card:ℚ) else 0 := by
let : ∀ i : Fin (dimension A),Nonempty (Fin (binSize A K v i)) :=
fun i => ⟨⟨0,binSize_positive A K hK hW v i⟩⟩
let : Nonempty {f // f∈integerFiber A K hK v} :=
⟨⟨(integerFiber_nonempty A K hK hW v).choose,(integerFiber_nonempty A K hK hW v).choose_spec⟩⟩
have hi (i : Fin (dimension A)) :
FairBits.uniformIntLaw (binSize A K v i) (binSize_positive A K hK hW v i)=
uniformLaw (α := Fin (binSize A K v i)) := by
apply RationalLaw.ext
funext x
simp only [FairBits.uniformIntLaw,uniformLaw,uniformMass,Fintype.card_fin]
unfold exactBinLaw
simp_rw [hi]
rw [pi_uniformLaw]
change (mapLaw (uniformLaw (α := (i : Fin (dimension A)) → Fin (binSize A K v i)))
(fun x => (binOffsetsEquiv A K hK v x).val)).mass f=_
rw [←FairBits.map_equiv (binOffsetsEquiv A K hK v),FairBits.uniform_equiv]
change (∑ x : {g // g∈integerFiber A K hK v},
if x.val=f then (1:ℚ)/Fintype.card {g // g∈integerFiber A K hK v} else 0)=_
rw [Fintype.card_coe]
by_cases hf : integerBin A K hK f=v
· rw [ite_eq_left hf]
let g : {g // g∈integerFiber A K hK v} := ⟨f,by simp only [integerFiber,Finset.mem_filter,
Finset.mem_univ,true_and,hf]⟩
have he (x : {g // g∈integerFiber A K hK v}) : x.val=f ↔ x=g := by
exact ⟨fun h => Subtype.ext h,fun h => congrArg Subtype.val h⟩
simp_rw [he]
simp
· rw [ite_eq_right hf]
apply Finset.sum_eq_zero
intro x _
have hxf : x.val≠f := by
intro he
have hx := (Finset.mem_filter.mp x.property).2
rw [he] at hx
exact hf hx
simp only [hxf,ite_false]
/-- The explicitly shifted bounded quotient draws have a uniform error
bound for every bin, including the case of no free coordinates. -/
theorem approximateBinLaw_variation (A : Instance I J) (K : ℕ) (hK : 0 < K)
(hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) (h : ℕ) :
variation (approximateBinLaw A K hK hW v h) (exactBinLaw A K hK hW v) ≤
(A.d:ℚ)/(2:ℚ)^(4*(h+A.d)) := by
apply (variation_map _ _ (binOffsetValue A K hK v)).trans
exact FairBits.dense_offset_product_variation (dimension A) h A.d (binSize A K v)
(binSize_positive A K hK hW v) (ForestScaledPenalty.free_card_le A)
end
end ContingencyTables.CompanionOracleDensity
end OAI
|