| import OAI.Combinatorics.ContingencyTables.Rooted.RootedBooleanPhase |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedWarmStart |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedConcentration |
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteLawMoments |
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteChainSlowdown |
| import OAI.Combinatorics.ContingencyTables.Transport.RealPathApproximation |
|
|
| namespace OAI |
|
|
| /-! # Selected-root Boolean row law and full-history perturbation -/ |
|
|
| namespace ContingencyTables.RootedBooleanPhase |
|
|
| open CompanionFactorialApplication CompanionOracleDensity CompanionWeightOracle |
| open CompanionRationalUpdates RootedOracleAcceptance |
| open CommonBasesFPRAS FirstSuccess FairBits TwoLiftStates GridBoundary ResidualMixture |
| open FiniteLawMoments RealKernelApproximation |
| open CompanionBooleanPhase (State proposal proposal_mass proposalBits proposal_codes stepBits stepWordEquiv |
| slowdown slowdown_bounds) |
| open CompanionConcentration (pairs_ne_nil) |
| open scoped BigOperators Classical |
|
|
| noncomputable section |
|
|
| private lemma word_probability {X Y : Type*} [Fintype X] [Fintype Y] [Nonempty X] |
| [DecidableEq Y] (draw : X → Y) (y : Y) : |
| uniformAverage (fun x => if draw x=y then (1:ℝ) else 0)= |
| ((mapLaw (uniformLaw (α := X)) draw).mass y:ℝ) := by |
| rw [word_expectation draw (fun z => if z=y then (1:ℝ) else 0)] |
| simp [expectation] |
|
|
| private lemma independent_decision {A B C D : Type*} |
| [Fintype A] [Fintype B] [Fintype C] [Fintype D] |
| (P : A → Prop) (Q : B → Prop) (R : C → D → Prop) |
| [DecidablePred P] [DecidablePred Q] [∀ c d,Decidable (R c d)] : |
| uniformAverage (fun z : A×(B×(C×D)) => |
| if P z.1 ∧ Q z.2.1 ∧ R z.2.2.1 z.2.2.2 then (1:ℝ) else 0)= |
| uniformAverage (fun a => if P a then (1:ℝ) else 0)* |
| uniformAverage (fun b => if Q b then (1:ℝ) else 0)* |
| uniformAverage (fun c => uniformAverage (fun d => if R c d then (1:ℝ) else 0)) := by |
| have he (z : A×(B×(C×D))) : |
| (if P z.1 ∧ Q z.2.1 ∧ R z.2.2.1 z.2.2.2 then (1:ℝ) else 0)= |
| (if P z.1 then 1 else 0)* |
| ((if Q z.2.1 then 1 else 0)*(if R z.2.2.1 z.2.2.2 then 1 else 0)) := by |
| by_cases hp : P z.1 <;> by_cases hq : Q z.2.1 <;> |
| by_cases hr : R z.2.2.1 z.2.2.2 <;> simp [hp,hq,hr] |
| have hs : (∑ a : A,∑ b : B,∑ c : C,∑ d : D, |
| (if P a then (1:ℝ) else 0)*((if Q b then 1 else 0)*(if R c d then 1 else 0)))= |
| (∑ a : A,if P a then (1:ℝ) else 0)*(∑ b : B,if Q b then (1:ℝ) else 0)* |
| (∑ c : C,∑ d : D,if R c d then (1:ℝ) else 0) := by |
| symm |
| simp only [Finset.sum_mul,mul_assoc] |
| simp only [Finset.mul_sum] |
| simp only [he,uniformAverage,Fintype.sum_prod_type,Fintype.card_prod,Nat.cast_mul, |
| ←Finset.sum_div] |
| rw [hs] |
| ring |
|
|
| private lemma lazy_probability : |
| uniformAverage (fun b : Fin 1 → Bool => if b 0=false then (1:ℝ) else 0)=1/2 := by |
| rw [uniformAverage_fin_succ] |
| simp only [Fin.cons_zero,uniformAverage_const] |
| norm_num [uniformAverage] |
|
|
| variable {I J : Type*} [Fintype I] [Fintype J] |
|
|
| /-- Every nontrivial output probability factors into its lazy bit, |
| unique neighbor code, and the actual rounded two-oracle acceptance. -/ |
| theorem transition_mass (A : Instance I J) (R : RootedCompletion.Selection A.T) (C : ℕ) (hC : 0<C) (K j k : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (hB : (K:ℝ)=binWidth A C) |
| (hj : j≤rationalHeight A C) (xi : ℚ) (hx0 : 0<xi) (hx1 : xi<1) |
| (v : Grid (I := Fin (dimension A)) K) (w : Pair A → Pair A → ℚ) |
| (hw : ∀ p q,0<w p q) (S T : State A) (hST : S≠T) : |
| ((transitionLaw A R C K j k hK hW xi v w S).mass T:ℝ)= |
| if ExchangeAdjacent S.val T.val then |
| (1/(2*(2:ℝ)^proposalBits A))* |
| uniformAverage (fun b : WeightWord A C K j xi×WeightWord A C K j xi => |
| (rationalThresholdMass k |
| (acceptance A R C K j hK hW xi v w S.val T.val b):ℝ)) |
| else 0 := by |
| have hp : uniformAverage (fun b : Fin (proposalBits A) → Bool => |
| if proposal A S b=some T then (1:ℝ) else 0)= |
| if ExchangeAdjacent S.val T.val then 1/(2:ℝ)^proposalBits A else 0 := by |
| rw [word_probability,proposal_mass] |
| split_ifs <;> simp |
| have ha (b : WeightWord A C K j xi×WeightWord A C K j xi) : |
| uniformAverage (fun coin : Fin k → Bool => |
| if rationalThresholdAccept k |
| (acceptance A R C K j hK hW xi v w S.val T.val b) coin then (1:ℝ) else 0)= |
| (rationalThresholdMass k |
| (acceptance A R C K j hK hW xi v w S.val T.val b):ℝ) := by |
| exact rationalThreshold_expectation k _ |
| (acceptance_bounds A R C hC K j hK hW hB hj xi hx0 hx1 v w hw S.val T.val b).1 |
| (acceptance_bounds A R C hC K j hK hW hB hj xi hx0 hx1 v w hw S.val T.val b).2 |
| calc |
| _ = uniformAverage (fun bits => if step A R C K j k hK hW xi v w S bits=T then (1:ℝ) else 0) := |
| (word_probability _ T).symm |
| _ = uniformAverage (fun b : (Fin 1 → Bool)×((Fin (proposalBits A) → Bool)× |
| ((WeightWord A C K j xi×WeightWord A C K j xi)×(Fin k → Bool))) => |
| if b.1 0=false ∧ proposal A S b.2.1=some T ∧ |
| rationalThresholdAccept k |
| (acceptance A R C K j hK hW xi v w S.val T.val b.2.2.1) b.2.2.2 |
| then (1:ℝ) else 0) := by |
| simp_rw [step_eq_iff A R C K j k hK hW xi v w S T hST] |
| have he := uniformAverage_equiv (stepWordEquiv A C K j k xi) |
| (fun b : (Fin 1 → Bool)×((Fin (proposalBits A) → Bool)× |
| ((WeightWord A C K j xi×WeightWord A C K j xi)×(Fin k → Bool))) => |
| if b.1 0=false ∧ proposal A S b.2.1=some T ∧ |
| rationalThresholdAccept k |
| (acceptance A R C K j hK hW xi v w S.val T.val b.2.2.1) b.2.2.2 |
| then (1:ℝ) else 0) |
| convert he using 1 |
| _ = _ := by |
| rw [independent_decision (fun b : Fin 1 → Bool => b 0=false) |
| (fun b : Fin (proposalBits A) → Bool => proposal A S b=some T) |
| (fun b coin => rationalThresholdAccept k |
| (acceptance A R C K j hK hW xi v w S.val T.val b) coin),lazy_probability,hp] |
| simp_rw [ha] |
| split_ifs <;> ring |
|
|
| /-- The exact target row is the source Metropolis chain, slowed by its |
| dyadic neighbor-code padding. The stationary distribution is unchanged. -/ |
| def referenceChain (A : Instance I J) (R : RootedCompletion.Selection A.T) (j : ℕ) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) : FiniteChain (State A) := |
| metropolisChain pairs PairedLabels.fresh (pairs_ne_nil A hp) PairedLabels.cover |
| (fun p q => (w p q:ℝ)) (RootedAnnealing.weight A R j) |
| (fun p q => by exact_mod_cast hw p q) (RootedAnnealing.weight_positive A R j) |
|
|
| private lemma chain_eq {X : Type*} [Fintype X] (C D : FiniteChain X) |
| (hP : C.P=D.P) (hpi : C.π=D.π) : C=D := by |
| cases C |
| cases D |
| dsimp only at hP hpi |
| cases hP |
| cases hpi |
| rfl |
|
|
| /-- The degree completion used to prove the signature and concentration |
| theorems leaves every state and transition of the literal chain intact. -/ |
| theorem referenceChain_eq_completed (A : Instance I J) (R : RootedCompletion.Selection A.T) (j : ℕ) |
| (hp : 0<Fintype.card (Labels A)) (w : Pair A → Pair A → ℚ) |
| (hw : ∀ p q,0<w p q) : |
| referenceChain A R j hp w hw= |
| metropolisChain pairs PairedLabels.fresh (pairs_ne_nil A hp) PairedLabels.cover |
| (fun p q => (w p q:ℝ)) |
| (DegreeCompletion.completeDegree (RootedAnnealing.weight A R j) |
| (pairs : List ((Labels A×Bool)×(Labels A×Bool))).length) |
| (fun p q => by exact_mod_cast hw p q) |
| (DegreeCompletion.completeDegree_positive _ _ (RootedWarmStart.actual_degree A R j).1) := by |
| have he (U : State A) : |
| chainWeight pairs (fun p q => (w p q:ℝ)) |
| (DegreeCompletion.completeDegree (RootedAnnealing.weight A R j) |
| (pairs : List ((Labels A×Bool)×(Labels A×Bool))).length) U.val= |
| chainWeight pairs (fun p q => (w p q:ℝ)) (RootedAnnealing.weight A R j) U.val := by |
| simp only [chainWeight,DegreeCompletion.completeDegree, |
| U.property.ncard PairedLabels.fresh PairedLabels.cover,ite_true] |
| apply chain_eq |
| · funext S T |
| dsimp only [referenceChain,metropolisChain,FiniteChain.ofMoves] |
| simp only [metropolisMove,he] |
| · funext S |
| dsimp only [referenceChain,metropolisChain,FiniteChain.ofMoves] |
| rw [ObservableBounds.chainTotal_completion _ _ _ PairedLabels.fresh PairedLabels.cover,he] |
|
|
| def targetChain (A : Instance I J) (R : RootedCompletion.Selection A.T) (j : ℕ) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) : FiniteChain (State A) := |
| FiniteChainSlowdown.slow (referenceChain A R j hp w hw) (slowdown A) |
| (by linarith [(slowdown_bounds A hp).1]) (slowdown_bounds A hp).2 |
|
|
| theorem target_mass (A : Instance I J) (R : RootedCompletion.Selection A.T) (j : ℕ) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) |
| (S T : State A) (hST : S≠T) : |
| (targetChain A R j hp w hw).P S T= |
| if ExchangeAdjacent S.val T.val then |
| (1/(2*(2:ℝ)^proposalBits A))*targetAcceptance A R j w S.val T.val else 0 := by |
| have hn : (Fintype.card (Labels A):ℝ)≠0 := by exact_mod_cast hp.ne' |
| have hs := targetWeight_positive A R j w hw S.val |
| have hm : targetAcceptance A R j w S.val T.val= |
| min (targetWeight A R j w S.val) (targetWeight A R j w T.val)/targetWeight A R j w S.val := by |
| unfold targetAcceptance |
| rw [←min_div_div_right hs.le,div_self hs.ne'] |
| dsimp only [targetChain,FiniteChainSlowdown.slow,referenceChain,metropolisChain,FiniteChain.ofMoves] |
| simp only [hST,ite_false,add_zero,metropolisMove,PairedLabels.length] |
| by_cases ha : ExchangeAdjacent S.val T.val |
| · rw [ite_eq_left ha,ite_eq_left ha] |
| simp only [←targetWeight_eq,slowdown,hm] |
| field_simp [hn,hs.ne'] |
| · simp [ha] |
| |
| private lemma distance_le_off_diagonal {X : Type*} [Fintype X] [DecidableEq X] |
| (p q : X → ℝ) (x : X) (hmass : ∑ y,p y=∑ y,q y) : |
| distance p q≤∑ y∈Finset.univ.erase x,|p y-q y| := by |
| have ht : (∑ y∈Finset.univ.erase x,(p y-q y))+(p x-q x)=0 := by |
| rw [Finset.sum_erase_add _ _ (Finset.mem_univ x),Finset.sum_sub_distrib,hmass,sub_self] |
| have hd : p x-q x= -(∑ y∈Finset.univ.erase x,(p y-q y)) := by linarith |
| have hb := Finset.abs_sum_le_sum_abs (fun y => p y-q y) (Finset.univ.erase x) |
| have he := Finset.sum_erase_add (Finset.univ : Finset X) (fun y => |p y-q y|) |
| (Finset.mem_univ x) |
| rw [hd,abs_neg] at he |
| unfold distance |
| linarith |
| |
| private lemma average_abs {X : Type*} [Fintype X] (f : X → ℝ) : |
| |uniformAverage f|≤uniformAverage (fun x => |f x|) := by |
| unfold uniformAverage |
| rw [abs_div,abs_of_nonneg (show (0:ℝ)≤Fintype.card X from Nat.cast_nonneg _)] |
| exact div_le_div_of_nonneg_right (Finset.abs_sum_le_sum_abs f Finset.univ) |
| (Nat.cast_nonneg _) |
| |
| /-- The complete transition row loses at most half the acceptance error. |
| The diagonal is controlled by conservation of probability, rather than |
| an additional independent error assumption. -/ |
| theorem row_distance (A : Instance I J) (R : RootedCompletion.Selection A.T) (C : ℕ) (hC : 0<C) (K j k : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (hB : (K:ℝ)=binWidth A C) |
| (hj : j≤rationalHeight A C) (xi : ℚ) (hx0 : 0<xi) (hx1 : xi≤1/4) |
| (hPL : PublishedInputs.FiniteBoxPrekopaLeindler (dimension A)) |
| (hCheeger : PublishedInputs.FiniteCheeger (Grid (I := Fin (dimension A)) K)) |
| (v : Grid (I := Fin (dimension A)) K) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) (S : State A) : |
| distance (fun T => ((transitionLaw A R C K j k hK hW xi v w S).mass T:ℝ)) |
| ((targetChain A R j hp w hw).P S)≤(6*(xi:ℝ)+1/(2:ℝ)^k)/2 := by |
| let e : ℝ := 6*(xi:ℝ)+1/(2:ℝ)^k |
| let a : ℝ := 1/(2*(2:ℝ)^proposalBits A) |
| have he : 0≤e := by dsimp only [e]; positivity |
| have ha : 0≤a := by dsimp only [a]; positivity |
| have hpnt (T : State A) (hST : S≠T) : |
| |((transitionLaw A R C K j k hK hW xi v w S).mass T:ℝ)- |
| (targetChain A R j hp w hw).P S T|≤ |
| if ExchangeAdjacent S.val T.val then a*e else 0 := by |
| rw [transition_mass A R C hC K j k hK hW hB hj xi hx0 |
| (by linarith) v w hw S T hST,target_mass A R j hp w hw S T hST] |
| by_cases h : ExchangeAdjacent S.val T.val |
| · simp only [h,ite_true] |
| rw [←mul_sub,abs_mul,abs_of_nonneg ha] |
| apply mul_le_mul_of_nonneg_left _ ha |
| rw [←uniformAverage_sub_const] |
| exact (average_abs _).trans |
| (average_acceptance_error A R C hC K j k hK hW hB hj xi hx0 hx1 |
| hPL hCheeger v w hw S.val T.val) |
| · simp [h] |
| have hm : (∑ T,((transitionLaw A R C K j k hK hW xi v w S).mass T:ℝ))= |
| ∑ T,(targetChain A R j hp w hw).P S T := by |
| rw [(targetChain A R j hp w hw).stochastic] |
| exact_mod_cast (transitionLaw A R C K j k hK hW xi v w S).total |
| have hc : ((Finset.univ.filter (fun T : State A => ExchangeAdjacent S.val T.val)).card:ℝ)≤ |
| (2:ℝ)^proposalBits A := by |
| have hh := proposal_codes A S |
| rw [Fintype.card_subtype] at hh |
| exact_mod_cast hh |
| calc |
| _ ≤ ∑ T∈Finset.univ.erase S, |
| |((transitionLaw A R C K j k hK hW xi v w S).mass T:ℝ)- |
| (targetChain A R j hp w hw).P S T| := distance_le_off_diagonal _ _ S hm |
| _ ≤ ∑ T∈Finset.univ.erase S, |
| if ExchangeAdjacent S.val T.val then a*e else 0 := by |
| apply Finset.sum_le_sum |
| intro T hT |
| exact hpnt T (Finset.mem_erase.mp hT).1.symm |
| _ ≤ ∑ T : State A,if ExchangeAdjacent S.val T.val then a*e else 0 := by |
| apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.erase_subset _ _) |
| intro T _ _ |
| split_ifs <;> positivity |
| _ = ((Finset.univ.filter (fun T : State A => ExchangeAdjacent S.val T.val)).card:ℝ)*(a*e) := by |
| rw [←Finset.sum_filter] |
| simp |
| _ ≤ (2:ℝ)^proposalBits A*(a*e) := mul_le_mul_of_nonneg_right hc (mul_nonneg ha he) |
| _ = e/2 := by dsimp only [a]; field_simp |
| |
| def pathLaw (A : Instance I J) (R : RootedCompletion.Selection A.T) (C K j k N n : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (xi : ℚ) |
| (v : Grid (I := Fin (dimension A)) K) (w : Pair A → Pair A → ℚ) (S : State A) : |
| RationalLaw (PathState (State A) N) := |
| walkLaw (liftRational (transitionLaw A R C K j k hK hW xi v w) |
| (fun a : PathState (State A) N => pathRead a) |
| (fun (a : PathState (State A) N) (T : State A) => pathPut a T)) (pathInitial N S) n |
| |
| def targetPathMass (A : Instance I J) (R : RootedCompletion.Selection A.T) (j : ℕ) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) (N n : ℕ) (S : State A) : |
| PathState (State A) N → ℝ := |
| ((liftKernel (targetChain A R j hp w hw).kernel |
| (fun a : PathState (State A) N => pathRead a) |
| (fun (a : PathState (State A) N) (T : State A) => pathPut a T)).power n).P (pathInitial N S) |
| |
| /-- The error controls the whole recorded phase history, not merely its |
| last state. Every step uses a disjoint fresh oracle/acceptance word. -/ |
| theorem path_distance_bound (A : Instance I J) (R : RootedCompletion.Selection A.T) (C : ℕ) (hC : 0<C) (K j k : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (hB : (K:ℝ)=binWidth A C) |
| (hj : j≤rationalHeight A C) (xi : ℚ) (hx0 : 0<xi) (hx1 : xi≤1/4) |
| (hPL : PublishedInputs.FiniteBoxPrekopaLeindler (dimension A)) |
| (hCheeger : PublishedInputs.FiniteCheeger (Grid (I := Fin (dimension A)) K)) |
| (v : Grid (I := Fin (dimension A)) K) (hp : 0<Fintype.card (Labels A)) |
| (w : Pair A → Pair A → ℚ) (hw : ∀ p q,0<w p q) (N n : ℕ) (S : State A) : |
| distance (X := PathState (State A) N) |
| (fun b : PathState (State A) N => ((pathLaw A R C K j k N n hK hW xi v w S).mass b:ℝ)) |
| (targetPathMass A R j hp w hw N n S)≤n*((6*(xi:ℝ)+1/(2:ℝ)^k)/2) := by |
| unfold pathLaw targetPathMass |
| apply walk_distance |
| intro a |
| apply (lifted_row_distance (transitionLaw A R C K j k hK hW xi v w) |
| (targetChain A R j hp w hw).kernel |
| (fun a : PathState (State A) N => pathRead a) |
| (fun (a : PathState (State A) N) (T : State A) => pathPut a T) a).trans |
| exact row_distance A R C hC K j k hK hW hB hj xi hx0 hx1 hPL hCheeger v hp w hw (pathRead a) |
| |
| /-- The same finite step word records the newly sampled state, so the |
| history law is physically realized by the concatenated step words. -/ |
| def recordedWalk (A : Instance I J) (R : RootedCompletion.Selection A.T) (C K j k N n : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (xi : ℚ) |
| (v : Grid (I := Fin (dimension A)) K) (w : Pair A → Pair A → ℚ) (S : State A) |
| (bits : Fin (n*stepBits A C K j k xi) → Bool) : PathState (State A) N := |
| wordWalk (fun a b => pathPut a (step A R C K j k hK hW xi v w (pathRead a) b)) |
| (pathInitial N S) n (oracleWalkWordEquiv n (stepBits A C K j k xi) bits) |
| |
| theorem recordedWalk_law (A : Instance I J) (R : RootedCompletion.Selection A.T) (C K j k N n : ℕ) |
| (hK : 1≤K) (hW : 100*A.d*K≤A.W) (xi : ℚ) |
| (v : Grid (I := Fin (dimension A)) K) (w : Pair A → Pair A → ℚ) (S : State A) : |
| mapLaw (uniformLaw (α := Fin (n*stepBits A C K j k xi) → Bool)) |
| (recordedWalk A R C K j k N n hK hW xi v w S)= |
| walkLaw (liftRational (transitionLaw A R C K j k hK hW xi v w) pathRead pathPut) |
| (pathInitial N S) n := by |
| unfold recordedWalk |
| rw [←map_equiv (oracleWalkWordEquiv n (stepBits A C K j k xi)),uniform_equiv] |
| rw [show mapLaw (uniformLaw (α := Fin n → Fin (stepBits A C K j k xi) → Bool)) |
| (wordWalk (fun a b => pathPut a (step A R C K j k hK hW xi v w (pathRead a) b)) |
| (pathInitial N S) n)=wordWalkLaw |
| (fun a b => pathPut a (step A R C K j k hK hW xi v w (pathRead a) b)) |
| (pathInitial N S) n from rfl,wordWalkLaw_eq] |
| apply congrArg (fun Q => walkLaw Q (pathInitial N S) n) |
| funext a |
| exact (mapLaw_comp (uniformLaw (α := Fin (stepBits A C K j k xi) → Bool)) |
| (step A R C K j k hK hW xi v w (pathRead a)) (pathPut a)).symm |
| |
| end |
| end ContingencyTables.RootedBooleanPhase |
| |
| end OAI |
| |
