File size: 4,447 Bytes
d5b7741 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | import OAI.Combinatorics.ContingencyTables.Rooted.RootedComponentSemantics
import OAI.Combinatorics.ContingencyTables.Transport.FiniteGraphRootSemantics
namespace OAI
/-! # Computing every root label before summing its signed demand
The input contains an adjacency list and one positive/negative demand
pair per vertex. The polynomial program computes the root labels itself.
-/
namespace ContingencyTables.RootedComponentCode
open MatchingFPRAS.TreeTyped Polynomial
open RootedCompletion RootedComponentProgram FiniteGraphRootProgram
open scoped BigOperators Classical
abbrev Input := GraphCode×List (ℕ×ℕ)
def entry (z : Input×ℕ) : Record :=
(rootCode (z.1.1,z.2),z.1.2.getD z.2 (0,0))
def entryRealizer : Realizer entry :=
pair (composition (pair (composition first first) second) rootCodeRealizer)
(composition (pair (composition first second) second) (getDFast (0,0)))
lemma polynomial_entry : PolynomialTime entryRealizer :=
polynomial_pair
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first) polynomial_second)
polynomial_rootCode)
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_second) polynomial_second)
(polynomial_getDFast (0,0)))
def labels (z : Input) : List Record :=
(List.range z.2.length).map (fun i => entry (z,i))
def indicesRealizer : Realizer (fun z : Input => List.range z.2.length) :=
composition (composition second listLength) range
lemma polynomial_indices : PolynomialTime indicesRealizer := by
apply polynomial_boundedRange (polynomial_composition polynomial_second polynomial_listLength) X
intro z
simpa only [Function.comp_apply,eval_X] using
(list_length_le_weight z.2).trans (weight_snd z)
def labelsRealizer : Realizer labels :=
composition (pair identity indicesRealizer) (mapWith entryRealizer)
lemma polynomial_labels : PolynomialTime labelsRealizer :=
polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
(polynomial_mapWith polynomial_entry)
def count (z : Input) : ℕ := total (labels z)
def countRealizer : Realizer count := composition labelsRealizer totalRealizer
theorem polynomial_count : PolynomialTime countRealizer :=
polynomial_composition polynomial_labels polynomial_total
lemma labels_graph {n : ℕ} (G : SimpleGraph (Fin n)) [DecidableRel G.Adj]
(p q : Fin n → ℕ) :
labels (FiniteGraphRootProgram.graphCode G,List.ofFn (fun i => (p i,q i)))=
records (FiniteGraphRoots.root G) p q := by
apply List.ext_getElem
· simp only [labels,List.length_map,List.length_range,List.length_ofFn,records]
· intro i hi hj
have hin : i<n := by
simpa only [records,List.length_ofFn] using hj
simp only [labels,List.getElem_map,List.getElem_range,entry,records,List.getElem_ofFn]
rw [FiniteGraphRootProgram.rootCode_eq G ⟨i,hin⟩]
simp only [List.getD_eq_getElem?_getD,List.getElem?_ofFn,hin,dite_true,Option.getD_some]
theorem count_graph {n : ℕ} (G : SimpleGraph (Fin n)) [DecidableRel G.Adj]
(p q : Fin n → ℕ) :
count (FiniteGraphRootProgram.graphCode G,List.ofFn (fun i => (p i,q i)))=
∑ a,(∑ i,if FiniteGraphRoots.root G i=a then (p i:ℤ)-q i else 0).natAbs := by
rw [count,labels_graph,total_records]
open CompanionFactorialApplication
/-- The binary root computation produces the actual penalty metadata
for the canonical row-then-column root convention. -/
theorem count_instance {m n : ℕ} (A : Instance (Fin m) (Fin n)) (z : View A → ℕ) :
count (FiniteGraphRootProgram.graphCode (A.T.comap finSumFinEquiv.symm),
List.ofFn (fun i : Fin (m+n) =>
(positiveDemand A z (finSumFinEquiv.symm i),
negativeDemand A z (finSumFinEquiv.symm i))))=
RootedPenaltyProgram.rootCount A (rowColumn A.T)
(ForestScaledPenalty.rowCounts A z) (ForestScaledPenalty.columnCounts A z) := by
rw [count,labels_graph]
have hh := total_records_rootCount A (rowColumn A.T)
(ForestScaledPenalty.rowCounts A z) (ForestScaledPenalty.columnCounts A z)
finSumFinEquiv.symm
(fun i => positiveDemand A z (finSumFinEquiv.symm i))
(fun i => negativeDemand A z (finSumFinEquiv.symm i))
(fun i => naturalDemand_eq A z (finSumFinEquiv.symm i))
simpa only [rowColumn_root,Equiv.apply_symm_apply,Equiv.symm_apply_apply] using hh
end ContingencyTables.RootedComponentCode
end OAI
|