openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Rooted /RootedComponentProgram.lean
| 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 | |