File size: 7,063 Bytes
97c3405 | 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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | import OAI.Combinatorics.ContingencyTables.Transport.FiniteGraphRootSemantics
import OAI.Combinatorics.ContingencyTables.Rooted.RootedCut
namespace OAI
/-! # Executing the selected root-away cut
Deletion filters the stored adjacency rows. The endpoint and cut side
are then computed by the bounded reachability program.
-/
namespace ContingencyTables.FiniteGraphCutProgram
open MatchingFPRAS.TreeTyped Polynomial FiniteGraphRootProgram
abbrev EdgeInput := GraphCode×(ℕ×ℕ)
abbrev KeepInput := ((ℕ×ℕ)×ℕ)×ℕ
def keep (z : KeepInput) : Bool :=
if z.1.2=z.1.1.1 then decide (z.2≠z.1.1.2)
else if z.1.2=z.1.1.2 then decide (z.2≠z.1.1.1) else true
def keepRealizer : Realizer keep := by
let I : Realizer (fun z : KeepInput => z.1.2) := composition first second
let U : Realizer (fun z : KeepInput => z.1.1.1) := composition (composition first first) first
let V : Realizer (fun z : KeepInput => z.1.1.2) := composition (composition first first) second
let neqU := composition (composition (pair second U) natEqual) boolNot
let neqV := composition (composition (pair second V) natEqual) boolNot
exact (choose (composition (pair I U) natEqual) neqV
(choose (composition (pair I V) natEqual) neqU (constant true))).congr (by
intro z
simp [keep])
lemma polynomial_keep : PolynomialTime keepRealizer := by
unfold keepRealizer
have hi : PolynomialTime (composition (first (A := (ℕ×ℕ)×ℕ) (B := ℕ)) second) :=
polynomial_composition polynomial_first polynomial_second
have hu : PolynomialTime (composition
(composition (first (A := (ℕ×ℕ)×ℕ) (B := ℕ)) first) first) :=
polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first
have hv : PolynomialTime (composition
(composition (first (A := (ℕ×ℕ)×ℕ) (B := ℕ)) first) second) :=
polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second
exact polynomial_congr _ (polynomial_choose
(polynomial_composition (polynomial_pair hi hu) polynomial_natEqual)
(polynomial_composition (polynomial_composition (polynomial_pair polynomial_second hv)
polynomial_natEqual) polynomial_boolNot)
(polynomial_choose (polynomial_composition (polynomial_pair hi hv) polynomial_natEqual)
(polynomial_composition (polynomial_composition (polynomial_pair polynomial_second hu)
polynomial_natEqual) polynomial_boolNot) (polynomial_constant true)))
def deleteRow (z : EdgeInput×ℕ) : List ℕ :=
(z.1.1.getD z.2 []).filter (fun a => keep ((z.1.2,z.2),a))
def deleteRowRealizer : Realizer deleteRow :=
composition (f := fun z : EdgeInput×ℕ =>
((z.1.2,z.2),z.1.1.getD z.2 []))
(g := fun z : ((ℕ×ℕ)×ℕ)×List ℕ => z.2.filter (fun a => keep (z.1,a)))
(pair (pair (composition first second) second)
(composition (pair (composition first first) second) (getDFast [])))
(filterWith keepRealizer)
lemma polynomial_deleteRow : PolynomialTime deleteRowRealizer :=
polynomial_composition (polynomial_pair
(polynomial_pair (polynomial_composition polynomial_first polynomial_second) polynomial_second)
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first) polynomial_second)
(polynomial_getDFast []))) (polynomial_filterWith polynomial_keep)
def deleteGraph (z : EdgeInput) : GraphCode :=
(indices z.1).map (fun i => deleteRow (z,i))
def deleteGraphRealizer : Realizer deleteGraph :=
composition (pair identity (composition first indicesRealizer)) (mapWith deleteRowRealizer)
theorem polynomial_deleteGraph : PolynomialTime deleteGraphRealizer :=
polynomial_composition (polynomial_pair polynomial_identity
(polynomial_composition polynomial_first polynomial_indices))
(polynomial_mapWith polynomial_deleteRow)
def reachableCode (z : Input×ℕ) : Bool := decide (z.2∈reached z.1)
def reachableCodeRealizer : Realizer reachableCode :=
composition (pair (composition first reachedRealizer) second) membership
lemma polynomial_reachableCode : PolynomialTime reachableCodeRealizer :=
polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_reached) polynomial_second)
polynomial_membership
abbrev CutInput := EdgeInput×ℕ
def awayCode (z : CutInput) : ℕ :=
if reachableCode ((deleteGraph z.1,z.1.2.1),z.2) then z.1.2.2 else z.1.2.1
def awayTestRealizer : Realizer (fun z : CutInput =>
reachableCode ((deleteGraph z.1,z.1.2.1),z.2)) :=
composition (pair (pair (composition first deleteGraphRealizer)
(composition (composition first second) first)) second) reachableCodeRealizer
lemma polynomial_awayTest : PolynomialTime awayTestRealizer :=
polynomial_composition (polynomial_pair
(polynomial_pair (polynomial_composition polynomial_first polynomial_deleteGraph)
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_first)) polynomial_second) polynomial_reachableCode
def awayCodeRealizer : Realizer awayCode :=
choose awayTestRealizer (composition (composition first second) second)
(composition (composition first second) first)
lemma polynomial_awayCode : PolynomialTime awayCodeRealizer :=
polynomial_choose polynomial_awayTest
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_second)
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_first)
def cutCode (z : CutInput×ℕ) : Bool :=
reachableCode ((deleteGraph z.1.1,awayCode z.1),z.2)
def cutCodeRealizer : Realizer cutCode :=
composition (pair (pair
(composition (composition first first) deleteGraphRealizer)
(composition first awayCodeRealizer)) second) reachableCodeRealizer
theorem polynomial_cutCode : PolynomialTime cutCodeRealizer :=
polynomial_composition (polynomial_pair (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_first)
polynomial_deleteGraph)
(polynomial_composition polynomial_first polynomial_awayCode)) polynomial_second)
polynomial_reachableCode
def canonicalCutCode (z : EdgeInput×ℕ) : Bool :=
cutCode ((z.1,rootCode (z.1.1,z.1.2.1)),z.2)
def canonicalCutCodeRealizer : Realizer canonicalCutCode :=
composition (pair (pair first
(composition (pair (composition first first)
(composition (composition first second) first)) rootCodeRealizer)) second)
cutCodeRealizer
theorem polynomial_canonicalCutCode : PolynomialTime canonicalCutCodeRealizer :=
polynomial_composition (polynomial_pair (polynomial_pair polynomial_first
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first)
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_first)) polynomial_rootCode)) polynomial_second) polynomial_cutCode
end ContingencyTables.FiniteGraphCutProgram
end OAI
|