File size: 3,228 Bytes
ea76aac | 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 | import OAI.Computability.LoopMatching.ExpandInput
import OAI.Computability.MatchingCount.BinarySolve
namespace OAI
/-! Polynomial-time approximation of weighted matchings with singleton loops. -/
namespace LoopMatching.InputMachine
open BinaryMatching BinaryMatching.StackCode
abbrev LoopData := ℕ × List Bool
abbrev Data := ℕ × (List Raw.InputData.Rec × List LoopData)
def loopRepr (r : LoopRecord) : LoopData := (r.vertex,r.multiplicity.bits)
def repr (G : LoopMatching.Input) : Data :=
(G.n,(G.ordinary.records.map Raw.InputData.repr,G.loops.map loopRepr))
def crossBlock (n j : ℕ) (r : LoopData) : List Raw.InputData.Rec :=
(List.range j).map (fun d => (r.1,(n+d,r.2)))
def cross (n j : ℕ) (rs : List LoopData) : List Raw.InputData.Rec :=
rs.flatMap (crossBlock n j)
def expanded (z : Data) (j : ℕ) : Raw.InputData.Data :=
(z.1+j,z.2.1 ++ cross z.1 j z.2.2)
@[fun_prop] theorem crossBlock_poly :
Poly (fun z : (ℕ × ℕ) × LoopData => crossBlock z.1.1 z.1.2 z.2) := by
exact Poly.mapWith (fun z : (ℕ × ℕ) × LoopData => List.range z.1.2)
(fun z : ((ℕ × ℕ) × LoopData) × ℕ =>
(z.1.2.1,(z.1.1.1+z.2,z.1.2.2))) (by fun_prop) (by fun_prop)
@[fun_prop] theorem cross_poly :
Poly (fun z : (ℕ × ℕ) × List LoopData => cross z.1.1 z.1.2 z.2) := by
apply Poly.flatMapWith (fun z : (ℕ × ℕ) × List LoopData => z.2)
(fun z : ((ℕ × ℕ) × List LoopData) × LoopData =>
crossBlock z.1.1.1 z.1.1.2 z.2) (by fun_prop)
exact Poly.comp _ (fun z : ((ℕ × ℕ) × List LoopData) × LoopData =>
(z.1.1,z.2)) crossBlock_poly (by fun_prop)
@[fun_prop] theorem expanded_poly : Poly (fun z : Data × ℕ => expanded z.1 z.2) := by
have hc : Poly (fun z : Data × ℕ => cross z.1.1 z.2 z.1.2.2) :=
Poly.comp _ (fun z : Data × ℕ => ((z.1.1,z.2),z.1.2.2)) cross_poly (by fun_prop)
unfold expanded
fun_prop
lemma cross_repr (n j : ℕ) (rs : List LoopRecord) :
cross n j (rs.map loopRepr) = (crossRecords n j rs).map Raw.InputData.repr := by
induction rs with
| nil => rfl
| cons r rs ih =>
simp only [List.map_cons, cross, List.flatMap_cons, crossRecords, List.map_append]
rw [← cross, ih]
simp only [crossBlock, List.map_map]
rfl
lemma expanded_repr (G : LoopMatching.Input) (j : ℕ) :
expanded (repr G) j = ((expand G j).n,(expand G j).records.map Raw.InputData.repr) := by
simp only [expanded, repr, cross_repr, expand, List.map_append]
def call (z : Data) (j : ℕ) : List Bool := Raw.InputData.solve (expanded z j)
@[fun_prop] theorem call_poly : Poly (fun z : Data × ℕ => call z.1 z.2) :=
Poly.comp Raw.InputData.solve _ Raw.InputData.solve_poly expanded_poly
lemma solve_repr (G : BinaryMatching.Input) :
Raw.InputData.solve (G.n,G.records.map Raw.InputData.repr) =
(Raw.InputData.sparseEstimate G).bits := by
unfold Raw.InputData.solve Raw.InputData.sparseEstimate
simp only [List.length_map]
split_ifs
· rfl
· exact Raw.InputData.smallSolve_repr G
lemma call_repr (G : LoopMatching.Input) (j : ℕ) :
call (repr G) j = (Raw.InputData.sparseEstimate (expand G j)).bits := by
rw [call, expanded_repr, solve_repr]
end LoopMatching.InputMachine
end OAI
|