File size: 6,175 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 137 138 | import OAI.Combinatorics.ContingencyTables.Rooted.RootedRootPenalty
import OAI.Combinatorics.ContingencyTables.Rooted.ForestAffineProgram
namespace OAI
/-! # Polynomial signed component sums for the executed root labels -/
namespace ContingencyTables.RootedComponentProgram
open MatchingFPRAS.TreeTyped Polynomial
open scoped BigOperators Classical
abbrev Record := ℕ×(ℕ×ℕ)
abbrev Input := ℕ×List Record
def positiveTerm (z : ℕ×Record) : ℕ := if z.1=z.2.1 then z.2.2.1 else 0
def negativeTerm (z : ℕ×Record) : ℕ := if z.1=z.2.1 then z.2.2.2 else 0
def positiveTermRealizer : Realizer positiveTerm :=
(choose (composition (pair first (composition second first)) natEqual)
(composition (composition second second) first) (constant 0)).congr (by
intro z
simp only [Function.comp_apply,decide_eq_true_eq,positiveTerm])
def negativeTermRealizer : Realizer negativeTerm :=
(choose (composition (pair first (composition second first)) natEqual)
(composition (composition second second) second) (constant 0)).congr (by
intro z
simp only [Function.comp_apply,decide_eq_true_eq,negativeTerm])
lemma polynomial_positiveTerm : PolynomialTime positiveTermRealizer :=
polynomial_congr _ (polynomial_choose
(polynomial_composition (polynomial_pair polynomial_first
(polynomial_composition polynomial_second polynomial_first)) polynomial_natEqual)
(polynomial_composition (polynomial_composition polynomial_second polynomial_second)
polynomial_first) (polynomial_constant 0))
lemma polynomial_negativeTerm : PolynomialTime negativeTermRealizer :=
polynomial_congr _ (polynomial_choose
(polynomial_composition (polynomial_pair polynomial_first
(polynomial_composition polynomial_second polynomial_first)) polynomial_natEqual)
(polynomial_composition (polynomial_composition polynomial_second polynomial_second)
polynomial_second) (polynomial_constant 0))
def parts (z : Input) : ℕ×ℕ :=
((z.2.map (fun r => positiveTerm (z.1,r))).sum,
(z.2.map (fun r => negativeTerm (z.1,r))).sum)
def partsRealizer : Realizer parts :=
pair (composition (mapWith positiveTermRealizer) listSum)
(composition (mapWith negativeTermRealizer) listSum)
lemma polynomial_parts : PolynomialTime partsRealizer :=
polynomial_pair
(polynomial_composition (polynomial_mapWith polynomial_positiveTerm) polynomial_listSum)
(polynomial_composition (polynomial_mapWith polynomial_negativeTerm) polynomial_listSum)
def absoluteDifference (z : ℕ×ℕ) : ℕ := z.1-z.2+(z.2-z.1)
def absoluteDifferenceRealizer : Realizer absoluteDifference :=
composition (pair subtract (composition (pair second first) subtract)) add
lemma polynomial_absoluteDifference : PolynomialTime absoluteDifferenceRealizer :=
polynomial_composition (polynomial_pair polynomial_subtract
(polynomial_composition (polynomial_pair polynomial_second polynomial_first) polynomial_subtract))
polynomial_add
lemma absoluteDifference_eq (p q : ℕ) : absoluteDifference (p,q)=( (p:ℤ)-q).natAbs := by
rcases Nat.le_total p q with hpq|hqp
· rw [Int.natAbs_natCast_sub_natCast_of_le hpq]
simp [absoluteDifference,Nat.sub_eq_zero_of_le hpq]
· rw [Int.natAbs_natCast_sub_natCast_of_ge hqp]
simp [absoluteDifference,Nat.sub_eq_zero_of_le hqp]
def component (z : Input) : ℕ := absoluteDifference (parts z)
def componentRealizer : Realizer component := composition partsRealizer absoluteDifferenceRealizer
lemma polynomial_component : PolynomialTime componentRealizer :=
polynomial_composition polynomial_parts polynomial_absoluteDifference
def total (rs : List Record) : ℕ :=
((List.range rs.length).map (fun a => component (a,rs))).sum
def totalRealizer : Realizer total :=
composition (composition (pair identity (composition listLength range))
(mapWith (composition (pair second first) componentRealizer))) listSum
theorem polynomial_total : PolynomialTime totalRealizer := by
have hr : PolynomialTime (composition (listLength (A := Record)) range) := by
apply polynomial_boundedRange polynomial_listLength X
intro rs
simpa only [Polynomial.eval_X] using list_length_le_weight rs
exact polynomial_composition
(polynomial_composition (polynomial_pair polynomial_identity hr)
(polynomial_mapWith (polynomial_composition
(polynomial_pair polynomial_second polynomial_first) polynomial_component))) polynomial_listSum
def records {n : ℕ} (root : Fin n → Fin n) (p q : Fin n → ℕ) : List Record :=
List.ofFn (fun i => ((root i).val,(p i,q i)))
lemma parts_records {n : ℕ} (root : Fin n → Fin n) (p q : Fin n → ℕ) (a : Fin n) :
((parts (a.val,records root p q)).1:ℤ)-(parts (a.val,records root p q)).2=
∑ i,if root i=a then (p i:ℤ)-q i else 0 := by
simp only [parts,records,List.map_ofFn,Function.comp_apply,positiveTerm,negativeTerm,
List.sum_ofFn,Nat.cast_sum]
rw [←Finset.sum_sub_distrib]
apply Finset.sum_congr rfl
intro i _
by_cases h : root i=a
· simp [h]
· have hval : a.val≠(root i).val := by
intro he
exact h (Fin.ext he.symm)
simp [h,hval]
theorem component_records {n : ℕ} (root : Fin n → Fin n) (p q : Fin n → ℕ) (a : Fin n) :
component (a.val,records root p q)=(∑ i,if root i=a then (p i:ℤ)-q i else 0).natAbs := by
rw [component,absoluteDifference_eq,parts_records]
theorem total_records {n : ℕ} (root : Fin n → Fin n) (p q : Fin n → ℕ) :
total (records root p q)=∑ a,(∑ i,if root i=a then (p i:ℤ)-q i else 0).natAbs := by
have he : (List.range n).map (fun a => component (a,records root p q))=
List.ofFn (fun a : Fin n => component (a.val,records root p q)) := by
apply List.ext_getElem
· simp only [List.length_map,List.length_range,List.length_ofFn]
· intro i hi _
simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn]
unfold total
rw [show (records root p q).length=n by simp only [records,List.length_ofFn]]
rw [he,List.sum_ofFn]
apply Finset.sum_congr rfl
intro a _
exact component_records root p q a
end ContingencyTables.RootedComponentProgram
end OAI
|