File size: 6,699 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 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | import OAI.Combinatorics.ContingencyTables.Rooted.ForestScaledPenalty
import OAI.Combinatorics.ContingencyTables.Rooted.ForestPenaltyBound
namespace OAI
/-! # Integer free assignments use the original scaled affine tree values -/
namespace ContingencyTables.ForestScaledPenalty
open scoped BigOperators Classical
open CompanionFactorialApplication GraphCompletionCounts ForestAssignmentSplit
open ForestAffineCoefficients ForestPhysicalCompletion ForestRootPenalty
variable {I J : Type*} [Fintype I] [Fintype J]
lemma free_coefficient_sum (A : Instance I J) (t : TreeCell A.T) (F : I×J → ℝ) :
(∑ f : FreeCell A.small A.T,coefficient A t f.val*F f.val)=
∑ a : I×J,coefficient A t a*F a := by
let p : I×J → Prop := fun a => A.small a.1 a.2=false ∧ ¬A.T.Adj (.inl a.1) (.inr a.2)
calc
_ = ∑ a ∈ Finset.univ.filter p,coefficient A t a*F a :=
(Finset.sum_subtype (p := p) (Finset.univ.filter p) (fun _ => by simp)
(fun a => coefficient A t a*F a)).symm
_ = _ := by
apply Finset.sum_subset (Finset.filter_subset _ _)
intro a _ ha
have hp : ¬p a := by simpa only [Finset.mem_filter,Finset.mem_univ,true_and] using ha
change ¬(A.small a.1 a.2=false ∧ ¬A.T.Adj (.inl a.1) (.inr a.2)) at hp
simp only [coefficient,hp,ite_false,zero_mul]
noncomputable def integerCube (A : Instance I J) (B : ℝ) (f : FreeIndex A.small A.T A.b) :
FreeCell A.small A.T → ℝ := fun a => B*(f a).val/((A.b a.val.1 a.val.2:ℝ)+1)
/-- The scaled affine value at each original integer free assignment is
exactly the manuscript's solved tree value divided by its capacity. -/
theorem scaledTree_integer (A : Instance I J) (B : ℝ) (hB : 0 < B)
(x q : I → J → ℤ) (f : FreeIndex A.small A.T A.b) (t : TreeCell A.T) :
scaledTree A B x q (integerCube A B f) t=
(solved A.small A.T A.r A.c x q
(fun i j => (freeTable A.small A.T A.b f i j:ℤ)) t.val.1 t.val.2:ℝ)/(A.b t.val.1 t.val.2:ℝ) := by
let F : I×J → ℝ := fun a => (freeTable A.small A.T A.b f a.1 a.2:ℝ)
have hterm (a : FreeCell A.small A.T) :
normalizedCoefficient A B t a*integerCube A B f a=
coefficient A t a.val*F a.val/(A.b t.val.1 t.val.2:ℝ) := by
have hN : (A.b a.val.1 a.val.2:ℝ)+1≠0 := by positivity
have hbt : (A.b t.val.1 t.val.2:ℝ)≠0 := by
exact_mod_cast (Nat.ne_of_gt (A.hlarge _ _ (A.hTG t.property)).2)
have hF : F a.val=(f a).val := by
simp [F,freeTable,a.property]
rw [hF]
unfold normalizedCoefficient integerCube
field_simp [hB.ne',hN,hbt]
unfold scaledTree AffinePenalty.affineValue normalizedOffset
simp_rw [hterm]
rw [← Finset.sum_div,free_coefficient_sum,← add_div]
have hh := solved_eq_affine A t x q
(fun i j => (freeTable A.small A.T A.b f i j:ℤ))
unfold affineTree AffinePenalty.affineValue at hh
apply congrArg (fun z : ℝ => z/(A.b t.val.1 t.val.2:ℝ))
simpa only [F,Int.cast_natCast] using hh.symm
lemma intervalCost_div (x b : ℝ) (hb : 0 < b) :
intervalCost (x/b)=max 0 (max (-x) (x-b))/b := by
unfold intervalCost
have he : x/b-1=(x-b)/b := by field_simp [hb.ne']
rw [he,← neg_div, max_div_div_right hb.le]
simpa only [zero_div] using max_div_div_right hb.le (0:ℝ) (max (-x) (x-b))
/-- The root residual in the continuous display is the original root
residual on every integer free assignment; it is independent of those
free values by the proved component-cut cancellation. -/
theorem rootConstant_eq_assignment (A : Instance I J) (x q free : I → J → ℤ) :
rootConstant A x q=
∑ a,if ForestPenaltyApplication.rootFlag A.T a then
|(signedResidual A.small A.T A.r A.c x q free a:ℝ)| else 0 := by
have hroot := root_eq_large A.small A.b A.T A.hTG A.hT A.hmax
(fun i j hs => (A.hlarge i j hs).2)
have hh := signedResidual_independent A.small A.T A.hTG A.r A.c x q free 0 A.X
A.hXr A.hXc hroot
unfold rootConstant
apply Finset.sum_congr rfl
intro a _
rw [hh]
lemma tree_sum_eq (A : Instance I J) (F : I×J → ℝ) :
(∑ t : TreeCell A.T,F t.val)=
∑ i,∑ j,if A.T.Adj (.inl i) (.inr j) then F (i,j) else 0 := by
let p : I×J → Prop := fun a => A.T.Adj (.inl a.1) (.inr a.2)
calc
_ = ∑ a ∈ Finset.univ.filter p,F a :=
(Finset.sum_subtype (p := p) (Finset.univ.filter p) (fun _ => by simp) F).symm
_ = ∑ a : I×J,if p a then F a else 0 := Finset.sum_filter _ _
_ = _ := by rw [Fintype.sum_prod_type]
/-- Thus the continuous display agrees term for term with the actual
root/tree penalty in the original finite definition of h_j. -/
theorem penalty_at_integer (A : Instance I J) (C B : ℝ) (hB : 0 < B)
(z : View A → ℕ) (f : FreeIndex A.small A.T A.b) :
penalty A C B (fun i j => (ForestCountIdentification.smallX A.small z i j:ℤ))
(fun i j => ((A.b i j-ForestCountIdentification.smallY A.small z i j:ℕ):ℤ))
(integerCube A B f)=C*ForestPenaltyBound.penalty A z f := by
let x := ForestCountIdentification.smallX A.small z
let y := ForestCountIdentification.smallY A.small z
let free := freeTable A.small A.T A.b f
let tree := solved A.small A.T A.r A.c (fun i j => (x i j:ℤ))
(fun i j => ((A.b i j-y i j:ℕ):ℤ)) (fun i j => (free i j:ℤ))
have hroot : rootConstant A (fun i j => (x i j:ℤ)) (fun i j => ((A.b i j-y i j:ℕ):ℤ))=
∑ a,if ForestPenaltyApplication.rootFlag A.T a then
|ForestLiteralCount.actualDeviation A.small A.T A.b x y free A.r A.c tree a| else 0 := by
rw [rootConstant_eq_assignment A _ _ (fun i j => (free i j:ℤ))]
apply Finset.sum_congr rfl
intro a _
rw [ForestRootPenalty.abs_actualDeviation_solved]
have htree : (∑ t : TreeCell A.T,intervalCost (scaledTree A B (fun i j => (x i j:ℤ))
(fun i j => ((A.b i j-y i j:ℕ):ℤ)) (integerCube A B f) t))=
∑ i,∑ j,if A.T.Adj (.inl i) (.inr j) then
max 0 (max (-(tree i j:ℝ)) ((tree i j:ℝ)-A.b i j))/(A.b i j:ℝ) else 0 := by
calc
_ = ∑ t : TreeCell A.T,
max 0 (max (-(tree t.val.1 t.val.2:ℝ)) ((tree t.val.1 t.val.2:ℝ)-A.b t.val.1 t.val.2))/
(A.b t.val.1 t.val.2:ℝ) := by
apply Finset.sum_congr rfl
intro t _
rw [scaledTree_integer A B hB]
exact intervalCost_div _ _ (by exact_mod_cast (A.hlarge _ _ (A.hTG t.property)).2)
_ = _ := tree_sum_eq A (fun a =>
max 0 (max (-(tree a.1 a.2:ℝ)) ((tree a.1 a.2:ℝ)-A.b a.1 a.2))/(A.b a.1 a.2:ℝ))
unfold penalty
change C*(rootConstant A (fun i j => (x i j:ℤ)) (fun i j => ((A.b i j-y i j:ℕ):ℤ))+_)=_
rw [hroot,htree]
rfl
end ContingencyTables.ForestScaledPenalty
end OAI
|