File size: 5,342 Bytes
d5b7741 | 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 | 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
|