openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /EndpointMatrixProgram.lean
| import OAI.Combinatorics.ContingencyTables.Machines.CellMinimumProgram | |
| namespace OAI | |
| /-! # Computing every attained cell endpoint | |
| Both scans use the dimensions of the stored margin lists. Each entry is | |
| computed by the binary feasibility search; neither scan enumerates tables. | |
| -/ | |
| namespace ContingencyTables.EndpointMatrixProgram | |
| open MatchingFPRAS.TreeTyped Polynomial ResidualGraphProgram | |
| abbrev Input := NetworkVertexCode.Input | |
| abbrev RowInput := Input × ℕ | |
| abbrev CellInput := RowInput × ℕ | |
| def context (z : CellInput) : CellLowerTestProgram.Context := (z.1.1,(z.1.2,z.2)) | |
| def contextRealizer : Realizer context := pair (composition first first) | |
| (pair (composition first second) second) | |
| lemma polynomial_context : PolynomialTime contextRealizer := | |
| polynomial_pair (polynomial_composition polynomial_first polynomial_first) | |
| (polynomial_pair (polynomial_composition polynomial_first polynomial_second) | |
| polynomial_second) | |
| def lowerEntry (z : CellInput) : ℕ := CellMinimumProgram.minimum (context z) | |
| def lowerEntryRealizer : Realizer lowerEntry := | |
| composition (f := context) (g := CellMinimumProgram.minimum) | |
| contextRealizer CellMinimumProgram.minimumRealizer | |
| lemma polynomial_lowerEntry : PolynomialTime lowerEntryRealizer := | |
| polynomial_composition polynomial_context CellMinimumProgram.polynomial_minimum | |
| def upperEntry (z : CellInput) : ℕ := CellMaximumProgram.maximum (context z) | |
| def upperEntryRealizer : Realizer upperEntry := | |
| composition (f := context) (g := CellMaximumProgram.maximum) | |
| contextRealizer CellMaximumProgram.maximumRealizer | |
| lemma polynomial_upperEntry : PolynomialTime upperEntryRealizer := | |
| polynomial_composition polynomial_context CellMaximumProgram.polynomial_maximum | |
| def columns (z : RowInput) : List ℕ := List.range z.1.1.2.length | |
| def columnsRealizer : Realizer columns := | |
| composition (composition (composition (composition first first) second) listLength) range | |
| lemma polynomial_columns : PolynomialTime columnsRealizer := by | |
| apply polynomial_boundedRange | |
| (polynomial_composition (polynomial_composition | |
| (polynomial_composition polynomial_first polynomial_first) polynomial_second) | |
| polynomial_listLength) X | |
| intro z | |
| simpa only [Function.comp_apply,eval_X] using | |
| (list_length_le_weight z.1.1.2).trans | |
| ((weight_snd z.1.1).trans ((weight_fst z.1).trans (weight_fst z))) | |
| def lowerRow (z : RowInput) : List ℕ := (columns z).map (fun j => lowerEntry (z,j)) | |
| def lowerRowRealizer : Realizer lowerRow := | |
| composition (pair identity columnsRealizer) (mapWith lowerEntryRealizer) | |
| lemma polynomial_lowerRow : PolynomialTime lowerRowRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity polynomial_columns) | |
| (polynomial_mapWith polynomial_lowerEntry) | |
| def upperRow (z : RowInput) : List ℕ := (columns z).map (fun j => upperEntry (z,j)) | |
| def upperRowRealizer : Realizer upperRow := | |
| composition (pair identity columnsRealizer) (mapWith upperEntryRealizer) | |
| lemma polynomial_upperRow : PolynomialTime upperRowRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity polynomial_columns) | |
| (polynomial_mapWith polynomial_upperEntry) | |
| def rows (z : Input) : List ℕ := List.range z.1.1.length | |
| def rowsRealizer : Realizer rows := | |
| composition (composition (composition first first) listLength) range | |
| lemma polynomial_rows : PolynomialTime rowsRealizer := by | |
| apply polynomial_boundedRange | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| polynomial_listLength) X | |
| intro z | |
| simpa only [Function.comp_apply,eval_X] using | |
| (list_length_le_weight z.1.1).trans ((weight_fst z.1).trans (weight_fst z)) | |
| def lowerMatrix (z : Input) : NatMatrix := (rows z).map (fun i => lowerRow (z,i)) | |
| def lowerMatrixRealizer : Realizer lowerMatrix := | |
| composition (pair identity rowsRealizer) (mapWith lowerRowRealizer) | |
| lemma polynomial_lowerMatrix : PolynomialTime lowerMatrixRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity polynomial_rows) | |
| (polynomial_mapWith polynomial_lowerRow) | |
| def upperMatrix (z : Input) : NatMatrix := (rows z).map (fun i => upperRow (z,i)) | |
| def upperMatrixRealizer : Realizer upperMatrix := | |
| composition (pair identity rowsRealizer) (mapWith upperRowRealizer) | |
| lemma polynomial_upperMatrix : PolynomialTime upperMatrixRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity polynomial_rows) | |
| (polynomial_mapWith polynomial_upperRow) | |
| def endpoints (z : Input) : NatMatrix × NatMatrix := (lowerMatrix z,upperMatrix z) | |
| def endpointsRealizer : Realizer endpoints := pair lowerMatrixRealizer upperMatrixRealizer | |
| lemma polynomial_endpoints : PolynomialTime endpointsRealizer := | |
| polynomial_pair polynomial_lowerMatrix polynomial_upperMatrix | |
| lemma lowerMatrix_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) : | |
| lowerMatrix (NetworkVertexCode.data r c b) = natCode (fun (i : Fin m) (j : Fin n) => | |
| CellMinimumProgram.minimum (NetworkVertexCode.data r c b,(i.val,j.val))) := by | |
| simp only [lowerMatrix,rows,NetworkVertexCode.data,List.length_ofFn, | |
| DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn,natCode] | |
| apply congrArg List.ofFn | |
| funext i | |
| dsimp only [Function.comp_apply] | |
| simp only [lowerRow,columns,List.length_ofFn,DirectedBFSCode.range_eq_map, | |
| ←List.ofFn_eq_map,List.map_ofFn] | |
| rfl | |
| lemma upperMatrix_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) : | |
| upperMatrix (NetworkVertexCode.data r c b) = natCode (fun (i : Fin m) (j : Fin n) => | |
| CellMaximumProgram.maximum (NetworkVertexCode.data r c b,(i.val,j.val))) := by | |
| simp only [upperMatrix,rows,NetworkVertexCode.data,List.length_ofFn, | |
| DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn,natCode] | |
| apply congrArg List.ofFn | |
| funext i | |
| dsimp only [Function.comp_apply] | |
| simp only [upperRow,columns,List.length_ofFn,DirectedBFSCode.range_eq_map, | |
| ←List.ofFn_eq_map,List.map_ofFn] | |
| rfl | |
| end ContingencyTables.EndpointMatrixProgram | |
| end OAI | |