| import OAI.Computability.LoopMatching.BinaryMultiply |
| import OAI.Computability.LoopMatching.InputMachine |
| import OAI.Computability.LoopMatching.Accumulator |
|
|
| namespace OAI |
|
|
| /-! Polynomial-time approximation of weighted matchings with singleton loops. -/ |
|
|
| namespace LoopMatching.RawAccumulator |
| open BinaryMatching.StackCode Polynomial |
|
|
| abbrev Data := InputMachine.Data |
| abbrev State := Data × (ℕ × (List Bool × List Bool)) |
|
|
| def step (s : State) : State := |
| (s.1,(s.2.1+1, |
| (SmallBinaryMultiply.horner ((s.2.1+1,s.2.2.1),InputMachine.call s.1 (s.2.1+1)), |
| SmallBinaryMultiply.mul (s.2.1+1,s.2.2.2)))) |
|
|
| def initial (z : Data) : State := (z,(0,(InputMachine.call z 0,[true]))) |
| def rawAccumulator (z : Data) : List Bool × List Bool := |
| (step^[z.1] (initial z)).2.2 |
|
|
| def term (z : Data) (j : ℕ) : ℕ := BitAdd.value (InputMachine.call z j) |
|
|
| @[fun_prop] theorem step_poly : Poly step := by |
| unfold step |
| fun_prop |
|
|
| @[fun_prop] theorem initial_poly : Poly initial := by |
| unfold initial |
| fun_prop |
|
|
| lemma orbit_context (z : Data) (k : ℕ) : (step^[k] (initial z)).1 = z := by |
| induction k with |
| | zero => rfl |
| | succ k ih => simpa only [Function.iterate_succ_apply', step] using ih |
|
|
| lemma orbit_index (z : Data) (k : ℕ) : (step^[k] (initial z)).2.1 = k := by |
| induction k with |
| | zero => rfl |
| | succ k ih => simp only [Function.iterate_succ_apply', step, ih] |
|
|
| lemma orbit_values (z : Data) (k : ℕ) : |
| BitAdd.value (step^[k] (initial z)).2.2.1 = Accumulator.Q (term z) k ∧ |
| BitAdd.value (step^[k] (initial z)).2.2.2 = k.factorial := by |
| induction k with |
| | zero => simp [initial, Accumulator.Q, term, BitAdd.value] |
| | succ k ih => |
| constructor <;> simp only [Function.iterate_succ_apply', step, orbit_context, orbit_index, |
| SmallBinaryMultiply.value_horner, SmallBinaryMultiply.value_mul, |
| ih.1, ih.2, Accumulator.Q_succ, Nat.factorial_succ, term] |
|
|
| lemma orbit_lengths (z : Data) (M k : ℕ) (hk : k ≤ z.1) |
| (hcall : ∀ j ≤ z.1, (InputMachine.call z j).length ≤ M) : |
| (step^[k] (initial z)).2.2.1.length ≤ M+k*(z.1+2) ∧ |
| (step^[k] (initial z)).2.2.2.length ≤ 1+k*(z.1+1) := by |
| induction k with |
| | zero => |
| constructor |
| · simpa only [Function.iterate_zero_apply, initial, Nat.zero_mul, |
| Nat.add_zero] using hcall 0 (by omega) |
| · simp [initial] |
| | succ k ih => |
| obtain ⟨hq,hd⟩ := ih (by omega) |
| have hc := hcall (k+1) hk |
| have hq' := SmallBinaryMultiply.length_horner |
| ((k+1,(step^[k] (initial z)).2.2.1),InputMachine.call z (k+1)) |
| have hd' := SmallBinaryMultiply.length_mul (k+1,(step^[k] (initial z)).2.2.2) |
| have hm : max (step^[k] (initial z)).2.2.1.length |
| (InputMachine.call z (k+1)).length ≤ M+k*(z.1+2) := |
| max_le hq (by omega) |
| simp only [Function.iterate_succ_apply', step, orbit_context, orbit_index] |
| constructor <;> nlinarith |
|
|
| noncomputable def callBound : Polynomial ℕ := |
| (X + InputMachine.call_poly.routine.time).comp (3*X+1) |
|
|
| lemma call_length_bound (z : Data) (N j : ℕ) |
| (hz : (encode z).length ≤ N) (hj : j ≤ N) : |
| (InputMachine.call z j).length ≤ callBound.eval N := by |
| have hin : (encode (z,j)).length ≤ 3*N+1 := by |
| rw [code_pair_length, code_nat_length] |
| change 2*(encode z).length+j+1 ≤ 3*N+1 |
| omega |
| have ho := InputMachine.call_poly.routine.length_bound (z,j) |
| change (encode (InputMachine.call z j)).length ≤ (encode (z,j)).length + |
| InputMachine.call_poly.routine.time.eval (encode (z,j)).length at ho |
| have hm := polynomial_eval_mono InputMachine.call_poly.routine.time hin |
| change InputMachine.call_poly.routine.time.eval (encode (z,j)).length ≤ |
| InputMachine.call_poly.routine.time.eval (3*N+1) at hm |
| rw [BitAdd.boolList_code_length] at ho |
| simp only [callBound, Polynomial.eval_comp, Polynomial.eval_add, |
| Polynomial.eval_X, Polynomial.eval_mul, Polynomial.eval_ofNat, |
| Polynomial.eval_one] |
| omega |
|
|
| lemma state_code_length (s : State) : |
| (encode s).length = 2*(encode s.1).length + 2*s.2.1 + |
| 6*s.2.2.1.length + 3*s.2.2.2.length + 3 := by |
| simp only [code_pair_length, code_nat_length, BitAdd.boolList_code_length] |
| omega |
|
|
| noncomputable def orbitBound : Polynomial ℕ := 20*(callBound+(X+1)^2+1) |
|
|
| lemma orbit_bound (z : Data) (k : ℕ) (hk : k ≤ z.1) : |
| (encode (step^[k] (initial z))).length ≤ |
| orbitBound.eval (encode (z.1,initial z)).length := by |
| let N := (encode (z.1,initial z)).length |
| have hz : (encode z).length ≤ N := by |
| simp only [N, initial, code_pair_length, code_nat_length] |
| omega |
| have hn : z.1 ≤ N := by |
| simp only [N, code_pair_length, code_nat_length] |
| omega |
| have hc : ∀ j ≤ z.1, (InputMachine.call z j).length ≤ callBound.eval N := by |
| intro j hj |
| exact call_length_bound z N j hz (hj.trans hn) |
| obtain ⟨hq,hd⟩ := orbit_lengths z (callBound.eval N) k hk hc |
| have hkN := hk.trans hn |
| have hqmul : k*(z.1+2) ≤ N*(N+2) := Nat.mul_le_mul hkN (by omega) |
| have hdmul : k*(z.1+1) ≤ N*(N+1) := Nat.mul_le_mul hkN (by omega) |
| rw [state_code_length, orbit_context, orbit_index] |
| change 2*(encode z).length + 2*k + 6*(step^[k] (initial z)).2.2.1.length + |
| 3*(step^[k] (initial z)).2.2.2.length + 3 ≤ orbitBound.eval N |
| simp only [orbitBound, Polynomial.eval_mul, Polynomial.eval_ofNat, |
| Polynomial.eval_add, Polynomial.eval_pow, Polynomial.eval_X, Polynomial.eval_one] |
| nlinarith |
|
|
| @[fun_prop] theorem orbit_poly : Poly (fun z : Data => step^[z.1] (initial z)) := by |
| exact Poly.iterateFrom step step_poly Prod.fst initial (by fun_prop) |
| initial_poly orbitBound orbit_bound |
|
|
| @[fun_prop] theorem rawAccumulator_poly : Poly rawAccumulator := by |
| unfold rawAccumulator |
| fun_prop |
|
|
| theorem rawAccumulator_values (z : Data) : |
| BitAdd.value (rawAccumulator z).1 = Accumulator.Q (term z) z.1 ∧ |
| BitAdd.value (rawAccumulator z).2 = z.1.factorial := orbit_values z z.1 |
|
|
| lemma term_repr (G : LoopMatching.Input) (j : ℕ) : |
| term (InputMachine.repr G) j = |
| BinaryMatching.Raw.InputData.sparseEstimate (expand G j) := by |
| rw [term, InputMachine.call_repr, BitAdd.value_bits] |
|
|
| theorem rawAccumulator_repr (G : LoopMatching.Input) : |
| BitAdd.value (rawAccumulator (InputMachine.repr G)).1 = |
| Accumulator.Q (fun j => BinaryMatching.Raw.InputData.sparseEstimate (expand G j)) G.n ∧ |
| BitAdd.value (rawAccumulator (InputMachine.repr G)).2 = G.n.factorial := by |
| have ht : term (InputMachine.repr G) = |
| fun j => BinaryMatching.Raw.InputData.sparseEstimate (expand G j) := |
| funext (term_repr G) |
| have hv := rawAccumulator_values (InputMachine.repr G) |
| rw [ht] at hv |
| exact hv |
|
|
| end LoopMatching.RawAccumulator |
|
|
| end OAI |
|
|
