| import OAI.Computability.LoopMatching.InputMachine |
|
|
| namespace OAI |
|
|
| /-! Polynomial-time approximation of weighted matchings with singleton loops. -/ |
|
|
| namespace LoopMatching.InputMachine |
| open BinaryMatching BinaryMatching.StackCode |
|
|
| abbrev LoopBits := List Bool × List Bool |
| abbrev BitsData := List Bool × (List Parse.RecordBits × List LoopBits) |
|
|
| def loopBitsRepr (r : LoopRecord) : LoopBits := (r.vertex.bits,r.multiplicity.bits) |
| def bitsRepr (G : LoopMatching.Input) : BitsData := |
| (G.n.bits,(G.ordinary.records.map Parse.recordRepr,G.loops.map loopBitsRepr)) |
|
|
| def supportBound (z : BitsData) : ℕ := 2*z.2.1.length+z.2.2.length |
|
|
| def decodeLoop (b : ℕ) (r : LoopBits) : LoopData := (Parse.boundedValue b r.1,r.2) |
|
|
| def decode (z : BitsData) : Data := |
| let b := supportBound z+1 |
| (Parse.boundedValue b z.1, |
| (z.2.1.map (Raw.InputData.decodeRecord b),z.2.2.map (decodeLoop b))) |
|
|
| @[fun_prop] theorem decodeLoop_poly : Poly (fun z : ℕ × LoopBits => decodeLoop z.1 z.2) := by |
| unfold decodeLoop |
| fun_prop |
|
|
| @[fun_prop] theorem decode_poly : Poly decode := by |
| have hr := Poly.mapWith (fun z : BitsData => z.2.1) |
| (fun z : BitsData × Parse.RecordBits => Raw.InputData.decodeRecord (supportBound z.1+1) z.2) |
| (by fun_prop) (by unfold supportBound; fun_prop) |
| have hs := Poly.mapWith (fun z : BitsData => z.2.2) |
| (fun z : BitsData × LoopBits => decodeLoop (supportBound z.1+1) z.2) |
| (by fun_prop) (by unfold supportBound; fun_prop) |
| have hn : Poly (fun z : BitsData => Parse.boundedValue (supportBound z+1) z.1) := by |
| unfold supportBound |
| fun_prop |
| exact Poly.pair _ _ hn (Poly.pair _ _ hr hs) |
|
|
| lemma supportBound_repr (G : LoopMatching.Input) : |
| supportBound (bitsRepr G) = 2*G.ordinary.records.length+G.loops.length := by |
| simp [supportBound,bitsRepr] |
|
|
| lemma decode_n_repr (G : LoopMatching.Input) : |
| (decode (bitsRepr G)).1 = min (2*G.ordinary.records.length+G.loops.length+1) G.n := by |
| simp [decode,bitsRepr,supportBound,Parse.boundedValue_bits] |
|
|
| lemma decode_lengths (z : BitsData) : |
| (decode z).2.1.length=z.2.1.length ∧ (decode z).2.2.length=z.2.2.length := by |
| simp [decode] |
|
|
| lemma decode_repr (G : LoopMatching.Input) |
| (hn : G.n ≤ 2*G.ordinary.records.length+G.loops.length) : |
| decode (bitsRepr G)=repr G := by |
| let b := 2*G.ordinary.records.length+G.loops.length+1 |
| have hb : G.n ≤ b := by dsimp [b]; omega |
| have hr : (G.ordinary.records.map Parse.recordRepr).map (Raw.InputData.decodeRecord b) = |
| G.ordinary.records.map Raw.InputData.repr := by |
| rw [List.map_map] |
| apply List.map_congr_left |
| intro r hr |
| exact Raw.InputData.decodeRecord_repr G.ordinary b hb r hr |
| have hs : (G.loops.map loopBitsRepr).map (decodeLoop b)=G.loops.map loopRepr := by |
| rw [List.map_map] |
| apply List.map_congr_left |
| intro r hr |
| have hv := G.valid r hr |
| change r.vertex < G.n at hv |
| simp only [Function.comp_def,decodeLoop,loopBitsRepr,loopRepr,Parse.boundedValue_bits] |
| rw [min_eq_right (by omega : r.vertex ≤ b)] |
| unfold decode |
| rw [supportBound_repr] |
| change (Parse.boundedValue b G.n.bits, |
| ((G.ordinary.records.map Parse.recordRepr).map (Raw.InputData.decodeRecord b), |
| (G.loops.map loopBitsRepr).map (decodeLoop b))) = _ |
| rw [Parse.boundedValue_bits,min_eq_right hb,hr,hs] |
| rfl |
|
|
| lemma sparse_guard_repr (G : LoopMatching.Input) : |
| (2*(decode (bitsRepr G)).2.1.length+(decode (bitsRepr G)).2.2.length < |
| (decode (bitsRepr G)).1) ↔ |
| 2*G.ordinary.records.length+G.loops.length < G.n := by |
| rw [decode_n_repr] |
| simp only [decode,bitsRepr,List.length_map] |
| omega |
|
|
| end LoopMatching.InputMachine |
|
|
| end OAI |
|
|
