| import OAI.Combinatorics.ContingencyTables.Rooted.RootedBinFramesProgram |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionOracleDraw |
|
|
| namespace OAI |
|
|
| /-! # The computed bin program has the analysed independent law |
|
|
| The execution order is the computed free-cell catalog. The mathematical |
| law uses another enumeration. Dependent word equivalences identify their |
| independent Boolean inputs, while preserving each physical cell's draw. |
| -/ |
|
|
| namespace ContingencyTables.RootedBinDrawLaw |
|
|
| open CompanionFactorialApplication ForestAssignmentSplit GridBoundary |
| open CompanionOracleDensity FirstSuccess ResidualMixture FairBits |
| open scoped BigOperators Classical |
|
|
| noncomputable section |
| variable {m n : ℕ} |
|
|
| local instance freeCellDecidableEq (A : Instance (Fin m) (Fin n)) : |
| DecidableEq (FreeCell A.small A.T) := by |
| letI : DecidableEq (Fin m) := Classical.decEq _ |
| letI : DecidableEq (Fin n) := Classical.decEq _ |
| infer_instance |
|
|
| abbrev FreeWords (A : Instance (Fin m) (Fin n)) (h : ℕ) := |
| (t : FreeCell A.small A.T) → Fin (offsetBitLength (freeRange A t) h A.d) → Bool |
|
|
| abbrev Words (A : Instance (Fin m) (Fin n)) (h : ℕ) := |
| (i : Fin (RootedCatalogGrid.freeCount A)) → |
| Fin (offsetBitLength (freeRange A (RootedForestCatalog.freeEquiv A i)) h A.d) → Bool |
|
|
| def freeWordEquiv (A : Instance (Fin m) (Fin n)) (h : ℕ) : |
| Words A h ≃ FreeWords A h := |
| Equiv.piCongrLeft (fun t : FreeCell A.small A.T => |
| Fin (offsetBitLength (freeRange A t) h A.d) → Bool) (RootedForestCatalog.freeEquiv A) |
|
|
| def originalWordEquiv (A : Instance (Fin m) (Fin n)) (h : ℕ) : |
| BinWords A h ≃ FreeWords A h := |
| Equiv.piCongrLeft (fun t : FreeCell A.small A.T => |
| Fin (offsetBitLength (freeRange A t) h A.d) → Bool) (index A) |
|
|
| def reindexWords (A : Instance (Fin m) (Fin n)) (h : ℕ) : |
| Words A h ≃ BinWords A h := |
| (freeWordEquiv A h).trans (originalWordEquiv A h).symm |
|
|
| def wordBits (A : Instance (Fin m) (Fin n)) (h : ℕ) : ℕ := |
| ∑ i : Fin (RootedCatalogGrid.freeCount A), |
| offsetBitLength (freeRange A (RootedForestCatalog.freeEquiv A i)) h A.d |
|
|
| def wordEquiv (A : Instance (Fin m) (Fin n)) (h : ℕ) : |
| (Fin (wordBits A h) → Bool) ≃ Words A h := |
| (Equiv.arrowCongr finSigmaFinEquiv.symm (Equiv.refl Bool)).trans |
| (Equiv.piCurry (fun _ _ => Bool)) |
|
|
| lemma wordBits_eq (A : Instance (Fin m) (Fin n)) (h : ℕ) : |
| wordBits A h=binWordBits A h := by |
| unfold wordBits binWordBits |
| apply Fintype.sum_equiv (RootedCatalogGrid.coordinateEquiv A) |
| intro i |
| simp only [RootedCatalogGrid.coordinateEquiv,Equiv.trans_apply, |
| Equiv.apply_symm_apply] |
|
|
| def draw (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) (bits : Words A h) : FreeIndex A.small A.T A.b := |
| binWordDraw A K hK hW (RootedCatalogGrid.gridEquiv A K v) h (reindexWords A h bits) |
|
|
| lemma draw_law (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) : |
| mapLaw (uniformLaw (α := Words A h)) (draw A K hK hW v h)= |
| approximateBinLaw A K hK hW (RootedCatalogGrid.gridEquiv A K v) h := by |
| have he := binWordDraw_law A K hK hW (RootedCatalogGrid.gridEquiv A K v) h |
| unfold draw |
| rw [←FairBits.map_equiv (reindexWords A h),FairBits.uniform_equiv] |
| apply RationalLaw.ext |
| funext f |
| exact congrArg (fun p => p.mass f) he |
|
|
| private lemma interval_bits_le (K N beta h d : ℕ) (hK : 0 < K) (hN : 0 < N) |
| (hb : beta < K) : |
| offsetBitLength (intervalSize K N beta) h d ≤ offsetBitLength N h d := by |
| simpa only [offsetBitLength,BinVectorProgram.activeWidth,BinVectorProgram.reservedWidth, |
| BinIntervalProgram.intervalSize_eq] using |
| BinVectorProgram.active_le_reserved K N beta h d hK hN hb |
|
|
| private lemma coordinate_scalar (K N beta h d : ℕ) (bits : List Bool) : |
| BinVectorProgram.coordinate ((((K,N),beta),(h,d)),bits)= |
| FairBits.endpoint K N beta+ProfilePrograms.scaledWordValue |
| (intervalSize K N beta,bits.take (offsetBitLength (intervalSize K N beta) h d)) := by |
| simp only [BinVectorProgram.coordinate,BinIntervalProgram.draw,BinIntervalProgram.endpoint_eq, |
| BinIntervalProgram.intervalSize_eq,BinVectorProgram.activeWidth,offsetBitLength] |
|
|
| private lemma original_value (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) |
| (h : ℕ) (bits : FreeWords A h) (i : Fin (dimension A)) : |
| (binWordDraw A K hK hW v h ((originalWordEquiv A h).symm bits) (index A i)).val= |
| (intervalEquiv K (freeRange A (index A i)) (naturalBin A v (index A i)) |
| hK (Nat.succ_pos _) (naturalBin_lt A v _) |
| (scaledBitInteger (binSize A K v i) (offsetBitLength (binSize A K v i) h A.d) |
| (binSize_positive A K hK hW v i) |
| (prefixWord (binBits_le A K hK v h i) (bits (index A i))))).val := by |
| change ((Equiv.piCongrLeft (fun t : FreeCell A.small A.T => |
| {z : ℕ // z∈FairBits.fiber K (freeRange A t) (naturalBin A v t)}) (index A)) |
| (fun j => intervalEquiv K (freeRange A (index A j)) (naturalBin A v (index A j)) |
| hK (Nat.succ_pos _) (naturalBin_lt A v _) |
| (scaledBitInteger (binSize A K v j) (offsetBitLength (binSize A K v j) h A.d) |
| (binSize_positive A K hK hW v j) |
| (prefixWord (binBits_le A K hK v h j) |
| ((originalWordEquiv A h).symm bits j)))) (index A i)).val=_ |
| rw [Equiv.piCongrLeft_apply_apply] |
| simp only [originalWordEquiv,Equiv.piCongrLeft_symm_apply] |
|
|
| private lemma original_free_value (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) |
| (h : ℕ) (bits : FreeWords A h) (t : FreeCell A.small A.T) |
| (hsize : 0 < intervalSize K (freeRange A t) (naturalBin A v t)) : |
| (binWordDraw A K hK hW v h ((originalWordEquiv A h).symm bits) t).val= |
| (intervalEquiv K (freeRange A t) (naturalBin A v t) |
| hK (Nat.succ_pos _) (naturalBin_lt A v t) |
| (scaledBitInteger (intervalSize K (freeRange A t) (naturalBin A v t)) |
| (offsetBitLength (intervalSize K (freeRange A t) (naturalBin A v t)) h A.d) |
| hsize (prefixWord (interval_bits_le K (freeRange A t) |
| (naturalBin A v t) h A.d hK (Nat.succ_pos _) (naturalBin_lt A v t)) |
| (bits t)))).val := by |
| obtain ⟨i,rfl⟩ := (index A).surjective t |
| simpa only [binSize] using original_value A K hK hW v h bits i |
|
|
| lemma draw_coordinate (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) (bits : Words A h) (i : Fin (RootedCatalogGrid.freeCount A)) : |
| BinVectorProgram.coordinate |
| ((((K,freeRange A (RootedForestCatalog.freeEquiv A i)),(v i).val.toNat),(h,A.d)), |
| List.ofFn (bits i))= |
| (draw A K hK hW v h bits (RootedForestCatalog.freeEquiv A i)).val := by |
| let w := RootedCatalogGrid.gridEquiv A K v |
| have hb : naturalBin A w (RootedForestCatalog.freeEquiv A i)=(v i).val.toNat := by |
| simp only [w,naturalBin,RootedCatalogGrid.gridEquiv_free,Equiv.symm_apply_apply] |
| have hp : 0 < intervalSize K (freeRange A (RootedForestCatalog.freeEquiv A i)) |
| (naturalBin A w (RootedForestCatalog.freeEquiv A i)) := by |
| simpa only [binSize,Equiv.apply_symm_apply] using |
| binSize_positive A K hK hW w ((index A).symm (RootedForestCatalog.freeEquiv A i)) |
| have hv := original_free_value A K hK hW w h (freeWordEquiv A h bits) |
| (RootedForestCatalog.freeEquiv A i) hp |
| let t := RootedForestCatalog.freeEquiv A i |
| let M := intervalSize K (freeRange A t) (naturalBin A w t) |
| let k := offsetBitLength M h A.d |
| have hk : k ≤ offsetBitLength (freeRange A t) h A.d := |
| interval_bits_le K (freeRange A t) (naturalBin A w t) h A.d hK |
| (Nat.succ_pos _) (naturalBin_lt A w t) |
| have hs := ProfilePrograms.scaledWordValue_ofFn M k hp |
| (prefixWord hk (freeWordEquiv A h bits t)) |
| change (draw A K hK hW v h bits t).val=FairBits.endpoint K (freeRange A t) |
| (naturalBin A w t)+(scaledBitInteger M k hp |
| (prefixWord hk (freeWordEquiv A h bits t))).val at hv |
| rw [←hs,←BinVectorProgram.take_ofFn_prefix hk] at hv |
| have hw : freeWordEquiv A h bits (RootedForestCatalog.freeEquiv A i)=bits i := |
| Equiv.piCongrLeft_apply_apply _ _ _ _ |
| dsimp only [t,M,k] at hv |
| rw [hw] at hv |
| rw [hb] at hv |
| rw [coordinate_scalar] |
| exact hv.symm |
|
|
| def flatDraw (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) (bits : Fin (wordBits A h) → Bool) : FreeIndex A.small A.T A.b := |
| draw A K hK hW v h (wordEquiv A h bits) |
|
|
| theorem flatDraw_law (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) : |
| mapLaw (uniformLaw (α := Fin (wordBits A h) → Bool)) (flatDraw A K hK hW v h)= |
| approximateBinLaw A K hK hW (RootedCatalogGrid.gridEquiv A K v) h := by |
| unfold flatDraw |
| rw [←FairBits.map_equiv (wordEquiv A h),FairBits.uniform_equiv,draw_law] |
|
|
| theorem program_flatDraw (A : Instance (Fin m) (Fin n)) (K : ℕ) (hK : 0 < K) |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (RootedCatalogGrid.freeCount A)) K) |
| (h : ℕ) (bits : Fin (wordBits A h) → Bool) : |
| RootedBinFramesProgram.draw (RootedBinFramesProgram.data A h v,List.ofFn bits)= |
| List.ofFn (fun i => (flatDraw A K hK hW v h bits |
| (RootedForestCatalog.freeEquiv A i)).val) := by |
| unfold RootedBinFramesProgram.draw |
| rw [RootedBinFramesProgram.frames_data] |
| let frames : Fin (RootedCatalogGrid.freeCount A) → BinVectorProgram.Frame := fun i => |
| (((K,freeRange A (RootedForestCatalog.freeEquiv A i)),(v i).val.toNat),(h,A.d)) |
| have he := BinVectorProgram.output_ofFn frames bits |
| refine he.trans ?_ |
| apply congrArg List.ofFn |
| funext i |
| exact draw_coordinate A K hK hW v h (wordEquiv A h bits) i |
|
|
| end |
| end ContingencyTables.RootedBinDrawLaw |
|
|
| end OAI |
|
|
