openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Transport /BoundedTableFeasibility.lean
| import OAI.Combinatorics.ContingencyTables.Transport.LayeredTableNetwork | |
| import Mathlib.Logic.Equiv.Fin.Basic | |
| namespace OAI | |
| /-! # Executed bounded-table feasibility from the cited flow bound | |
| The test runs the concrete residual algorithm on the literal three-layer | |
| network. It handles zero margins, empty row or column types, and structural | |
| zeros. No bounded-table feasibility oracle is assumed. | |
| -/ | |
| namespace ContingencyTables.BoundedTableFeasibility | |
| open LayeredTableNetwork | |
| open scoped BigOperators | |
| def vertices (m n : ℕ) : Vertex m n ≃ Fin (2+(m+n)) := | |
| (Equiv.sumCongr finTwoEquiv.symm finSumFinEquiv).trans finSumFinEquiv | |
| variable {m n : ℕ} | |
| def networkCapacity (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) : | |
| PublishedEdmondsKarp.Capacity (2+(m+n)) := | |
| fun u v=>capacity r c b ((vertices m n).symm u) ((vertices m n).symm v) | |
| def pull (f : PublishedEdmondsKarp.Flow (2+(m+n))) : Vertex m n → Vertex m n → ℤ := | |
| fun u v=>f (vertices m n u) (vertices m n v) | |
| def push (f : Vertex m n → Vertex m n → ℤ) : PublishedEdmondsKarp.Flow (2+(m+n)) := | |
| fun u v=>f ((vertices m n).symm u) ((vertices m n).symm v) | |
| lemma source_ne_sink : vertices m n (source : Vertex m n)≠vertices m n sink := by | |
| intro h | |
| have he := (vertices m n).injective h | |
| cases he | |
| lemma capacity_loop (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) | |
| (u : Fin (2+(m+n))) : networkCapacity r c b u u=0 := | |
| capacity_diagonal r c b _ | |
| lemma pull_feasible (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) | |
| (f : PublishedEdmondsKarp.Flow (2+(m+n))) | |
| (hf : PublishedEdmondsKarp.Feasible (networkCapacity r c b) | |
| (vertices m n source) (vertices m n sink) f) : Feasible r c b (pull f) := by | |
| refine ⟨fun u v=>hf.1 _ _,?_,?_⟩ | |
| · intro u v | |
| simpa only [pull,networkCapacity,Equiv.symm_apply_apply] using hf.2.1 | |
| (vertices m n u) (vertices m n v) | |
| · intro u hs ht | |
| have h := hf.2.2 (vertices m n u) | |
| (fun he=>hs ((vertices m n).injective he)) | |
| (fun he=>ht ((vertices m n).injective he)) | |
| simpa only [pull,(vertices m n).sum_comp] using h | |
| lemma push_feasible (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) | |
| (f : Vertex m n → Vertex m n → ℤ) (hf : Feasible r c b f) : | |
| PublishedEdmondsKarp.Feasible (networkCapacity r c b) | |
| (vertices m n source) (vertices m n sink) (push f) := by | |
| refine ⟨fun u v=>hf.1 _ _,fun u v=>hf.2.1 _ _,?_⟩ | |
| intro u hs ht | |
| have h := hf.2.2 ((vertices m n).symm u) | |
| (fun he=>hs ((vertices m n).symm_apply_eq.mp he)) | |
| (fun he=>ht ((vertices m n).symm_apply_eq.mp he)) | |
| simpa only [push,(vertices m n).symm.sum_comp] using h | |
| lemma pull_value (f : PublishedEdmondsKarp.Flow (2+(m+n))) : | |
| value (pull f)=PublishedEdmondsKarp.value (vertices m n source) f := by | |
| exact (vertices m n).sum_comp (fun v=>f (vertices m n source) v) | |
| lemma push_value (f : Vertex m n → Vertex m n → ℤ) : | |
| PublishedEdmondsKarp.value (vertices m n source) (push f)=value f := by | |
| simp only [PublishedEdmondsKarp.value,push,Equiv.symm_apply_apply] | |
| exact (vertices m n).symm.sum_comp (fun v=>f source v) | |
| def computedFlow (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) : | |
| Vertex m n → Vertex m n → ℤ := | |
| pull (EdmondsKarpAlgorithm.maxFlow (networkCapacity r c b) | |
| (vertices m n source) (vertices m n sink)) | |
| def feasibleTest (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) : Bool := | |
| decide ((∑ i,r i)=∑ j,c j ∧ value (computedFlow r c b)=∑ i,(r i:ℤ)) | |
| theorem computedFlow_feasible (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1) | |
| (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) : | |
| Feasible r c b (computedFlow r c b) := | |
| pull_feasible r c b _ (EdmondsKarpAlgorithm.maxFlow_correct hEK | |
| (networkCapacity r c b) (capacity_loop r c b) _ _ source_ne_sink).1 | |
| theorem feasibleTest_correct (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1) | |
| (r : Fin m → ℕ) (c : Fin n → ℕ) (b : Fin m → Fin n → ℕ) : | |
| feasibleTest r c b=true ↔ ∃ X,HasMargins X r c ∧ ∀ i j,X i j≤b i j := by | |
| rw [feasibleTest,decide_eq_true_eq] | |
| constructor | |
| · rintro ⟨htotal,hvalue⟩ | |
| exact ⟨decode (computedFlow r c b),decode_boundedTable r c b _ | |
| (computedFlow_feasible hEK r c b) hvalue htotal⟩ | |
| · rintro ⟨X,hm,hb⟩ | |
| refine ⟨totals_equal hm,?_⟩ | |
| have hmax := EdmondsKarpAlgorithm.maxFlow_correct hEK | |
| (networkCapacity r c b) (capacity_loop r c b) | |
| (vertices m n source) (vertices m n sink) source_ne_sink | |
| have hle := hmax.2 (push (tableFlow r c X)) | |
| (push_feasible r c b _ (tableFlow_feasible r c b X hm hb)) | |
| rw [push_value,tableFlow_value,←pull_value] at hle | |
| exact le_antisymm (value_le_total r c b _ (computedFlow_feasible hEK r c b)) hle | |
| end ContingencyTables.BoundedTableFeasibility | |
| end OAI | |