| import OAI.Combinatorics.ContingencyTables.Transport.GraphCompletionUnique |
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteGraphRoots |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| Only reachability and constancy on each component are needed for the |
| integral completion. Making these data explicit permits the executed |
| least-root selector to replace the original quotient representative, |
| without asserting that two different selectors are equal. |
| -/ |
|
|
| namespace ContingencyTables.RootedCompletion |
|
|
| open scoped BigOperators Classical |
| open SimpleGraph GraphIntegralCompletion ForestCut ForestCapacity MaximumForest |
|
|
| variable {V : Type*} |
|
|
| structure Selection (G : SimpleGraph V) where |
| root : V → V |
| reachable : ∀ v,G.Reachable v (root v) |
| constant : ∀ {u v},G.Reachable u v → root u=root v |
|
|
| lemma Selection.idempotent {G : SimpleGraph V} (S : Selection G) (v : V) : |
| S.root (S.root v)=S.root v := (S.constant (S.reachable v)).symm |
|
|
| noncomputable def original (G : SimpleGraph V) : Selection G where |
| root := componentRoot G |
| reachable := componentRoot_reachable G |
| constant := componentRoot_constant G |
|
|
| def canonical {n : ℕ} (G : SimpleGraph (Fin n)) [DecidableRel G.Adj] : Selection G where |
| root := FiniteGraphRoots.root G |
| reachable := FiniteGraphRoots.root_reachable G |
| constant := FiniteGraphRoots.root_constant G |
|
|
| def Selection.map {W : Type*} {G : SimpleGraph V} {H : SimpleGraph W} |
| (S : Selection G) (e : G ≃g H) : Selection H where |
| root v := e (S.root (e.symm v)) |
| reachable v := by |
| have h := (S.reachable (e.symm v)).map e.toHom |
| change H.Reachable (e (e.symm v)) (e (S.root (e.symm v))) at h |
| simpa only [RelIso.apply_symm_apply] using h |
| constant h := congrArg e (S.constant (h.map e.symm.toHom)) |
|
|
| /-- The concrete row-then-column vertex order of the contingency graph. -/ |
| def rowColumn {m n : ℕ} (T : SimpleGraph (Fin m⊕Fin n)) [DecidableRel T.Adj] : |
| Selection T := |
| (canonical (T.comap finSumFinEquiv.symm)).map (Iso.comap finSumFinEquiv.symm T) |
|
|
| lemma rowColumn_root {m n : ℕ} (T : SimpleGraph (Fin m⊕Fin n)) [DecidableRel T.Adj] |
| (v : Fin m⊕Fin n) : |
| (rowColumn T).root v=finSumFinEquiv.symm |
| (FiniteGraphRoots.root (T.comap finSumFinEquiv.symm) (finSumFinEquiv v)) := rfl |
|
|
| noncomputable def path {G : SimpleGraph V} (S : Selection G) (v : V) : G.Walk v (S.root v) := |
| Classical.choice (S.reachable v) |
|
|
| variable [Fintype V] |
|
|
| noncomputable def flow {G : SimpleGraph V} (S : Selection G) (r : V → ℤ) (a b : V) : ℤ := |
| ∑ v,r v*walkFlow (path S v) a b |
|
|
| lemma flow_skew {G : SimpleGraph V} (S : Selection G) (r : V → ℤ) (a b : V) : |
| flow S r a b= -flow S r b a := by |
| unfold flow |
| rw [←Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro v _ |
| rw [walkFlow_skew,mul_neg] |
|
|
| lemma flow_supported {G : SimpleGraph V} (S : Selection G) (r : V → ℤ) |
| (a b : V) (hab : ¬G.Adj a b) : flow S r a b=0 := by |
| unfold flow |
| apply Finset.sum_eq_zero |
| intro v _ |
| rw [walkFlow_supported _ a b hab,mul_zero] |
|
|
| theorem flow_divergence_all {G : SimpleGraph V} (S : Selection G) (r : V → ℤ) (a : V) : |
| (∑ b,flow S r a b)=r a-∑ v,if S.root v=a then r v else 0 := by |
| unfold flow |
| rw [Finset.sum_comm] |
| simp_rw [←Finset.mul_sum,walkFlow_sum,mul_sub,Finset.sum_sub_distrib] |
| simp [mul_ite,eq_comm] |
|
|
| theorem flow_divergence {G : SimpleGraph V} (S : Selection G) (r : V → ℤ) |
| (a : V) (ha : a≠S.root a) : (∑ b,flow S r a b)=r a := by |
| have hroot : ∀ v,S.root v≠a := by |
| intro v hv |
| have h := S.idempotent v |
| rw [hv] at h |
| exact ha h.symm |
| rw [flow_divergence_all] |
| simp only [hroot,ite_false,Finset.sum_const_zero,sub_zero] |
|
|
| variable {I J : Type*} [Fintype I] [Fintype J] |
|
|
| omit [Fintype V] in |
| noncomputable def table (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (r : I → ℤ) (c : J → ℤ) (i : I) (j : J) : ℤ := |
| flow S (Sum.elim r (fun j => -c j)) (.inl i) (.inr j) |
|
|
| omit [Fintype V] in |
| lemma table_supported (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (r : I → ℤ) (c : J → ℤ) (i : I) (j : J) (h : ¬T.Adj (.inl i) (.inr j)) : |
| table T S r c i j=0 := flow_supported S _ _ _ h |
|
|
| omit [Fintype V] in |
| lemma table_row (small : I → J → Bool) (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (hT : T≤cellGraph small) (r : I → ℤ) (c : J → ℤ) (i : I) |
| (hi : Sum.inl i≠S.root (.inl i)) : (∑ j,table T S r c i j)=r i := by |
| have hs := flow_divergence S (Sum.elim r (fun j => -c j)) (.inl i) hi |
| rw [Fintype.sum_sum_type] at hs |
| have hz : (∑ i',flow S (Sum.elim r (fun j => -c j)) (.inl i) (.inl i'))=0 := by |
| apply Finset.sum_eq_zero |
| intro i' _ |
| apply flow_supported |
| intro h |
| exact hT h |
| simpa only [hz,zero_add,Sum.elim_inl,table] using hs |
|
|
| omit [Fintype V] in |
| lemma table_column (small : I → J → Bool) (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (hT : T≤cellGraph small) (r : I → ℤ) (c : J → ℤ) (j : J) |
| (hj : Sum.inr j≠S.root (.inr j)) : (∑ i,table T S r c i j)=c j := by |
| have hs := flow_divergence S (Sum.elim r (fun j => -c j)) (.inr j) hj |
| rw [Fintype.sum_sum_type] at hs |
| have hz : (∑ j',flow S (Sum.elim r (fun j => -c j)) (.inr j) (.inr j'))=0 := by |
| apply Finset.sum_eq_zero |
| intro j' _ |
| apply flow_supported |
| intro h |
| exact hT h |
| have hskew : (∑ i,flow S (Sum.elim r (fun j => -c j)) (.inr j) (.inl i))= |
| -(∑ i,table T S r c i j) := by |
| rw [←Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact flow_skew S _ _ _ |
| simpa only [hz,add_zero,Sum.elim_inr,hskew,neg_inj] using hs |
|
|
| omit [Fintype V] in |
| theorem zero_of_nonroot_sums (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (hT : T.IsAcyclic) (z : I → J → ℝ) |
| (hsupport : ∀ i j,¬T.Adj (.inl i) (.inr j) → z i j=0) |
| (hr : ∀ i,Sum.inl i≠S.root (.inl i) → (∑ j,z i j)=0) |
| (hc : ∀ j,Sum.inr j≠S.root (.inr j) → (∑ i,z i j)=0) : |
| ∀ i j,z i j=0 := by |
| intro i₀ j₀ |
| by_cases ht : T.Adj (.inl i₀) (.inr j₀) |
| · let t : Sym2 (I⊕J) := s(Sum.inl i₀,Sum.inr j₀) |
| let D := T.deleteEdges {t} |
| let root := S.root (.inl i₀) |
| obtain ⟨v,hv,hroot,hcross⟩ := exists_root_avoiding_side T hT ht root |
| (S.reachable (.inl i₀)).symm |
| let rowU : I → Bool := fun i => side D v (.inl i) |
| let colU : J → Bool := fun j => side D v (.inr j) |
| have hcross' : rowU i₀≠colU j₀ := hcross |
| have hnonroot : ∀ a : I⊕J,side D v a=true → a≠S.root a := by |
| intro a ha he |
| have hva : D.Reachable v a := by simpa only [side,decide_eq_true_eq] using ha |
| have hcomp := hv.trans (hva.mono (T.deleteEdges_le {t})) |
| have hsame : S.root a=root := by |
| rw [←S.constant hcomp,S.idempotent] |
| have haroot : a=root := he.trans hsame |
| have hbad : side D v root=true := by simpa only [haroot] using ha |
| exact Bool.false_ne_true (hroot.symm.trans hbad) |
| let f : I×J → ℝ := fun a => cutTerm (fun _ _ => false) rowU colU 0 0 z 0 a.1 a.2 |
| have hsum : (∑ a,f a)=0 := by |
| rw [Fintype.sum_prod_type] |
| apply cut_sum_zero |
| · intro i hi |
| simpa only [rowDifference,Bool.false_eq_true,ite_false,Pi.zero_apply,sub_zero] |
| using hr i (hnonroot (.inl i) hi) |
| · intro j hj |
| simpa only [columnDifference,Bool.false_eq_true,ite_false,Pi.zero_apply,sub_zero] |
| using hc j (hnonroot (.inr j) hj) |
| have hother : ∀ a : I×J,a≠(i₀,j₀) → f a=0 := by |
| rintro ⟨i,j⟩ hne |
| by_cases hij : T.Adj (.inl i) (.inr j) |
| · have he : rowU i=colU j := side_eq_of_tree_edge T t v hij |
| (fun h => hne (cell_edge_injective h)) |
| simp [f,cutTerm,he] |
| · simp [f,cutTerm,hsupport i j hij] |
| have hisolate : (∑ a,f a)=f (i₀,j₀) := by |
| apply Finset.sum_eq_single (i₀,j₀) |
| · intro a _ hne |
| exact hother a hne |
| · simp |
| rw [hisolate] at hsum |
| have habs : |f (i₀,j₀)|=|z i₀ j₀| := by |
| simp only [f,cutTerm,Bool.false_eq_true,ite_false,Pi.zero_apply,sub_zero, |
| abs_mul,abs_indicator_sub hcross',one_mul] |
| rw [hsum,abs_zero] at habs |
| exact abs_eq_zero.mp habs.symm |
| · exact hsupport i₀ j₀ ht |
|
|
| omit [Fintype V] in |
| theorem table_unique (small : I → J → Bool) (T : SimpleGraph (I⊕J)) (S : Selection T) |
| (hTG : T≤cellGraph small) (hT : T.IsAcyclic) (r : I → ℤ) (c : J → ℤ) |
| (z : I → J → ℤ) |
| (hsupport : ∀ i j,¬T.Adj (.inl i) (.inr j) → z i j=0) |
| (hr : ∀ i,Sum.inl i≠S.root (.inl i) → (∑ j,z i j)=r i) |
| (hc : ∀ j,Sum.inr j≠S.root (.inr j) → (∑ i,z i j)=c j) : |
| z=table T S r c := by |
| let delta : I → J → ℝ := fun i j => (z i j:ℝ)-table T S r c i j |
| have hz := zero_of_nonroot_sums T S hT delta (by |
| intro i j hij |
| simp only [delta,hsupport i j hij,Int.cast_zero,table_supported T S r c i j hij,sub_self]) |
| (by |
| intro i hi |
| dsimp only [delta] |
| rw [Finset.sum_sub_distrib,←Int.cast_sum,←Int.cast_sum, |
| hr i hi,table_row small T S hTG r c i hi,sub_self]) |
| (by |
| intro j hj |
| dsimp only [delta] |
| rw [Finset.sum_sub_distrib,←Int.cast_sum,←Int.cast_sum, |
| hc j hj,table_column small T S hTG r c j hj,sub_self]) |
| funext i j |
| exact_mod_cast (sub_eq_zero.mp (hz i j)) |
|
|
| omit [Fintype V] in |
| theorem table_original (small : I → J → Bool) (T : SimpleGraph (I⊕J)) |
| (hTG : T≤cellGraph small) (hT : T.IsAcyclic) (r : I → ℤ) (c : J → ℤ) : |
| table T (original T) r c=tableCompletion T r c := |
| GraphCompletionUnique.tableCompletion_unique small T hTG hT r c _ |
| (table_supported T (original T) r c) |
| (table_row small T (original T) hTG r c) |
| (table_column small T (original T) hTG r c) |
|
|
| end ContingencyTables.RootedCompletion |
|
|
| end OAI |
|
|
