| import Mathlib |
| import OAI.Probability.ParisiFinite.UsedVertices |
|
|
| namespace OAI |
|
|
| /-! Labels. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder |
| open Filter |
| open scoped BigOperators |
| open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate |
| open scoped InnerProductSpace ComplexConjugate |
| open Filter Topology |
| open Filter Set Topology |
| open scoped InnerProductSpace ComplexConjugate Topology |
| open scoped InnerProductSpace |
| open scoped BigOperators Topology InnerProductSpace |
| open scoped BigOperators InnerProductSpace |
| open scoped BigOperators Matrix Topology ComplexConjugate |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators Topology |
| open scoped BigOperators Matrix Topology |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator |
| open scoped BigOperators |
|
|
| namespace BoundedBranch |
|
|
| |
| def labels (n : ℕ) : (h : ℕ) → Tree n h → Multiset (Fin n) |
| | 0, _ => 0 |
| | h+1, b => ∑i, (b i).elim 0 (fun c => {i}+labels n h c) |
|
|
| def links (n : ℕ) : (h : ℕ) → Fin n → Tree n h → Multiset (Fin n × Fin n) |
| | 0, _, _ => 0 |
| | h+1, i, b => ∑j, (b j).elim 0 (fun c => {(i,j)}+links n h j c) |
|
|
| @[simp] theorem card_labels (n h : ℕ) (b : Tree n h) : (labels n h b).card=size n h b := by |
| induction h with |
| | zero => rfl |
| | succ h ih => |
| change (∑i, (b i).elim 0 (fun c => {i}+labels n h c)).card=_ |
| rw [Multiset.card_sum] |
| apply Finset.sum_congr rfl |
| intro i hi |
| cases hb : b i with |
| | none => rfl |
| | some c => simp [ih,add_comm] |
|
|
| @[simp] theorem map_snd_links (n h : ℕ) (i : Fin n) (b : Tree n h) : |
| (links n h i b).map Prod.snd=labels n h b := by |
| induction h generalizing i with |
| | zero => rfl |
| | succ h ih => |
| change (∑j,(b j).elim 0 (fun c => {(i,j)}+links n h j c)).map Prod.snd=_ |
| rw [show (∑j,(b j).elim 0 (fun c => {(i,j)}+links n h j c)).map Prod.snd = |
| ∑j,((b j).elim 0 (fun c => {(i,j)}+links n h j c)).map Prod.snd from |
| map_sum (Multiset.mapAddMonoidHom Prod.snd) _ _] |
| apply Finset.sum_congr rfl |
| intro j hj |
| cases hb : b j with |
| | none => rfl |
| | some c => simp [ih] |
|
|
| @[simp] theorem card_links (n h : ℕ) (i : Fin n) (b : Tree n h) : |
| (links n h i b).card=size n h b := by |
| rw [←card_labels n h b,←map_snd_links n h i b,Multiset.card_map] |
|
|
| |
| def unfoldTree {n : ℕ} (U S : Finset (Fin n)) (parent : Fin n → Fin n) : |
| (h : ℕ) → Fin n → Tree n h |
| | 0, _ => () |
| | h+1, i => fun j => if j∈U\S ∧ parent j=i then some (unfoldTree U S parent h j) else none |
|
|
| namespace Parent |
| variable {n : ℕ} (U S : Finset (Fin n)) (parent : Fin n → Fin n) (rank : Fin n → ℕ) |
|
|
| def layer (k : ℕ) : Finset (Fin n) := U.filter (fun i => rank i=k) |
|
|
| lemma labels_unfold (h : ℕ) (i : Fin n) : |
| labels n (h+1) (unfoldTree U S parent (h+1) i)= |
| ∑j:Fin n, if j∈U\S ∧ parent j=i then |
| {j}+labels n h (unfoldTree U S parent h j) else 0 := by |
| apply Finset.sum_congr rfl |
| intro j hj |
| simp only [unfoldTree] |
| split_ifs <;> rfl |
|
|
| lemma links_unfold (h : ℕ) (i : Fin n) : |
| links n (h+1) i (unfoldTree U S parent (h+1) i)= |
| ∑j:Fin n, if j∈U\S ∧ parent j=i then |
| {(i,j)}+links n h j (unfoldTree U S parent h j) else 0 := by |
| apply Finset.sum_congr rfl |
| intro j hj |
| simp only [unfoldTree] |
| split_ifs <;> rfl |
|
|
| variable (hS : S⊆U) (hzero : ∀i∈U, rank i=0 ↔ i∈S) |
| (hparent : ∀j∈U\S, parent j∈U ∧ rank (parent j)+1=rank j) |
|
|
| include hzero hparent in |
| lemma child_layer_iff (k : ℕ) (j : Fin n) : |
| j∈U\S ∧ parent j∈layer U rank k ↔ j∈layer U rank (k+1) := by |
| constructor |
| · rintro ⟨hj,hp⟩ |
| rcases Finset.mem_sdiff.mp hj with ⟨hjU,hjS⟩ |
| rcases Finset.mem_filter.mp hp with ⟨hpU,hpk⟩ |
| exact Finset.mem_filter.mpr ⟨hjU,by rw [←(hparent j (by simp [hjU,hjS])).2,hpk]⟩ |
| · intro hj |
| rcases Finset.mem_filter.mp hj with ⟨hjU,hjrank⟩ |
| have hjS : j∉S := by |
| intro hjS |
| have := (hzero j hjU).mpr hjS |
| omega |
| have hp := hparent j (Finset.mem_sdiff.mpr ⟨hjU,hjS⟩) |
| refine ⟨Finset.mem_sdiff.mpr ⟨hjU,hjS⟩,Finset.mem_filter.mpr ⟨hp.1,?_⟩⟩ |
| omega |
|
|
| include hzero hparent in |
| |
|
|
| theorem sum_labels_layer (h k : ℕ) : |
| (∑i∈layer U rank k, labels n h (unfoldTree U S parent h i))= |
| ∑j∈U, if k<rank j ∧ rank j ≤ k+h then ({j}:Multiset (Fin n)) else 0 := by |
| induction h generalizing k with |
| | zero => |
| simp only [labels,Finset.sum_const_zero,Nat.add_zero] |
| symm |
| apply Finset.sum_eq_zero |
| intro j hj |
| exact ite_eq_right (by omega) |
| | succ h ih => |
| simp_rw [labels_unfold] |
| rw [Finset.sum_comm] |
| have ht (j : Fin n) : (∑i∈layer U rank k, if j∈U\S ∧ parent j=i then |
| ({j}:Multiset (Fin n))+labels n h (unfoldTree U S parent h j) else 0)= |
| if j∈layer U rank (k+1) then {j}+labels n h (unfoldTree U S parent h j) else 0 := by |
| by_cases hj : j∈U\S |
| · simp only [hj,true_and,Finset.sum_ite_eq] |
| congr 1 |
| exact propext (by simpa only [hj,true_and] using child_layer_iff U S parent rank hzero hparent k j) |
| · have hjL : j∉layer U rank (k+1) := by |
| intro hh |
| exact hj ((child_layer_iff U S parent rank hzero hparent k j).mpr hh).1 |
| simp [hj,hjL] |
| simp_rw [ht] |
| rw [←Finset.sum_filter] |
| simp only [Finset.filter_mem_eq_inter,Finset.univ_inter] |
| rw [Finset.sum_add_distrib,ih] |
| rw [layer,Finset.sum_filter] |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro j hj |
| by_cases h₁ : rank j=k+1 |
| · simp [h₁] |
| · have hr : (k<rank j ∧ rank j≤k+(h+1)) ↔ (k+1<rank j ∧ rank j≤k+1+h) := by omega |
| simp only [h₁,ite_false,zero_add,hr] |
|
|
| include hS hzero hparent in |
| |
| theorem sum_labels_roots (h : ℕ) (hbound : ∀j∈U, rank j≤h) : |
| (∑i∈S,labels n h (unfoldTree U S parent h i))=(U\S).val := by |
| have hL : layer U rank 0=S := by |
| ext i |
| simp only [layer,Finset.mem_filter] |
| constructor |
| · rintro ⟨hi,hr⟩ |
| exact (hzero i hi).mp hr |
| · intro hi |
| exact ⟨hS hi,(hzero i (hS hi)).mpr hi⟩ |
| calc |
| _ = ∑i∈layer U rank 0,labels n h (unfoldTree U S parent h i) := by rw [hL] |
| _ = ∑j∈U, if 0<rank j ∧ rank j≤0+h then ({j}:Multiset (Fin n)) else 0 := |
| sum_labels_layer U S parent rank hzero hparent h 0 |
| _ = (U\S).val := by |
| have he (j : Fin n) (hj : j∈U) : |
| (0<rank j ∧ rank j≤0+h) ↔ j∉S := by |
| have hz := hzero j hj |
| have hb := hbound j hj |
| constructor |
| · rintro ⟨hr,_⟩ hjS |
| have := hz.mpr hjS |
| omega |
| · intro hjS |
| exact ⟨Nat.pos_of_ne_zero (fun hr => hjS (hz.mp hr)),by simpa using hb⟩ |
| have hh : (∑j∈U, if 0<rank j ∧ rank j≤0+h then ({j}:Multiset (Fin n)) else 0)= |
| ∑j∈U\S, ({j}:Multiset (Fin n)) := by |
| rw [Finset.sdiff_eq_filter,Finset.sum_filter] |
| apply Finset.sum_congr rfl |
| intro j hj |
| simp only [he j hj] |
| rw [hh] |
| exact Finset.sum_multiset_singleton _ |
|
|
| lemma links_eq_map_labels (h : ℕ) (i : Fin n) : |
| links n h i (unfoldTree U S parent h i)= |
| (labels n h (unfoldTree U S parent h i)).map (fun j => (parent j,j)) := by |
| induction h generalizing i with |
| | zero => rfl |
| | succ h ih => |
| rw [links_unfold,labels_unfold] |
| rw [show (∑j:Fin n,if j∈U\S ∧ parent j=i then |
| ({j}:Multiset (Fin n))+labels n h (unfoldTree U S parent h j) else 0).map |
| (fun j => (parent j,j)) = |
| ∑j:Fin n,(if j∈U\S ∧ parent j=i then |
| ({j}:Multiset (Fin n))+labels n h (unfoldTree U S parent h j) else 0).map |
| (fun j => (parent j,j)) from |
| map_sum (Multiset.mapAddMonoidHom (fun j => (parent j,j))) _ _] |
| apply Finset.sum_congr rfl |
| intro j hj |
| by_cases hp : j∈U\S ∧ parent j=i |
| · simp [hp,ih] |
| · rw [ite_eq_right hp,ite_eq_right hp]; rfl |
|
|
| include hS hzero hparent in |
| |
| theorem sum_links_roots (h : ℕ) (hbound : ∀j∈U, rank j≤h) : |
| (∑i∈S,links n h i (unfoldTree U S parent h i))= |
| (U\S).val.map (fun j => (parent j,j)) := by |
| rw [←sum_labels_roots U S parent rank hS hzero hparent h hbound] |
| rw [show (∑i∈S, labels n h (unfoldTree U S parent h i)).map (fun j => (parent j,j))= |
| ∑i∈S, (labels n h (unfoldTree U S parent h i)).map (fun j => (parent j,j)) from |
| map_sum (Multiset.mapAddMonoidHom (fun j => (parent j,j))) _ _] |
| exact Finset.sum_congr rfl (fun i _ => links_eq_map_labels U S parent h i) |
|
|
| end Parent |
| end BoundedBranch |
|
|
| |
|
|
| open scoped BigOperators Matrix Topology |
| open MeasureTheory ProbabilityTheory Filter |
|
|
| namespace SKQAOA.Locality |
| variable {n : ℕ} |
|
|
| def ball (E : Finset (Edge n)) (S : Finset (Fin n)) : ℕ → Finset (Fin n) |
| | 0 => S |
| | h+1 => neighborhood E (ball E S h) |
|
|
| lemma ball_mono (E : Finset (Edge n)) (S : Finset (Fin n)) : Monotone (ball E S) := by |
| apply monotone_nat_of_le_succ |
| intro h |
| exact subset_neighborhood E (ball E S h) |
|
|
| lemma subset_ball (E : Finset (Edge n)) (S : Finset (Fin n)) (h : ℕ) : S⊆ball E S h := |
| ball_mono E S (Nat.zero_le h) |
|
|
| lemma ball_succ_start (E : Finset (Edge n)) (S : Finset (Fin n)) (h : ℕ) : |
| ball E (neighborhood E S) h=ball E S (h+1) := by |
| induction h with |
| | zero => rfl |
| | succ h ih => exact congrArg (neighborhood E) ih |
|
|
| lemma incident_mem_neighborhood {E : Finset (Edge n)} {S : Finset (Fin n)} {e : Edge n} |
| (he : e∈E) (hu : e.1.1∈S ∨ e.1.2∈S) : |
| e.1.1∈neighborhood E S ∧ e.1.2∈neighborhood E S := |
| active_endpoints (Finset.mem_filter.mpr ⟨he,hu⟩) |
|
|
| |
| lemma new_vertex_parent {E : Finset (Edge n)} {S : Finset (Fin n)} {v : Fin n} |
| (hv : v∈neighborhood E S) (hvS : v∉S) : |
| ∃(u : Fin n) (e : Edge n), e∈E ∧ u∈S ∧ |
| ((e.1.1=v ∧ e.1.2=u) ∨ (e.1.1=u ∧ e.1.2=v)) := by |
| rcases Finset.mem_union.mp hv with hv | hv |
| · exact (hvS hv).elim |
| rcases Finset.mem_biUnion.mp hv with ⟨e,he,hve⟩ |
| rcases Finset.mem_filter.mp he with ⟨he,htouch⟩ |
| rcases Finset.mem_insert.mp hve with hve | hve |
| · have hv' : e.1.1=v := hve.symm |
| have hu : e.1.2∈S := by |
| rcases htouch with h|h |
| · exact (hvS (hv' ▸ h)).elim |
| · exact h |
| exact ⟨e.1.2,e,he,hu,Or.inl ⟨hv',rfl⟩⟩ |
| · have hv' : e.1.2=v := (Finset.mem_singleton.mp hve).symm |
| have hu : e.1.1∈S := by |
| rcases htouch with h|h |
| · exact h |
| · exact (hvS (hv' ▸ h)).elim |
| exact ⟨e.1.1,e,he,hu,Or.inr ⟨rfl,hv'⟩⟩ |
|
|
| |
| def rank (E : Finset (Edge n)) (S : Finset (Fin n)) (v : Fin n) : ℕ := |
| sInf {h | v∈ball E S h} |
|
|
| lemma rank_le_of_mem {E : Finset (Edge n)} {S : Finset (Fin n)} {v : Fin n} {h : ℕ} |
| (hv : v∈ball E S h) : rank E S v≤h := Nat.sInf_le hv |
|
|
| lemma mem_ball_rank {E : Finset (Edge n)} {S : Finset (Fin n)} {v : Fin n} {h : ℕ} |
| (hv : v∈ball E S h) : v∈ball E S (rank E S v) := |
| Nat.sInf_mem (show Set.Nonempty {k | v∈ball E S k} from ⟨h,hv⟩) |
|
|
| lemma rank_zero_iff {E : Finset (Edge n)} {S : Finset (Fin n)} {v : Fin n} {h : ℕ} |
| (hv : v∈ball E S h) : rank E S v=0 ↔ v∈S := by |
| constructor |
| · intro hr |
| have hh := mem_ball_rank hv |
| rw [hr] at hh |
| exact hh |
| · intro hvS |
| exact Nat.eq_zero_of_le_zero (rank_le_of_mem (h := 0) hvS) |
|
|
| |
|
|
| theorem exists_parent {E : Finset (Edge n)} {S : Finset (Fin n)} {v : Fin n} {h : ℕ} |
| (hv : v∈ball E S h) (hvS : v∉S) : |
| ∃(u : Fin n) (e : Edge n), e∈E ∧ u∈ball E S h ∧ |
| rank E S u+1=rank E S v ∧ |
| ((e.1.1=v ∧ e.1.2=u) ∨ (e.1.1=u ∧ e.1.2=v)) := by |
| have hr : rank E S v≠0 := fun hr => hvS ((rank_zero_iff hv).mp hr) |
| obtain ⟨k,hk⟩ := Nat.exists_eq_succ_of_ne_zero hr |
| have hvk : v∈neighborhood E (ball E S k) := by |
| have hh := mem_ball_rank hv |
| simpa only [hk,ball] using hh |
| have hvnot : v∉ball E S k := by |
| intro hh |
| have := rank_le_of_mem hh |
| omega |
| obtain ⟨u,e,he,hu,hend⟩ := new_vertex_parent hvk hvnot |
| have huk : rank E S u≤k := rank_le_of_mem hu |
| have hub : u∈ball E S (rank E S u) := mem_ball_rank hu |
| have hvup : v∈ball E S (rank E S u+1) := by |
| have ht : e.1.1∈ball E S (rank E S u) ∨ e.1.2∈ball E S (rank E S u) := by |
| rcases hend with ⟨_,he₂⟩|⟨he₁,_⟩ |
| · exact Or.inr (he₂ ▸ hub) |
| · exact Or.inl (he₁ ▸ hub) |
| have ha := incident_mem_neighborhood he ht |
| rcases hend with ⟨he₁,_⟩|⟨_,he₂⟩ |
| · exact he₁ ▸ ha.1 |
| · exact he₂ ▸ ha.2 |
| have hvr := rank_le_of_mem hvup |
| have hbound := rank_le_of_mem hv |
| refine ⟨u,e,he,ball_mono E S (by omega) hu,by omega,hend⟩ |
|
|
| |
|
|
| theorem relevant_endpoints_in_ball (E : Finset (Edge n)) (p : ℕ) |
| (γ β : Fin p → ℝ) (S : Finset (Fin n)) {e : Edge n} |
| (he : e∈relevantEdges E (qaoaWord p γ β) S) : |
| e.1.1∈ball E S p ∧ e.1.2∈ball E S p := by |
| induction p generalizing S with |
| | zero => simp [qaoaWord,relevantEdges] at he |
| | succ p ih => |
| simp only [qaoaWord,relevantEdges] at he |
| rcases Finset.mem_union.mp he with he|he |
| · have hh := active_endpoints he |
| exact ⟨ball_mono E S (by omega : 1≤p+1) hh.1, |
| ball_mono E S (by omega : 1≤p+1) hh.2⟩ |
| · have hh := ih _ _ _ he |
| simpa only [ball_succ_start] using hh |
|
|
| end Locality |
|
|
| namespace SiteHistories |
| variable {n : ℕ} |
|
|
| lemma ball_subset_used (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| Locality.ball (H∪{r}) {r.1.1,r.1.2} p ⊆ usedVertices r H := by |
| induction p with |
| | zero => |
| intro v hv |
| rcases Finset.mem_insert.mp hv with rfl|hv |
| · exact fst_mem_usedVertices _ _ (by simp) |
| · have := Finset.mem_singleton.mp hv |
| subst v |
| exact snd_mem_usedVertices _ _ (by simp) |
| | succ p ih => |
| intro v hv |
| rcases Finset.mem_union.mp hv with hv|hv |
| · exact ih hv |
| rcases Finset.mem_biUnion.mp hv with ⟨e,he,hv⟩ |
| exact Finset.mem_biUnion.mpr ⟨e,(Finset.mem_filter.mp he).1,hv⟩ |
|
|
| |
|
|
| theorem used_eq_ball (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) |
| (H : Finset (Edge n)) |
| (hcone : H⊆Locality.relevantEdges (H∪{r}) (qaoaWord p γ β) {r.1.1,r.1.2}) : |
| usedVertices r H=Locality.ball (H∪{r}) {r.1.1,r.1.2} p := by |
| apply Finset.Subset.antisymm _ (ball_subset_used r H p) |
| intro v hv |
| rcases Finset.mem_biUnion.mp hv with ⟨e,he,hv⟩ |
| rcases Finset.mem_union.mp he with he|he |
| · have hh := Locality.relevant_endpoints_in_ball (H∪{r}) p γ β _ (hcone he) |
| rcases Finset.mem_insert.mp hv with hv|hv |
| · exact hv ▸ hh.1 |
| · exact (Finset.mem_singleton.mp hv) ▸ hh.2 |
| · have he' := Finset.mem_singleton.mp he |
| subst e |
| exact Locality.subset_ball _ _ p hv |
|
|
| end SiteHistories |
| end SKQAOA |
|
|
| |
|
|
| open scoped BigOperators |
|
|
| namespace SKQAOA |
| namespace FiniteGraph |
| variable {n : ℕ} |
|
|
| |
|
|
| def pairEdges (u v : Fin n) : Finset (Edge n) := |
| if h : u<v then {⟨(u,v),h⟩} else |
| if h' : v<u then {⟨(v,u),h'⟩} else ∅ |
|
|
| lemma mem_pairEdges (u v : Fin n) (e : Edge n) : |
| e∈pairEdges u v ↔ ((e.1.1=u ∧ e.1.2=v) ∨ (e.1.1=v ∧ e.1.2=u)) := by |
| simp only [pairEdges] |
| split_ifs with h h' |
| · rw [Finset.mem_singleton] |
| constructor |
| · rintro rfl |
| exact Or.inl ⟨rfl,rfl⟩ |
| · rintro (⟨hu,hv⟩|⟨hv,hu⟩) |
| · exact Subtype.ext (Prod.ext hu hv) |
| · have := e.2 |
| rw [hu,hv] at this |
| exact (lt_asymm h this).elim |
| · rw [Finset.mem_singleton] |
| constructor |
| · rintro rfl |
| exact Or.inr ⟨rfl,rfl⟩ |
| · rintro (⟨hu,hv⟩|⟨hv,hu⟩) |
| · have := e.2 |
| rw [hu,hv] at this |
| exact (h this).elim |
| · exact Subtype.ext (Prod.ext hv hu) |
| · simp only [Finset.notMem_empty,false_iff] |
| rintro (⟨hu,hv⟩|⟨hv,hu⟩) |
| · exact h (by simpa only [hu,hv] using e.2) |
| · exact h' (by simpa only [hu,hv] using e.2) |
|
|
| def edgesOfLinks (l : Multiset (Fin n × Fin n)) : Finset (Edge n) := |
| l.toFinset.biUnion (fun q => pairEdges q.1 q.2) |
|
|
| lemma mem_edgesOfLinks (l : Multiset (Fin n × Fin n)) (e : Edge n) : |
| e∈edgesOfLinks l ↔ ∃q∈l, |
| ((e.1.1=q.1 ∧ e.1.2=q.2) ∨ (e.1.1=q.2 ∧ e.1.2=q.1)) := by |
| simp only [edgesOfLinks,Finset.mem_biUnion,Multiset.mem_toFinset,mem_pairEdges] |
|
|
| |
|
|
| lemma parentEdge_injective (U S : Finset (Fin n)) (parent : Fin n → Fin n) |
| (rank : Fin n → ℕ) (edge : Fin n → Edge n) |
| (hrank : ∀j∈U\S, rank (parent j)+1=rank j) |
| (hedge : ∀j∈U\S, (edge j∈pairEdges (parent j) j)) : |
| Set.InjOn edge (↑(U\S) : Set (Fin n)) := by |
| intro i hi j hj heq |
| have hi' := (mem_pairEdges (parent i) i (edge i)).mp (hedge i hi) |
| have hj' := (mem_pairEdges (parent j) j (edge j)).mp (hedge j hj) |
| rw [heq] at hi' |
| rcases hi' with ⟨hp,hi'⟩|⟨hi',hp⟩ <;> rcases hj' with ⟨hq,hj'⟩|⟨hj',hq⟩ |
| · exact hi'.symm.trans hj' |
| · have h1 : parent i=j := hp.symm.trans hj' |
| have h2 : parent j=i := hq.symm.trans hi' |
| have hir := hrank i hi |
| have hjr := hrank j hj |
| rw [h1] at hir |
| rw [h2] at hjr |
| omega |
| · have h1 : parent i=j := hp.symm.trans hj' |
| have h2 : parent j=i := hq.symm.trans hi' |
| have hir := hrank i hi |
| have hjr := hrank j hj |
| rw [h1] at hir |
| rw [h2] at hjr |
| omega |
| · exact hi'.symm.trans hj' |
|
|
| lemma edge_unique {u v : Fin n} {e f : Edge n} |
| (he : e∈pairEdges u v) (hf : f∈pairEdges u v) : e=f := by |
| unfold pairEdges at he hf |
| split_ifs at he hf <;> simp_all |
|
|
| lemma edgesOfLinks_parent (U S : Finset (Fin n)) (parent : Fin n → Fin n) |
| (edge : Fin n → Edge n) |
| (hedge : ∀j∈U\S, edge j∈pairEdges (parent j) j) : |
| edgesOfLinks ((U\S).val.map (fun j => (parent j,j)))=(U\S).image edge := by |
| ext e |
| simp only [mem_edgesOfLinks,Multiset.mem_map,Finset.mem_val,Finset.mem_image] |
| constructor |
| · rintro ⟨q,⟨j,hj,rfl⟩,he⟩ |
| exact ⟨j,hj,(edge_unique (hedge j hj) ((mem_pairEdges _ _ _).mpr he))⟩ |
| · rintro ⟨j,hj,rfl⟩ |
| exact ⟨(parent j,j),⟨j,hj,rfl⟩,(mem_pairEdges _ _ _).mp (hedge j hj)⟩ |
|
|
| end FiniteGraph |
| end SKQAOA |
|
|
| |
|
|
| open scoped BigOperators Topology |
|
|
| namespace BoundedBranch |
| abbrev Forest (n h : ℕ) := Tree n h × Tree n h |
|
|
| def forestSize {n h : ℕ} (b : Forest n h) : ℕ := size n h b.1+size n h b.2 |
|
|
| def forestLabels {n h : ℕ} (b : Forest n h) : Multiset (Fin n) := |
| labels n h b.1+labels n h b.2 |
|
|
| def forestLinks {n h : ℕ} (r₁ r₂ : Fin n) (b : Forest n h) : Multiset (Fin n × Fin n) := |
| links n h r₁ b.1+links n h r₂ b.2 |
|
|
| def forestWeight {n h : ℕ} (x : ℝ) (b : Forest n h) : ℝ := |
| weight n x h b.1*weight n x h b.2 |
|
|
| @[simp] lemma card_forestLabels {n h : ℕ} (b : Forest n h) : |
| (forestLabels b).card=forestSize b := by simp [forestLabels,forestSize] |
|
|
| @[simp] lemma card_forestLinks {n h : ℕ} (r₁ r₂ : Fin n) (b : Forest n h) : |
| (forestLinks r₁ r₂ b).card=forestSize b := by simp [forestLinks,forestSize] |
|
|
| @[simp] lemma map_snd_forestLinks {n h : ℕ} (r₁ r₂ : Fin n) (b : Forest n h) : |
| (forestLinks r₁ r₂ b).map Prod.snd=forestLabels b := by |
| simp only [forestLinks,Multiset.map_add,map_snd_links,forestLabels] |
|
|
| lemma forestWeight_eq_pow {n h : ℕ} (x : ℝ) (b : Forest n h) : |
| forestWeight x b=(x/(n:ℝ))^(forestSize b) := by |
| simp only [forestWeight,weight_eq_pow,forestSize,pow_add] |
|
|
| lemma forestWeight_nonneg {n h : ℕ} {x : ℝ} (hx : 0≤x) (b : Forest n h) : |
| 0≤forestWeight x b := |
| mul_nonneg (weight_nonneg n h hx b.1) (weight_nonneg n h hx b.2) |
|
|
| lemma forestWeight_scale {n h : ℕ} (x z : ℝ) (b : Forest n h) : |
| forestWeight (z*x) b=z^(forestSize b)*forestWeight x b := by |
| simp only [forestWeight_eq_pow,mul_div_assoc,mul_pow] |
|
|
| lemma sum_forestWeight (n h : ℕ) (x : ℝ) : |
| (∑b : Forest n h,forestWeight x b)=(partition n h x)^2 := by |
| simp only [forestWeight,Fintype.sum_prod_type,←Finset.mul_sum,←Finset.sum_mul, |
| partition,pow_two] |
|
|
| lemma sum_forestWeight_le_tower (n h : ℕ) {x : ℝ} (hx : 0≤x) : |
| (∑b : Forest n h,forestWeight x b)≤(tower x h)^2 := by |
| rw [sum_forestWeight] |
| exact pow_le_pow_left₀ (partition_nonneg n h hx) (partition_le_tower n h hx) 2 |
|
|
| |
| lemma forest_tail_bound (n h L : ℕ) {x : ℝ} (hx : 0≤x) : |
| (∑b : Forest n h with L≤forestSize b,forestWeight x b)≤(tower (2*x) h)^2/(2:ℝ)^L := by |
| have hp : (0:ℝ)<2^L := pow_pos (by norm_num) _ |
| apply (le_div_iff₀ hp).mpr |
| rw [mul_comm,Finset.mul_sum] |
| calc |
| _ ≤ ∑b : Forest n h with L≤forestSize b,forestWeight (2*x) b := by |
| apply Finset.sum_le_sum |
| intro b hb |
| rw [forestWeight_scale] |
| exact mul_le_mul_of_nonneg_right |
| (pow_le_pow_right₀ (by norm_num) (Finset.mem_filter.mp hb).2) |
| (forestWeight_nonneg hx b) |
| _ ≤ ∑b : Forest n h,forestWeight (2*x) b := |
| Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) |
| (fun b _ _ => forestWeight_nonneg (by positivity) b) |
| _ ≤ _ := sum_forestWeight_le_tower n h (by positivity) |
|
|
| end BoundedBranch |
|
|
| |
|
|
| open scoped BigOperators |
|
|
| namespace SKQAOA.SiteHistories |
| open BoundedBranch Locality FiniteGraph |
| variable {n : ℕ} |
|
|
| def roots (r : Edge n) : Finset (Fin n) := {r.1.1,r.1.2} |
| def reached (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : Finset (Fin n) := |
| ball (H∪{r}) (roots r) p |
|
|
| def distance (r : Edge n) (H : Finset (Edge n)) : Fin n → ℕ := |
| rank (H∪{r}) (roots r) |
|
|
| lemma exists_parent_pair (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) |
| (hv : v∈reached r H p\roots r) : |
| ∃q : Fin n × Edge n, q.2∈H∪{r} ∧ q.1∈reached r H p ∧ |
| distance r H q.1+1=distance r H v ∧ q.2∈pairEdges q.1 v := by |
| obtain ⟨u,e,he,hu,hr,hend⟩ := exists_parent (Finset.mem_sdiff.mp hv).1 |
| (Finset.mem_sdiff.mp hv).2 |
| refine ⟨(u,e),he,hu,hr,(mem_pairEdges _ _ _).mpr ?_⟩ |
| exact hend.symm |
|
|
| def parentPair (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) : Fin n × Edge n := |
| if hv : v∈reached r H p\roots r then |
| Classical.choose (exists_parent_pair r H p v hv) else (v,r) |
|
|
| lemma parentPair_spec (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) |
| (hv : v∈reached r H p\roots r) : |
| (parentPair r H p v).2∈H∪{r} ∧ (parentPair r H p v).1∈reached r H p ∧ |
| distance r H (parentPair r H p v).1+1=distance r H v ∧ |
| (parentPair r H p v).2∈pairEdges (parentPair r H p v).1 v := by |
| simpa only [parentPair,dite_eq_left hv] using Classical.choose_spec (exists_parent_pair r H p v hv) |
|
|
| def parent (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) : Fin n := |
| (parentPair r H p v).1 |
|
|
| def parentEdge (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) : Edge n := |
| (parentPair r H p v).2 |
|
|
| lemma parent_spec (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| ∀v∈reached r H p\roots r, parent r H p v∈reached r H p ∧ |
| distance r H (parent r H p v)+1=distance r H v := by |
| intro v hv |
| exact ⟨(parentPair_spec r H p v hv).2.1,(parentPair_spec r H p v hv).2.2.1⟩ |
|
|
| lemma distance_zero (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| ∀v∈reached r H p, distance r H v=0 ↔ v∈roots r := by |
| intro v hv |
| exact rank_zero_iff hv |
|
|
| lemma distance_bound (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| ∀v∈reached r H p, distance r H v≤p := by |
| intro v hv |
| exact rank_le_of_mem hv |
|
|
| lemma roots_subset_reached (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| roots r⊆reached r H p := subset_ball _ _ _ |
|
|
| lemma parentEdge_mem (r : Edge n) (H : Finset (Edge n)) (p : ℕ) (v : Fin n) |
| (hv : v∈reached r H p\roots r) : parentEdge r H p v∈H := by |
| have hh := parentPair_spec r H p v hv |
| rcases Finset.mem_union.mp hh.1 with he|he |
| · exact he |
| · have he' : parentEdge r H p v=r := Finset.mem_singleton.mp he |
| have hvnot := (Finset.mem_sdiff.mp hv).2 |
| have hl : parentEdge r H p v∈pairEdges (parent r H p v) v := hh.2.2.2 |
| rw [he'] at hl |
| rcases (mem_pairEdges _ _ _).mp hl with ⟨_,hrv⟩|⟨hrv,_⟩ |
| · exact (hvnot (by simp [roots,←hrv])).elim |
| · exact (hvnot (by simp [roots,←hrv])).elim |
|
|
| |
|
|
| def forestCode (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : Forest n p := |
| (unfoldTree (reached r H p) (roots r) (parent r H p) p r.1.1, |
| unfoldTree (reached r H p) (roots r) (parent r H p) p r.1.2) |
|
|
| lemma forestCode_labels (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestLabels (forestCode r H p)=(reached r H p\roots r).val := by |
| have he := Parent.sum_labels_roots (reached r H p) (roots r) (parent r H p) |
| (distance r H) (roots_subset_reached r H p) |
| (distance_zero r H p) (parent_spec r H p) p (distance_bound r H p) |
| simpa only [roots,Finset.sum_pair (ne_of_lt r.2),forestLabels,forestCode] using he |
|
|
| lemma forestCode_links (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestLinks r.1.1 r.1.2 (forestCode r H p)= |
| (reached r H p\roots r).val.map (fun v => (parent r H p v,v)) := by |
| have he := Parent.sum_links_roots (reached r H p) (roots r) (parent r H p) |
| (distance r H) (roots_subset_reached r H p) |
| (distance_zero r H p) (parent_spec r H p) p (distance_bound r H p) |
| simpa only [roots,Finset.sum_pair (ne_of_lt r.2),forestLinks,forestCode] using he |
|
|
| lemma forestCode_size (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestSize (forestCode r H p)=(reached r H p\roots r).card := by |
| rw [←card_forestLabels,forestCode_labels] |
| rfl |
|
|
| def forestVertices {p : ℕ} (r : Edge n) (b : Forest n p) : Finset (Fin n) := |
| roots r∪(forestLabels b).toFinset |
|
|
| def forestEdges {p : ℕ} (r : Edge n) (b : Forest n p) : Finset (Edge n) := |
| edgesOfLinks (forestLinks r.1.1 r.1.2 b) |
|
|
| lemma forestCode_vertices (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestVertices r (forestCode r H p)=reached r H p := by |
| rw [forestVertices,forestCode_labels] |
| simp only [Finset.val_toFinset] |
| exact Finset.union_sdiff_of_subset (roots_subset_reached r H p) |
|
|
| lemma forestCode_edges (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestEdges r (forestCode r H p)=(reached r H p\roots r).image (parentEdge r H p) := by |
| rw [forestEdges,forestCode_links] |
| exact edgesOfLinks_parent _ _ _ _ (fun v hv => (parentPair_spec r H p v hv).2.2.2) |
|
|
| lemma forestCode_edges_subset (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| forestEdges r (forestCode r H p)⊆H := by |
| rw [forestCode_edges] |
| rintro e he |
| obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp he |
| exact parentEdge_mem r H p v hv |
|
|
| lemma forestCode_edges_card (r : Edge n) (H : Finset (Edge n)) (p : ℕ) : |
| (forestEdges r (forestCode r H p)).card=forestSize (forestCode r H p) := by |
| rw [forestCode_edges,forestCode_size] |
| apply Finset.card_image_iff.mpr |
| exact parentEdge_injective _ _ _ (distance r H) _ |
| (fun v hv => (parent_spec r H p v hv).2) |
| (fun v hv => (parentPair_spec r H p v hv).2.2.2) |
|
|
| end SKQAOA.SiteHistories |
|
|
| end |
|
|
| end OAI |
|
|
