math / data /lean /OAI /Computability /DirectedFeedback /Encoding /InstanceEquivalences.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
32.7 kB
import Mathlib
import OAI.Computability.DirectedFeedback.Machines.RuntimeFinish
namespace OAI
namespace DFVSGames.Integration.InstanceEquivalences
open DFVSGames.Foundations.Target
open GapSemantics
def renameConstraint {n m q : Nat} (e : Fin n ≃ Fin m) (c : Constraint n q) :
Constraint m q where
source := e c.source
target := e c.target
permutation := c.permutation
@[simp] theorem renameConstraint_satisfied {n m q : Nat} (e : Fin n ≃ Fin m)
(c : Constraint n q) (labeling : Fin m β†’ Fin q) :
(renameConstraint e c).satisfied labeling = c.satisfied (labeling ∘ e) := rfl
theorem rename_count {n m q : Nat} (e : Fin n ≃ Fin m)
(constraints : List (Constraint n q)) (labeling : Fin m β†’ Fin q) :
countSatisfied labeling (constraints.map (renameConstraint e)) =
countSatisfied (labeling ∘ e) constraints := by
induction constraints with
| nil => rfl
| cons c cs ih =>
by_cases hc : c.satisfied (labeling ∘ e) = true <;> simp [countSatisfied, ih, hc]
def renameInstance {q m : Nat} (g : Instance q) (e : Fin g.vertices ≃ Fin m) :
Instance q where
vertices := m
constraints := g.constraints.map (renameConstraint e)
nonempty := by
intro h
exact g.nonempty (List.map_eq_nil_iff.mp h)
theorem countSatisfied_perm {n q : Nat} (labeling : Fin n β†’ Fin q)
{constraints constraints' : List (Constraint n q)}
(h : constraints.Perm constraints') :
countSatisfied labeling constraints = countSatisfied labeling constraints' := by
rw [countSatisfied_eq_sum, countSatisfied_eq_sum]
exact (h.map (fun c => if c.satisfied labeling then (1 : Nat) else 0)).sum_eq
theorem satisfactionRate_eq_of_rename_perm {q : Nat} (g h : Instance q)
(e : Fin g.vertices ≃ Fin h.vertices)
(hp : h.constraints.Perm (g.constraints.map (renameConstraint e)))
(labeling : Fin h.vertices β†’ Fin q) :
satisfactionRate h labeling = satisfactionRate g (labeling ∘ e) := by
have hcount := countSatisfied_perm labeling hp
rw [rename_count] at hcount
have hlength := hp.length_eq
simp only [List.length_map] at hlength
unfold satisfactionRate
rw [hcount, hlength]
theorem completeAt_iff_of_rename_perm {q : Nat} (error : RationalError)
(g h : Instance q) (e : Fin g.vertices ≃ Fin h.vertices)
(hp : h.constraints.Perm (g.constraints.map (renameConstraint e))) :
CompleteAt error h ↔ CompleteAt error g := by
rw [completeAt_iff, completeAt_iff]
constructor
· rintro ⟨labeling, hl⟩
refine ⟨labeling ∘ e, ?_⟩
rwa [satisfactionRate_eq_of_rename_perm g h e hp] at hl
· rintro ⟨labeling, hl⟩
refine ⟨labeling ∘ e.symm, ?_⟩
rw [satisfactionRate_eq_of_rename_perm g h e hp]
simpa [Function.comp_def] using hl
theorem soundAt_iff_of_rename_perm {q : Nat} (error : RationalError)
(g h : Instance q) (e : Fin g.vertices ≃ Fin h.vertices)
(hp : h.constraints.Perm (g.constraints.map (renameConstraint e))) :
SoundAt error h ↔ SoundAt error g := by
rw [soundAt_iff, soundAt_iff]
constructor
Β· intro hs labeling
have hl := hs (labeling ∘ e.symm)
rw [satisfactionRate_eq_of_rename_perm g h e hp] at hl
simpa [Function.comp_def] using hl
Β· intro hs labeling
rw [satisfactionRate_eq_of_rename_perm g h e hp]
exact hs (labeling ∘ e)
theorem rename_rate {q m : Nat} (g : Instance q) (e : Fin g.vertices ≃ Fin m)
(labeling : Fin m β†’ Fin q) :
satisfactionRate (renameInstance g e) labeling = satisfactionRate g (labeling ∘ e) :=
satisfactionRate_eq_of_rename_perm g (renameInstance g e) e (.refl _) labeling
theorem completeAt_rename_iff {q m : Nat} (error : RationalError)
(g : Instance q) (e : Fin g.vertices ≃ Fin m) :
CompleteAt error (renameInstance g e) ↔ CompleteAt error g :=
completeAt_iff_of_rename_perm error g (renameInstance g e) e (.refl _)
theorem soundAt_rename_iff {q m : Nat} (error : RationalError)
(g : Instance q) (e : Fin g.vertices ≃ Fin m) :
SoundAt error (renameInstance g e) ↔ SoundAt error g :=
soundAt_iff_of_rename_perm error g (renameInstance g e) e (.refl _)
end DFVSGames.Integration.InstanceEquivalences
namespace DFVSGames.MachineUniformCopyOrder
def occurrenceMajor {Ξ± : Type*} (C : Nat) (edges : List Ξ±) : List Ξ± :=
edges.flatMap (fun edge => List.replicate C edge)
def copyMajor {Ξ± : Type*} (C : Nat) (edges : List Ξ±) : List Ξ± :=
(List.replicate C edges).flatten
theorem occurrenceMajor_perm_copyMajor {Ξ± : Type*} (C : Nat) (edges : List Ξ±) :
(occurrenceMajor C edges).Perm (copyMajor C edges) := by
induction C with
| zero => simp [occurrenceMajor, copyMajor]
| succ C ih =>
have split : (edges ++ occurrenceMajor C edges).Perm
(occurrenceMajor (C + 1) edges) := by
simpa only [occurrenceMajor, List.map_id, List.replicate_succ, id_eq] using
List.map_append_flatMap_perm edges id (fun edge => List.replicate C edge)
simpa only [copyMajor, List.replicate_succ, List.flatten_cons] using
split.symm.trans (ih.append_left edges)
theorem selected_count_eq {Ξ± : Type*} (C : Nat) (edges : List Ξ±)
(keep : Ξ± β†’ Bool) :
((occurrenceMajor C edges).filter keep).length =
((copyMajor C edges).filter keep).length :=
((occurrenceMajor_perm_copyMajor C edges).filter keep).length_eq
theorem mem_iff {Ξ± : Type*} (C : Nat) (edges : List Ξ±) (edge : Ξ±) :
edge ∈ occurrenceMajor C edges ↔ edge ∈ copyMajor C edges :=
(occurrenceMajor_perm_copyMajor C edges).mem_iff
theorem copyMajor_selected_count {Ξ± : Type*} (C : Nat) (edges : List Ξ±)
(keep : Ξ± β†’ Bool) :
((copyMajor C edges).filter keep).length = C * (edges.filter keep).length := by
induction C with
| zero => simp [copyMajor]
| succ C ih =>
change (((edges ++ copyMajor C edges).filter keep).length) = _
rw [List.filter_append, List.length_append, ih]
rw [Nat.add_mul, Nat.one_mul]
omega
theorem occurrenceMajor_selected_count {Ξ± : Type*} (C : Nat) (edges : List Ξ±)
(keep : Ξ± β†’ Bool) :
((occurrenceMajor C edges).filter keep).length = C * (edges.filter keep).length := by
rw [selected_count_eq, copyMajor_selected_count]
theorem encoded_rows_perm {Ξ± Ξ² : Type*} (C : Nat) (edges : List Ξ±)
(encode : Ξ± β†’ List Ξ²) :
((occurrenceMajor C edges).map encode).Perm ((copyMajor C edges).map encode) :=
(occurrenceMajor_perm_copyMajor C edges).map encode
open DFVSGames.Foundations.Target
theorem countSatisfied_eq {n q : Nat} (C : Nat)
(edges : List (Constraint n q)) (labeling : Fin n β†’ Fin q) :
countSatisfied labeling (occurrenceMajor C edges) =
countSatisfied labeling (copyMajor C edges) :=
DFVSGames.Integration.InstanceEquivalences.countSatisfied_perm labeling
(occurrenceMajor_perm_copyMajor C edges)
end DFVSGames.MachineUniformCopyOrder
namespace DFVSGames.Reduction.WeightRounding
def floorMass (D q : Nat) (ps : List Nat) : Nat :=
(ps.map (fun p => D * p / q)).sum
def roundCounts (D q : Nat) : Nat β†’ List Nat β†’ List Nat
| _, [] => []
| 0, p :: ps => (D * p / q) :: roundCounts D q 0 ps
| r + 1, p :: ps => (D * p / q + 1) :: roundCounts D q r ps
def deficit (D q : Nat) (ps : List Nat) : Nat := D - floorMass D q ps
def rounded (D q : Nat) (ps : List Nat) : List Nat :=
roundCounts D q (deficit D q ps) ps
theorem length_roundCounts (D q r : Nat) (ps : List Nat) :
(roundCounts D q r ps).length = ps.length := by
induction ps generalizing r with
| nil => simp [roundCounts]
| cons p ps ih => cases r <;> simp [roundCounts, ih]
theorem sum_roundCounts (D q r : Nat) (ps : List Nat) (hr : r ≀ ps.length) :
(roundCounts D q r ps).sum = floorMass D q ps + r := by
induction ps generalizing r with
| nil =>
have : r = 0 := by simpa using hr
subst r
simp [roundCounts, floorMass]
| cons p ps ih =>
cases r with
| zero => simp [roundCounts, floorMass, ih 0 (Nat.zero_le _)]
| succ r =>
have hr' : r ≀ ps.length := by simpa using hr
simp only [roundCounts, List.sum_cons, ih r hr', floorMass,
List.map_cons, List.sum_cons]
omega
theorem floorMass_mul_le (D q : Nat) (ps : List Nat) :
floorMass D q ps * q ≀ D * ps.sum := by
induction ps with
| nil => simp [floorMass]
| cons p ps ih =>
have hp := Nat.div_mul_le_self (D * p) q
simp only [floorMass, List.map_cons, List.sum_cons, Nat.add_mul,
Nat.mul_add] at *
omega
theorem scaled_sum_lt (D q : Nat) (ps : List Nat) (hq : 0 < q)
(hne : ps β‰  []) :
D * ps.sum < (floorMass D q ps + ps.length) * q := by
induction ps with
| nil => contradiction
| cons p ps ih =>
have hp : D * p < (D * p / q + 1) * q :=
(Nat.div_lt_iff_lt_mul hq).mp (Nat.lt_succ_self _)
cases ps with
| nil => simpa [floorMass] using hp
| cons t ts =>
have ht := ih (by simp)
simp only [floorMass, List.map_cons, List.sum_cons, List.length_cons,
Nat.add_mul, Nat.mul_add, Nat.one_mul] at *
omega
theorem floorMass_le_target (D q : Nat) (ps : List Nat) (hq : 0 < q)
(hmass : ps.sum = q) : floorMass D q ps ≀ D := by
apply Nat.le_of_mul_le_mul_right (c := q) _ hq
simpa [hmass] using floorMass_mul_le D q ps
theorem deficit_lt_length (D q : Nat) (ps : List Nat) (hq : 0 < q)
(hmass : ps.sum = q) : deficit D q ps < ps.length := by
have hne : ps β‰  [] := by intro h; subst ps; simp at hmass; omega
have hlt := scaled_sum_lt D q ps hq hne
rw [hmass] at hlt
have ht := Nat.lt_of_mul_lt_mul_right hlt
have hlo := floorMass_le_target D q ps hq hmass
unfold deficit
omega
theorem sum_rounded (D q : Nat) (ps : List Nat) (hq : 0 < q)
(hmass : ps.sum = q) : (rounded D q ps).sum = D := by
have hr := deficit_lt_length D q ps hq hmass
have hl := floorMass_le_target D q ps hq hmass
rw [rounded, sum_roundCounts D q _ ps (Nat.le_of_lt hr)]
unfold deficit
omega
def selectedSum : List Nat β†’ (Nat β†’ Bool) β†’ Nat
| [], _ => 0
| p :: ps, keep => (if keep 0 then p else 0) +
selectedSum ps (fun i => keep (i + 1))
theorem floor_entry_bounds (D q p : Nat) (hq : 0 < q) (b : Bool) :
let n := D * p / q + if b then 1 else 0
n * q ≀ D * p + q ∧ D * p ≀ n * q + q := by
have hlo := Nat.div_mul_le_self (D * p) q
have hhi : D * p < (D * p / q + 1) * q :=
(Nat.div_lt_iff_lt_mul hq).mp (Nat.lt_succ_self _)
cases b <;> simp only [Bool.false_eq_true, ↓reduceIte,
Nat.add_zero, Nat.add_mul, Nat.one_mul] at * <;> omega
theorem selected_roundCounts_error (D q r : Nat) (ps : List Nat)
(keep : Nat β†’ Bool) (hq : 0 < q) :
selectedSum (roundCounts D q r ps) keep * q ≀
D * selectedSum ps keep + ps.length * q ∧
D * selectedSum ps keep ≀
selectedSum (roundCounts D q r ps) keep * q + ps.length * q := by
induction ps generalizing r keep with
| nil => simp [roundCounts, selectedSum]
| cons p ps ih =>
cases r with
| zero =>
have hi := ih 0 (fun i => keep (i + 1))
have hp := floor_entry_bounds D q p hq false
cases hk : keep 0 <;>
simp only [roundCounts, selectedSum, hk, Bool.false_eq_true, ↓reduceIte,
Nat.add_zero, Nat.zero_add, List.length_cons,
Nat.add_mul, Nat.mul_add, Nat.one_mul] at * <;> omega
| succ r =>
have hi := ih r (fun i => keep (i + 1))
have hp := floor_entry_bounds D q p hq true
cases hk : keep 0 <;>
simp only [roundCounts, selectedSum, hk, Bool.false_eq_true, ↓reduceIte,
Nat.zero_add, List.length_cons,
Nat.add_mul, Nat.mul_add, Nat.one_mul] at * <;> omega
theorem selected_rounded_error (D q : Nat) (ps : List Nat)
(keep : Nat β†’ Bool) (hq : 0 < q) :
selectedSum (rounded D q ps) keep * q ≀
D * selectedSum ps keep + ps.length * q ∧
D * selectedSum ps keep ≀
selectedSum (rounded D q ps) keep * q + ps.length * q :=
selected_roundCounts_error D q _ ps keep hq
def replicateOccurrences {Ξ± : Type} : List (Ξ± Γ— Nat) β†’ List Ξ±
| [] => []
| (e, n) :: rest => List.replicate n e ++ replicateOccurrences rest
theorem length_replicateOccurrences {Ξ± : Type} (es : List (Ξ± Γ— Nat)) :
(replicateOccurrences es).length = (es.map Prod.snd).sum := by
induction es with
| nil => simp [replicateOccurrences]
| cons en es ih =>
rcases en with ⟨e, n⟩
simp [replicateOccurrences, ih]
def copyIndices : List Nat β†’ List Nat
| [] => []
| n :: ns => List.replicate n 0 ++ (copyIndices ns).map Nat.succ
theorem length_copyIndices (ns : List Nat) : (copyIndices ns).length = ns.sum := by
induction ns with
| nil => simp [copyIndices]
| cons n ns ih => simp [copyIndices, ih]
theorem mem_copyIndices_lt (ns : List Nat) (i : Nat) (hi : i ∈ copyIndices ns) :
i < ns.length := by
induction ns generalizing i with
| nil => simp [copyIndices] at hi
| cons n ns ih =>
simp only [copyIndices, List.mem_append] at hi
rcases hi with hi | hi
Β· have hz := List.eq_of_mem_replicate hi
subst i
simp
· rcases List.mem_map.mp hi with ⟨j, hj, rfl⟩
have hj' := ih j hj
simp only [List.length_cons]
omega
theorem count_copyIndices (ns : List Nat) (keep : Nat β†’ Bool) :
((copyIndices ns).filter keep).length = selectedSum ns keep := by
induction ns generalizing keep with
| nil => simp [copyIndices, selectedSum]
| cons n ns ih =>
simp only [copyIndices, List.filter_append, List.length_append,
List.filter_map, List.length_map, ih]
cases hk : keep 0 <;> simp [hk, selectedSum, Function.comp_def]
def uniformSource (D q : Nat) (ps : List Nat) : List Nat := copyIndices (rounded D q ps)
theorem uniformSource_indices_lt (D q : Nat) (ps : List Nat) (i : Nat)
(hi : i ∈ uniformSource D q ps) : i < ps.length := by
have h := mem_copyIndices_lt (rounded D q ps) i hi
simpa only [rounded, length_roundCounts] using h
theorem length_uniformSource (D q : Nat) (ps : List Nat) (hq : 0 < q)
(hmass : ps.sum = q) : (uniformSource D q ps).length = D := by
rw [uniformSource, length_copyIndices, sum_rounded D q ps hq hmass]
theorem uniformSource_nonempty (D q : Nat) (ps : List Nat) (hD : 0 < D)
(hq : 0 < q) (hmass : ps.sum = q) : uniformSource D q ps β‰  [] := by
intro h
have hl := length_uniformSource D q ps hq hmass
rw [h] at hl
simp at hl
omega
theorem uniformSource_error (D q : Nat) (ps : List Nat)
(keep : Nat β†’ Bool) (hq : 0 < q) :
((uniformSource D q ps).filter keep).length * q ≀
D * selectedSum ps keep + ps.length * q ∧
D * selectedSum ps keep ≀
((uniformSource D q ps).filter keep).length * q + ps.length * q := by
simpa only [uniformSource, count_copyIndices] using selected_rounded_error D q ps keep hq
def ceilQuotient (n a : Nat) : Nat := (n + a - 1) / a
theorem le_ceilQuotient_mul (n a : Nat) (ha : 0 < a) :
n ≀ ceilQuotient n a * a := by
have he := Nat.mod_add_div (n + a - 1) a
have hr := Nat.mod_lt (n + a - 1) ha
unfold ceilQuotient
rw [Nat.mul_comm a] at he
omega
theorem ceilQuotient_le (n a : Nat) (ha : 0 < a) : ceilQuotient n a ≀ n := by
have hm : n ≀ n * a := by
simpa using Nat.mul_le_mul_left n ha
unfold ceilQuotient
apply (Nat.div_le_iff_le_mul ha).mpr
omega
def targetDenominator (m a b : Nat) : Nat := ceilQuotient (4 * m * b) a
theorem targetDenominator_error_budget (m a b : Nat) (ha : 0 < a) :
4 * m * b ≀ targetDenominator m a b * a :=
le_ceilQuotient_mul _ a ha
theorem targetDenominator_size (m a b : Nat) (ha : 0 < a) :
targetDenominator m a b ≀ 4 * b * m := by
have h := ceilQuotient_le (4 * m * b) a ha
simpa [targetDenominator, Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm] using h
theorem targetDenominator_positive (m a b : Nat) (hm : 0 < m)
(ha : 0 < a) (hb : 0 < b) : 0 < targetDenominator m a b := by
have h := targetDenominator_error_budget m a b ha
have hp : 0 < 4 * m * b := Nat.mul_pos (Nat.mul_pos (by decide) hm) hb
by_cases hz : targetDenominator m a b = 0
Β· rw [hz] at h
simp at h
omega
Β· omega
end DFVSGames.Reduction.WeightRounding
namespace DFVSGames.Explicit.Rounding
open scoped BigOperators
abbrev IntegerRounding := DFVSGames.Reduction.WeightRounding.ceilQuotient
def denominator (h a b : Nat) : Nat := IntegerRounding (h * b) a
theorem denominator_budget (h a b : Nat) (ha : 0 < a) :
h * b ≀ denominator h a b * a :=
DFVSGames.Reduction.WeightRounding.le_ceilQuotient_mul _ _ ha
theorem denominator_size (h a b : Nat) (ha : 0 < a) :
denominator h a b ≀ b * h := by
simpa [denominator, Nat.mul_comm] using
DFVSGames.Reduction.WeightRounding.ceilQuotient_le (h * b) a ha
theorem denominator_positive (h a b : Nat) (hh : 0 < h)
(ha : 0 < a) (hb : 0 < b) : 0 < denominator h a b := by
have hp := Nat.mul_pos hh hb
have he := denominator_budget h a b ha
by_contra hn
have hz : denominator h a b = 0 := by omega
rw [hz] at he
simp at he
omega
variable {h : Nat}
def remainder (Q q : Nat) (p : Fin h β†’ Nat) (i : Fin h) : Nat :=
(Q * p i) % q
def priority (Q q : Nat) (p : Fin h β†’ Nat) (i j : Fin h) : Prop :=
remainder Q q p j < remainder Q q p i ∨
(remainder Q q p i = remainder Q q p j ∧ i ≀ j)
instance priorityDecidable (Q q : Nat) (p : Fin h β†’ Nat) :
DecidableRel (priority Q q p) := fun _ _ => inferInstanceAs
(Decidable (_ < _ ∨ (_ = _ ∧ _ ≀ _)))
instance priorityTrans (Q q : Nat) (p : Fin h β†’ Nat) :
IsTrans (Fin h) (priority Q q p) where
trans := by
intro i j k hij hjk
unfold priority at *
omega
instance priorityAntisymm (Q q : Nat) (p : Fin h β†’ Nat) :
Std.Antisymm (priority Q q p) where
antisymm := by
intro i j hij hji
apply Fin.ext
unfold priority at *
omega
instance priorityTotal (Q q : Nat) (p : Fin h β†’ Nat) :
Std.Total (priority Q q p) where
total := by
intro i j
unfold priority
omega
def remainderOrder (Q q : Nat) (p : Fin h β†’ Nat) : List (Fin h) :=
Finset.univ.sort (priority Q q p)
theorem remainderOrder_sorted (Q q : Nat) (p : Fin h β†’ Nat) :
(remainderOrder Q q p).Pairwise (priority Q q p) :=
Finset.pairwise_sort _ _
@[simp] theorem remainderOrder_length (Q q : Nat) (p : Fin h β†’ Nat) :
(remainderOrder Q q p).length = h := by
simp [remainderOrder]
theorem remainderOrder_nodup (Q q : Nat) (p : Fin h β†’ Nat) :
(remainderOrder Q q p).Nodup := Finset.sort_nodup _ _
def floorCount (Q q : Nat) (p : Fin h β†’ Nat) (i : Fin h) : Nat :=
Q * p i / q
def deficit (Q q : Nat) (p : Fin h β†’ Nat) : Nat :=
Q - βˆ‘ i, floorCount Q q p i
theorem floor_sum_le (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) : (βˆ‘ i, floorCount Q q p i) ≀ Q := by
have he := DFVSGames.Reduction.WeightRounding.floorMass_le_target
Q q (List.ofFn p) hq (by simpa [List.sum_ofFn] using hmass)
simpa [DFVSGames.Reduction.WeightRounding.floorMass, List.map_ofFn,
List.sum_ofFn, floorCount] using he
theorem deficit_lt (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) : deficit Q q p < h := by
have he := DFVSGames.Reduction.WeightRounding.deficit_lt_length
Q q (List.ofFn p) hq (by simpa [List.sum_ofFn] using hmass)
simpa [DFVSGames.Reduction.WeightRounding.deficit,
DFVSGames.Reduction.WeightRounding.floorMass, List.map_ofFn,
List.sum_ofFn, floorCount, deficit] using he
def incremented (Q q : Nat) (p : Fin h β†’ Nat) : Finset (Fin h) :=
((remainderOrder Q q p).take (deficit Q q p)).toFinset
def count (Q q : Nat) (p : Fin h β†’ Nat) (i : Fin h) : Nat :=
floorCount Q q p i + if i ∈ incremented Q q p then 1 else 0
theorem incremented_card (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) : (incremented Q q p).card = deficit Q q p := by
rw [incremented, List.toFinset_card_of_nodup
((remainderOrder_nodup Q q p).take), List.length_take,
remainderOrder_length, Nat.min_eq_left (Nat.le_of_lt (deficit_lt Q q p hq hmass))]
theorem sum_count (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) : βˆ‘ i, count Q q p i = Q := by
have hc := incremented_card Q q p hq hmass
have hf := floor_sum_le Q q p hq hmass
simp only [count, Finset.sum_add_distrib, Finset.sum_boole,
Finset.filter_mem_eq_inter, Finset.univ_inter, Nat.cast_id]
rw [hc, deficit]
omega
theorem count_error (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q) (i : Fin h) :
count Q q p i * q ≀ Q * p i + q ∧
Q * p i ≀ count Q q p i * q + q := by
have hlo := Nat.div_mul_le_self (Q * p i) q
have hhi : Q * p i < (Q * p i / q + 1) * q :=
(Nat.div_lt_iff_lt_mul hq).mp (Nat.lt_succ_self _)
unfold count floorCount
split <;> simp only [Nat.add_zero, Nat.add_mul, Nat.one_mul] at * <;> omega
theorem incremented_priority (Q q : Nat) (p : Fin h β†’ Nat) (i j : Fin h)
(hi : i ∈ incremented Q q p) (hj : j βˆ‰ incremented Q q p) :
priority Q q p i j := by
have hi' : i ∈ (remainderOrder Q q p).take (deficit Q q p) := by
simpa [incremented] using hi
have hj' : j βˆ‰ (remainderOrder Q q p).take (deficit Q q p) := by
simpa [incremented] using hj
have hm : j ∈ remainderOrder Q q p := by simp [remainderOrder]
have hd : j ∈ (remainderOrder Q q p).drop (deficit Q q p) := by
rw [← List.take_append_drop (deficit Q q p) (remainderOrder Q q p),
List.mem_append] at hm
exact hm.resolve_left hj'
have hs := remainderOrder_sorted Q q p
rw [← List.take_append_drop (deficit Q q p) (remainderOrder Q q p),
List.pairwise_append] at hs
exact hs.2.2 i hi' j hd
theorem selected_count_error (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(s : Finset (Fin h)) :
(βˆ‘ i ∈ s, count Q q p i) * q ≀ Q * (βˆ‘ i ∈ s, p i) + s.card * q ∧
Q * (βˆ‘ i ∈ s, p i) ≀ (βˆ‘ i ∈ s, count Q q p i) * q + s.card * q := by
constructor
Β· simpa [Finset.sum_mul, Finset.mul_sum, Finset.sum_add_distrib] using
(Finset.sum_le_sum fun i (_ : i ∈ s) => (count_error Q q p hq i).1)
Β· simpa [Finset.sum_mul, Finset.mul_sum, Finset.sum_add_distrib] using
(Finset.sum_le_sum fun i (_ : i ∈ s) => (count_error Q q p hq i).2)
theorem ratio_error (n p m Q q : Nat) (hQ : 0 < Q) (hq : 0 < q)
(hu : n * q ≀ Q * p + m * q) (hl : Q * p ≀ n * q + m * q) :
|(n : β„š) / Q - (p : β„š) / q| ≀ (m : β„š) / Q := by
have hQ' : (0 : β„š) < Q := by exact_mod_cast hQ
have hq' : (0 : β„š) < q := by exact_mod_cast hq
have hu' : (n : β„š) * q ≀ Q * p + m * q := by exact_mod_cast hu
have hl' : (Q : β„š) * p ≀ n * q + m * q := by exact_mod_cast hl
rw [div_sub_div _ _ hQ'.ne' hq'.ne', abs_div, abs_of_pos (mul_pos hQ' hq')]
apply (div_le_iffβ‚€ (mul_pos hQ' hq')).mpr
calc
|(n : β„š) * q - (Q : β„š) * p| ≀ (m : β„š) * q :=
abs_le.mpr ⟨by nlinarith, by nlinarith⟩
_ = ((m : β„š) / Q) * (Q * q) := by field_simp [hQ'.ne']
theorem count_ratio_error (Q q : Nat) (p : Fin h β†’ Nat)
(hQ : 0 < Q) (hq : 0 < q) (i : Fin h) :
|(count Q q p i : β„š) / Q - (p i : β„š) / q| ≀ 1 / (Q : β„š) := by
have he := count_error Q q p hq i
simpa using ratio_error (count Q q p i) (p i) 1 Q q hQ hq
(by simpa using he.1) (by simpa using he.2)
theorem selected_ratio_error (Q q : Nat) (p : Fin h β†’ Nat)
(hQ : 0 < Q) (hq : 0 < q) (s : Finset (Fin h)) :
|((βˆ‘ i ∈ s, count Q q p i : Nat) : β„š) / Q -
((βˆ‘ i ∈ s, p i : Nat) : β„š) / q| ≀ (h : β„š) / Q := by
have he := selected_count_error Q q p hq s
have hb := ratio_error _ _ _ Q q hQ hq he.1 he.2
refine hb.trans ?_
apply div_le_div_of_nonneg_right _ (by exact_mod_cast hQ.le)
exact_mod_cast (show s.card ≀ h from
(Finset.card_le_card (Finset.subset_univ s)).trans_eq (by simp))
theorem denominator_ratio_budget (h a b : Nat) (hh : 0 < h)
(ha : 0 < a) (hb : 0 < b) :
(h : β„š) / denominator h a b ≀ (a : β„š) / b := by
have hQ : (0 : β„š) < denominator h a b := by
exact_mod_cast denominator_positive h a b hh ha hb
have hb' : (0 : β„š) < b := by exact_mod_cast hb
apply (div_le_div_iffβ‚€ hQ hb').mpr
have hc : (h : β„š) * b ≀ denominator h a b * (a : β„š) := by
exact_mod_cast denominator_budget h a b ha
simpa [mul_comm] using hc
theorem denominator_eq_ceil (h a b : Nat) (ha : 0 < a) (hb : 0 < b) :
denominator h a b = Nat.ceil ((h : β„š) / ((a : β„š) / b)) := by
have ha' : (0 : β„š) < a := by exact_mod_cast ha
have hb' : (0 : β„š) < b := by exact_mod_cast hb
have hr : (h : β„š) / ((a : β„š) / b) = ((h * b : Nat) : β„š) / a := by
push_cast
field_simp [ha'.ne', hb'.ne']
rw [hr]
apply le_antisymm
Β· unfold denominator IntegerRounding DFVSGames.Reduction.WeightRounding.ceilQuotient
apply (Nat.div_le_iff_le_mul ha).mpr
have hc := (div_le_iffβ‚€ ha').mp (Nat.le_ceil (((h * b : Nat) : β„š) / a))
have hn : h * b ≀ Nat.ceil (((h * b : Nat) : β„š) / a) * a := by
exact_mod_cast hc
omega
Β· apply Nat.ceil_le.mpr
apply (div_le_iffβ‚€ ha').mpr
exact_mod_cast denominator_budget h a b ha
theorem selected_tolerance (a b q : Nat) (p : Fin h β†’ Nat)
(hh : 0 < h) (ha : 0 < a) (hb : 0 < b) (hq : 0 < q)
(s : Finset (Fin h)) :
|((βˆ‘ i ∈ s, count (denominator h a b) q p i : Nat) : β„š) /
denominator h a b - ((βˆ‘ i ∈ s, p i : Nat) : β„š) / q| ≀
(a : β„š) / b :=
(selected_ratio_error _ q p (denominator_positive h a b hh ha hb) hq s).trans
(denominator_ratio_budget h a b hh ha hb)
theorem selected_weight_error (Q q : Nat) (p : Fin h β†’ Nat)
(hQ : 0 < Q) (hq : 0 < q) (keep : Fin h β†’ Bool) :
|(βˆ‘ i, if keep i then (count Q q p i : β„š) / Q else 0) -
(βˆ‘ i, if keep i then (p i : β„š) / q else 0)| ≀ (h : β„š) / Q := by
have he := selected_ratio_error Q q p hQ hq (Finset.univ.filter fun i => keep i)
simpa [Nat.cast_sum, Finset.sum_filter, div_eq_mul_inv, Finset.sum_mul, ite_mul] using he
theorem selected_weight_tolerance (a b q : Nat) (p : Fin h β†’ Nat)
(hh : 0 < h) (ha : 0 < a) (hb : 0 < b) (hq : 0 < q)
(keep : Fin h β†’ Bool) :
|(βˆ‘ i, if keep i then (count (denominator h a b) q p i : β„š) /
denominator h a b else 0) -
(βˆ‘ i, if keep i then (p i : β„š) / q else 0)| ≀ (a : β„š) / b :=
(selected_weight_error _ q p (denominator_positive h a b hh ha hb) hq keep).trans
(denominator_ratio_budget h a b hh ha hb)
def copies (Q q : Nat) (p : Fin h β†’ Nat) : List (Fin h) :=
(List.ofFn fun i => List.replicate (count Q q p i) i).flatten
theorem copies_length (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) : (copies Q q p).length = Q := by
simpa [copies, List.map_ofFn, List.sum_ofFn] using sum_count Q q p hq hmass
theorem copies_nonempty (Q q : Nat) (p : Fin h β†’ Nat) (hQ : 0 < Q)
(hq : 0 < q) (hmass : βˆ‘ i, p i = q) : copies Q q p β‰  [] := by
intro he
have hl := copies_length Q q p hq hmass
rw [he] at hl
simp at hl
omega
theorem copies_filter_length (Q q : Nat) (p : Fin h β†’ Nat) (keep : Fin h β†’ Bool) :
((copies Q q p).filter keep).length =
βˆ‘ i, if keep i then count Q q p i else 0 := by
simp [copies, List.filter_flatten, List.map_ofFn, List.sum_ofFn,
List.filter_replicate, apply_ite]
theorem count_le (Q q : Nat) (p : Fin h β†’ Nat) (hq : 0 < q)
(hmass : βˆ‘ i, p i = q) (i : Fin h) : count Q q p i ≀ Q := by
calc
count Q q p i ≀ βˆ‘ j, count Q q p j :=
Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ i)
_ = Q := sum_count Q q p hq hmass
end DFVSGames.Explicit.Rounding
namespace DFVSGames.MachineUniformRounding
open scoped BigOperators
open DFVSGames.Explicit.Rounding
theorem denominator_uniform (h C : Nat) : denominator h 1 C = C * h := by
simp [denominator, IntegerRounding,
DFVSGames.Reduction.WeightRounding.ceilQuotient, Nat.mul_comm]
theorem denominator_uniform_eq_ceil (h C : Nat) (hC : 0 < C) :
C * h = Nat.ceil ((h : β„š) / (1 / (C : β„š))) := by
simpa only [denominator_uniform, Nat.cast_one] using
denominator_eq_ceil h 1 C (by omega) hC
theorem uniform_mass (h : Nat) : (βˆ‘ _ : Fin h, (1 : Nat)) = h := by simp
theorem scaled_quota_uniform (h C : Nat) (hh : 0 < h) :
(denominator h 1 C : β„š) * (1 / (h : β„š)) = C := by
have hn : (h : β„š) β‰  0 := by exact_mod_cast hh.ne'
rw [denominator_uniform]
push_cast
field_simp [hn]
theorem floorCount_uniform (h C : Nat) (hh : 0 < h) (i : Fin h) :
floorCount (C * h) h (fun _ => 1) i = C := by
simpa [floorCount, Nat.mul_comm] using Nat.mul_div_cancel_left C hh
theorem remainder_uniform (h C : Nat) (i : Fin h) :
remainder (C * h) h (fun _ => 1) i = 0 := by
simp [remainder]
theorem deficit_uniform (h C : Nat) (hh : 0 < h) :
deficit (C * h) h (fun _ : Fin h => 1) = 0 := by
simp only [deficit, floorCount_uniform h C hh]
simp [Nat.mul_comm]
theorem incremented_uniform (h C : Nat) (hh : 0 < h) :
incremented (C * h) h (fun _ : Fin h => 1) = βˆ… := by
simp [incremented, deficit_uniform h C hh]
theorem count_uniform (h C : Nat) (hh : 0 < h) (i : Fin h) :
count (denominator h 1 C) h (fun _ => 1) i = C := by
rw [denominator_uniform]
simp [count, floorCount_uniform h C hh, incremented_uniform h C hh]
theorem copies_uniform (h C : Nat) (hh : 0 < h) :
copies (denominator h 1 C) h (fun _ : Fin h => 1) =
(List.ofFn fun i : Fin h => List.replicate C i).flatten := by
simp only [copies, count_uniform h C hh]
theorem copies_uniform_length (h C : Nat) (hh : 0 < h) :
(copies (denominator h 1 C) h (fun _ : Fin h => 1)).length = C * h := by
rw [copies_length _ _ _ hh (uniform_mass h), denominator_uniform]
theorem normalized_count_uniform (h C : Nat) (hh : 0 < h) (hC : 0 < C)
(i : Fin h) :
(count (denominator h 1 C) h (fun _ => 1) i : β„š) /
denominator h 1 C = 1 / (h : β„š) := by
have hn : (h : β„š) β‰  0 := by exact_mod_cast hh.ne'
have hCn : (C : β„š) β‰  0 := by exact_mod_cast hC.ne'
rw [count_uniform h C hh, denominator_uniform]
push_cast
field_simp [hn, hCn]
theorem selected_weights_exact (h C : Nat) (hh : 0 < h) (hC : 0 < C)
(keep : Fin h β†’ Bool) :
(βˆ‘ i, if keep i then
(count (denominator h 1 C) h (fun _ => 1) i : β„š) / denominator h 1 C else 0) =
βˆ‘ i, if keep i then 1 / (h : β„š) else 0 := by
simp_rw [normalized_count_uniform h C hh hC]
end DFVSGames.MachineUniformRounding
namespace DFVSGames.Integration.DyadicErrors
open DFVSGames.Foundations.Target
open GapSemantics
def dyadicError (n : Nat) : RationalError where
numerator := 1
denominator := 2 ^ (n + 2)
numeratorPositive := by decide
denominatorPositive := by positivity
belowHalf := by
have h : 2 ^ 2 ≀ 2 ^ (n + 2) := Nat.pow_le_pow_right (by decide) (by omega)
norm_num at h ⊒
omega
theorem errorValue_dyadic (n : Nat) :
errorValue (dyadicError n) = (1 / 2 : β„š) ^ (n + 2) := by
simp [errorValue, dyadicError]
theorem exists_dyadic_below_real {Ξ΅ : ℝ} (hΞ΅ : 0 < Ξ΅) :
βˆƒ n : Nat, (errorValue (dyadicError n) : ℝ) < Ξ΅ := by
obtain ⟨n, hn⟩ := exists_nat_one_div_lt hΡ
refine ⟨n, ?_⟩
have hnat : n + 1 ≀ 2 ^ (n + 2) :=
le_trans (Nat.succ_le_of_lt Nat.lt_two_pow_self)
(Nat.pow_le_pow_right (by decide) (by omega))
have hden : (n : ℝ) + 1 ≀ (2 : ℝ) ^ (n + 2) := by exact_mod_cast hnat
have hfrac : (1 : ℝ) / 2 ^ (n + 2) ≀ 1 / ((n : ℝ) + 1) :=
one_div_le_one_div_of_le (by positivity) hden
simpa [errorValue_dyadic, div_pow] using lt_of_le_of_lt hfrac hn
theorem exists_dyadic_below (e : RationalError) :
βˆƒ n : Nat, errorValue (dyadicError n) < errorValue e := by
have he : (0 : ℝ) < errorValue e := by exact_mod_cast errorValue_pos e
obtain ⟨n, hn⟩ := exists_dyadic_below_real he
exact ⟨n, by exact_mod_cast hn⟩
theorem completeAt_real_of_dyadic {q n : Nat} {Ξ΅ : ℝ} {g : Instance q}
(hΞ΅ : (errorValue (dyadicError n) : ℝ) ≀ Ξ΅)
(hg : CompleteAt (dyadicError n) g) :
βˆƒ labeling, 1 - Ξ΅ ≀
(countSatisfied labeling g.constraints : ℝ) / g.constraints.length := by
obtain ⟨labeling, hl⟩ := (completeAt_iff_real (dyadicError n) g).1 hg
exact ⟨labeling, le_trans (sub_le_sub_left hΡ 1) hl⟩
theorem soundAt_real_of_dyadic {q n : Nat} {Ξ΄ : ℝ} {g : Instance q}
(hΞ΄ : (errorValue (dyadicError n) : ℝ) ≀ Ξ΄)
(hg : SoundAt (dyadicError n) g) :
βˆ€ labeling, (countSatisfied labeling g.constraints : ℝ) / g.constraints.length ≀ Ξ΄ := by
intro labeling
exact le_trans ((soundAt_iff_real (dyadicError n) g).1 hg labeling) hΞ΄
end DFVSGames.Integration.DyadicErrors
end OAI