File size: 4,662 Bytes
f0f05de | 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 | import OAI.Combinatorics.BinaryEdit.Branching
import Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality
namespace OAI
/-!
# Finite indices for the sparse-activity obstruction
Internal nodes are indexed by their depth and finite sequence of child
indices. Absence of a sparse active node bounds the cardinality of active
leaves, which controls the Fourier mass.
-/
noncomputable section
namespace TreeEdit.BinaryLower.FiniteActivity
open Classical
/-- All internal nodes of a complete tree of depth `h`. -/
abbrev InternalNode (α : Type*) (h : ℕ) := Σ j : Fin h, Fin (j : ℕ) → α
/-- A bad node is active but has fewer than `b` active children. -/
def sparseNode {α : Type*} [Fintype α] {h : ℕ}
(active : List α → Prop) (b : ℕ) (v : InternalNode α h) : Prop :=
active (List.ofFn v.2) ∧
Branching.activeChildCount active (List.ofFn v.2) < b
/-- Absence of bad nodes in the finite node indexing gives the full active
leaf cardinality lower bound. -/
theorem dense_of_no_sparse {α : Type*} [Fintype α]
(active : List α → Prop) (b h : ℕ)
(hroot : active []) (hno : ¬ ∃ v : InternalNode α h, sparseNode active b v) :
b ^ h ≤ (Finset.univ.filter fun f : Fin h → α => active (List.ofFn f)).card := by
classical
have hlocal : ∀ p : List α, p.length < h → active p →
b ≤ Branching.activeChildCount active p := by
intro p hp ha
by_contra hb
have hsmall : Branching.activeChildCount active p < b := Nat.lt_of_not_ge hb
let v : InternalNode α h := ⟨⟨p.length, hp⟩, p.get⟩
apply hno
refine ⟨v, ?_⟩
simpa [sparseNode, v] using And.intro ha hsmall
have hbranch := Branching.branchesAtLeast_of_local active b h h hlocal [] (by simp)
simpa only [List.nil_append] using
Branching.pow_le_card_active_paths active b h [] hbranch hroot
/-- Character formulation of the sparse-node predicate. -/
def characterSparse {α G : Type*} [Fintype α] [AddCommGroup G] {h : ℕ}
(w : List α → G) (b : ℕ) (v : InternalNode α h) (χ : AddChar G ℂ) : Prop :=
sparseNode (fun p => χ (w p) ≠ 1) b v
/-- For a root-active character that escapes every sparse-node test, the
number of active terminal vectors is at least the branching factor to the
height. -/
theorem character_dense_of_no_sparse {α G : Type*}
[Fintype α] [AddCommGroup G]
(w : List α → G) (b h : ℕ) (χ : AddChar G ℂ)
(hroot : χ (w []) ≠ 1)
(hno : ¬ ∃ v : InternalNode α h, characterSparse w b v χ) :
(b : ℝ) ^ h ≤
((Finset.univ.filter fun f : Fin h → α => χ (w (List.ofFn f)) ≠ 1).card : ℝ) := by
classical
have hd := dense_of_no_sparse (fun p => χ (w p) ≠ 1) b h hroot hno
exact_mod_cast hd
/-- Adapter to the actual cyclic coordinate generators used by the spectral
leaf tests. The only structural identity needed here is `w_leaf = e_leaf`. -/
theorem character_dense_of_leaf_generators {α G : Type*}
[Fintype α] [AddCommGroup G]
(w : List α → G) (b h : ℕ) (e : (Fin h → α) → G) (χ : AddChar G ℂ)
(hgen : ∀ f : Fin h → α, w (List.ofFn f) = e f)
(hroot : χ (w []) ≠ 1)
(hno : ¬ ∃ v : InternalNode α h, characterSparse w b v χ) :
(b : ℝ) ^ h ≤
((Finset.univ.filter fun f : Fin h → α => χ (e f) ≠ 1).card : ℝ) := by
classical
simpa only [hgen] using character_dense_of_no_sparse w b h χ hroot hno
/-- Exact sum of the reciprocal-subtree budgets over the finite internal-node
index. The result is independent of the branching width. -/
theorem internal_node_budget (m h : ℕ) (hm : m ≠ 0) (C : ℝ) :
(∑ v : InternalNode (Fin m) h, C / (m : ℝ) ^ (v.1 : ℕ)) = h * C := by
have hm' : (m : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hm
rw [Fintype.sum_sigma]
have hlevel : ∀ j : Fin h,
(∑ _f : Fin (j : ℕ) → Fin m, C / (m : ℝ) ^ (j : ℕ)) = C := by
intro j
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fun,
Fintype.card_fin, nsmul_eq_mul, Nat.cast_pow]
rw [mul_comm, div_mul_cancel₀ _ (pow_ne_zero _ hm')]
simp only [hlevel, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
/-- The leaf-coordinate edit budgets sum to exactly the word length. -/
theorem leaf_budget (m h : ℕ) (hm : m ≠ 0) (M : ℝ) :
(∑ _f : Fin h → Fin m, M / (m : ℝ) ^ h) = M := by
have hm' : (m : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hm
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fun,
Fintype.card_fin, nsmul_eq_mul, Nat.cast_pow]
rw [mul_comm, div_mul_cancel₀ _ (pow_ne_zero _ hm')]
end TreeEdit.BinaryLower.FiniteActivity
end
end OAI
|