| import OAI.Combinatorics.EditApproximation.Numerics.Numerics |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! |
| # The actual fixed-block action hull |
|
|
| Coordinates are precisely the child/state pairs occurring in a finite band. |
| Each action assigns its fixed rational child mass to one state per child. |
| This verifies the probability, coverage and block-mass hypotheses used by |
| the numerical optimizer and optimistic entropy regret. |
| -/ |
|
|
| namespace EditApproximation |
|
|
| open Finset |
|
|
|
|
|
|
|
|
|
|
| theorem action_coordinate_mem {β σ : Type*} [Fintype β] [DecidableEq β] [DecidableEq σ] |
| (band : Finset (β → σ)) {action : β → σ} (haction : action ∈ band) (child : β) : |
| (child, action child) ∈ bandCoordinates band := by |
| apply mem_biUnion.mpr |
| exact ⟨action, haction, mem_image.mpr ⟨child, mem_univ _, rfl⟩⟩ |
|
|
| theorem actionVector_probability {β σ : Type*} [Fintype β] [Nonempty β] |
| [DecidableEq β] [DecidableEq σ] (band : Finset (β → σ)) |
| (mass : β → ℚ) (hpos : ∀ child, 0 < mass child) |
| {action : β → σ} (haction : action ∈ band) : |
| (∀ coordinate ∈ bandCoordinates band, (0 : ℝ) ≤ actionVector mass action coordinate) ∧ |
| (∑ coordinate ∈ bandCoordinates band, (actionVector mass action coordinate : ℝ)) = 1 := by |
| have htotal : (0 : ℚ) < ∑ child, mass child := sum_pos (fun child _ => hpos child) univ_nonempty |
| constructor |
| · intro coordinate _ |
| unfold actionVector |
| split_ifs |
| · exact_mod_cast (div_pos (hpos _) htotal).le |
| · norm_num |
| · have hsubset : (univ.image fun child => (child, action child)) ⊆ bandCoordinates band := by |
| intro coordinate hc |
| obtain ⟨child, _, rfl⟩ := mem_image.mp hc |
| exact action_coordinate_mem band haction child |
| have hsum : (∑ coordinate ∈ bandCoordinates band, (actionVector mass action coordinate : ℝ)) = |
| ∑ coordinate ∈ univ.image (fun child => (child, action child)), |
| (actionVector mass action coordinate : ℝ) := by |
| symm |
| apply sum_subset hsubset |
| intro coordinate _ hnot |
| have hne : coordinate.2 ≠ action coordinate.1 := by |
| intro heq |
| exact hnot (mem_image.mpr ⟨coordinate.1, mem_univ _, Prod.ext rfl heq.symm⟩) |
| simp only [actionVector, ite_eq_right hne, Rat.cast_zero] |
| rw [hsum, sum_image] |
| · simp only [actionVector, ite_true, Rat.cast_div] |
| rw [← sum_div] |
| have hcast : (∑ child, (mass child : ℝ)) = ((∑ child, mass child : ℚ) : ℝ) := by |
| norm_cast |
| rw [hcast] |
| exact div_self (by exact_mod_cast htotal.ne') |
| · intro i _ j _ hij |
| exact congrArg Prod.fst hij |
| |
| theorem actionVector_coordinate_coverage {β σ : Type*} [Fintype β] [Nonempty β] |
| [DecidableEq β] [DecidableEq σ] (band : Finset (β → σ)) |
| (mass : β → ℚ) (hpos : ∀ child, 0 < mass child) : |
| ∀ coordinate ∈ bandCoordinates band, ∃ action ∈ band, |
| (0 : ℝ) < actionVector mass action coordinate := by |
| intro coordinate hcoordinate |
| obtain ⟨action, ha, hcoordinate⟩ := mem_biUnion.mp hcoordinate |
| obtain ⟨child, _, heq⟩ := mem_image.mp hcoordinate |
| subst coordinate |
| refine ⟨action, ha, ?_⟩ |
| simp only [actionVector, ite_true] |
| have htotal : (0 : ℚ) < ∑ child, mass child := sum_pos (fun child _ => hpos child) univ_nonempty |
| exact_mod_cast div_pos (hpos child) htotal |
| |
| theorem actionVector_block_mass {β σ : Type*} [Fintype β] [DecidableEq β] [DecidableEq σ] |
| (band : Finset (β → σ)) (mass : β → ℚ) |
| {action : β → σ} (haction : action ∈ band) (child : β) : |
| (∑ coordinate ∈ bandCoordinates band with coordinate.1 = child, |
| (actionVector mass action coordinate : ℝ)) = |
| (mass child / (∑ i, mass i) : ℚ) := by |
| rw [sum_eq_single (child, action child)] |
| · simp only [actionVector, ite_true] |
| · intro coordinate hc hne |
| have hchild : coordinate.1 = child := (mem_filter.mp hc).2 |
| have hstate : coordinate.2 ≠ action child := by |
| intro hstate |
| exact hne (Prod.ext hchild hstate) |
| simp only [actionVector, hchild, ite_eq_right hstate, Rat.cast_zero] |
| · intro hnot |
| exact False.elim (hnot (mem_filter.mpr ⟨action_coordinate_mem band haction child, rfl⟩)) |
| |
| theorem actionVector_inner_product {β σ : Type*} [Fintype β] |
| [DecidableEq β] [DecidableEq σ] (band : Finset (β → σ)) |
| (mass : β → ℚ) (gain : β × σ → ℝ) |
| {action : β → σ} (haction : action ∈ band) : |
| (∑ coordinate ∈ bandCoordinates band, gain coordinate * (actionVector mass action coordinate : ℝ)) = |
| ∑ child, gain (child, action child) * (mass child / (∑ i, mass i) : ℚ) := by |
| have hsubset : (univ.image fun child => (child, action child)) ⊆ bandCoordinates band := by |
| intro coordinate hc |
| obtain ⟨child, _, rfl⟩ := mem_image.mp hc |
| exact action_coordinate_mem band haction child |
| have hsum : (∑ coordinate ∈ bandCoordinates band, |
| gain coordinate * (actionVector mass action coordinate : ℝ)) = |
| ∑ coordinate ∈ univ.image (fun child => (child, action child)), |
| gain coordinate * (actionVector mass action coordinate : ℝ) := by |
| symm |
| apply sum_subset hsubset |
| intro coordinate _ hnot |
| have hne : coordinate.2 ≠ action coordinate.1 := by |
| intro heq |
| exact hnot (mem_image.mpr ⟨coordinate.1, mem_univ _, Prod.ext rfl heq.symm⟩) |
| simp only [actionVector, ite_eq_right hne, Rat.cast_zero, mul_zero] |
| rw [hsum, sum_image] |
| · simp only [actionVector, ite_true] |
| · intro i _ j _ hij |
| exact congrArg Prod.fst hij |
| |
| /-- The coordinate normalization translates entropy gains exactly into |
| the unnormalized costs of a band action. -/ |
| theorem actionVector_cost_identity {β σ : Type*} [Fintype β] [Nonempty β] |
| [DecidableEq β] [DecidableEq σ] (band : Finset (β → σ)) |
| (mass : β → ℚ) (hpos : ∀ child, 0 < mass child) (cost : β × σ → ℝ) |
| {action : β → σ} (haction : action ∈ band) : |
| -((∑ child, mass child : ℚ) : ℝ) * |
| (∑ coordinate ∈ bandCoordinates band, |
| (-cost coordinate / (mass coordinate.1 : ℝ)) * (actionVector mass action coordinate : ℝ)) = |
| ∑ child, cost (child, action child) := by |
| rw [actionVector_inner_product band mass _ haction, mul_sum] |
| apply sum_congr rfl |
| intro child _ |
| have hmass : (mass child : ℝ) ≠ 0 := by exact_mod_cast (hpos child).ne' |
| have htotal : ((∑ child, mass child : ℚ) : ℝ) ≠ 0 := by |
| exact_mod_cast (sum_pos (fun child _ => hpos child) univ_nonempty).ne' |
| rw [Rat.cast_div] |
| field_simp |
|
|
| theorem band_block_nonempty {β σ : Type*} [Fintype β] [DecidableEq β] [DecidableEq σ] |
| (band : Finset (β → σ)) (hband : band.Nonempty) (child : β) : |
| ((bandCoordinates band).filter fun coordinate => coordinate.1 = child).Nonempty := by |
| obtain ⟨action, ha⟩ := hband |
| exact ⟨(child, action child), mem_filter.mpr ⟨action_coordinate_mem band ha child, rfl⟩⟩ |
|
|
| theorem band_hull_block_mass {β σ : Type*} [Fintype β] [DecidableEq β] [DecidableEq σ] |
| (band : Finset (β → σ)) (mass : β → ℚ) (child : β) |
| (p : β × σ → ℝ) |
| (hp : p ∈ convexHull ℝ (rationalVertexSet (band.toList.map (actionVector mass)))) : |
| (∑ coordinate ∈ bandCoordinates band with coordinate.1 = child, p coordinate) = |
| (mass child / (∑ i, mass i) : ℚ) := by |
| let targetMass : ℝ := (mass child / (∑ i, mass i) : ℚ) |
| have hconvex : Convex ℝ {q : β × σ → ℝ | |
| (∑ coordinate ∈ bandCoordinates band with coordinate.1 = child, q coordinate) = |
| targetMass} := by |
| intro x hx y hy a b _ _ hab |
| change (∑ coordinate ∈ bandCoordinates band with coordinate.1 = child, |
| (a * x coordinate + b * y coordinate)) = targetMass |
| rw [sum_add_distrib, ← mul_sum, ← mul_sum, hx, hy] |
| calc |
| a * targetMass + b * targetMass = (a + b) * targetMass := by ring |
| _ = targetMass := by rw [hab, one_mul] |
| have hsubset : rationalVertexSet (band.toList.map (actionVector mass)) ⊆ |
| {q : β × σ → ℝ | |
| (∑ coordinate ∈ bandCoordinates band with coordinate.1 = child, q coordinate) = |
| targetMass} := by |
| rintro _ ⟨vertex, hv, rfl⟩ |
| obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hv |
| exact actionVector_block_mass band mass (mem_toList.mp ha) child |
| exact convexHull_min hsubset hconvex hp |
|
|
| theorem band_entropy_optimizer {β σ : Type*} [Fintype β] [Nonempty β] |
| [DecidableEq β] [DecidableEq σ] (band : Finset (β → σ)) (hband : band.Nonempty) |
| (mass : β → ℚ) (hpos : ∀ child, 0 < mass child) |
| (linear : β × σ → ℚ) (H : ℕ) (hH : 4 ≤ H) : |
| let coordinates := bandCoordinates band |
| let vertices := band.toList.map (actionVector mass) |
| ∃ maximizer ∈ convexHull ℝ (rationalVertexSet vertices), |
| IsMaxOn (entropyValue coordinates 1 (fun i => (linear i : ℝ))) |
| (convexHull ℝ (rationalVertexSet vertices)) maximizer ∧ |
| (∑ i ∈ coordinates, |(finiteRationalOptimizer coordinates vertices linear |
| (H + coordinates.card + 2) ((H + coordinates.card + 2) ^ 80) i : ℝ) - maximizer i|) ≤ |
| 1 / (H : ℝ) ^ 3 := by |
| dsimp only |
| have hvertices : band.toList.map (actionVector mass) ≠ [] := by |
| obtain ⟨action, ha⟩ := hband |
| intro hnil |
| have hmem : actionVector mass action ∈ band.toList.map (actionVector mass) := |
| List.mem_map.mpr ⟨action, mem_toList.mpr ha, rfl⟩ |
| simp only [hnil, List.not_mem_nil] at hmem |
| apply finite_entropy_optimizer _ _ _ _ hvertices hH |
| · intro p hp |
| obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hp |
| exact actionVector_probability band mass hpos (mem_toList.mp ha) |
| · intro coordinate hc |
| obtain ⟨action, ha, hpositive⟩ := actionVector_coordinate_coverage band mass hpos coordinate hc |
| exact ⟨actionVector mass action, List.mem_map.mpr ⟨action, mem_toList.mpr ha, rfl⟩, hpositive⟩ |
|
|
| end EditApproximation |
|
|
| end OAI |
|
|
