| import OAI.NumberTheory.Ostmann.Arithmetic.BulkSlotNodup |
| import OAI.NumberTheory.Ostmann.Arithmetic.FrozenFrequencyAverage |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| namespace Ostmann |
| open scoped Classical BigOperators |
|
|
| theorem prime_list_injective_of_pairwise {σ : Type*} (value : σ → ℕ) |
| (L : List σ) (hprime : ∀ i ∈ L, (value i).Prime) |
| (hp : (L.map value).Pairwise Nat.Coprime) : |
| ∀ i ∈ L, ∀ j ∈ L, value i = value j → i = j := by |
| have hn : (L.map value).Nodup := by |
| apply hp.imp_of_mem |
| intro a b ha hb hab |
| obtain ⟨i, hi, rfl⟩ := List.mem_map.mp ha |
| obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hb |
| exact (Nat.coprime_primes (hprime i hi) (hprime j hj)).mp hab |
| exact fun i hi j hj hij => List.inj_on_of_nodup_map hn hi hj hij |
|
|
| theorem buildMovingSlotData_injective_of_support {σ : Type*} |
| (value : σ → ℕ) (n m : ℕ) (slot : (TreeLeafIndex n × Fin m) ↪ σ) |
| (t : FrequencyTree ℤ n) (small : TreeLeafTuple (List σ) n) |
| (samples : MovingSampleSlots σ n) (outside : List ℕ) |
| (hprime : ∀ i, (value i).Prime) |
| (hs : movingRegularOutsidePairwise value outside |
| (buildMovingSlotData n t small (bulkSlotLeaves n m slot) samples)) : |
| Function.Injective (value ∘ slot) := by |
| let T := buildMovingSlotData n t small (bulkSlotLeaves n m slot) samples |
| have hp : (T.regularSlots.map value).Pairwise Nat.Coprime := by |
| have hroot : (T.regularSlots.map value ++ outside).Pairwise Nat.Coprime := by |
| cases hT : T with |
| | leaf s L => simpa only [T, hT, movingRegularOutsidePairwise, |
| MovingSlotData.regularSlots] using hs |
| | node s CL CR u left right => |
| have hs' := hs |
| change movingRegularOutsidePairwise value outside T at hs' |
| rw [hT] at hs' |
| exact hs'.1 |
| exact (List.pairwise_append.mp hroot).1 |
| have hm (j) : slot j ∈ T.regularSlots := by |
| apply (buildMovingSlotData_regular_perm n t small (bulkSlotLeaves n m slot) samples).mem_iff.mpr |
| exact List.mem_append_right _ ((mem_flatten_bulkSlotLeaves n m slot _).mpr ⟨j, rfl⟩) |
| intro i j hij |
| exact slot.injective (prime_list_injective_of_pairwise value T.regularSlots |
| (fun i _ => hprime i) hp (slot i) (hm i) (slot j) (hm j) hij) |
|
|
| /-- The frequency factor vanishes on collisions before any averaging or |
| resampling is performed. -/ |
| theorem movingFrequencyPageAverage_zero_of_bulk_collision {σ : Type*} |
| (value : σ → ℕ) (n m : ℕ) (slot : (TreeLeafIndex n × Fin m) ↪ σ) |
| (t : FrequencyTree ℤ n) (small : TreeLeafTuple (List σ) n) |
| (samples : MovingSampleSlots σ n) (outside : List ℕ) |
| (hprime : ∀ i, (value i).Prime) (hbad : ¬Function.Injective (value ∘ slot)) |
| (F : Bool → {k : ℕ} → MovingSlotData σ k → ℤ → ℂ) |
| (E : Bool → {k : ℕ} → MovingSlotData σ k → ℤ → ℤ → ℤ → ℝ) |
| (T : Bool → MovingSlotData σ n) |
| (hT : T false = buildMovingSlotData n t small (bulkSlotLeaves n m slot) samples) |
| (nodes : Bool → List MovingFormulaNode) (R : ℤ) |
| (r : ℕ) [NeZero r] (input : PublishedProgressionInput) (Q : ℕ) (y : ℝ) : |
| movingFrequencyPageAverage value outside F E T nodes R r input Q y = 0 := by |
| have hsupport : ¬(∀ b, movingRegularOutsidePairwise value outside (T b) ∧ |
| ∀ f ∈ nodes b, f.guard.frequencyBounds) := by |
| intro hs |
| apply hbad |
| apply buildMovingSlotData_injective_of_support value n m slot t small samples outside hprime |
| rw [← hT] |
| exact (hs false).1 |
| rw [movingFrequencyPageAverage_core] |
| simp only [hsupport, ite_false, zero_mul] |
|
|
| /-- Inserting the distinctness gate leaves the literal supported arithmetic |
| coefficient unchanged. -/ |
| theorem movingFrequencyPageAverage_collision_gate {σ : Type*} |
| (value : σ → ℕ) (n m : ℕ) (slot : (TreeLeafIndex n × Fin m) ↪ σ) |
| (t : FrequencyTree ℤ n) (small : TreeLeafTuple (List σ) n) |
| (samples : MovingSampleSlots σ n) (outside : List ℕ) |
| (hprime : ∀ i, (value i).Prime) |
| (F : Bool → {k : ℕ} → MovingSlotData σ k → ℤ → ℂ) |
| (E : Bool → {k : ℕ} → MovingSlotData σ k → ℤ → ℤ → ℤ → ℝ) |
| (T : Bool → MovingSlotData σ n) |
| (hT : T false = buildMovingSlotData n t small (bulkSlotLeaves n m slot) samples) |
| (nodes : Bool → List MovingFormulaNode) (R : ℤ) |
| (r : ℕ) [NeZero r] (input : PublishedProgressionInput) (Q : ℕ) (y : ℝ) (A : ℂ) : |
| movingFrequencyPageAverage value outside F E T nodes R r input Q y * A = |
| if Function.Injective (value ∘ slot) then |
| movingFrequencyPageAverage value outside F E T nodes R r input Q y * A else 0 := by |
| by_cases h : Function.Injective (value ∘ slot) |
| · simp only [h, ite_true] |
| · rw [ite_eq_right h, movingFrequencyPageAverage_zero_of_bulk_collision value n m slot |
| t small samples outside hprime h F E T hT nodes R r input Q y, zero_mul] |
|
|
| end Ostmann |
|
|
| end OAI |
|
|
