Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Combinatorics.IndependentSets.Reduction.AuxiliaryJointMeasurable

namespace OAI

namespace LargeIndependentSets.PhaseTest
open MeasureTheory Set ProductAveraging Coefficient
open scoped BigOperators Classical NNReal
variable {ι : Type} [Fintype ι] [DecidableEq ι]
variable {M : ι → Type} [∀ j, Fintype (M j)]
variable {κ τ : Type} [Fintype κ]

lemma full_absorption_square (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
    (hq : ∀ j k, q j (p j k) = r k) (a : τ → ι) {m : ℕ} (hm : 0 < m)
    (t : ι → Fin (m+1)) (ht : Full t) (F : (κ → Circle) → ℝ)
    (hFm : Measurable F) (hb : ∀ x, |F x| ≤ 1) :
    (∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
      ∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw)) =
    ∫ θ, (F (phase p (fun j => value (t j)) θ))^2
      ∂Measure.pi (fun _ : Sigma M => rotationLaw) := by
  obtain ⟨j,hj⟩ := ht
  have hi := bounded_sq_integrable (μ := (Measure.pi (fun _ : Sigma M => rotationLaw)).prod volume)
    (hFm.comp (auxiliary_joint_measurable p r a (fun j => value (t j))))
    (fun v => hb (auxiliary p r a (fun j => value (t j)) v.1 v.2))
  rw [integral_integral_swap hi]
  have h (z : ι → Circle) := absorption_integral p q r hq a j
    (fun j => value (t j)) (value_full hm _ hj) z (fun x => (F x)^2) (hFm.pow_const 2)
  simp_rw [h]
  simp

lemma continuous_full_bound (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
    (hq : ∀ j k, q j (p j k) = r k) (a : τ → ι) {m : ℕ} (hm : 0 < m)
    {ρ ε : ℝ} (hρ : 0 ≤ ρ) (F : (κ → Circle) → ℝ)
    (hFm : Measurable F) (hb : ∀ x, |F x| ≤ 1)
    (haux : (∑ t : ι → Fin (m+1), mass m ρ t *
      ∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
      ∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw)) < 4*ε) :
    (∑ t ∈ Finset.univ.filter Full, mass m ρ t *
      ∫ θ, (F (phase p (fun j => value (t j)) θ))^2
        ∂Measure.pi (fun _ : Sigma M => rotationLaw)) < 4*ε := by
  calc
    _ = ∑ t ∈ Finset.univ.filter Full, mass m ρ t *
        ∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
          ∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw) := by
      apply Finset.sum_congr rfl
      intro t ht
      rw [full_absorption_square p q r hq a hm t (Finset.mem_filter.mp ht).2 F hFm hb]
    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
      (fun t _ _ => mul_nonneg (mass_nonneg m hρ t)
        (integral_nonneg fun θ => integral_nonneg fun z => sq_nonneg _))
    _ < _ := haux
end LargeIndependentSets.PhaseTest

namespace LargeIndependentSets.BooleanJunta
open MeasureTheory Set ProductAveraging
open scoped BigOperators Classical NNReal
variable {C : Type} [Fintype C] [DecidableEq C]

omit [DecidableEq C] in
lemma arbitrary_sampler_preserving (k : ℕ) :
    MeasurePreserving (fun v : C → Cube k × ℝ => fun c => scalarCell (v c).1 (v c).2)
      (Measure.pi (fun _ : C => seedLaw k)) (Measure.pi (fun _ : C => unitLaw)) :=
  measurePreserving_pi _ _ (fun _ => scalarSampler_preserving k)
lemma arbitrary_cells_preserving (k : ℕ) :
    MeasurePreserving (fun v : C → Cube k × ℝ => fun c => (v c).1)
      (Measure.pi (fun _ : C => seedLaw k)) (uniformLaw (C → Cube k)) := by
  rw [uniformLaw_pi]
  exact measurePreserving_pi _ _ (fun _ => measurePreserving_fst)
omit [DecidableEq C] in
lemma arbitrary_seeds_in_unit (k : ℕ) :
    ∀ᵐ v ∂Measure.pi (fun _ : C => seedLaw k), ∀ c, (v c).2 ∈ Icc (0:ℝ) 1 := by
  have hu : ∀ᵐ u ∂unitLaw, u ∈ Icc (0:ℝ) 1 := ae_restrict_mem measurableSet_Icc
  have hs : ∀ᵐ p : Cube k × ℝ ∂seedLaw k, p.2 ∈ Icc (0:ℝ) 1 :=
    (measurePreserving_snd (μ:=uniformLaw (Cube k)) (ν:=unitLaw)).quasiMeasurePreserving.ae hu
  rw [ae_all_iff]
  intro c
  exact (measurePreserving_eval (fun _ : C => seedLaw k) c).quasiMeasurePreserving.ae hs
end LargeIndependentSets.BooleanJunta

namespace LargeIndependentSets.PhaseTest
open MeasureTheory Set ProductAveraging Coefficient BooleanJunta
open scoped BigOperators Classical NNReal
variable {ι : Type} [Fintype ι] [DecidableEq ι]
variable {M : ι → Type} [∀ j, Fintype (M j)]
variable {κ : Type} [Fintype κ]

lemma discrete_square_le_continuous (p : ∀ j, κ → M j) (t : ι → ℝ)
    (ht : ∀ j, |t j| ≤ 1) (k : ℕ) {L : ℝ≥0}
    (F : (κ → Circle) → ℝ) (hF : LipschitzWith L F) (hb : ∀ x, |F x| ≤ 1) :
    (𝔼 v : Sigma M → Cube k,
      (F (phase p t (fun c => scalarCell (v c) 0)))^2) ≤
    (∫ θ, (F (phase p t θ))^2 ∂Measure.pi (fun _ : Sigma M => rotationLaw)) +
      2*L*Fintype.card ι*(1/2:ℝ)^k := by
  have hrot : rotationLaw = unitLaw := by
    simp only [rotationLaw, unitLaw, restrict_Ico_eq_restrict_Icc]
  have hsp := arbitrary_sampler_preserving (C:=Sigma M) k
  have hcp := arbitrary_cells_preserving (C:=Sigma M) k
  have hm : Measurable (fun θ => F (phase p t θ)) := hF.continuous.measurable.comp (phase_measurable p t)
  have hd : Measurable (fun v : Sigma M → Cube k => (F (phase p t (fun c => scalarCell (v c) 0)))^2) := measurable_of_finite _
  have hi := bounded_sq_integrable (μ:=Measure.pi (fun _ : Sigma M => seedLaw k))
    (hm.comp hsp.measurable) (fun v => hb _)
  simp only [Function.comp_def] at hi
  have hdi : Integrable (fun v : Sigma M → Cube k × ℝ =>
      (F (phase p t (fun c => scalarCell (v c).1 0)))^2)
      (Measure.pi (fun _ : Sigma M => seedLaw k)) :=
    bounded_sq_integrable (hF.continuous.measurable.comp ((phase_measurable p t).comp
      (Measurable.of_eval (fun c => (measurable_of_finite (fun q : Cube k => scalarCell q 0)).comp
        (measurable_fst.comp (measurable_pi_apply c)))))) (fun v => hb _)
  have hle : (∫ v, (F (phase p t (fun c => scalarCell (v c).1 0)))^2
      ∂Measure.pi (fun _ : Sigma M => seedLaw k)) ≤
    (∫ v, (F (phase p t (fun c => scalarCell (v c).1 (v c).2)))^2 +
      2*L*Fintype.card ι*(1/2:ℝ)^k ∂Measure.pi (fun _ : Sigma M => seedLaw k)) := by
    apply integral_mono_ae hdi (hi.add (integrable_const _))
    filter_upwards [arbitrary_seeds_in_unit (C:=Sigma M) k] with v hv
    have hdist : ∀ c, |scalarCell (v c).1 (v c).2-scalarCell (v c).1 0| ≤ (1/2:ℝ)^k := by
      intro c
      have h := (scalarCell_lipschitz (v c).1).dist_le_mul (v c).2 0
      rw [Real.dist_eq, Real.dist_eq, sub_zero, abs_of_nonneg (hv c).1] at h
      exact h.trans (by simpa using mul_le_mul_of_nonneg_left (hv c).2 (by positivity : 0 ≤ (1/2:ℝ)^k))
    have he := grid_square_error p t ht (fun c => scalarCell (v c).1 (v c).2)
      (fun c => scalarCell (v c).1 0) (by positivity : 0 ≤ (1/2:ℝ)^k) hdist hF hb
    dsimp only [Pi.add_apply, Function.comp_def]
    linarith [abs_le.mp he]
  rw [integral_add hi (integrable_const _)] at hle
  rw [integral_preserving hcp hd.aestronglyMeasurable, integral_uniformLaw] at hle
  have hsample := integral_preserving hsp (hm.pow_const 2).aestronglyMeasurable
  change (∫ v, (F (phase p t (fun c => scalarCell (v c).1 (v c).2)))^2
    ∂Measure.pi (fun _ : Sigma M => seedLaw k)) = _ at hsample
  rw [hsample] at hle
  simpa only [hrot, integral_const, Measure.real, measure_univ, ENNReal.toReal_one, one_smul] using hle
end LargeIndependentSets.PhaseTest

namespace LargeIndependentSets.BooleanJunta
open scoped BigOperators Classical

def gridIndex : {k : ℕ} → Cube k → ℕ
  | 0, _ => 0
  | k+1, (b,x) => (if b then 2^k else 0) + gridIndex x
lemma gridIndex_lt {k : ℕ} (x : Cube k) : gridIndex x < 2^k := by
  induction k with
  | zero => simp [gridIndex]
  | succ k ih =>
    rcases x with ⟨b,x⟩
    have hx := ih x
    have hp : 0 < 2^k := by positivity
    cases b <;> simp only [gridIndex, Bool.false_eq_true, ↓reduceIte, zero_add, pow_succ] <;> omega
lemma gridIndex_injective (k : ℕ) : Function.Injective (@gridIndex k) := by
  induction k with
  | zero => intro x y _; exact Subsingleton.elim _ _
  | succ k ih =>
    intro ⟨b,x⟩ ⟨c,y⟩ he
    have hx := gridIndex_lt x
    have hy := gridIndex_lt y
    cases b <;> cases c <;> simp only [gridIndex, Bool.false_eq_true, ↓reduceIte, zero_add] at he
    · exact Prod.ext rfl (ih he)
    · omega
    · omega
    · exact Prod.ext rfl (ih (Nat.add_left_cancel he))
lemma cube_card (k : ℕ) : Fintype.card (Cube k) = 2^k := by
  induction k with
  | zero => simp [Cube]
  | succ k ih =>
    change Fintype.card (Bool × Cube k) = _
    simp only [Fintype.card_prod, Fintype.card_bool, ih, pow_succ]
    omega
noncomputable def gridEquiv (k : ℕ) : Cube k ≃ Fin (2^k) :=
  Equiv.ofBijective (fun x => ⟨gridIndex x, gridIndex_lt x⟩)
    ((Fintype.bijective_iff_injective_and_card _).mpr
      ⟨fun x y h => gridIndex_injective k (congrArg Fin.val h), by simp [cube_card]⟩)
lemma scalarCell_zero_grid {k : ℕ} (x : Cube k) :
    scalarCell x 0 = (gridEquiv k x).val / (2:ℝ)^k := by
  change scalarCell x 0 = (gridIndex x : ℝ) / (2:ℝ)^k
  induction k with
  | zero => simp [scalarCell, gridIndex]
  | succ k ih =>
    rcases x with ⟨b,x⟩
    have hp : (2:ℝ)^k ≠ 0 := by positivity
    cases b <;> simp only [scalarCell, gridIndex, Bool.false_eq_true, ↓reduceIte,
      zero_add, Nat.cast_add, Nat.cast_pow, Nat.cast_ofNat, ih, pow_succ]
    · ring
    · field_simp
end LargeIndependentSets.BooleanJunta

end OAI

	import Mathlib
	import OAI.Combinatorics.IndependentSets.Reduction.AuxiliaryJointMeasurable

	namespace OAI

	namespace LargeIndependentSets.PhaseTest
	open MeasureTheory Set ProductAveraging Coefficient
	open scoped BigOperators Classical NNReal
	variable {ι : Type} [Fintype ι] [DecidableEq ι]
	variable {M : ι → Type} [∀ j, Fintype (M j)]
	variable {κ τ : Type} [Fintype κ]

	lemma full_absorption_square (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
	(hq : ∀ j k, q j (p j k) = r k) (a : τ → ι) {m : ℕ} (hm : 0 < m)
	(t : ι → Fin (m+1)) (ht : Full t) (F : (κ → Circle) → ℝ)
	(hFm : Measurable F) (hb : ∀ x, \|F x\| ≤ 1) :
	(∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
	∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw)) =
	∫ θ, (F (phase p (fun j => value (t j)) θ))^2
	∂Measure.pi (fun _ : Sigma M => rotationLaw) := by
	obtain ⟨j,hj⟩ := ht
	have hi := bounded_sq_integrable (μ := (Measure.pi (fun _ : Sigma M => rotationLaw)).prod volume)
	(hFm.comp (auxiliary_joint_measurable p r a (fun j => value (t j))))
	(fun v => hb (auxiliary p r a (fun j => value (t j)) v.1 v.2))
	rw [integral_integral_swap hi]
	have h (z : ι → Circle) := absorption_integral p q r hq a j
	(fun j => value (t j)) (value_full hm _ hj) z (fun x => (F x)^2) (hFm.pow_const 2)
	simp_rw [h]
	simp

	lemma continuous_full_bound (p : ∀ j, κ → M j) (q : ∀ j, M j → τ) (r : κ → τ)
	(hq : ∀ j k, q j (p j k) = r k) (a : τ → ι) {m : ℕ} (hm : 0 < m)
	{ρ ε : ℝ} (hρ : 0 ≤ ρ) (F : (κ → Circle) → ℝ)
	(hFm : Measurable F) (hb : ∀ x, \|F x\| ≤ 1)
	(haux : (∑ t : ι → Fin (m+1), mass m ρ t *
	∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
	∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw)) < 4*ε) :
	(∑ t ∈ Finset.univ.filter Full, mass m ρ t *
	∫ θ, (F (phase p (fun j => value (t j)) θ))^2
	∂Measure.pi (fun _ : Sigma M => rotationLaw)) < 4*ε := by
	calc
	_ = ∑ t ∈ Finset.univ.filter Full, mass m ρ t *
	∫ θ, ∫ z, (F (auxiliary p r a (fun j => value (t j)) θ z))^2
	∂(volume : Measure (ι → Circle)) ∂Measure.pi (fun _ : Sigma M => rotationLaw) := by
	apply Finset.sum_congr rfl
	intro t ht
	rw [full_absorption_square p q r hq a hm t (Finset.mem_filter.mp ht).2 F hFm hb]
	_ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
	(fun t _ _ => mul_nonneg (mass_nonneg m hρ t)
	(integral_nonneg fun θ => integral_nonneg fun z => sq_nonneg _))
	_ < _ := haux
	end LargeIndependentSets.PhaseTest

	namespace LargeIndependentSets.BooleanJunta
	open MeasureTheory Set ProductAveraging
	open scoped BigOperators Classical NNReal
	variable {C : Type} [Fintype C] [DecidableEq C]

	omit [DecidableEq C] in
	lemma arbitrary_sampler_preserving (k : ℕ) :
	MeasurePreserving (fun v : C → Cube k × ℝ => fun c => scalarCell (v c).1 (v c).2)
	(Measure.pi (fun _ : C => seedLaw k)) (Measure.pi (fun _ : C => unitLaw)) :=
	measurePreserving_pi _ _ (fun _ => scalarSampler_preserving k)
	lemma arbitrary_cells_preserving (k : ℕ) :
	MeasurePreserving (fun v : C → Cube k × ℝ => fun c => (v c).1)
	(Measure.pi (fun _ : C => seedLaw k)) (uniformLaw (C → Cube k)) := by
	rw [uniformLaw_pi]
	exact measurePreserving_pi _ _ (fun _ => measurePreserving_fst)
	omit [DecidableEq C] in
	lemma arbitrary_seeds_in_unit (k : ℕ) :
	∀ᵐ v ∂Measure.pi (fun _ : C => seedLaw k), ∀ c, (v c).2 ∈ Icc (0:ℝ) 1 := by
	have hu : ∀ᵐ u ∂unitLaw, u ∈ Icc (0:ℝ) 1 := ae_restrict_mem measurableSet_Icc
	have hs : ∀ᵐ p : Cube k × ℝ ∂seedLaw k, p.2 ∈ Icc (0:ℝ) 1 :=
	(measurePreserving_snd (μ:=uniformLaw (Cube k)) (ν:=unitLaw)).quasiMeasurePreserving.ae hu
	rw [ae_all_iff]
	intro c
	exact (measurePreserving_eval (fun _ : C => seedLaw k) c).quasiMeasurePreserving.ae hs
	end LargeIndependentSets.BooleanJunta

	namespace LargeIndependentSets.PhaseTest
	open MeasureTheory Set ProductAveraging Coefficient BooleanJunta
	open scoped BigOperators Classical NNReal
	variable {ι : Type} [Fintype ι] [DecidableEq ι]
	variable {M : ι → Type} [∀ j, Fintype (M j)]
	variable {κ : Type} [Fintype κ]

	lemma discrete_square_le_continuous (p : ∀ j, κ → M j) (t : ι → ℝ)
	(ht : ∀ j, \|t j\| ≤ 1) (k : ℕ) {L : ℝ≥0}
	(F : (κ → Circle) → ℝ) (hF : LipschitzWith L F) (hb : ∀ x, \|F x\| ≤ 1) :
	(𝔼 v : Sigma M → Cube k,
	(F (phase p t (fun c => scalarCell (v c) 0)))^2) ≤
	(∫ θ, (F (phase p t θ))^2 ∂Measure.pi (fun _ : Sigma M => rotationLaw)) +
	2LFintype.card ι*(1/2:ℝ)^k := by
	have hrot : rotationLaw = unitLaw := by
	simp only [rotationLaw, unitLaw, restrict_Ico_eq_restrict_Icc]
	have hsp := arbitrary_sampler_preserving (C:=Sigma M) k
	have hcp := arbitrary_cells_preserving (C:=Sigma M) k
	have hm : Measurable (fun θ => F (phase p t θ)) := hF.continuous.measurable.comp (phase_measurable p t)
	have hd : Measurable (fun v : Sigma M → Cube k => (F (phase p t (fun c => scalarCell (v c) 0)))^2) := measurable_of_finite _
	have hi := bounded_sq_integrable (μ:=Measure.pi (fun _ : Sigma M => seedLaw k))
	(hm.comp hsp.measurable) (fun v => hb _)
	simp only [Function.comp_def] at hi
	have hdi : Integrable (fun v : Sigma M → Cube k × ℝ =>
	(F (phase p t (fun c => scalarCell (v c).1 0)))^2)
	(Measure.pi (fun _ : Sigma M => seedLaw k)) :=
	bounded_sq_integrable (hF.continuous.measurable.comp ((phase_measurable p t).comp
	(Measurable.of_eval (fun c => (measurable_of_finite (fun q : Cube k => scalarCell q 0)).comp
	(measurable_fst.comp (measurable_pi_apply c)))))) (fun v => hb _)
	have hle : (∫ v, (F (phase p t (fun c => scalarCell (v c).1 0)))^2
	∂Measure.pi (fun _ : Sigma M => seedLaw k)) ≤
	(∫ v, (F (phase p t (fun c => scalarCell (v c).1 (v c).2)))^2 +
	2LFintype.card ι*(1/2:ℝ)^k ∂Measure.pi (fun _ : Sigma M => seedLaw k)) := by
	apply integral_mono_ae hdi (hi.add (integrable_const _))
	filter_upwards [arbitrary_seeds_in_unit (C:=Sigma M) k] with v hv
	have hdist : ∀ c, \|scalarCell (v c).1 (v c).2-scalarCell (v c).1 0\| ≤ (1/2:ℝ)^k := by
	intro c
	have h := (scalarCell_lipschitz (v c).1).dist_le_mul (v c).2 0
	rw [Real.dist_eq, Real.dist_eq, sub_zero, abs_of_nonneg (hv c).1] at h
	exact h.trans (by simpa using mul_le_mul_of_nonneg_left (hv c).2 (by positivity : 0 ≤ (1/2:ℝ)^k))
	have he := grid_square_error p t ht (fun c => scalarCell (v c).1 (v c).2)
	(fun c => scalarCell (v c).1 0) (by positivity : 0 ≤ (1/2:ℝ)^k) hdist hF hb
	dsimp only [Pi.add_apply, Function.comp_def]
	linarith [abs_le.mp he]
	rw [integral_add hi (integrable_const _)] at hle
	rw [integral_preserving hcp hd.aestronglyMeasurable, integral_uniformLaw] at hle
	have hsample := integral_preserving hsp (hm.pow_const 2).aestronglyMeasurable
	change (∫ v, (F (phase p t (fun c => scalarCell (v c).1 (v c).2)))^2
	∂Measure.pi (fun _ : Sigma M => seedLaw k)) = _ at hsample
	rw [hsample] at hle
	simpa only [hrot, integral_const, Measure.real, measure_univ, ENNReal.toReal_one, one_smul] using hle
	end LargeIndependentSets.PhaseTest

	namespace LargeIndependentSets.BooleanJunta
	open scoped BigOperators Classical

	def gridIndex : {k : ℕ} → Cube k → ℕ
	\| 0, _ => 0
	\| k+1, (b,x) => (if b then 2^k else 0) + gridIndex x
	lemma gridIndex_lt {k : ℕ} (x : Cube k) : gridIndex x < 2^k := by
	induction k with
	\| zero => simp [gridIndex]
	\| succ k ih =>
	rcases x with ⟨b,x⟩
	have hx := ih x
	have hp : 0 < 2^k := by positivity
	cases b <;> simp only [gridIndex, Bool.false_eq_true, ↓reduceIte, zero_add, pow_succ] <;> omega
	lemma gridIndex_injective (k : ℕ) : Function.Injective (@gridIndex k) := by
	induction k with
	\| zero => intro x y _; exact Subsingleton.elim _ _
	\| succ k ih =>
	intro ⟨b,x⟩ ⟨c,y⟩ he
	have hx := gridIndex_lt x
	have hy := gridIndex_lt y
	cases b <;> cases c <;> simp only [gridIndex, Bool.false_eq_true, ↓reduceIte, zero_add] at he
	· exact Prod.ext rfl (ih he)
	· omega
	· omega
	· exact Prod.ext rfl (ih (Nat.add_left_cancel he))
	lemma cube_card (k : ℕ) : Fintype.card (Cube k) = 2^k := by
	induction k with
	\| zero => simp [Cube]
	\| succ k ih =>
	change Fintype.card (Bool × Cube k) = _
	simp only [Fintype.card_prod, Fintype.card_bool, ih, pow_succ]
	omega
	noncomputable def gridEquiv (k : ℕ) : Cube k ≃ Fin (2^k) :=
	Equiv.ofBijective (fun x => ⟨gridIndex x, gridIndex_lt x⟩)
	((Fintype.bijective_iff_injective_and_card _).mpr
	⟨fun x y h => gridIndex_injective k (congrArg Fin.val h), by simp [cube_card]⟩)
	lemma scalarCell_zero_grid {k : ℕ} (x : Cube k) :
	scalarCell x 0 = (gridEquiv k x).val / (2:ℝ)^k := by
	change scalarCell x 0 = (gridIndex x : ℝ) / (2:ℝ)^k
	induction k with
	\| zero => simp [scalarCell, gridIndex]
	\| succ k ih =>
	rcases x with ⟨b,x⟩
	have hp : (2:ℝ)^k ≠ 0 := by positivity
	cases b <;> simp only [scalarCell, gridIndex, Bool.false_eq_true, ↓reduceIte,
	zero_add, Nat.cast_add, Nat.cast_pow, Nat.cast_ofNat, ih, pow_succ]
	· ring
	· field_simp
	end LargeIndependentSets.BooleanJunta

	end OAI