| import OAI.Combinatorics.ContingencyTables.Rooted.RootedCatalogGrid |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedOracleFiniteStep |
|
|
| namespace OAI |
|
|
| /-! # The actual oracle transition in computed catalog order |
|
|
| Axis proposals are uniform over a bounded dyadic code space. Changing |
| the coordinate order preserves their frequencies, even though it need |
| not preserve the value obtained from an individual proposal word. |
| -/ |
|
|
| namespace ContingencyTables.RootedCatalogGrid |
|
|
| open CompanionFactorialApplication ForestAssignmentSplit GridBoundary |
| open RootedCompletion ResidualMixture FirstSuccess FairBits |
| open CompanionOracleDensity (oracleStepBits rationalHeight) |
| open scoped BigOperators Classical |
|
|
| noncomputable section |
| variable {m n : ℕ} |
|
|
| lemma freeCount_eq (A : Instance (Fin m) (Fin n)) : |
| freeCount A=CompanionOracleDensity.dimension A := by |
| simpa only [Fintype.card_fin] using Fintype.card_congr (RootedForestCatalog.freeEquiv A) |
|
|
| lemma freeCount_le (A : Instance (Fin m) (Fin n)) : freeCount A≤A.d := by |
| rw [freeCount_eq] |
| exact ForestScaledPenalty.free_card_le A |
|
|
| def exponent (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) : ℕ := |
| RootedOracleDensity.gridExponent A (rowColumn A.T) C a z (gridEquiv A K v) |
|
|
| def finiteStepLaw (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) : |
| RationalLaw (Grid (I := Fin (freeCount A)) K) := |
| finiteAcceptLaw v (fun code : Fin (2^Nat.clog 2 (8*A.d)) => axisCodeStep v code) |
| (fun w => acceptDyadic (exponent A C a z w-exponent A C a z v) (rationalHeight A C)) |
|
|
| theorem finiteStepLaw_eq (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) : |
| finiteStepLaw A C a z v= |
| equivLaw (gridEquiv A K).symm |
| (RootedOracleDensity.finiteOracleStepLaw A (rowColumn A.T) C a z (gridEquiv A K v)) := by |
| apply RationalLaw.eq_of_off_diagonal _ _ v |
| intro w hw |
| have hvw : v≠w := Ne.symm hw |
| have he : gridEquiv A K v≠gridEquiv A K w := |
| fun h => hvw ((gridEquiv A K).injective h) |
| change (finiteAcceptLaw v |
| (fun code : Fin (2^Nat.clog 2 (8*A.d)) => axisCodeStep v code) |
| (fun b => acceptDyadic (exponent A C a z b-exponent A C a z v) |
| (rationalHeight A C))).mass w= |
| (RootedOracleDensity.finiteOracleStepLaw A (rowColumn A.T) C a z |
| (gridEquiv A K v)).mass (gridEquiv A K w) |
| rw [finiteAcceptLaw_off_diagonal v w _ _ hvw, |
| RootedOracleDensity.finiteOracleStepLaw, |
| finiteAcceptLaw_off_diagonal (gridEquiv A K v) (gridEquiv A K w) _ _ he, |
| axisCodeStep_count (dense_proposal_code_bound A.d (freeCount A) (freeCount_le A)), |
| axisCodeStep_count (dense_proposal_code_bound A.d (CompanionOracleDensity.dimension A) |
| (ForestScaledPenalty.free_card_le A)),neighbor_iff] |
| rfl |
|
|
| def bitStep (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) |
| (bits : Fin (oracleStepBits A C) → Bool) : Grid (I := Fin (freeCount A)) K := |
| let draw := pairWordEquiv (Nat.clog 2 (8*A.d)) (rationalHeight A C) bits |
| match axisCodeStep v draw.1 with |
| | none => v |
| | some w => if draw.2.val < 2^(rationalHeight A C-(exponent A C a z w-exponent A C a z v)) |
| then w else v |
|
|
| def bitStepLaw (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) : |
| RationalLaw (Grid (I := Fin (freeCount A)) K) := |
| mapLaw (uniformLaw (α := Fin (oracleStepBits A C) → Bool)) (bitStep A C a z v) |
|
|
| lemma bitStepLaw_eq_finite (A : Instance (Fin m) (Fin n)) (C a : ℕ) (z : View A → ℕ) |
| {K : ℕ} (v : Grid (I := Fin (freeCount A)) K) : |
| bitStepLaw A C a z v=finiteStepLaw A C a z v := by |
| let E := pairWordEquiv (Nat.clog 2 (8*A.d)) (rationalHeight A C) |
| let f := finiteAcceptStep v |
| (fun code : Fin (2^Nat.clog 2 (8*A.d)) => axisCodeStep v code) |
| (fun w => acceptDyadic (exponent A C a z w-exponent A C a z v) (rationalHeight A C)) |
| have hf : bitStep A C a z v=fun bits => f (E bits) := by |
| funext bits |
| dsimp [bitStep,f,E,finiteAcceptStep] |
| simp only [acceptDyadic] |
| cases axisCodeStep v ((pairWordEquiv (Nat.clog 2 (8*A.d)) (rationalHeight A C)) bits).1 with |
| | none => rfl |
| | some w => dsimp only; split_ifs <;> rfl |
| unfold bitStepLaw |
| rw [hf] |
| change mapLaw (uniformLaw (α := Fin (Nat.clog 2 (8*A.d)+rationalHeight A C) → Bool)) |
| (fun bits => f (E bits))=_ |
| rw [←map_equiv E,uniform_equiv,←uniform_product] |
| rfl |
|
|
| /-- The actual catalog-order finite-word experiment has the exact |
| transition law of the oracle mixing theorem. -/ |
| theorem bitStepLaw_eq (A : Instance (Fin m) (Fin n)) (C a : ℕ) (hC : 0 < C) |
| (haH : a≤rationalHeight A C) (z : View A → ℕ) (hz : BalancedBox.InBox (bounds A) z) |
| {K : ℕ} (hK : 1≤K) (hKB : (K:ℝ)≤CompanionOracleDensity.binWidth A C) |
| (v : Grid (I := Fin (freeCount A)) K) : |
| bitStepLaw A C a z v= |
| equivLaw (gridEquiv A K).symm |
| (RootedOracleDensity.oracleTransitionLaw A (rowColumn A.T) C a z hK (gridEquiv A K v)) := by |
| rw [bitStepLaw_eq_finite,finiteStepLaw_eq, |
| RootedOracleDensity.finiteOracleStepLaw_eq A (rowColumn A.T) C a hC haH z hz hK hKB] |
|
|
| end |
| end ContingencyTables.RootedCatalogGrid |
|
|
| end OAI |
|
|
