| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.AllGraph |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.PacketLocality |
| open Construction SourceProbability FiniteDistribution Games RankGraph PacketSeeds |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : Nat} [NeZero M] [NeZero T] |
|
|
| abbrev Slots (T : Nat) := Fin (T+1) |
| def localGame (f : Slots T → X ≃ Y × Bool) : Game (Slots T) (Slots T) (Slots T) X Y where |
| edgeLaw := uniform _ |
| left := id |
| right := id |
| project e x := (f e x).1 |
|
|
| variable (G : Game U V E X Y) (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (s : Seed X Y M T N) (e : Slots T → E) (a : U → X) (b : V → Y) |
|
|
| lemma comp_snoc {t : Nat} {A B : Type} (f : A → B) (v : Fin t → A) (w : A) : |
| (fun i : Fin (t+1) => f ((Fin.snoc v w : Fin (t+1) → A) i))=Fin.snoc (fun i => f (v i)) (f w) := Fin.comp_snoc _ _ _ |
| |
| lemma map_snoc_apply {t : Nat} {A B : Type} (f : A → B) (v : Fin t → A) (w : A) (i : Fin (t+1)) : |
| f ((Fin.snoc v w : Fin (t+1) → A) i)= (Fin.snoc (fun i => f (v i)) (f w) : Fin (t+1) → B) i := |
| congrFun (Fin.comp_snoc f v w) i |
| |
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| lemma deleted_fill : |
| AllLabels.deleted G hYX fiber a b (fill G s e) ↔ |
| AllLabels.deleted (localGame (fiber ∘ e)) hYX (fiber ∘ e) |
| (a ∘ G.left ∘ e) (b ∘ G.right ∘ e) (fill (localGame (fiber ∘ e)) s id) := by |
| rcases s with s | (s | (s | s)) |
| · rfl |
| · simp +unfoldPartialApp only [AllLabels.deleted,TestGraph.LabelDeleted,fill,fillBig,fillCommon,fillPrefix,fresh, |
| wildcard,bigWildcard,labels,vertices,localGame,map_snoc_apply,Function.comp_def,id_eq] |
| rfl |
| · rfl |
| · simp +unfoldPartialApp only [AllLabels.deleted,TestGraph.LabelDeleted,fill,fillCompare,comparison, |
| fillCommon,fillPrefix,fresh,localGame,twoLevel,eval_vertex,labels,vertices, |
| map_snoc_apply,Function.comp_def,id_eq] |
| rfl |
| |
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| lemma height_fill : |
| AllLabels.height G hYX fiber a b (fill G s e) = |
| AllLabels.height (localGame (fiber ∘ e)) hYX (fiber ∘ e) |
| (a ∘ G.left ∘ e) (b ∘ G.right ∘ e) (fill (localGame (fiber ∘ e)) s id) := by |
| rcases s with s | (s | (s | s)) |
| · rfl |
| · simp +unfoldPartialApp only [AllLabels.height,fill,fillBig,fillCommon,fillPrefix,fresh, |
| wildcard,bigWildcard,labels,vertices,localGame,map_snoc_apply,Function.comp_def,id_eq] |
| rfl |
| · rfl |
| · simp +unfoldPartialApp only [AllLabels.height,fill,fillCompare,comparison, |
| fillCommon,fillPrefix,fresh,localGame,twoLevel,eval_vertex,labels,vertices, |
| map_snoc_apply,Function.comp_def,id_eq] |
| rfl |
| |
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| lemma code_fill : |
| AllLabels.code G hYX fiber a b (fill G s e) = |
| AllLabels.code (localGame (fiber ∘ e)) hYX (fiber ∘ e) |
| (a ∘ G.left ∘ e) (b ∘ G.right ∘ e) (fill (localGame (fiber ∘ e)) s id) := by |
| unfold AllLabels.code |
| rw [deleted_fill G hYX fiber s e a b] |
| split_ifs |
| · rfl |
| · congr 2 |
| exact height_fill G hYX fiber s e a b |
| |
| end DirectedFeedback.PacketLocality |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RawFamily |
| open BoundedExpr Construction PacketSeeds Games RankGraph |
| variable (q M T N : Nat) [NeZero q] [NeZero M] [NeZero T] [NeZero N] |
| abbrev X := Fin q × Bool |
| abbrev Y := Fin q |
| abbrev Shape := RankPackets.Shape (X q) (Y q) T N |
| abbrev Seed := PacketSeeds.Seed (X q) (Y q) M T N |
| abbrev Tag := Shape q T N ⊕ Seed q M T N |
| instance tagNonempty : Nonempty (Tag q M T N) := ⟨.inl (.inl ⟨0,fun _ => 0⟩)⟩ |
| omit [NeZero q] in |
| theorem hYX : Fintype.card (Y q) ≤ Fintype.card (X q) := by simp [X,Y,Fintype.card_prod]; omega |
| variable (D C : Nat) (c : Seed q M T N → Nat) |
| def scale (x : List Bool) : Nat := C*(GameRead.m x)^(T+1) |
| def r (x : List Bool) : Nat := scale T C x*(D+1) |
| def base (x : List Bool) := SumBox.base (GameRead.n x) (GameRead.m x) |
| def copies (x : List Bool) := SumBox.copies (r T D C x) c |
| |
| def size (x : List Bool) := SumBox.size (Shape q T N) (Seed q M T N) |
| (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c |
| def tag (x : List Bool) (i : Nat) := SumBox.tag (Shape q T N) (Seed q M T N) |
| (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c i |
| def digit (x : List Bool) (i : Nat) (j : Fin (T+1)) := SumBox.digits (Seed q M T N) |
| (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c i j |
| def copy (x : List Bool) (i : Nat) := SumBox.copy (Seed q M T N) |
| (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c i |
| def valid (x : List Bool) (i : Nat) := SumBox.valid (Shape q T N) (Seed q M T N) |
| (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c i |
| |
| def isRank : Tag q M T N → Prop | .inl _ => True | .inr _ => False |
| def u (x : List Bool) (i : Nat) (j : Fin (T+1)) : Nat := |
| if isRank q M T N (tag q M T N D C c x i) then digit q M T N D C c x i j |
| else GameRead.left q x (digit q M T N D C c x i j) |
| def v (x : List Bool) (i : Nat) (j : Fin (T+1)) : Nat := |
| if isRank q M T N (tag q M T N D C c x i) then digit q M T N D C c x i j |
| else GameRead.right q x (digit q M T N D C c x i j) |
|
|
| def tagRule (s : Tag q M T N) (f : Fin (T+1) → X q ≃ Y q × Bool) : |
| LocalPrinter.Rule (Fin (T+1)) (Fin (T+1)) (X q) (Y q) (2*N+1) := fun a b => |
| AllLabels.code (PacketLocality.localGame f) (hYX q) f a b |
| (match s with |
| | .inl r => .inl (RankPackets.fill r id) |
| | .inr s => PacketSeeds.fill (PacketLocality.localGame f) s id) |
| def rule (x : List Bool) (i : Nat) := tagRule q M T N (tag q M T N D C c x i) |
| (fun j => GameRead.fiber q x (digit q M T N D C c x i j)) |
|
|
| omit [NeZero T] in |
| theorem scale_def (s : Nat) : Def (r:=s) (fun x _ => scale T C x) := |
| (Def.lit C).mul ((GameRead.m_def s).pow (T+1)) |
| omit [NeZero T] in |
| theorem r_def (s : Nat) : Def (r:=s) (fun x _ => r T D C x) := |
| (scale_def T C s).mul (Def.lit (D+1)) |
| theorem base_def (s : Nat) : Def (r:=s) (fun x _ => base x) := |
| ((GameRead.n_def s).add (GameRead.m_def s)).add (Def.lit 1) |
| omit [NeZero q] [NeZero M] [NeZero T] [NeZero N] in |
| theorem copies_def (s : Nat) : Def (r:=s) (fun x _ => copies q M T N D C c x) := |
| ((r_def T D C s).add (Def.lit (∑ s,c s))).add (Def.lit 1) |
| omit [NeZero q] [NeZero M] [NeZero T] [NeZero N] in |
| theorem size_def : Def (r:=0) (fun x _ => size q M T N D C c x) := |
| (Def.lit (Fintype.card (Tag q M T N))).mul |
| (((base_def 0).pow (T+1)).mul (copies_def q M T N D C c 0)) |
| omit [NeZero q] [NeZero M] [NeZero T] in |
| theorem tag_def : FDef (r:=1) (fun x a => tag q M T N D C c x (a 0)) := |
| BoxCodec.tag_def _ (base_def 1) (copies_def q M T N D C c 1) (Def.arg 0) (T+1) |
| omit [NeZero q] [NeZero M] [NeZero T] [NeZero N] in |
| theorem digit_def (j : Fin (T+1)) : Def (r:=1) (fun x a => digit q M T N D C c x (a 0) j) := |
| BoxCodec.digits_def (base_def 1) (copies_def q M T N D C c 1) (Def.arg 0) (T+1) j |
| omit [NeZero q] [NeZero M] [NeZero T] [NeZero N] in |
| theorem copy_def : Def (r:=1) (fun x a => copy q M T N D C c x (a 0)) := |
| BoxCodec.copy_def (base_def 1) (copies_def q M T N D C c 1) (Def.arg 0) (T+1) |
| omit [NeZero q] [NeZero M] [NeZero T] in |
| theorem isRank_def : PDef (r:=1) (fun x a => isRank q M T N (tag q M T N D C c x (a 0))) := |
| (tag_def q M T N D C c).toDef (fun s => if isRank q M T N s then 1 else 0) |
| omit [NeZero q] [NeZero M] [NeZero T] in |
| theorem u_def (j : Fin (T+1)) : Def (r:=1) (fun x a => u q M T N D C c x (a 0) j) := |
| (isRank_def q M T N D C c).nite (digit_def q M T N D C c j) |
| (GameRead.left_def q (digit_def q M T N D C c j)) |
| omit [NeZero q] [NeZero M] [NeZero T] in |
| theorem v_def (j : Fin (T+1)) : Def (r:=1) (fun x a => v q M T N D C c x (a 0) j) := |
| (isRank_def q M T N D C c).nite (digit_def q M T N D C c j) |
| (GameRead.right_def q (digit_def q M T N D C c j)) |
| omit [NeZero M] [NeZero T] in |
| theorem rule_def : FDef (r:=1) (fun x a => rule q M T N D C c x (a 0)) := |
| ((tag_def q M T N D C c).pair (FDef.pi (fun j => |
| GameRead.fiber_def q (digit_def q M T N D C c j)))).map (fun z => tagRule q M T N z.1 z.2) |
| omit [NeZero q] [NeZero M] [NeZero T] in |
| theorem valid_def : PDef (r:=1) (fun x a => valid q M T N D C c x (a 0)) := by |
| let f : Tag q M T N → Nat := Sum.elim (fun _ => 0) c |
| have ht := tag_def q M T N D C c |
| have hd := digit_def q M T N D C c |
| have hj := copy_def q M T N D C c |
| have hi := isRank_def q M T N D C c |
| have h := (hi.and ((PDef.all (fun j => PDef.lt (hd j) (GameRead.n_def 1))).and |
| (PDef.lt hj (r_def T D C 1)))).or |
| (hi.not.and ((PDef.all (fun j => PDef.lt (hd j) (GameRead.m_def 1))).and |
| (PDef.lt hj (ht.toDef f)))) |
| apply h.congr |
| intro x a |
| unfold valid SumBox.valid |
| simp only [tag,digit,copy] |
| cases SumBox.tag (Shape q T N) (Seed q M T N) (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c (a 0) <;> simp [isRank,f] |
|
|
| def family (hC : 0<C) : LocalPrinter.Family (Fin (T+1)) (Fin (T+1)) (X q) (Y q) (2*N+1) where |
| n := size q M T N D C c |
| k := fun x => 4*scale T C x |
| valid := valid q M T N D C c |
| u := u q M T N D C c |
| v := v q M T N D C c |
| rule := rule q M T N D C c |
| n_def := size_def q M T N D C c |
| k_def := (Def.lit 4).mul (scale_def T C 0) |
| valid_def := valid_def q M T N D C c |
| u_def := u_def q M T N D C c |
| v_def := v_def q M T N D C c |
| rule_def := rule_def q M T N D C c |
| k_pos x := by unfold scale; have := GameRead.m_pos x; positivity |
|
|
| end DirectedFeedback.RawFamily |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.PacketSeeds |
| open SourceProbability FiniteDistribution Construction PrefixExperiment Games |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : Nat} [NeZero M] [NeZero T] |
| variable (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
|
|
| def mass (H K : Nat) : Seed X Y M T N → ℝ |
| | .inl s => H*(fullLaw ψLaw).weight s |
| | .inr (.inl s) => Fintype.card X*(bigLaw ψLaw).weight s |
| | .inr (.inr (.inl s)) => Fintype.card Y*(smallLaw ψLaw).weight s |
| | .inr (.inr (.inr s)) => K*(compareLaw ψLaw).weight s |
|
|
| theorem mass_nonnegative (H K : Nat) (s : Seed X Y M T N) : 0 ≤ mass ψLaw H K s := by |
| rcases s with s | (s | (s | s)) <;> exact mul_nonneg (Nat.cast_nonneg _) (FiniteDistribution.nonnegative _ _) |
|
|
| omit [Nonempty X] in |
| theorem slot_rational : (slotLaw (X:=X) (M:=M)).RationalMass := |
| RationalMass.uniform.sigma (fun i => Construction.subsetLaw_rational i) |
|
|
| omit [Nonempty X] in |
| theorem common_rational (hψ : ψLaw.RationalMass) : (commonLaw (M:=M) ψLaw).RationalMass := |
| hψ.product (RationalMass.uniform.sigma (fun _ => slot_rational.iid _)) |
|
|
| omit [Nonempty Y] in |
| theorem localCompare_rational (t : Nat) : (localCompareLaw (Y:=Y) (M:=M) t).RationalMass := by |
| apply RationalMass.uniform.sigma |
| intro i |
| apply RationalMass.uniform.product |
| apply RationalMass.table |
| intro _ b |
| obtain ⟨⟨b₁,b₂⟩,b₃⟩ := b |
| have hp : Rational (bias i) := (Rational.nat 2).inv.pow _ |
| have h1 := Rational.one.sub hp |
| cases b₁ <;> cases b₂ <;> cases b₃ <;> |
| first | exact Rational.one.sub ((Rational.nat 2).mul hp) |
| | exact hp.pow 2 | exact hp.mul h1 | exact Rational.zero |
|
|
| theorem mass_rational (hψ : ψLaw.RationalMass) (H K : Nat) (s : Seed X Y M T N) : |
| Rational (mass ψLaw H K s) := by |
| rcases s with s | (s | (s | s)) |
| · exact (Rational.nat H).mul ((hψ.product (slot_rational.iid T)) s) |
| · exact (Rational.nat _).mul (((common_rational ψLaw hψ).product |
| (RationalMass.uniform.sigma (fun _ => RationalMass.uniform))) s) |
| · exact (Rational.nat _).mul (((common_rational ψLaw hψ).product |
| (RationalMass.uniform.sigma (fun _ => RationalMass.uniform))) s) |
| · exact (Rational.nat K).mul (((common_rational ψLaw hψ).sigma |
| (fun d => localCompare_rational d.2.1.val)) s) |
|
|
| theorem denominator (hψ : ψLaw.RationalMass) (H K : Nat) : |
| ∃ C : Nat, 0<C ∧ ∃ c : Seed X Y M T N → Nat, ∀ s, (C:ℝ)*mass ψLaw H K s=c s := |
| fixed_denominator _ (mass_rational ψLaw hψ H K) (mass_nonnegative ψLaw H K) |
|
|
| variable (G : Game U V E X Y) |
|
|
| theorem moment (D H K : Nat) (f : AllVertex U V E X Y M T N → ℝ) |
| (hf : ∀ r, f (.inl r)=0) : |
| (∑ s, mass ψLaw H K s*(G.edgeLaw.iid (T+1)).expectation (fun e => f (fill G s e))) = |
| ∑ v, allCost G ψLaw D H K v*f v := by |
| have hex := sample_full ψLaw G (fun v => f (.inr (.inl (.inl v)))) |
| have heb := sample_big ψLaw G (fun v => f (.inr (.inl (.inr (.inl v))))) |
| have hes := sample_small ψLaw G (fun v => f (.inr (.inl (.inr (.inr v))))) |
| have hec := sample_compare ψLaw G (fun v => f (.inr (.inr v))) |
| calc |
| _ = H*(fullLaw ψLaw).expectation (fun s => (G.edgeLaw.iid (T+1)).expectation |
| (fun e => f (.inr (.inl (.inl (fillFull G s e)))))) + |
| (Fintype.card X)*(bigLaw ψLaw).expectation (fun s => (G.edgeLaw.iid (T+1)).expectation |
| (fun e => f (.inr (.inl (.inr (.inl (fillBig G s e))))))) + |
| (Fintype.card Y)*(smallLaw ψLaw).expectation (fun s => (G.edgeLaw.iid (T+1)).expectation |
| (fun e => f (.inr (.inl (.inr (.inr (fillSmall G s e))))))) + |
| K*(compareLaw ψLaw).expectation (fun s => (G.edgeLaw.iid (T+1)).expectation |
| (fun e => f (.inr (.inr (fillCompare G s e))))) := by |
| simp only [Fintype.sum_sum_type,mass,fill,expectation,Finset.mul_sum] |
| ring_nf |
| _ = _ := by |
| rw [hex,heb,hes,hec] |
| simp only [Fintype.sum_sum_type,allCost,hf,mul_zero,Finset.sum_const_zero,zero_add, |
| expectation,Finset.mul_sum] |
| ring_nf |
|
|
| theorem iid_uniform_expectation {A : Type} [Fintype A] [Nonempty A] (L : Nat) (f : (Fin L → A) → ℝ) : |
| ((uniform A).iid L).expectation f = (∑ a, f a)/(Fintype.card A:ℝ)^L := by |
| simp only [expectation,iid,uniform,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
| simp only [div_eq_mul_inv,Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro a _ |
| ring |
|
|
| theorem integer_moment [Nonempty E] (hE : G.edgeLaw=uniform E) (D H K C : Nat) |
| (c : Seed X Y M T N → Nat) (hc : ∀ s, (C:ℝ)*mass ψLaw H K s=c s) |
| (f : AllVertex U V E X Y M T N → ℝ) (hf : ∀ r, f (.inl r)=0) : |
| (∑ s, (c s:ℝ)*∑ e : Fin (T+1) → E, f (fill G s e)) = |
| (C*(Fintype.card E)^(T+1):Nat)*(∑ v, allCost G ψLaw D H K v*f v) := by |
| rw [← moment ψLaw G D H K f hf] |
| simp only [hE,iid_uniform_expectation,Nat.cast_mul,Nat.cast_pow,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro s _ |
| have hm : ((Fintype.card E:ℝ)^(T+1)) ≠ 0 := by positivity |
| rw [← hc s] |
| field_simp |
| simp only [Finset.mul_sum] |
|
|
| end DirectedFeedback.PacketSeeds |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.LivePackets |
| open Construction SourceProbability FiniteDistribution Games RankGraph PacketSeeds |
| variable {W E X Y : Type} [Fintype W] [Fintype E] [Fintype X] [Fintype Y] |
| [Nonempty W] [Nonempty E] [Nonempty X] [Nonempty Y] |
| variable {M T N : Nat} [NeZero M] [NeZero T] |
|
|
| abbrev Live (r : Nat) (c : Seed X Y M T N → Nat) := |
| ((RankPackets.Shape X Y T N × (Fin (T+1) → W)) × Fin r) ⊕ |
| (Σ s : Seed X Y M T N, (Fin (T+1) → E) × Fin (c s)) |
| instance liveFintype (r : Nat) (c : Seed X Y M T N → Nat) : Fintype (Live (W:=W) (E:=E) r c) := by |
| unfold Live |
| infer_instance |
|
|
| variable (G : Game W W E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (r : Nat) (c : Seed X Y M T N → Nat) |
| def project : Live (W:=W) (E:=E) r c → AllVertex W W E X Y M T N |
| | .inl a => .inl (RankPackets.fill a.1.1 a.1.2) |
| | .inr a => PacketSeeds.fill G a.1 a.2.1 |
|
|
| omit [Nonempty W] [Nonempty E] [Nonempty X] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem sum_project (f : AllVertex W W E X Y M T N → ℝ) (hf : ∀ z, f (.inl z)=0) : |
| (∑ a : Live (W:=W) (E:=E) r c, f (project G r c a)) = |
| ∑ s, (c s:ℝ)*∑ e : Fin (T+1) → E, f (PacketSeeds.fill G s e) := by |
| simp only [Fintype.sum_sum_type,project,hf,Finset.sum_const_zero,zero_add,Fintype.sum_sigma, |
| Fintype.sum_prod_type,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] |
| simp only [Finset.mul_sum] |
|
|
| omit [Nonempty W] in |
| theorem sum_cost (hE : G.edgeLaw=uniform E) (D H K C : Nat) |
| (hc : ∀ s, (C:ℝ)*mass ψLaw H K s=c s) |
| (f : AllVertex W W E X Y M T N → ℝ) (hf : ∀ z, f (.inl z)=0) : |
| (∑ a : Live (W:=W) (E:=E) r c, f (project G r c a)) = |
| (C*(Fintype.card E)^(T+1):Nat)*(∑ v, allCost G ψLaw D H K v*f v) := by |
| rw [sum_project G r c f hf] |
| exact integer_moment ψLaw G hE D H K C c hc f hf |
|
|
| omit [Nonempty E] [Nonempty X] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem rank_fiber_bound (z : Rank W W X Y T N) : |
| r ≤ PotentialCover.fiberCount (project G r c) (.inl z) := by |
| obtain ⟨⟨s,a⟩,ha⟩ := RankPackets.fill_surjective (W:=W) (X:=X) (Y:=Y) (T:=T) (N:=N) z |
| change RankPackets.fill s a=z at ha |
| let f : Fin r → {v : Live (W:=W) (E:=E) r c // project G r c v=.inl z} := |
| fun j => ⟨.inl ((s,a),j),by change Sum.inl (RankPackets.fill s a)=Sum.inl z; rw [ha]⟩ |
| have hf : Function.Injective f := by |
| intro i j h |
| have := congrArg Subtype.val h |
| simpa [f] using this |
| have hcard := Fintype.card_le_of_injective f hf |
| rw [Fintype.card_fin] at hcard |
| convert hcard using 1 |
| rw [Fintype.card_subtype] |
| unfold PotentialCover.fiberCount |
| congr 1 |
| ext v |
| simp |
|
|
| omit [Nonempty W] in |
| theorem test_fiber_count (hE : G.edgeLaw=uniform E) (D H K C : Nat) |
| (hc : ∀ s, (C:ℝ)*mass ψLaw H K s=c s) |
| (z : Wild W W X Y M T N ⊕ Compare W E X Y M T N) : |
| (PotentialCover.fiberCount (project G r c) (.inr z):ℝ) = |
| (C*(Fintype.card E)^(T+1):Nat)*allCost G ψLaw D H K (.inr z) := by |
| have h := sum_cost G ψLaw r c hE D H K C hc (fun v => if v=.inr z then 1 else 0) |
| (fun _ => by simp) |
| simp only [mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true] at h |
| rw [← h] |
| simp only [PotentialCover.fiberCount,Finset.card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero] |
| |
| theorem fiber_weight (hE : G.edgeLaw=uniform E) (D H K C : Nat) |
| (hc : ∀ s, (C:ℝ)*mass ψLaw H K s=c s) |
| (hr : C*(Fintype.card E)^(T+1)*(D+1) ≤ r) |
| (v : AllVertex W W E X Y M T N) : |
| (C*(Fintype.card E)^(T+1):Nat)*allCost G ψLaw D H K v ≤ |
| PotentialCover.fiberCount (project G r c) v := by |
| cases v with |
| | inl z => |
| have hh := le_trans hr (rank_fiber_bound G r c z) |
| simpa only [allCost,Nat.cast_mul,Nat.cast_add,Nat.cast_one,Nat.cast_pow] using |
| (show (C*(Fintype.card E)^(T+1)*(D+1):Nat)≤PotentialCover.fiberCount (project G r c) (.inl z) from hh) |
| |> (fun h => (Nat.cast_le (α:=ℝ)).mpr h) |
| | inr z => exact (test_fiber_count G ψLaw r c hE D H K C hc z).symm.le |
| |
| end DirectedFeedback.LivePackets |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.FiniteLift |
| variable {L B : Type} [Fintype L] [Fintype B] |
| variable {n : Nat} (e : L → Fin n) (he : Function.Injective e) |
| include he |
| def pull (F : Finset (Fin n)) : Finset L := Finset.univ.filter (fun a => e a ∈ F) |
| |
| theorem pull_card (F : Finset (Fin n)) : (pull e F).card ≤ F.card := by |
| calc |
| _ = ((pull e F).image e).card := (Finset.card_image_of_injective _ he).symm |
| _ ≤ F.card := Finset.card_le_card (by intro x hx; obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hx; exact (Finset.mem_filter.mp ha).2) |
| |
| theorem pull_feedback (R : Fin n → Fin n → Prop) (F : Finset (Fin n)) (hF : FeedbackR R F) : |
| FeedbackR (fun a b => R (e a) (e b)) (pull e F) := by |
| intro k f hi ha |
| obtain ⟨i,hi⟩ := hF k (e ∘ f) (he.comp hi) ha |
| exact ⟨i,by simp [pull] at hi ⊢; exact hi⟩ |
| |
| theorem feedback_cost (p : L → B) (R : B → B → Prop) (S : Fin n → Fin n → Prop) |
| (hcover : ∀ a b, R (p a) (p b) → S (e a) (e b)) (w : B → ℝ) (C D : Nat) |
| (hw : ∀ b, (C:ℝ)*w b ≤ PotentialCover.fiberCount p b) |
| (hgap : ∀ F : Finset B, FeedbackR R F → (D:ℝ)<∑ b ∈ F,w b) |
| (hC : 0<C) (F : Finset (Fin n)) (hF : FeedbackR S F) : |
| (C*D:Nat) < (F.card:ℝ) := by |
| have hp := pull_feedback e he S F hF |
| have hb := PotentialCover.feedback_project p R (fun a b => S (e a) (e b)) hcover (pull e F) hp |
| have hc := PotentialCover.weight_le_card p w C hw (pull e F) |
| have hd := mul_lt_mul_of_pos_left (hgap _ hb) (show (0:ℝ)<C by exact_mod_cast hC) |
| have hcard : ((pull e F).card:ℝ)≤F.card := by exact_mod_cast pull_card e he F |
| rw [Nat.cast_mul] |
| linarith |
| end DirectedFeedback.FiniteLift |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RawFamily |
| open Construction Games PacketSeeds SourceProbability FiniteDistribution RankGraph |
| variable {q M T N : Nat} [NeZero q] [NeZero M] [NeZero T] [NeZero N] |
| variable (D C : Nat) (c : Seed q M T N → Nat) (hC : 0<C) (x : List Bool) |
| abbrev W := Fin (GameRead.n x) |
| abbrev E := Fin (GameRead.m x) |
| instance wNonempty : Nonempty (W x) := ⟨⟨0,GameRead.n_pos x⟩⟩ |
| instance eNonempty : Nonempty (E x) := ⟨⟨0,GameRead.m_pos x⟩⟩ |
| abbrev Live := LivePackets.Live (W:=W x) (E:=E x) (r T D C x) c |
| |
| def embed (z : Live D C c x) : Fin ((family q M T N D C c hC).n x) := |
| SumBox.embed (Shape q T N) (Seed q M T N) (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c z |
| |
| omit [NeZero M] [NeZero T] in |
| theorem embed_injective : Function.Injective (embed D C c hC x) := SumBox.embed_injective _ _ _ _ _ _ _ |
| omit [NeZero M] [NeZero T] in |
| theorem valid_embed (z : Live D C c x) : (family q M T N D C c hC).valid x (embed D C c hC x z).val := |
| SumBox.valid_embed _ _ _ _ _ _ _ z |
| omit [NeZero M] [NeZero T] in |
| theorem valid_surjective (i : Fin ((family q M T N D C c hC).n x)) |
| (hi : (family q M T N D C c hC).valid x i.val) : ∃z, embed D C c hC x z=i := |
| SumBox.valid_surjective _ _ _ _ _ _ _ i hi |
| |
| omit [NeZero M] [NeZero T] in |
| theorem tag_embed (z : Live D C c x) : |
| tag q M T N D C c x (embed D C c hC x z).val= |
| (match z with | .inl a => .inl a.1.1 | .inr a => .inr a.1) := by |
| have h := SumBox.tag_embed (Shape q T N) (Seed q M T N) (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c z |
| rcases z with a | a <;> exact h |
| |
| omit [NeZero M] [NeZero T] in |
| theorem digit_embed (z : Live D C c x) (j : Fin (T+1)) : |
| digit q M T N D C c x (embed D C c hC x z).val j= |
| (match z with | .inl a => (a.1.2 j).val | .inr a => (a.2.1 j).val) := by |
| have h := SumBox.digits_embed (Shape q T N) (Seed q M T N) (GameRead.n x) (GameRead.m x) (T+1) (r T D C x) c z j |
| rcases z with a | a <;> exact h |
| |
| variable (G : Game (W x) (W x) (E x) (X q) (Y q)) |
| variable (fiber : E x → X q ≃ Y q × Bool) |
| variable (hl : ∀e : E x, GameRead.left q x e.val=(G.left e).val) |
| variable (hr : ∀e : E x, GameRead.right q x e.val=(G.right e).val) |
| variable (hf : ∀e : E x, GameRead.fiber q x e.val=fiber e) |
| include hl hr hf |
| |
| omit [NeZero M] [NeZero T] in |
| theorem value_embed (z : Live D C c x) (a : Nat → X q) (b : Nat → Y q) : |
| (family q M T N D C c hC).value x (embed D C c hC x z).val a b= |
| AllLabels.code G (hYX q) fiber (a ∘ Fin.val) (b ∘ Fin.val) |
| (LivePackets.project G (r T D C x) c z) := by |
| change rule q M T N D C c x (embed D C c hC x z).val |
| (a ∘ u q M T N D C c x (embed D C c hC x z).val) |
| (b ∘ v q M T N D C c x (embed D C c hC x z).val)=_ |
| unfold rule u v |
| simp_rw [tag_embed D C c hC x z,digit_embed D C c hC x z] |
| rcases z with ⟨⟨s,e⟩,j⟩ | ⟨s,e,j⟩ |
| · dsimp +instances only [isRank,tagRule,LivePackets.project] |
| unfold AllLabels.code |
| simp +instances only [AllLabels.deleted,TestGraph.LabelDeleted] |
| congr 2 |
| apply Fin.ext |
| change 2*(eval _ _ (RankPackets.fill s id)).val=2*(eval _ _ (RankPackets.fill s e)).val |
| rw [RankPackets.eval_fill s e (a ∘ Fin.val) (b ∘ Fin.val)] |
| simp +instances only [ite_true] |
| rfl |
| · simp only [isRank,tagRule,LivePackets.project] |
| simp_rw [hl,hr,hf] |
| exact (PacketLocality.code_fill G (hYX q) fiber s e (a ∘ Fin.val) (b ∘ Fin.val)).symm |
| |
| omit [NeZero M] [NeZero T] in |
| theorem cover_arc (a b : Live D C c x) |
| (h : AllArc G (hYX q) fiber (LivePackets.project G (r T D C x) c a) |
| (LivePackets.project G (r T D C x) c b)) : |
| (family q M T N D C c hC).Arc x (embed D C c hC x a).val (embed D C c hC x b).val := by |
| rw [LocalPrinter.Family.arc_global] |
| refine ⟨?_,valid_embed D C c hC x a,valid_embed D C c hC x b,?_⟩ |
| · intro he |
| have hab := embed_injective D C c hC x (Fin.ext he) |
| subst b |
| exact TestGraph.arc_irrefl _ _ _ h |
| · intro l k |
| rw [value_embed D C c hC x G fiber hl hr hf,value_embed D C c hC x G fiber hl hr hf] |
| exact AllLabels.ordered_arc G (hYX q) fiber _ _ h |
| |
| def liveDeleted (a : W x → X q) (b : W x → Y q) : Finset (Live D C c x) := |
| Finset.univ.filter (fun z => AllLabels.deleted G (hYX q) fiber a b (LivePackets.project G (r T D C x) c z)) |
| |
| omit [NeZero M] [NeZero T] in |
| theorem deleted_eq_image (a : Nat → X q) (b : Nat → Y q) : |
| (family q M T N D C c hC).deleted x a b = |
| (liveDeleted D C c x G fiber (a ∘ Fin.val) (b ∘ Fin.val)).image (embed D C c hC x) := by |
| ext i |
| constructor |
| · intro hi |
| obtain ⟨hv,hd⟩ := (Finset.mem_filter.mp hi).2 |
| obtain ⟨z,rfl⟩ := valid_surjective D C c hC x i hv |
| refine Finset.mem_image.mpr ⟨z,?_,rfl⟩ |
| rw [value_embed D C c hC x G fiber hl hr hf] at hd |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(AllLabels.code_none _ _ _ _ _ _).mp hd⟩ |
| · intro hi |
| obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hi |
| apply Finset.mem_filter.mpr |
| refine ⟨Finset.mem_univ _,valid_embed D C c hC x z,?_⟩ |
| rw [value_embed D C c hC x G fiber hl hr hf] |
| exact (AllLabels.code_none _ _ _ _ _ _).mpr (Finset.mem_filter.mp hz).2 |
| |
| end DirectedFeedback.RawFamily |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RawFamily |
| open Construction Games PacketSeeds SourceProbability FiniteDistribution RankGraph |
| variable {q D : Nat} [NeZero q] (P : Parameters D) (R : RankParameters P (X q)) [NeZero R.N] |
| variable (C : Nat) (c : Seed q P.M P.T R.N → Nat) (hC : 0<C) |
| variable (hc : ∀s, (C:ℝ)*mass R.law (8*(D+1)) P.K s=c s) |
| variable (x : List Bool) |
| variable (G : Game (W x) (W x) (E x) (X q) (Y q)) |
| variable (fiber : E x → X q ≃ Y q × Bool) |
| variable (hl : ∀e : E x, GameRead.left q x e.val=(G.left e).val) |
| variable (hr : ∀e : E x, GameRead.right q x e.val=(G.right e).val) |
| variable (hf : ∀e : E x, GameRead.fiber q x e.val=fiber e) |
| variable (hE : G.edgeLaw=uniform (E x)) |
| variable (hproj : ∀e a, (fiber e a).1=G.project e a) |
| |
| def extend {n : Nat} {A : Type} [Nonempty A] (a : Fin n → A) (i : Nat) : A := |
| if h : i<n then a ⟨i,h⟩ else Classical.choice inferInstance |
| @[simp] theorem extend_restrict {n : Nat} {A : Type} [Nonempty A] (a : Fin n → A) : |
| extend a ∘ Fin.val=a := by funext i; simp [extend] |
| |
| theorem feedback_printer_iff (F : Finset (Fin ((family q P.M P.T R.N D C c hC).n x))) : |
| ((family q P.M P.T R.N D C c hC).printer.graph x).Feedback F ↔ |
| FeedbackR (fun i j => (family q P.M P.T R.N D C c hC).Arc x i.val j.val) F := by |
| let Pn := (family q P.M P.T R.N D C c hC).printer |
| constructor |
| · intro h n f hi ha |
| apply h n f |
| exact ⟨hi,fun i => (Pn.mem_pairs x _ _).mpr (ha i)⟩ |
| · intro h n f hh |
| exact h n f hh.1 (fun i => (Pn.mem_pairs x _ _).mp (hh.2 i)) |
| |
| include hc hE hproj in |
| omit [NeZero R.N] in |
| theorem live_card_bound (a : W x → X q) (b : W x → Y q) |
| (hscore : 1-(P.theta:ℝ)≤G.score a b) : |
| ((liveDeleted D C c x G fiber a b).card:ℝ) ≤ 4*scale P.T C x := by |
| have hsum := LivePackets.sum_cost G R.law (r P.T D C x) c hE D (8*(D+1)) P.K C hc |
| (fun v => if AllLabels.deleted G (hYX q) fiber a b v then 1 else 0) |
| (fun z => by simp [AllLabels.deleted,TestGraph.LabelDeleted]) |
| have hbound := AllLabels.completeness P R G (hYX q) fiber hproj a b hscore |
| have hcard : ((liveDeleted D C c x G fiber a b).card:ℝ)= |
| ∑ z : Live D C c x, (if AllLabels.deleted G (hYX q) fiber a b (LivePackets.project G (r P.T D C x) c z) then 1 else 0) := by |
| simp only [liveDeleted,Finset.card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero] |
| rw [hcard,hsum] |
| simp only [Fintype.card_fin,E,mul_ite,mul_one,mul_zero,Nat.cast_mul,Nat.cast_add,Nat.cast_one,scale,Nat.cast_ofNat,Nat.cast_pow] |
| have hs : (0:ℝ)≤C*(GameRead.m x)^(P.T+1) := by positivity |
| have hh := mul_le_mul_of_nonneg_left hbound hs |
| convert hh using 1; first | rfl | ring |
| |
| include hc hl hr hf hE hproj in |
| theorem completeness (a : W x → X q) (b : W x → Y q) |
| (hscore : 1-(P.theta:ℝ)≤G.score a b) : |
| ((family q P.M P.T R.N D C c hC).printer.graph x).dfvs ≤ 4*scale P.T C x := by |
| let F := family q P.M P.T R.N D C c hC |
| have hfb := F.deleted_feedback x (extend a) (extend b) |
| have he := deleted_eq_image D C c hC x G fiber hl hr hf (extend a) (extend b) |
| simp only [extend_restrict] at he |
| have hcard := Finset.card_image_le (s:=liveDeleted D C c x G fiber a b) (f:=embed D C c hC x) |
| have hb := live_card_bound P R C c hc x G fiber hE hproj a b hscore |
| apply (Digraph.dfvs_le_iff _ _).mpr |
| refine ⟨F.deleted x (extend a) (extend b),?_,?_⟩ |
| · exact (feedback_printer_iff P R C c hC x _).mpr hfb |
| · change (F.deleted x (extend a) (extend b)).card≤_ |
| rw [he] |
| have hnat : (liveDeleted D C c x G fiber a b).card≤4*scale P.T C x := by exact_mod_cast hb |
| exact hcard.trans hnat |
| |
| include hc hl hr hf hE hproj in |
| theorem soundness (hsound : G.Sound P.theta) : |
| (D*scale P.T C x:Nat) < (((family q P.M P.T R.N D C c hC).printer.graph x).dfvs:ℝ) := by |
| let F := family q P.M P.T R.N D C c hC |
| obtain ⟨Q,hQ,hcard⟩ := Digraph.dfvs_attained (F.printer.graph x) |
| have hfib := LivePackets.fiber_weight G R.law (r P.T D C x) c hE D (8*(D+1)) P.K C hc |
| (by simp only [r,scale,E,Fintype.card_fin]; exact le_rfl) |
| have hgap := all_soundness G P R (hYX q) fiber hproj hsound |
| have hcast : ((8*(D+1):Nat):ℝ)=8*((D:ℝ)+1) := by push_cast; rfl |
| rw [hcast] at hfib |
| have hs : 0<scale P.T C x := by unfold scale; have hm := GameRead.m_pos x; positivity |
| have hh := FiniteLift.feedback_cost (embed D C c hC x) (embed_injective D C c hC x) |
| (LivePackets.project G (r P.T D C x) c) (AllArc G (hYX q) fiber) |
| (fun i j => F.Arc x i.val j.val) |
| (cover_arc D C c hC x G fiber hl hr hf) |
| (allCost G R.law D (8*((D:ℝ)+1)) P.K) (scale P.T C x) D |
| (by simpa only [scale,E,Fintype.card_fin] using hfib) |
| hgap hs Q ((feedback_printer_iff P R C c hC x Q).mp hQ) |
| have hh' := lt_of_lt_of_eq hh (congrArg (fun n : Nat => (n:ℝ)) hcard) |
| simpa only [Nat.mul_comm] using hh' |
| |
| end DirectedFeedback.RawFamily |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RawFamily |
| open Construction Games PacketSeeds SourceProbability FiniteDistribution RankGraph |
| open DFVSGames.Foundations DFVSGames.Foundations.Target DFVSGames.Foundations.Complexity |
| open DFVSGames.Explicit.MachineOutputContract |
| variable {D : Nat} (P : Parameters D) (S : BinaryGapReduction P.theta P.theta) |
| local instance packetLocalityAlphabetNeZero : NeZero S.alphabet := |
| ⟨by have := S.alphabetAtLeastTwo; omega⟩ |
| variable (R : RankParameters P (X S.alphabet)) [NeZero R.N] |
| variable (C : Nat) (c : Seed S.alphabet P.M P.T R.N → Nat) (hC : 0<C) |
| variable (hc : ∀ s, (C:ℝ)*mass R.law (8*(D+1)) P.K s=c s) |
| |
| def Model (x : List Bool) (G : Game (W x) (W x) (E x) (X S.alphabet) (Y S.alphabet)) |
| (f : E x → X S.alphabet ≃ Y S.alphabet × Bool) : Prop := |
| (∀ e : E x, GameRead.left S.alphabet x e.val=(G.left e).val) ∧ |
| (∀ e : E x, GameRead.right S.alphabet x e.val=(G.right e).val) ∧ |
| (∀ e : E x, GameRead.fiber S.alphabet x e.val=f e) ∧ |
| G.edgeLaw=uniform (E x) ∧ (∀ e a, (f e a).1=G.project e a) |
| |
| lemma encoded_model (I : Instance S.alphabet) |
| (p : (U : Type) → [Fintype U] → (E : Type) → [Fintype E] → |
| Game U U E (X S.alphabet) (Y S.alphabet) → Prop) |
| (hp : p _ _ (FullGame.game I)) : |
| ∃ (G : Game (W (gameBits I)) (W (gameBits I)) (E (gameBits I)) (X S.alphabet) (Y S.alphabet)) |
| (f : E (gameBits I) → X S.alphabet ≃ Y S.alphabet × Bool), |
| Model P S (gameBits I) G f ∧ p _ _ G := by |
| have aux (n m : Nat) [Nonempty (Fin m)] (hn : n=I.vertices) |
| (hm : m=I.constraints.length) : |
| ∃ (G : Game (Fin n) (Fin n) (Fin m) (X S.alphabet) (Y S.alphabet)) |
| (f : Fin m → X S.alphabet ≃ Y S.alphabet × Bool), |
| ((∀ e, GameRead.left S.alphabet (gameBits I) e.val=(G.left e).val) ∧ |
| (∀ e, GameRead.right S.alphabet (gameBits I) e.val=(G.right e).val) ∧ |
| (∀ e, GameRead.fiber S.alphabet (gameBits I) e.val=f e) ∧ |
| G.edgeLaw=uniform (Fin m) ∧ (∀ e a, (f e a).1=G.project e a)) ∧ p _ _ G := by |
| subst n m |
| refine ⟨FullGame.game I,FullGame.fiber I,?_,hp⟩ |
| exact ⟨GameRead.left_encoded S.alphabet I,GameRead.right_encoded S.alphabet I, |
| GameRead.fiber_encoded S.alphabet I,rfl,FullGame.fiber_project I⟩ |
| exact aux _ _ (GameRead.n_encoded _ _) (GameRead.m_encoded _ _) |
| |
| include hc in |
| theorem encoded_yes (input : List Bool) (h : DFVSGames.BinaryLanguage.language input) : |
| ((family S.alphabet P.M P.T R.N D C c hC).printer.inst (gameBits (S.construct input))).graph.dfvs ≤ |
| ((family S.alphabet P.M P.T R.N D C c hC).printer.inst (gameBits (S.construct input))).k := by |
| obtain ⟨G,f,⟨hl,hr,hf,hE,hproj⟩,a,b,hab⟩ := encoded_model P S (S.construct input) |
| (fun _ _ _ _ G => ∃ a b, 1-(P.theta:ℝ)≤G.score a b) (FullGame.completeness S input h) |
| exact completeness P R C c hC hc _ G f hl hr hf hE hproj a b hab |
| |
| include hc in |
| theorem encoded_no (A : ℝ) (hA : 4*A≤D) (input : List Bool) |
| (h : ¬DFVSGames.BinaryLanguage.language input) : |
| A*((family S.alphabet P.M P.T R.N D C c hC).printer.inst (gameBits (S.construct input))).k < |
| (((family S.alphabet P.M P.T R.N D C c hC).printer.inst (gameBits (S.construct input))).graph.dfvs:ℝ) := by |
| obtain ⟨G,f,⟨hl,hr,hf,hE,hproj⟩,hg⟩ := encoded_model P S (S.construct input) |
| (fun _ _ _ _ G => G.Sound P.theta) (FullGame.soundness S input h) |
| have hh := soundness P R C c hC hc _ G f hl hr hf hE hproj hg |
| apply lt_of_le_of_lt _ hh |
| change A*((4*scale P.T C (gameBits (S.construct input)):Nat):ℝ)≤_ |
| push_cast |
| nlinarith [mul_le_mul_of_nonneg_right hA (Nat.cast_nonneg (α:=ℝ) (scale P.T C (gameBits (S.construct input))))] |
| |
| end DirectedFeedback.RawFamily |
| |
| end |
| end |
| |
| end OAI |
| |
