| import OAI.Combinatorics.ContingencyTables.Sampling.AllSmallRational |
| import OAI.Combinatorics.ContingencyTables.Sampling.FirstPaperBooleanProposal |
| import OAI.Combinatorics.ContingencyTables.Machines.FiniteWordWalk |
| import OAI.Combinatorics.ContingencyTables.Dense.DenseBooleanWalk |
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteDeterministicJoint |
| import OAI.Combinatorics.ContingencyTables.Sampling.FirstPaperIdealRejection |
|
|
| namespace OAI |
|
|
| /-! # Boolean implementation when all cells are retained -/ |
|
|
| namespace ContingencyTables.SmallGraphProfiles |
| open scoped BigOperators Classical |
| open ResidualMixture FirstSuccess FairBits CompletionTranslation CompletionCounts |
|
|
| noncomputable section |
| universe u |
| variable {I J : Type u} [Fintype I] [Fintype J] [LinearOrder I] [LinearOrder J] |
| variable (r : I → ℕ) (c : J → ℕ) |
| local notation "s" => smallProposalBits (I := I) (J := J) |
| local instance : DecidableEq (PaperStates r c) := Classical.decEq _ |
|
|
| def unitBitStep (x : PaperStates r c) (bits : Fin s → Bool) : PaperStates r c := |
| (smallBitProposal r c x bits).getD x |
|
|
| lemma unitBitStep_law (x : PaperStates r c) : |
| mapLaw (uniformLaw (α := Fin s → Bool)) (unitBitStep r c x)=unitSmallStep r c x := by |
| unfold unitBitStep |
| calc |
| _ = mapLaw (mapLaw (uniformLaw (α := Fin s → Bool)) (smallBitProposal r c x)) |
| (fun z : Option (PaperStates r c) => z.getD x) := |
| (mapLaw_comp _ (smallBitProposal r c x) |
| (fun z : Option (PaperStates r c) => z.getD x)).symm |
| _ = _ := by rw [smallBitProposal_law_decidableEq r c _ x]; rfl |
|
|
| def flatUnitWalk (x : PaperStates r c) (n : ℕ) (bits : Fin (n*s) → Bool) : PaperStates r c := |
| wordWalk (unitBitStep r c) x n (GridBoundary.gridWordEquiv n s bits) |
|
|
| lemma flatUnitWalk_law (x : PaperStates r c) (n : ℕ) : |
| mapLaw (uniformLaw (α := Fin (n*s) → Bool)) (flatUnitWalk r c x n)= |
| walkLaw (unitSmallStep r c) x n := by |
| unfold flatUnitWalk |
| rw [←map_equiv (GridBoundary.gridWordEquiv n s),uniform_equiv] |
| change wordWalkLaw _ _ _=_ |
| rw [wordWalkLaw_eq] |
| exact congrArg (fun K => walkLaw K x n) (funext (unitBitStep_law r c)) |
|
|
| lemma uniform_singleton_joint [Nonempty (PaperStates r c)] |
| (hsmall : ∀ i j,FirstPaperPhysicalMarginal.paperSmall r c i j=true) |
| (fallback : (z : PaperStates r c) → PaperFibre r c z) : |
| mapLaw (uniformLaw (α := PaperStates r c)) |
| (fun z => (⟨z,fallback z⟩ : PaperStateJoint r c))= |
| uniformLaw (α := PaperStateJoint r c) := by |
| rw [mapLaw_deterministicJoint] |
| have he (z : PaperStates r c) : pointLaw (fallback z)=uniformLaw (α := PaperFibre r c z) := by |
| let : Subsingleton (PaperFibre r c z) := |
| PhysicalCompletionFibres.completionFibre_subsingleton _ _ _ _ _ _ _ hsmall |
| exact pointLaw_eq_uniform _ |
| simp_rw [he] |
| apply dependentJointLaw_uniform |
| intro z |
| simp only [uniformLaw,uniformMass,paperFibre_card_allSmall r c hsmall, |
| Nat.cast_one,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] |
|
|
|
|
| def unitJointDraw (fallback : (z : PaperStates r c) → PaperFibre r c z) |
| (x : PaperStates r c) (n : ℕ) (bits : Fin (n*s) → Bool) : PaperStateJoint r c := |
| let z := flatUnitWalk r c x n bits |
| ⟨z,fallback z⟩ |
|
|
| lemma unitJointDraw_law (fallback : (z : PaperStates r c) → PaperFibre r c z) |
| (x : PaperStates r c) (n : ℕ) : |
| mapLaw (uniformLaw (α := Fin (n*s) → Bool)) (unitJointDraw r c fallback x n)= |
| mapLaw (walkLaw (unitSmallStep r c) x n) |
| (fun z => (⟨z,fallback z⟩ : PaperStateJoint r c)) := by |
| unfold unitJointDraw |
| calc |
| _ = mapLaw (mapLaw (uniformLaw (α := Fin (n*s) → Bool)) (flatUnitWalk r c x n)) |
| (fun z => (⟨z,fallback z⟩ : PaperStateJoint r c)) := |
| (mapLaw_comp _ (flatUnitWalk r c x n) |
| (fun z => (⟨z,fallback z⟩ : PaperStateJoint r c))).symm |
| _ = _ := by rw [flatUnitWalk_law] |
|
|
| theorem unitJointDraw_variation [Nonempty I] [Nonempty J] [Nonempty (PaperStates r c)] |
| (hsmall : ∀ i j,FirstPaperPhysicalMarginal.paperSmall r c i j=true) |
| (fallback : (z : PaperStates r c) → PaperFibre r c z) |
| (x : PaperStates r c) (n : ℕ) : |
| (variation (mapLaw (uniformLaw (α := Fin (n*s) → Bool)) |
| (unitJointDraw r c fallback x n)) (uniformLaw (α := PaperStateJoint r c)):ℝ) ≤ |
| ((stateBound r c+1:ℕ):ℝ)^(2*dimensionAllowance (I := I) (J := J))* |
| Real.exp (-(n:ℝ)/(dimensionAllowance (I := I) (J := J):ℝ)^160) := by |
| rw [unitJointDraw_law] |
| have hv := variation_map (walkLaw (unitSmallStep r c) x n) |
| (uniformLaw (α := PaperStates r c)) (fun z => (⟨z,fallback z⟩ : PaperStateJoint r c)) |
| rw [uniform_singleton_joint r c hsmall fallback] at hv |
| exact ((Rat.cast_le (K := ℝ)).mpr hv).trans (unitSmallWalk_variation r c hsmall x n) |
|
|
| end |
| end ContingencyTables.SmallGraphProfiles |
|
|
| end OAI |
|
|
