File size: 5,754 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 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 | import OAI.Computability.LoopMatching.Accumulator
import OAI.Computability.LoopMatching.CountDecomposition
import OAI.Computability.LoopMatching.ExpandInput
import OAI.Computability.MatchingCount.BinarySolve
namespace OAI
/-! Polynomial-time approximation of weighted matchings with singleton loops. -/
namespace LoopMatching
open scoped BigOperators
namespace Approximation
def term (G : Input) (j : ℕ) : ℕ :=
BinaryMatching.Raw.InputData.sparseEstimate (expand G j)
def output (G : Input) : ℕ × ℕ :=
(Accumulator.Q (term G) G.n, G.n.factorial)
theorem term_bounds (G : Input) (j : ℕ) :
term G j ≤ BinaryMatching.count (expand G j) ∧
BinaryMatching.count (expand G j) ≤ 2 ^ (9 * (G.n + j)) * term G j ∧
(term G j = 0 ↔ BinaryMatching.count (expand G j) = 0) := by
simpa only [term, expand_n] using
BinaryMatching.Raw.InputData.sparseEstimate_correct (expand G j)
theorem output_den_pos (G : Input) : 0 < (output G).2 := Nat.factorial_pos _
theorem output_value (G : Input) :
outputValue (output G) =
∑ j ∈ Finset.range (G.n + 1), (term G j : ℚ) / (j.factorial : ℚ) :=
Accumulator.quotient_eq_sum (term G) G.n
theorem factorial_profile_bounds (a b : ℕ → ℕ) (C n : ℕ)
(hlo : ∀ j ≤ n, a j ≤ j.factorial * b j)
(hhi : ∀ j ≤ n, j.factorial * b j ≤ C * a j) :
Accumulator.Q a n ≤ n.factorial * (∑ j ∈ Finset.range (n + 1), b j) ∧
n.factorial * (∑ j ∈ Finset.range (n + 1), b j) ≤ C * Accumulator.Q a n := by
revert hlo hhi
induction n with
| zero =>
intro hlo hhi
simpa using And.intro (hlo 0 (by omega)) (hhi 0 (by omega))
| succ n ih =>
intro hlo hhi
obtain ⟨hl, hu⟩ := ih (fun j hj => hlo j (by omega))
(fun j hj => hhi j (by omega))
have hlastlo := hlo (n + 1) (by omega)
have hlasthi := hhi (n + 1) (by omega)
rw [Accumulator.Q_succ, Finset.sum_range_succ]
constructor
· calc
(n + 1) * Accumulator.Q a n + a (n + 1) ≤
(n + 1) * (n.factorial * (∑ j ∈ Finset.range (n + 1), b j)) +
(n + 1).factorial * b (n + 1) :=
Nat.add_le_add (Nat.mul_le_mul_left _ hl) hlastlo
_ = (n + 1).factorial *
((∑ j ∈ Finset.range (n + 1), b j) + b (n + 1)) := by
rw [Nat.factorial_succ]; ring
· calc
(n + 1).factorial *
((∑ j ∈ Finset.range (n + 1), b j) + b (n + 1)) =
(n + 1) * (n.factorial * (∑ j ∈ Finset.range (n + 1), b j)) +
(n + 1).factorial * b (n + 1) := by
rw [Nat.factorial_succ]; ring
_ ≤ (n + 1) * (C * Accumulator.Q a n) + C * a (n + 1) :=
Nat.add_le_add (Nat.mul_le_mul_left _ hu) hlasthi
_ = C * ((n + 1) * Accumulator.Q a n + a (n + 1)) := by ring
theorem output_bounds_of_expanded_count (G : Input)
(expanded_count : ∀ j ≤ G.n,
BinaryMatching.count (expand G j) = j.factorial * countWithLoops G j) :
(output G).1 ≤ (output G).2 * count G ∧
(output G).2 * count G ≤ 2 ^ (18 * G.n) * (output G).1 ∧
((output G).1 = 0 ↔ count G = 0) := by
have hlo : ∀ j ≤ G.n, term G j ≤ j.factorial * countWithLoops G j := by
intro j hj
rw [← expanded_count j hj]
exact (term_bounds G j).1
have hhi : ∀ j ≤ G.n,
j.factorial * countWithLoops G j ≤ 2 ^ (18 * G.n) * term G j := by
intro j hj
rw [← expanded_count j hj]
apply (term_bounds G j).2.1.trans
apply Nat.mul_le_mul_right
apply Nat.pow_le_pow_right (by omega : 1 ≤ (2 : ℕ))
omega
obtain ⟨hl, hu⟩ := factorial_profile_bounds (term G) (countWithLoops G)
(2 ^ (18 * G.n)) G.n hlo hhi
rw [← count_eq_sum_countWithLoops G] at hl hu
change (output G).1 ≤ (output G).2 * count G at hl
change (output G).2 * count G ≤ 2 ^ (18 * G.n) * (output G).1 at hu
refine ⟨hl, hu, ?_⟩
constructor
· intro hz
rw [hz, mul_zero] at hu
have hprod : (output G).2 * count G = 0 := Nat.eq_zero_of_le_zero hu
exact (Nat.mul_eq_zero.mp hprod).resolve_left (Nat.ne_of_gt (output_den_pos G))
· intro hz
rw [hz, mul_zero] at hl
exact Nat.eq_zero_of_le_zero hl
theorem output_magnitude (G : Input) (B : ℕ)
(hB : ∀ j ≤ G.n, term G j ≤ B) :
(output G).1 ≤ (G.n + 1).factorial * B ∧
(output G).2 = G.n.factorial :=
⟨Accumulator.Q_le_factorial_mul (term G) G.n B hB, rfl⟩
private theorem succ_le_two_pow (n : ℕ) : n + 1 ≤ 2 ^ n := by
induction n with
| zero => simp
| succ n ih =>
rw [pow_succ]
have hp : 0 < 2 ^ n := by positivity
omega
theorem factorial_le_two_pow_square (n : ℕ) : n.factorial ≤ 2 ^ (n * n) := by
induction n with
| zero => simp
| succ n ih =>
calc
(n + 1).factorial = (n + 1) * n.factorial := Nat.factorial_succ n
_ ≤ 2 ^ n * 2 ^ (n * n) := Nat.mul_le_mul (succ_le_two_pow n) ih
_ = 2 ^ (n + n * n) := (pow_add 2 n (n * n)).symm
_ ≤ 2 ^ ((n + 1) * (n + 1)) := by
apply Nat.pow_le_pow_right (by omega : 1 ≤ (2 : ℕ))
nlinarith
theorem output_exponential_magnitude (G : Input) (B : ℕ)
(hB : ∀ j ≤ G.n, term G j ≤ 2 ^ B) :
(output G).1 ≤ 2 ^ ((G.n + 1) * (G.n + 1) + B) ∧
(output G).2 ≤ 2 ^ (G.n * G.n) := by
constructor
· calc
(output G).1 ≤ (G.n + 1).factorial * 2 ^ B :=
(output_magnitude G (2 ^ B) hB).1
_ ≤ 2 ^ ((G.n + 1) * (G.n + 1)) * 2 ^ B :=
Nat.mul_le_mul_right _ (factorial_le_two_pow_square (G.n + 1))
_ = 2 ^ ((G.n + 1) * (G.n + 1) + B) := (pow_add _ _ _).symm
· exact factorial_le_two_pow_square G.n
end Approximation
end LoopMatching
end OAI
|