openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Rooted /RootedComponentSemantics.lean
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedComponentProgram | |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedPenaltyProgram | |
| namespace OAI | |
| /-! # The executed component sums equal the root penalty | |
| The root-only filter in the manuscript costs no separate test: every | |
| nonroot has an empty root fibre. This connects the polynomial grouped | |
| signed-sum program to the actual selected-root discrepancy. | |
| -/ | |
| namespace ContingencyTables.RootedComponentProgram | |
| open scoped BigOperators Classical | |
| open CompanionFactorialApplication RootedCompletion | |
| variable {I J : Type*} [Fintype I] [Fintype J] | |
| lemma componentTotal_zero (A : Instance I J) (S : Selection A.T) | |
| (d : I⊕J → ℤ) (a : I⊕J) (ha : a≠S.root a) : | |
| RootedRootPenalty.componentTotal A S d a=0 := by | |
| have hroot (v : I⊕J) : S.root v≠a := by | |
| intro hv | |
| apply ha | |
| calc | |
| a=S.root v := hv.symm | |
| _=S.root (S.root v) := (S.idempotent v).symm | |
| _=S.root a := congrArg S.root hv | |
| unfold RootedRootPenalty.componentTotal | |
| apply Finset.sum_eq_zero | |
| intro v _ | |
| simp only [hroot v,ite_false,zero_mul] | |
| theorem rootCount_eq_componentTotals (A : Instance I J) (S : Selection A.T) | |
| (x q : I → J → ℤ) : | |
| RootedPenaltyProgram.rootCount A S x q= | |
| ∑ a,(RootedRootPenalty.componentTotal A S | |
| (ForestRootPenalty.smallDemand A.small A.X x q) a).natAbs := by | |
| unfold RootedPenaltyProgram.rootCount | |
| simp_rw [RootedRootPenalty.signedResidual_eq_small,Int.natAbs_neg] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| by_cases ha : a=S.root a | |
| · have hflag : RootedPenalty.rootFlag S a=true := decide_eq_true ha | |
| exact ite_eq_left hflag | |
| · rw [componentTotal_zero A S _ a ha] | |
| simp only [Int.natAbs_zero,ite_self] | |
| /-- The positive and negative entries may be the actual row and column | |
| small-view sums. Their difference is the only representation invariant | |
| needed by the finite signed component program. -/ | |
| theorem total_records_rootCount (A : Instance I J) (S : Selection A.T) | |
| (x q : I → J → ℤ) {n : ℕ} (e : Fin n ≃ I⊕J) (p m : Fin n → ℕ) | |
| (hd : ∀ i,(p i:ℤ)-m i=ForestRootPenalty.smallDemand A.small A.X x q (e i)) : | |
| total (records (fun i => e.symm (S.root (e i))) p m)= | |
| RootedPenaltyProgram.rootCount A S x q := by | |
| have hs (a : Fin n) : | |
| (∑ i,if e.symm (S.root (e i))=a then (p i:ℤ)-m i else 0)= | |
| RootedRootPenalty.componentTotal A S | |
| (ForestRootPenalty.smallDemand A.small A.X x q) (e a) := by | |
| calc | |
| _=∑ i,if S.root (e i)=e a then | |
| ForestRootPenalty.smallDemand A.small A.X x q (e i) else 0 := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [hd i] | |
| simp only [Equiv.symm_apply_eq] | |
| _=∑ v,if S.root v=e a then | |
| ForestRootPenalty.smallDemand A.small A.X x q v else 0 := | |
| Fintype.sum_equiv e _ _ (fun _ => rfl) | |
| _=_ := by | |
| simp only [RootedRootPenalty.componentTotal,ite_mul,one_mul,zero_mul] | |
| rw [total_records] | |
| calc | |
| _=∑ a,(RootedRootPenalty.componentTotal A S | |
| (ForestRootPenalty.smallDemand A.small A.X x q) (e a)).natAbs := by | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| rw [hs] | |
| _=∑ a,(RootedRootPenalty.componentTotal A S | |
| (ForestRootPenalty.smallDemand A.small A.X x q) a).natAbs := | |
| Fintype.sum_equiv e _ _ (fun _ => rfl) | |
| _=_ := (rootCount_eq_componentTotals A S x q).symm | |
| noncomputable def positiveDemand (A : Instance I J) (z : View A → ℕ) : I⊕J → ℕ := | |
| Sum.elim | |
| (fun i => ∑ j,if A.small i j then (A.X i j).toNat else 0) | |
| (fun j => ∑ i,if A.small i j then A.b i j-ForestCountIdentification.smallY A.small z i j else 0) | |
| noncomputable def negativeDemand (A : Instance I J) (z : View A → ℕ) : I⊕J → ℕ := | |
| Sum.elim | |
| (fun i => ∑ j,if A.small i j then ForestCountIdentification.smallX A.small z i j else 0) | |
| (fun j => ∑ i,if A.small i j then (A.X i j).toNat else 0) | |
| theorem naturalDemand_eq (A : Instance I J) (z : View A → ℕ) (a : I⊕J) : | |
| (positiveDemand A z a:ℤ)-negativeDemand A z a= | |
| ForestRootPenalty.smallDemand A.small A.X (ForestScaledPenalty.rowCounts A z) | |
| (ForestScaledPenalty.columnCounts A z) a := by | |
| cases a with | |
| | inl i => | |
| simp only [positiveDemand,negativeDemand,Sum.elim_inl,Nat.cast_sum,Nat.cast_ite,Nat.cast_zero, | |
| ForestRootPenalty.smallDemand] | |
| rw [←Finset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| cases A.small i j <;> | |
| simp only [Bool.false_eq_true,ite_false,ite_true,sub_zero, | |
| ForestScaledPenalty.rowCounts,Int.toNat_of_nonneg (A.hX i j).1] | |
| | inr j => | |
| simp only [positiveDemand,negativeDemand,Sum.elim_inr,Nat.cast_sum,Nat.cast_ite,Nat.cast_zero, | |
| ForestRootPenalty.smallDemand] | |
| rw [←Finset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| cases A.small i j <;> | |
| simp only [Bool.false_eq_true,ite_false,ite_true,sub_zero, | |
| ForestScaledPenalty.columnCounts,Int.toNat_of_nonneg (A.hX i j).1] | |
| end ContingencyTables.RootedComponentProgram | |
| end OAI | |