math / data /lean /OAI /Computability /VertexCover /Analysis /Restriction.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
15.1 kB
import Mathlib
import OAI.Computability.VertexCover.Analysis.ThresholdListEnergy
namespace OAI
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
namespace VertexCover.Restriction
variable {E : Type*} [AddCommGroup E] [Module ℝ E]
structure EnergyForm (E : Type*) [AddCommGroup E] [Module ℝ E] where
form : E β†’β‚—[ℝ] E β†’β‚—[ℝ] ℝ
symm : βˆ€ x y, form x y = form y x
nonneg : βˆ€ x, 0 ≀ form x x
namespace EnergyForm
variable (B : EnergyForm E)
def energy (x : E) : ℝ := B.form x x
@[simp] theorem energy_zero : B.energy 0 = 0 := by simp [energy]
theorem energy_nonneg (x : E) : 0 ≀ B.energy x := B.nonneg x
theorem energy_add (x y : E) :
B.energy (x + y) = B.energy x + B.energy y + 2 * B.form x y := by
simp only [energy, map_add, LinearMap.add_apply]
rw [B.symm y x]
ring
theorem energy_sub (x y : E) :
B.energy (x - y) = B.energy x + B.energy y - 2 * B.form x y := by
simp only [energy, map_sub, LinearMap.sub_apply]
rw [B.symm y x]
ring
structure Projection where
toLinearMap : E β†’β‚—[ℝ] E
idem : βˆ€ x, toLinearMap (toLinearMap x) = toLinearMap x
selfAdjoint : βˆ€ x y, B.form (toLinearMap x) y = B.form x (toLinearMap y)
namespace Projection
variable {B : EnergyForm E}
instance : CoeFun (B.Projection) (fun _ => E β†’ E) := ⟨fun P => P.toLinearMap⟩
@[simp] theorem apply_idem (P : B.Projection) (x : E) : P (P x) = P x := P.idem x
@[simp] theorem map_zero (P : B.Projection) : P 0 = 0 := P.toLinearMap.map_zero
@[simp] theorem map_add (P : B.Projection) (x y : E) : P (x + y) = P x + P y :=
P.toLinearMap.map_add x y
@[simp] theorem map_sub (P : B.Projection) (x y : E) : P (x - y) = P x - P y :=
P.toLinearMap.map_sub x y
@[simp] theorem map_smul (P : B.Projection) (a : ℝ) (x : E) : P (a β€’ x) = a β€’ P x :=
P.toLinearMap.map_smul a x
@[ext] theorem ext {P Q : B.Projection} (h : βˆ€ x, P x = Q x) : P = Q := by
cases P with
| mk p hp hs =>
cases Q with
| mk q hq ht =>
have : p = q := LinearMap.ext h
subst q
rfl
def ident : B.Projection where
toLinearMap := LinearMap.id
idem _ := rfl
selfAdjoint _ _ := rfl
@[simp] theorem ident_apply (x : E) : (ident : B.Projection) x = x := rfl
def zero : B.Projection where
toLinearMap := 0
idem _ := rfl
selfAdjoint x y := by simp
@[simp] theorem zero_apply (x : E) : (zero : B.Projection) x = 0 := rfl
def residual (P : B.Projection) : B.Projection where
toLinearMap := LinearMap.id - P.toLinearMap
idem x := by simp
selfAdjoint x y := by
simpa only [LinearMap.sub_apply, LinearMap.id_apply, _root_.map_sub] using
congrArg (fun value => B.form x y - value) (P.selfAdjoint x y)
@[simp] theorem residual_apply (P : B.Projection) (x : E) : P.residual x = x - P x := rfl
@[simp] theorem residual_residual (P : B.Projection) : P.residual.residual = P := by
ext x
simp
theorem inner_image (P : B.Projection) (x : E) : B.form x (P x) = B.energy (P x) := by
simpa only [P.apply_idem, energy] using (P.selfAdjoint x (P x)).symm
theorem pythagoras (P : B.Projection) (x : E) :
B.energy x = B.energy (P x) + B.energy (P.residual x) := by
rw [residual_apply, B.energy_sub, P.inner_image]
ring
theorem energy_le (P : B.Projection) (x : E) : B.energy (P x) ≀ B.energy x := by
have h := P.pythagoras x
have := B.energy_nonneg (P.residual x)
linarith
def comp (P Q : B.Projection) (h : βˆ€ x, P (Q x) = Q (P x)) : B.Projection where
toLinearMap := P.toLinearMap.comp Q.toLinearMap
idem x := by
change P (Q (P (Q x))) = P (Q x)
rw [← h, P.apply_idem, Q.apply_idem]
selfAdjoint x y := by
change B.form (P (Q x)) y = B.form x (P (Q y))
rw [P.selfAdjoint, Q.selfAdjoint, h]
@[simp] theorem comp_apply (P Q : B.Projection) (h) (x : E) : P.comp Q h x = P (Q x) := rfl
theorem residual_commute (P Q : B.Projection) (h : βˆ€ x, P (Q x) = Q (P x)) (x : E) :
P.residual (Q x) = Q (P.residual x) := by
simp [h]
theorem comp_loss_le (P Q : B.Projection) (h : βˆ€ x, P (Q x) = Q (P x)) (x : E) :
B.energy ((P.comp Q h).residual x) ≀
B.energy (P.residual x) + B.energy (Q.residual x) := by
have h₁ := P.pythagoras (Q x)
have hβ‚‚ := Q.pythagoras x
have h₃ := (P.comp Q h).pythagoras x
have hβ‚„ := Q.energy_le (P.residual x)
rw [← P.residual_commute Q h] at hβ‚„
simp only [comp_apply] at h₃
linarith
theorem residual_le_of_nested (P Q : B.Projection) (h : βˆ€ x, P (Q x) = Q x) (x : E) :
B.energy (P.residual x) ≀ B.energy (Q.residual x) := by
have horth : B.form (P.residual x) (P x - Q x) = 0 := by
rw [residual_apply]
simp only [_root_.map_sub, LinearMap.sub_apply]
rw [P.selfAdjoint x (P x), P.apply_idem, P.selfAdjoint x (Q x), h]
ring
have he := B.energy_add (P.residual x) (P x - Q x)
have hs : P.residual x + (P x - Q x) = Q.residual x := by simp
rw [hs, horth, mul_zero, add_zero] at he
have := B.energy_nonneg (P x - Q x)
linarith
def productMap {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection) : List ΞΉ β†’ E β†’β‚—[ℝ] E
| [] => LinearMap.id
| i :: is => (P i).toLinearMap.comp (productMap P is)
@[simp] theorem productMap_nil {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection) (x : E) :
productMap P [] x = x := rfl
@[simp] theorem productMap_cons {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(i : ΞΉ) (is : List ΞΉ) (x : E) :
productMap P (i :: is) x = P i (productMap P is x) := rfl
@[simp] theorem productMap_append {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(is js : List ΞΉ) (x : E) :
productMap P (is ++ js) x = productMap P is (productMap P js x) := by
induction is with
| nil => rfl
| cons i is ih => simp only [List.cons_append, productMap_cons, ih]
theorem productMap_commute {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(Q : B.Projection) (h : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x))
(is : List ΞΉ) (x : E) :
productMap P is (Q x) = Q (productMap P is x) := by
induction is with
| nil => rfl
| cons i is ih => simp only [productMap_cons, ih, h]
theorem productMap_fixed_of_mem {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(is : List ι) (j : ι) (hj : j ∈ is) (x : E) :
P j (productMap P is x) = productMap P is x := by
induction is with
| nil => simp at hj
| cons i is ih =>
rcases List.mem_cons.mp hj with rfl | ht
Β· simp only [productMap_cons, apply_idem]
Β· simp only [productMap_cons, h j i, ih ht]
def product {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(is : List ΞΉ) : B.Projection where
toLinearMap := productMap P is
idem x := by
induction is with
| nil => rfl
| cons i is ih =>
simp only [productMap_cons]
rw [productMap_commute P (P i) (fun j => h j i), (P i).apply_idem, ih]
selfAdjoint x y := by
induction is generalizing x y with
| nil => rfl
| cons i is ih =>
simp only [productMap_cons]
rw [(P i).selfAdjoint, ih,
productMap_commute P (P i) (fun j => h j i)]
@[simp] theorem product_apply {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection) (h) (is : List ΞΉ)
(x : E) : product P h is x = productMap P is x := rfl
theorem product_loss_le {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(is : List ΞΉ) (x : E) :
B.energy ((product P h is).residual x) ≀
(is.map (fun i => B.energy ((P i).residual x))).sum := by
induction is with
| nil => simp [residual_apply]
| cons i is ih =>
have hc : βˆ€ x, P i (product P h is x) = product P h is (P i x) :=
fun x => (productMap_commute P (P i) (fun j => h j i) is x).symm
have he : product P h (i :: is) = (P i).comp (product P h is) hc := by
ext x
rfl
rw [he, List.map_cons, List.sum_cons]
exact ((P i).comp_loss_le (product P h is) hc x).trans (add_le_add le_rfl ih)
def difference (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (i : β„•) : B.Projection :=
(P i).residual.comp (product P h (List.range i)) (fun x => by
simp only [residual_apply, product_apply, _root_.map_sub]
rw [productMap_commute P (P i) (fun k => h k i)])
@[simp] theorem difference_apply (P : β„• β†’ B.Projection) (h) (i : β„•) (x : E) :
difference P h i x = productMap P (List.range i) x -
P i (productMap P (List.range i) x) := rfl
theorem difference_energy_sum (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (n : β„•) (x : E) :
(βˆ‘ i ∈ Finset.range n, B.energy (difference P h i x)) +
B.energy (productMap P (List.range n) x) = B.energy x := by
induction n with
| zero => simp
| succ n ih =>
rw [Finset.sum_range_succ, List.range_succ, productMap_append]
simp only [productMap_cons, productMap_nil]
rw [productMap_commute P (P n) (fun k => h k n)]
have he := (P n).pythagoras (productMap P (List.range n) x)
simp only [residual_apply] at he
rw [difference_apply]
linarith
theorem difference_energy_sum_le (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (n : β„•) (x : E) :
(βˆ‘ i ∈ Finset.range n, B.energy (difference P h i x)) ≀ B.energy x := by
have := difference_energy_sum P h n x
have := B.energy_nonneg (productMap P (List.range n) x)
linarith
theorem difference_commute (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x))
(i : β„•) (x : E) : difference P h i (Q x) = Q (difference P h i x) := by
simp only [difference_apply, productMap_commute P Q hq, map_sub, hq]
theorem difference_residual_budget (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x))
(n : β„•) (x : E) :
(βˆ‘ i ∈ Finset.range n, B.energy (Q.residual (difference P h i x))) ≀
B.energy (Q.residual x) := by
have hr : βˆ€ i, βˆ€ x, P i (Q.residual x) = Q.residual (P i x) := by
intro i x
simp [hq]
simpa only [← difference_commute P h Q.residual hr] using
difference_energy_sum_le P h n (Q.residual x)
theorem difference_retained_le (P : β„• β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x))
(i : β„•) (x : E) : B.energy (Q (difference P h i x)) ≀ B.energy (Q x) := by
rw [← difference_commute P h Q hq]
exact (difference P h i).energy_le (Q x)
theorem productMap_map {ΞΉ ΞΊ : Type*} (P : ΞΊ β†’ B.Projection) (g : ΞΉ β†’ ΞΊ)
(is : List ΞΉ) (x : E) :
productMap P (is.map g) x = productMap (fun i => P (g i)) is x := by
induction is with
| nil => rfl
| cons i is ih => simp only [List.map_cons, productMap_cons, ih]
def natExtension {d : β„•} (P : Fin d β†’ B.Projection) (i : β„•) : B.Projection :=
if h : i < d then P ⟨i,h⟩ else ident
@[simp] theorem natExtension_fin {d : β„•} (P : Fin d β†’ B.Projection) (i : Fin d) :
natExtension P i.val = P i := dite_eq_left i.isLt
theorem natExtension_commute {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) :
βˆ€ i j, βˆ€ x, natExtension P i (natExtension P j x) =
natExtension P j (natExtension P i x) := by
intro i j x
unfold natExtension
split_ifs <;> simp only [ident_apply, h]
theorem natExtension_commute_of {d : β„•} (P : Fin d β†’ B.Projection) (Q : B.Projection)
(h : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x)) (i : β„•) (x : E) :
natExtension P i (Q x) = Q (natExtension P i x) := by
unfold natExtension
split_ifs <;> simp only [ident_apply, h]
theorem productMap_range_natExtension {d : β„•} (P : Fin d β†’ B.Projection) (x : E) :
productMap (natExtension P) (List.range d) x = productMap P (List.finRange d) x := by
have he : (List.finRange d).map Fin.val = List.range d := by
apply List.ext_getElem
Β· simp
Β· intro i hi hj
simp
rw [← he, productMap_map]
simp only [natExtension_fin]
def finDifference {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (i : Fin d) : B.Projection :=
difference (natExtension P) (natExtension_commute P h) i.val
theorem finDifference_energy_sum {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (x : E) :
(βˆ‘ i : Fin d, B.energy (finDifference P h i x)) +
B.energy (productMap P (List.finRange d) x) = B.energy x := by
have he := difference_energy_sum (natExtension P) (natExtension_commute P h) d x
rw [← Fin.sum_univ_eq_sum_range, productMap_range_natExtension] at he
exact he
theorem finDifference_residual_budget {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x)) (x : E) :
(βˆ‘ i : Fin d, B.energy (Q.residual (finDifference P h i x))) ≀
B.energy (Q.residual x) := by
have he := difference_residual_budget (natExtension P) (natExtension_commute P h)
Q (natExtension_commute_of P Q hq) d x
rw [← Fin.sum_univ_eq_sum_range] at he
exact he
theorem finDifference_retained_le {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x)) (i : Fin d) (x : E) :
B.energy (Q (finDifference P h i x)) ≀ B.energy (Q x) :=
difference_retained_le (natExtension P) (natExtension_commute P h)
Q (natExtension_commute_of P Q hq) i.val x
theorem finDifference_centered {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (i : Fin d) (x : E) :
(P i).residual (finDifference P h i x) = finDifference P h i x := by
simp only [finDifference, difference_apply, natExtension_fin, residual_apply,
map_sub, apply_idem, sub_self, sub_zero]
theorem finDifference_commute {d : β„•} (P : Fin d β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x))
(Q : B.Projection) (hq : βˆ€ i, βˆ€ x, P i (Q x) = Q (P i x)) (i : Fin d) (x : E) :
finDifference P h i (Q x) = Q (finDifference P h i x) :=
difference_commute (natExtension P) (natExtension_commute P h)
Q (natExtension_commute_of P Q hq) i.val x
theorem product_loss_finset {ΞΉ : Type*} (P : ΞΉ β†’ B.Projection)
(h : βˆ€ i j, βˆ€ x, P i (P j x) = P j (P i x)) (s : Finset ΞΉ) (x : E) :
B.energy ((product P h s.toList).residual x) ≀ βˆ‘ i ∈ s, B.energy ((P i).residual x) := by
classical
have he := product_loss_le P h s.toList x
rw [← List.sum_toFinset _ s.nodup_toList] at he
simpa using he
end Projection
end EnergyForm
end VertexCover.Restriction
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end OAI