| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.Rational |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open SourceProbability FiniteDistribution Games RankGraph |
| 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 AllVertex (U V E X Y : Type) [Fintype X] [Fintype Y] (M T N : Nat) := TestGraph.Vertex U V X Y (Wild U V X Y M T N) (Compare U E X Y M T N) T N |
| instance rawFullFintype : Fintype (Full U X M T N) := inferInstance |
| instance rawBigFintype : Fintype (Big U X M T N) := inferInstance |
| instance rawSmallFintype : Fintype (Small U V X Y M T N) := inferInstance |
| instance rawCompareFintype : Fintype (Compare U E X Y M T N) := inferInstance |
| instance allVertexFintype : Fintype (AllVertex U V E X Y M T N) := by |
| unfold AllVertex TestGraph.Vertex Wild |
| infer_instance |
| |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| |
| def supportEmbed : OutputVertex (M:=M) G ψLaw → AllVertex U V E X Y M T N |
| | .inl r => .inl r |
| | .inr (.inl w) => .inr (.inl (forgetWild G ψLaw w)) |
| | .inr (.inr c) => .inr (.inr c.val) |
| |
| def allCost (D H K : ℝ) : AllVertex U V E X Y M T N → ℝ |
| | .inl _ => D+1 |
| | .inr (.inl (.inl d)) => H*(fullLaw G ψLaw).weight d |
| | .inr (.inl (.inr (.inl d))) => Fintype.card X*(bigLaw G ψLaw).weight d |
| | .inr (.inl (.inr (.inr d))) => Fintype.card Y*(smallLaw G ψLaw).weight d |
| | .inr (.inr d) => K*(comparisonLaw G ψLaw).weight d |
| |
| def AllArc (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) := |
| TestGraph.Arc (wildcard (M:=M) (T:=T) (N:=N) (U:=U) (V:=V) hYX) (comparison (M:=M) G fiber) |
| |
| theorem supportEmbed_injective : Function.Injective (supportEmbed (M:=M) G ψLaw) := by |
| intro a b h |
| rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> |
| simp only [supportEmbed,Sum.inl.injEq,Sum.inr.injEq,Sum.inl_ne_inr,Sum.inr_ne_inl] at h ⊢ |
| · exact h |
| · rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> |
| simp_all [forgetWild,Subtype.ext_iff] |
| · exact Subtype.ext h |
| |
| theorem embed_arc (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| {a b : OutputVertex (M:=M) G ψLaw} (h : OutputArc G ψLaw hYX fiber a b) : |
| AllArc G hYX fiber (supportEmbed G ψLaw a) (supportEmbed G ψLaw b) := by |
| cases h with |
| | rank h => exact .rank h |
| | wild_in w x h => exact .wild_in (forgetWild G ψLaw w) x h |
| | wild_out w x h => exact .wild_out (forgetWild G ψLaw w) x h |
| | comp_in c => exact .comp_in c.val |
| | comp_out c => exact .comp_out c.val |
| |
| theorem allCost_sum (D H K : ℝ) (f : AllVertex U V E X Y M T N → Bool) : |
| (∑ v, if f v then allCost G ψLaw D H K v else 0) = |
| totalDeletionCost G ψLaw D H K (fun v => f (supportEmbed G ψLaw v)) := by |
| simp only [totalDeletionCost,Fintype.sum_sum_type,allCost,vertexCost,supportEmbed,forgetWild] |
| have hs {A : Type} [Fintype A] (μ : FiniteDistribution A) (c : ℝ) (g : A → Bool) : |
| (∑ a, if g a then c*μ.weight a else 0) = |
| ∑ a : μ.Support, if g a.val then c*μ.weight a.val else 0 := by |
| simpa only [Finset.mul_sum,mul_ite,mul_one,mul_zero,mul_assoc] using |
| congrArg (fun z => c*z) (μ.sum_support (fun a => if g a then 1 else 0)).symm |
| rw [hs (fullLaw G ψLaw),hs (bigLaw G ψLaw),hs (smallLaw G ψLaw),hs (comparisonLaw G ψLaw)] |
| congr 3 |
| |
| theorem all_soundness {D : Nat} (P : Parameters D) (R : RankParameters P X) |
| (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| (hproj : ∀ e x, (fiber e x).1=G.project e x) (hsound : G.Sound P.theta) |
| (F : Finset (AllVertex U V E X Y P.M P.T R.N)) |
| (hF : FeedbackR (AllArc G hYX fiber) F) : |
| (D:ℝ) < ∑ v ∈ F, allCost G R.law D (8*((D:ℝ)+1)) P.K v := by |
| let Q := Finset.univ.filter (fun v => supportEmbed G R.law v ∈ F) |
| have hQ : FeedbackR (OutputArc G R.law hYX fiber) Q := by |
| intro n f hi ha |
| obtain ⟨i,hi⟩ := hF n (fun i => supportEmbed G R.law (f i)) |
| ((supportEmbed_injective G R.law).comp hi) (fun i => embed_arc G R.law hYX fiber (ha i)) |
| exact ⟨i,by simpa [Q] using hi⟩ |
| have h := parameterized_soundness P R G hYX fiber hproj hsound Q hQ |
| have hv : (fun v => decide (v ∈ Q))=(fun v => decide (supportEmbed G R.law v ∈ F)) := by |
| funext v |
| simp [Q] |
| rw [hv] at h |
| rw [← allCost_sum G R.law (D:ℝ) (8*((D:ℝ)+1)) P.K (fun v => decide (v ∈ F))] at h |
| simpa using h |
| |
| end DirectedFeedback.Construction |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.GraphPrinter |
| open BoundedExpr |
| |
| structure Family where |
| n : List Bool → Nat |
| k : List Bool → Nat |
| arc : List Bool → Nat → Nat → Prop |
| n_def : Def (r:=0) (fun x _ => n x) |
| k_def : Def (r:=0) (fun x _ => k x) |
| arc_def : PDef (r:=2) (fun x a => arc x (a 0) (a 1)) |
| k_pos : ∀ x, 0 < k x |
| irrefl : ∀ x i, ¬arc x i i |
|
|
| namespace Family |
| variable (F : Family) |
|
|
| def pairs (x : List Bool) : List (Fin (F.n x) × Fin (F.n x)) := |
| ((List.finRange (F.n x)).product (List.finRange (F.n x))).filter |
| (fun p => decide (F.arc x p.1.val p.2.val)) |
|
|
| @[simp] theorem mem_pairs (x : List Bool) (a b : Fin (F.n x)) : |
| (a,b) ∈ F.pairs x ↔ F.arc x a.val b.val := by simp [pairs] |
|
|
| def graph (x : List Bool) : Digraph where |
| n := F.n x |
| arcs := F.pairs x |
| loopless := by |
| rintro ⟨a,b⟩ hab he |
| have h := (F.mem_pairs x a b).mp hab |
| change a=b at he |
| subst b |
| exact F.irrefl x a.val h |
| nodup := (List.nodup_finRange _).product (List.nodup_finRange _) |> fun h => h.filter _ |
|
|
| def inst (x : List Bool) : GapInstance := ⟨F.graph x,F.k x,F.k_pos x⟩ |
|
|
| def count (x : List Bool) : Nat := |
| ∑ i ∈ Finset.range (F.n x), ∑ j ∈ Finset.range (F.n x), if F.arc x i j then 1 else 0 |
|
|
| theorem count_eq (x : List Bool) : F.count x=(F.pairs x).length := by |
| have he : (F.pairs x).toFinset = Finset.univ.filter |
| (fun p : Fin (F.n x) × Fin (F.n x) => F.arc x p.1.val p.2.val) := by |
| ext ⟨a,b⟩ |
| simp [pairs] |
| have hnd : (F.pairs x).Nodup := (F.graph x).nodup |
| rw [← List.toFinset_card_of_nodup hnd,he,Finset.card_filter] |
| simp only [count,Finset.sum_range,Fintype.sum_prod_type] |
|
|
| private theorem flatMap_filter {A B : Type} (l : List A) (p : A → Bool) (f : A → List B) : |
| (l.filter p).flatMap f = l.flatMap (fun a => if p a then f a else []) := by |
| induction l with |
| | nil => rfl |
| | cons a l ih => |
| by_cases h : p a=true <;> simp [h,ih] |
|
|
| private theorem map_fin_values (n : Nat) : (List.finRange n).map Fin.val=List.range n := by |
| apply List.ext_getElem |
| · simp |
| · intro i hi hi' |
| simp |
|
|
| def edgeBits (x : List Bool) : List Bool := |
| (List.range (F.n x)).flatMap (fun i => (List.range (F.n x)).flatMap |
| (fun j => if F.arc x i j then natBits i++natBits j else [])) |
|
|
| theorem edgeBits_eq (x : List Bool) : F.edgeBits x= |
| (F.pairs x).flatMap (fun e => natBits e.1.val++natBits e.2.val) := by |
| rw [edgeBits,pairs,flatMap_filter] |
| change _ = (List.flatMap (fun i => (List.finRange (F.n x)).map (fun j => (i,j))) |
| (List.finRange (F.n x))).flatMap _ |
| rw [List.flatMap_assoc] |
| simp only [List.flatMap_map] |
| rw [← map_fin_values (F.n x),List.flatMap_map] |
| congr 1 |
| funext i |
| simp only [List.flatMap_map,decide_eq_true_eq] |
|
|
| theorem n_def_any (r : Nat) : Def (r:=r) (fun x _ => F.n x) := |
| F.n_def.subst Fin.elim0 (fun i => i.elim0) |
|
|
| theorem count_def : Def (r:=0) (fun x _ => F.count x) := by |
| have ha : Def (r:=2) (fun x a => if F.arc x (a 1) (a 0) then 1 else 0) := |
| F.arc_def.rename ![1,0] |
| simpa only [count,Fin.cons_zero,Fin.cons_one] using |
| (F.n_def_any 0).sum ((F.n_def_any 1).sum ha) |
|
|
| theorem edgeBits_def : OutDef (r:=0) (fun x _ => F.edgeBits x) := by |
| have ha : PDef (r:=2) (fun x a => F.arc x (a 1) (a 0)) := |
| F.arc_def.rename ![1,0] |
| have hb : OutDef (r:=2) (fun x a => if F.arc x (a 1) (a 0) |
| then natBits (a 1)++natBits (a 0) else []) := |
| ((OutDef.nat (Def.arg 1)).append (OutDef.nat (Def.arg 0))).when ha |
| simpa only [edgeBits,Fin.cons_zero,Fin.cons_one] using |
| OutDef.loop (F.n_def_any 0) (OutDef.loop (F.n_def_any 1) hb) |
|
|
| def bits (x : List Bool) : List Bool := natBits (F.k x)++natBits (F.n x)++ |
| (List.range (F.n x)).flatMap natBits++natBits (F.count x)++F.edgeBits x |
|
|
| theorem bits_def : OutDef (r:=0) (fun x _ => F.bits x) := by |
| have hv : OutDef (r:=0) (fun x _ => (List.range (F.n x)).flatMap natBits) := by |
| change OutDef (fun x (_ : Fin 0 → Nat) => (List.range (F.n x)).flatMap (fun i => List.replicate i true++[false])) |
| simpa only [Fin.cons_zero] using OutDef.loop (F.n_def_any 0) (OutDef.nat (Def.arg 0)) |
| exact ((((OutDef.nat F.k_def).append (OutDef.nat F.n_def)).append hv).append |
| (OutDef.nat F.count_def)).append F.edgeBits_def |
|
|
| theorem bits_correct (x : List Bool) : F.bits x=(F.inst x).bits := by |
| simp only [bits,GapInstance.bits,inst,Digraph.bits,graph] |
| rw [count_eq,edgeBits_eq] |
| simp only [List.flatMap_append,List.flatMap_cons,List.flatMap_nil,List.append_nil, |
| List.flatMap_assoc,List.append_assoc] |
|
|
| noncomputable def computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool) |
| GapInstance.bits F.inst := by |
| let o := F.bits_def.choose |
| have ho : ∀ x, o.eval x Fin.elim0=(F.inst x).bits := fun x => |
| (F.bits_def.choose_spec x Fin.elim0).trans (F.bits_correct x) |
| exact Output.realizes _ _ o ho |
|
|
| theorem computation_finite (k : F.computation.tm.K) : Finite (F.computation.tm.Γ k) := by |
| unfold computation |
| exact Output.realizes_alphabet _ _ _ _ k |
|
|
| end Family |
| end DirectedFeedback.GraphPrinter |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical |
| namespace DirectedFeedback.LocalAssignments |
|
|
| def Consistent {S A : Type} (coords : S → Nat) (labels : S → A) : Prop := |
| ∀ i j, coords i=coords j → labels i=labels j |
|
|
| theorem extend_global {S A : Type} [Nonempty A] (coords : S → Nat) (labels : S → A) |
| (hc : Consistent coords labels) : ∃ all : Nat → A, all ∘ coords=labels := by |
| let all : Nat → A := fun v => if h : ∃ i, coords i=v then labels h.choose |
| else Classical.choice inferInstance |
| exact ⟨all,funext (fun i => by |
| dsimp [all] |
| split_ifs with h |
| · exact hc _ _ h.choose_spec |
| · exact False.elim (h ⟨i,rfl⟩))⟩ |
|
|
| theorem restriction_consistent {S A : Type} (coords : S → Nat) (all : Nat → A) : |
| Consistent coords (all ∘ coords) := fun _ _ h => congrArg all h |
|
|
| theorem forall_iff {S T X Y : Type} [Nonempty X] [Nonempty Y] |
| (u : S → Nat) (v : T → Nat) (P : (S → X) → (T → Y) → Prop) : |
| (∀ a : Nat → X, ∀ b : Nat → Y, P (a ∘ u) (b ∘ v)) ↔ |
| ∀ a b, Consistent u a → Consistent v b → P a b := by |
| constructor |
| · intro h a b ha hb |
| obtain ⟨la,hla⟩ := extend_global u a ha |
| obtain ⟨lb,hlb⟩ := extend_global v b hb |
| simpa only [hla,hlb] using h la lb |
| · intro h a b |
| exact h _ _ (restriction_consistent u a) (restriction_consistent v b) |
|
|
| namespace Definability |
| open BoundedExpr |
| variable {r : Nat} {S A : Type} [Fintype S] [Fintype A] |
|
|
| omit [Fintype A] in |
| theorem consistent_def (c : S → List Bool → (Fin r → Nat) → Nat) |
| (hc : ∀ i, Def (c i)) (a : S → A) : |
| PDef (fun x z => Consistent (fun i => c i x z) a) := by |
| exact PDef.all (fun i => PDef.all (fun j => |
| (PDef.nat_eq (hc i) (hc j)).imp (PDef.const (a i=a j)))) |
|
|
| end Definability |
| end DirectedFeedback.LocalAssignments |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.LocalPrinter |
| open BoundedExpr LocalAssignments |
|
|
| abbrev Rule (S T X Y : Type) (H : Nat) := (S → X) → (T → Y) → Option (Fin H) |
|
|
| def Ordered {H : Nat} : Option (Fin H) → Option (Fin H) → Prop |
| | some a,some b => a < b |
| | _,_ => True |
|
|
| def potential {H : Nat} (a : Option (Fin H)) : Nat := (a.map Fin.val).getD 0 |
|
|
| theorem ordered_iff {H : Nat} (a b : Option (Fin H)) : |
| Ordered a b ↔ (a ≠ none → b ≠ none → potential a < potential b) := by |
| cases a <;> cases b <;> simp [Ordered,potential] |
|
|
| structure Family (S T X Y : Type) [Fintype S] [Fintype T] [Fintype X] [Fintype Y] |
| (H : Nat) where |
| n : List Bool → Nat |
| k : List Bool → Nat |
| valid : List Bool → Nat → Prop |
| u : List Bool → Nat → S → Nat |
| v : List Bool → Nat → T → Nat |
| rule : List Bool → Nat → Rule S T X Y H |
| n_def : Def (r:=0) (fun x _ => n x) |
| k_def : Def (r:=0) (fun x _ => k x) |
| valid_def : PDef (r:=1) (fun x a => valid x (a 0)) |
| u_def : ∀ s, Def (r:=1) (fun x a => u x (a 0) s) |
| v_def : ∀ t, Def (r:=1) (fun x a => v x (a 0) t) |
| rule_def : FDef (r:=1) (fun x a => rule x (a 0)) |
| k_pos : ∀ x, 0 < k x |
|
|
| namespace Family |
| variable {S T X Y : Type} [Fintype S] [Fintype T] [Fintype X] [Fintype Y] |
| [Nonempty X] [Nonempty Y] {H : Nat} (F : Family S T X Y H) |
|
|
| def Arc (x : List Bool) (i j : Nat) : Prop := |
| i ≠ j ∧ F.valid x i ∧ F.valid x j ∧ |
| ∀ a : S ⊕ S → X, ∀ b : T ⊕ T → Y, |
| Consistent (Sum.elim (F.u x i) (F.u x j)) a → |
| Consistent (Sum.elim (F.v x i) (F.v x j)) b → |
| Ordered (F.rule x i (a ∘ Sum.inl) (b ∘ Sum.inl)) |
| (F.rule x j (a ∘ Sum.inr) (b ∘ Sum.inr)) |
|
|
| def value (x : List Bool) (i : Nat) (a : Nat → X) (b : Nat → Y) : Option (Fin H) := |
| F.rule x i (a ∘ F.u x i) (b ∘ F.v x i) |
|
|
| theorem arc_global (x : List Bool) (i j : Nat) : F.Arc x i j ↔ |
| i ≠ j ∧ F.valid x i ∧ F.valid x j ∧ |
| ∀ a : Nat → X, ∀ b : Nat → Y, Ordered (F.value x i a b) (F.value x j a b) := by |
| unfold Arc value |
| apply and_congr_right |
| intro _ |
| apply and_congr_right |
| intro _ |
| apply and_congr_right |
| intro _ |
| exact (forall_iff (Sum.elim (F.u x i) (F.u x j)) (Sum.elim (F.v x i) (F.v x j)) |
| (fun a b => Ordered (F.rule x i (a ∘ Sum.inl) (b ∘ Sum.inl)) |
| (F.rule x j (a ∘ Sum.inr) (b ∘ Sum.inr)))).symm |
|
|
| omit [Nonempty X] [Nonempty Y] in |
| theorem arc_def : PDef (r:=2) (fun x a => F.Arc x (a 0) (a 1)) := by |
| have hu (s : S ⊕ S) : Def (r:=2) (fun x a => Sum.elim (F.u x (a 0)) (F.u x (a 1)) s) := by |
| cases s with |
| | inl s => exact (F.u_def s).rename (fun _ => 0) |
| | inr s => exact (F.u_def s).rename (fun _ => 1) |
| have hv (t : T ⊕ T) : Def (r:=2) (fun x a => Sum.elim (F.v x (a 0)) (F.v x (a 1)) t) := by |
| cases t with |
| | inl t => exact (F.v_def t).rename (fun _ => 0) |
| | inr t => exact (F.v_def t).rename (fun _ => 1) |
| have hr0 := F.rule_def.rename (s:=2) (fun _ => 0) |
| have hr1 := F.rule_def.rename (s:=2) (fun _ => 1) |
| have hv0 : PDef (r:=2) (fun x a => F.valid x (a 0)) := F.valid_def.rename (fun _ => 0) |
| have hv1 : PDef (r:=2) (fun x a => F.valid x (a 1)) := F.valid_def.rename (fun _ => 1) |
| exact ((PDef.nat_eq (Def.arg 0) (Def.arg 1)).not).and |
| (hv0.and (hv1.and |
| (PDef.all (fun a => PDef.all (fun b => |
| (Definability.consistent_def _ hu a).imp |
| ((Definability.consistent_def _ hv b).imp |
| ((hr0.pair hr1).toDef (fun r => if Ordered (r.1 (a ∘ Sum.inl) (b ∘ Sum.inl)) |
| (r.2 (a ∘ Sum.inr) (b ∘ Sum.inr)) then 1 else 0)))))))) |
|
|
| def printer : GraphPrinter.Family where |
| n := F.n |
| k := F.k |
| arc := F.Arc |
| n_def := F.n_def |
| k_def := F.k_def |
| arc_def := F.arc_def |
| k_pos := F.k_pos |
| irrefl := fun _ _ h => h.1 rfl |
|
|
| def deleted (x : List Bool) (a : Nat → X) (b : Nat → Y) : Finset (Fin (F.n x)) := |
| Finset.univ.filter (fun i => F.valid x i.val ∧ F.value x i.val a b=none) |
|
|
| theorem deleted_feedback (x : List Bool) (a : Nat → X) (b : Nat → Y) : |
| FeedbackR (fun i j : Fin (F.n x) => F.Arc x i.val j.val) (F.deleted x a b) := by |
| intro n f _ ha |
| by_contra hn |
| have hv (j) : F.valid x (f j).val := (ha j).2.1 |
| have hs (j) : F.value x (f j).val a b ≠ none := by |
| intro h |
| exact hn ⟨j,by simp [deleted,h,hv]⟩ |
| have hi (j) : potential (F.value x (f j).val a b) < potential (F.value x (f (j+1)).val a b) := |
| (ordered_iff _ _).mp (((F.arc_global x _ _).mp (ha j)).2.2.2 a b) (hs j) (hs (j+1)) |
| have hsum := Finset.sum_lt_sum_of_nonempty Finset.univ_nonempty (fun j _ => hi j) |
| have he : (∑ j : Fin (n+1), potential (F.value x (f (j+1)).val a b)) = |
| ∑ j : Fin (n+1), potential (F.value x (f j).val a b) := |
| Fintype.sum_equiv (Equiv.addRight (1 : Fin (n+1))) _ _ (fun _ => rfl) |
| rw [he] at hsum |
| exact (lt_irrefl _ hsum) |
|
|
| end Family |
| end DirectedFeedback.LocalPrinter |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.AllLabels |
| open Construction SourceProbability FiniteDistribution Games RankGraph |
| 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 (G : Game U V E X Y) (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) |
|
|
| abbrev deleted (a : U → X) (b : V → Y) : AllVertex U V E X Y M T N → Prop := |
| TestGraph.LabelDeleted (wildcard (M:=M) (T:=T) (N:=N) hYX) (comparison G fiber) a b |
| abbrev pot (a : U → X) (b : V → Y) : AllVertex U V E X Y M T N → ℚ := |
| TestGraph.labelPotential (wildcard (M:=M) (T:=T) (N:=N) hYX) (comparison G fiber) a b |
|
|
| def height (a : U → X) (b : V → Y) : AllVertex U V E X Y M T N → Nat |
| | .inl r => 2*(eval a b r).val |
| | .inr (.inl w) => 2*((wildcard hYX w).level ((wildcard hYX w).cell (labels a b (wildcard hYX w).tuple))).val |
| | .inr (.inr c) => (eval a b (comparison G fiber c).source).val+(eval a b (comparison G fiber c).target).val |
|
|
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem height_bound (a : U → X) (b : V → Y) (v : AllVertex U V E X Y M T N) : |
| height G hYX fiber a b v<2*N+1 := by |
| rcases v with r | (w | c) |
| · have := (eval a b r).isLt |
| dsimp [height] |
| omega |
| · have := ((wildcard hYX w).level ((wildcard hYX w).cell (labels a b (wildcard hYX w).tuple))).isLt |
| dsimp [height] |
| omega |
| · have := (eval a b (comparison G fiber c).source).isLt |
| have := (eval a b (comparison G fiber c).target).isLt |
| dsimp [height] |
| omega |
|
|
| def code (a : U → X) (b : V → Y) (v : AllVertex U V E X Y M T N) : Option (Fin (2*N+1)) := |
| if deleted G hYX fiber a b v then none else some ⟨height G hYX fiber a b v,height_bound G hYX fiber a b v⟩ |
|
|
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem code_none (a : U → X) (b : V → Y) (v : AllVertex U V E X Y M T N) : |
| code G hYX fiber a b v=none ↔ deleted G hYX fiber a b v := by simp [code] |
|
|
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem height_potential (a : U → X) (b : V → Y) (v : AllVertex U V E X Y M T N) : |
| (height G hYX fiber a b v:ℚ)=2*pot G hYX fiber a b v := by |
| rcases v with r | (w | c) <;> simp [height,pot,TestGraph.labelPotential]; ring |
|
|
| omit [Fintype U] [Fintype V] [Nonempty Y] [NeZero M] [NeZero T] in |
| theorem ordered_arc (a : U → X) (b : V → Y) {v w : AllVertex U V E X Y M T N} |
| (h : AllArc G hYX fiber v w) : LocalPrinter.Ordered (code G hYX fiber a b v) (code G hYX fiber a b w) := by |
| by_cases hv : deleted G hYX fiber a b v |
| · simp [code,hv,LocalPrinter.Ordered] |
| by_cases hw : deleted G hYX fiber a b w |
| · simp [code,hw,LocalPrinter.Ordered] |
| simp only [code,hv,hw,ite_false,LocalPrinter.Ordered] |
| change height G hYX fiber a b v<height G hYX fiber a b w |
| have hi := TestGraph.labelPotential_increases (wildcard hYX) (comparison G fiber) a b h hv hw |
| have hi' : (height G hYX fiber a b v:ℚ)<height G hYX fiber a b w := by |
| rw [height_potential,height_potential] |
| exact mul_lt_mul_of_pos_left hi (by norm_num) |
| exact_mod_cast hi' |
|
|
| theorem embed_deleted (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) (a : U → X) (b : V → Y) |
| (v : OutputVertex (M:=M) G ψLaw) : |
| decide (deleted G hYX fiber a b (supportEmbed G ψLaw v))=labelDeleted G ψLaw hYX fiber a b v := by |
| rcases v with r | (w | c) |
| · rfl |
| · rcases w with w | (w | w) <;> rfl |
| · rfl |
|
|
| theorem completeness {D : Nat} (P : Parameters D) (R : RankParameters P X) |
| (G : Game U V E X Y) (hYX : Fintype.card Y≤Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| (hproj : ∀ e x, (fiber e x).1=G.project e x) |
| (a : U → X) (b : V → Y) (hscore : 1-(P.theta:ℝ)≤G.score a b) : |
| (∑ v : AllVertex U V E X Y P.M P.T R.N, |
| if deleted G hYX fiber a b v then allCost G R.law D (8*((D:ℝ)+1)) P.K v else 0) ≤ 4 := by |
| have hh := weighted_completeness (M:=P.M) G R.law hYX fiber a b hproj |
| D (8*((D:ℝ)+1)) P.K (by positivity) (by exact_mod_cast P.K_pos.le) |
| have hloss : (P.K:ℝ)*(1-G.score a b) ≤ (P.K:ℝ)*P.theta := |
| mul_le_mul_of_nonneg_left (by linarith) (Nat.cast_nonneg _) |
| have he := allCost_sum (M:=P.M) G R.law (D:ℝ) (8*((D:ℝ)+1)) P.K |
| (fun v => decide (deleted G hYX fiber a b v)) |
| simp only [decide_eq_true_eq] at he |
| rw [he] |
| simp only [embed_deleted] |
| linarith [P.fullChernoff,P.Ktheta] |
|
|
| end DirectedFeedback.AllLabels |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.SourceProbability.FiniteDistribution |
|
|
| theorem fixed_denominator {Ω : Type} [Fintype Ω] (w : Ω → ℝ) |
| (hw : ∀ x, Rational (w x)) (hn : ∀ x, 0 ≤ w x) : |
| ∃ C : Nat, 0 < C ∧ ∃ c : Ω → Nat, ∀ x, (C:ℝ)*w x=c x := by |
| choose q hq using hw |
| let C := ∏ x, (q x).den |
| have hC : 0 < C := Finset.prod_pos (fun x _ => (q x).den_pos) |
| have hd (x : Ω) : (q x).den ∣ C := Finset.dvd_prod_of_mem _ (Finset.mem_univ x) |
| choose k hk using hd |
| refine ⟨C,hC,fun x => (q x).num.toNat*k x,?_⟩ |
| intro x |
| have hnum : 0 ≤ (q x).num := Rat.num_nonneg.mpr (by exact_mod_cast hq x ▸ hn x) |
| rw [hq x,Rat.cast_def,hk x,Nat.cast_mul,Nat.cast_mul] |
| have hden : ((q x).den:ℝ) ≠ 0 := by exact_mod_cast (q x).den_ne_zero |
| have hh : (((q x).num.toNat:Nat):ℝ)=((q x).num:ℝ) := by |
| exact_mod_cast Int.toNat_of_nonneg hnum |
| rw [hh] |
| field_simp |
|
|
| theorem integral_realization {Ω : Type} [Fintype Ω] (μ : FiniteDistribution Ω) |
| (hμ : μ.RationalMass) : |
| ∃ C : Nat, 0 < C ∧ ∃ c : Ω → Nat, |
| (∀ x, (C:ℝ)*μ.weight x=c x) ∧ ∑ x, c x=C := by |
| obtain ⟨C,hC,c,hc⟩ := fixed_denominator μ.weight hμ μ.nonnegative |
| refine ⟨C,hC,c,hc,?_⟩ |
| have hh : (∑ x, (c x:ℝ)) = C := by |
| simp only [← hc,← Finset.mul_sum,μ.normalized,mul_one] |
| exact_mod_cast hh |
|
|
| theorem pushforward_comp {Ω Γ Ξ : Type} [Fintype Ω] [Fintype Γ] [Fintype Ξ] |
| (μ : FiniteDistribution Ω) (f : Ω → Γ) (g : Γ → Ξ) : |
| (μ.pushforward f).pushforward g=μ.pushforward (g ∘ f) := by |
| apply eq_of_weight_eq |
| intro z |
| simp only [pushforward] |
| calc |
| _ = ∑ y, ∑ x, if f x=y then (if g y=z then μ.weight x else 0) else 0 := by |
| apply Finset.sum_congr rfl |
| intro y _ |
| by_cases h : g y=z <;> simp [h] |
| _ = _ := by rw [Finset.sum_comm]; simp |
|
|
| theorem pushforward_product {Ω Γ A B : Type} [Fintype Ω] [Fintype Γ] [Fintype A] [Fintype B] |
| (μ : FiniteDistribution Ω) (ν : FiniteDistribution Γ) (f : Ω → A) (g : Γ → B) : |
| (μ.product ν).pushforward (Prod.map f g) = (μ.pushforward f).product (ν.pushforward g) := by |
| apply eq_of_weight_eq |
| rintro ⟨a,b⟩ |
| simp only [pushforward,product,Fintype.sum_prod_type,Prod.map_apply,Prod.mk.injEq] |
| rw [Finset.sum_mul_sum] |
| apply Finset.sum_congr rfl |
| intro x _ |
| apply Finset.sum_congr rfl |
| intro y _ |
| by_cases hf : f x=a <;> by_cases hg : g y=b <;> simp [hf,hg] |
|
|
| theorem pushforward_fst {Ω Γ : Type} [Fintype Ω] [Fintype Γ] |
| (μ : FiniteDistribution Ω) (ν : FiniteDistribution Γ) : |
| (μ.product ν).pushforward Prod.fst=μ := by |
| apply eq_of_weight_eq |
| intro x |
| simp only [pushforward,product,Fintype.sum_prod_type] |
| rw [Finset.sum_comm] |
| simp [← Finset.mul_sum,ν.normalized] |
|
|
| end DirectedFeedback.SourceProbability.FiniteDistribution |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.SourceProbability.FiniteDistribution |
|
|
| theorem eq_of_expectation_eq {A : Type} [Fintype A] |
| (μ ν : FiniteDistribution A) (h : ∀ f : A → ℝ, μ.expectation f=ν.expectation f) : μ=ν := by |
| apply eq_of_weight_eq |
| intro a |
| simpa [expectation,mul_ite] using h (fun x => if x=a then 1 else 0) |
|
|
| def zipEquiv (A B : Type) (n : Nat) : |
| ((Fin n → A) × (Fin n → B)) ≃ (Fin n → A × B) where |
| toFun p i := (p.1 i,p.2 i) |
| invFun p := (fun i => (p i).1,fun i => (p i).2) |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| theorem iid_zip {A B : Type} [Fintype A] [Fintype B] |
| (μ : FiniteDistribution A) (ν : FiniteDistribution B) (n : Nat) : |
| ((μ.iid n).product (ν.iid n)).transport (zipEquiv A B n)=(μ.product ν).iid n := by |
| apply eq_of_weight_eq |
| intro z |
| change (∏ i, μ.weight (z i).1)*(∏ i,ν.weight (z i).2)= |
| ∏ i, μ.weight (z i).1*ν.weight (z i).2 |
| exact (Finset.prod_mul_distrib).symm |
|
|
| theorem expectation_iid_zip {A B : Type} [Fintype A] [Fintype B] |
| (μ : FiniteDistribution A) (ν : FiniteDistribution B) (n : Nat) |
| (f : (Fin n → A × B) → ℝ) : |
| (μ.iid n).expectation (fun a => (ν.iid n).expectation (fun b => f (fun i => (a i,b i)))) = |
| ((μ.product ν).iid n).expectation f := by |
| rw [← iid_zip,expectation_transport,expectation_product] |
| rfl |
|
|
| theorem expectation_iid_map {A B : Type} [Fintype A] [Fintype B] |
| (μ : FiniteDistribution A) (g : A → B) (n : Nat) (f : (Fin n → B) → ℝ) : |
| (μ.iid n).expectation (fun a => f (fun i => g (a i))) = |
| ((μ.pushforward g).iid n).expectation f := by |
| rw [iid_pushforward,expectation_pushforward] |
|
|
| theorem sample_prefix {E U S : Type} [Fintype E] [Fintype U] [Fintype S] |
| (μ : FiniteDistribution E) (left : E → U) (ν : FiniteDistribution S) |
| {t L : Nat} (ht : t≤L) (f : (Fin t → U × S) → ℝ) : |
| (ν.iid t).expectation (fun s => (μ.iid L).expectation |
| (fun e => f (fun j => (left (e (Fin.castLE ht j)),s j)))) = |
| (((μ.pushforward left).product ν).iid t).expectation f := by |
| rw [expectation_comm] |
| change (μ.iid L).expectation (fun e => (ν.iid t).expectation |
| (fun s => f (fun j => (left (takePrefix ht e j),s j)))) = _ |
| rw [expectation_iid_take μ ht (fun e => (ν.iid t).expectation |
| (fun s => f (fun j => (left (e j),s j))))] |
| rw [expectation_iid_map μ left t (fun a => (ν.iid t).expectation |
| (fun s => f (fun j => (a j,s j))))] |
| exact expectation_iid_zip _ _ _ _ |
|
|
| theorem sample_prefix_fresh {E U S : Type} [Fintype E] [Fintype U] [Fintype S] |
| (μ : FiniteDistribution E) (left : E → U) (ν : FiniteDistribution S) |
| {t L : Nat} (ht : t<L) (f : (Fin t → U × S) → E → ℝ) : |
| (ν.iid t).expectation (fun s => (μ.iid L).expectation |
| (fun e => f (fun j => (left (e (Fin.castLE (Nat.le_of_lt ht) j)),s j)) (e ⟨t,ht⟩))) = |
| (((μ.pushforward left).product ν).iid t).expectation |
| (fun a => μ.expectation (f a)) := by |
| have h (s : Fin t → S) := expectation_iid_prefix_fresh μ ht |
| (fun e fresh => f (fun j => (left (e j),s j)) fresh) |
| calc |
| _ = (ν.iid t).expectation (fun s => (μ.iid t).expectation |
| (fun e => μ.expectation (fun fresh => f (fun j => (left (e j),s j)) fresh))) := |
| expectation_congr _ h |
| _ = _ := sample_prefix μ left ν le_rfl (fun a => μ.expectation (f a)) |
|
|
| end DirectedFeedback.SourceProbability.FiniteDistribution |
|
|
| 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] |
|
|
| abbrev SlotSeed (X : Type) (M : Nat) := Σ _ : Fin M, X → Bool |
| abbrev PrefixSeed (X : Type) (M t : Nat) := Fin t → SlotSeed X M |
| abbrev FullSeed (X : Type) [Fintype X] (M T N : Nat) := |
| Emb (rankLength X T) N × PrefixSeed X M T |
| abbrev CommonSeed (X : Type) [Fintype X] (M T N : Nat) := |
| Emb (rankLength X T) N × (Σ t : Fin T, PrefixSeed X M t.val) |
| abbrev BigSeed (X : Type) [Fintype X] (M T N : Nat) := |
| CommonSeed X M T N × Pivotal.LabelOrder X |
| abbrev SmallSeed (X Y : Type) [Fintype X] [Fintype Y] (M T N : Nat) := |
| CommonSeed X M T N × Pivotal.LabelOrder Y |
| abbrev CompareSeed (X Y : Type) [Fintype X] (M T N : Nat) := |
| Σ d : CommonSeed X M T N, Σ _ : Fin M, Fin (Prefix.cellCount d.2.1.val) × (Y → Coupling.Block) |
|
|
| abbrev Seed (X Y : Type) [Fintype X] [Fintype Y] (M T N : Nat) := |
| FullSeed X M T N ⊕ (BigSeed X M T N ⊕ (SmallSeed X Y M T N ⊕ CompareSeed X Y M T N)) |
| instance seedFullFintype : Fintype (FullSeed X M T N) := inferInstance |
| instance seedCommonFintype : Fintype (CommonSeed X M T N) := inferInstance |
| instance seedBigFintype : Fintype (BigSeed X M T N) := inferInstance |
| instance seedSmallFintype : Fintype (SmallSeed X Y M T N) := inferInstance |
| instance seedCompareFintype : Fintype (CompareSeed X Y M T N) := inferInstance |
| instance seedFintype : Fintype (Seed X Y M T N) := by unfold Seed; infer_instance |
| |
| def slotLaw : FiniteDistribution (SlotSeed X M) := (uniform (Fin M)).sigma subsetLaw |
| variable (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| |
| def fullLaw : FiniteDistribution (FullSeed X M T N) := ψLaw.product (slotLaw.iid T) |
| def commonLaw : FiniteDistribution (CommonSeed X M T N) := |
| ψLaw.product ((uniform (Fin T)).sigma (fun t => slotLaw.iid t.val)) |
| def bigLaw : FiniteDistribution (BigSeed X M T N) := (commonLaw ψLaw).product Pivotal.labelOrderLaw |
| def smallLaw : FiniteDistribution (SmallSeed X Y M T N) := (commonLaw ψLaw).product Pivotal.labelOrderLaw |
| |
| def localCompareLaw (t : Nat) : FiniteDistribution (Σ _ : Fin M, Fin (Prefix.cellCount t) × (Y → Coupling.Block)) := |
| (uniform (Fin M)).sigma (fun i => (uniform (Fin (Prefix.cellCount t))).product |
| (Coupling.law (bias i) (bias_pos i).le (by linarith [bias_le_quarter i]))) |
| def compareLaw : FiniteDistribution (CompareSeed X Y M T N) := |
| (commonLaw ψLaw).sigma (fun d => localCompareLaw d.2.1.val) |
| |
| variable (G : Game U V E X Y) |
| |
| def fillPrefix {t : Nat} (ht : t≤T+1) (a : PrefixSeed X M t) (e : Fin (T+1) → E) : |
| PrefixData U X M t := fun j => (G.left (e (Fin.castLE ht j)),a j) |
| def fillFull (a : FullSeed X M T N) (e : Fin (T+1) → E) : Full U X M T N := |
| (a.1,fillPrefix G (Nat.le_succ T) a.2 e) |
| def fillCommon (a : CommonSeed X M T N) (e : Fin (T+1) → E) : Common U X M T N := |
| (a.1,⟨a.2.1,fillPrefix G (by have := a.2.1.isLt; omega) a.2.2 e⟩) |
| def fresh (a : CommonSeed X M T N) (e : Fin (T+1) → E) : E := |
| e ⟨a.2.1.val,by have := a.2.1.isLt; omega⟩ |
| def fillBig (a : BigSeed X M T N) (e : Fin (T+1) → E) : Big U X M T N := |
| (fillCommon G a.1 e,(G.left (fresh a.1 e),a.2)) |
| def fillSmall (a : SmallSeed X Y M T N) (e : Fin (T+1) → E) : Small U V X Y M T N := |
| (fillCommon G a.1 e,(G.right (fresh a.1 e),a.2)) |
| def fillCompare (a : CompareSeed X Y M T N) (e : Fin (T+1) → E) : Compare U E X Y M T N := |
| ⟨fillCommon G a.1 e,fresh a.1 e,a.2⟩ |
| |
| def fill : Seed X Y M T N → (Fin (T+1) → E) → AllVertex U V E X Y M T N |
| | .inl a,e => .inr (.inl (.inl (fillFull G a e))) |
| | .inr (.inl a),e => .inr (.inl (.inr (.inl (fillBig G a e)))) |
| | .inr (.inr (.inl a)),e => .inr (.inl (.inr (.inr (fillSmall G a e)))) |
| | .inr (.inr (.inr a)),e => .inr (.inr (fillCompare G a e)) |
| |
| omit [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] [NeZero T] in |
| theorem sample_full (f : Full U X M T N → ℝ) : |
| (fullLaw ψLaw).expectation (fun a => (G.edgeLaw.iid (T+1)).expectation (fun e => f (fillFull G a e))) = |
| (Construction.fullLaw G ψLaw).expectation f := by |
| simp only [fullLaw,Construction.fullLaw,expectation_product] |
| apply expectation_congr |
| intro ψ |
| exact sample_prefix G.edgeLaw G.left slotLaw (Nat.le_succ T) (fun a => f (ψ,a)) |
| |
| omit [Fintype V] [Fintype Y] [Nonempty Y] in |
| theorem sample_big (f : Big U X M T N → ℝ) : |
| (bigLaw ψLaw).expectation (fun a => (G.edgeLaw.iid (T+1)).expectation (fun e => f (fillBig G a e))) = |
| (Construction.bigLaw G ψLaw).expectation f := by |
| simp only [bigLaw,commonLaw,Construction.bigLaw,Construction.common,PrefixExperiment.commonLaw, |
| expectation_product,expectation_sigma] |
| apply expectation_congr |
| intro ψ |
| apply expectation_congr |
| intro t |
| simp_rw [expectation_comm Pivotal.labelOrderLaw (G.edgeLaw.iid (T+1))] |
| simp only [Construction.bigMarginal,expectation_pushforward] |
| exact sample_prefix_fresh G.edgeLaw G.left slotLaw (by have := t.isLt; omega : t.val<T+1) |
| (fun a e => Pivotal.labelOrderLaw.expectation (fun o => f ((ψ,⟨t,a⟩),(G.left e,o)))) |
| |
| omit [Nonempty X] in |
| theorem sample_small (f : Small U V X Y M T N → ℝ) : |
| (smallLaw ψLaw).expectation (fun a => (G.edgeLaw.iid (T+1)).expectation (fun e => f (fillSmall G a e))) = |
| (Construction.smallLaw G ψLaw).expectation f := by |
| simp only [smallLaw,commonLaw,Construction.smallLaw,Construction.common,PrefixExperiment.commonLaw, |
| expectation_product,expectation_sigma] |
| apply expectation_congr |
| intro ψ |
| apply expectation_congr |
| intro t |
| simp_rw [expectation_comm Pivotal.labelOrderLaw (G.edgeLaw.iid (T+1))] |
| simp only [Construction.smallMarginal,expectation_pushforward] |
| exact sample_prefix_fresh G.edgeLaw G.left slotLaw (by have := t.isLt; omega : t.val<T+1) |
| (fun a e => Pivotal.labelOrderLaw.expectation (fun o => f ((ψ,⟨t,a⟩),(G.right e,o)))) |
| |
| omit [Fintype V] [Nonempty X] [Nonempty Y] in |
| theorem sample_compare (f : Compare U E X Y M T N → ℝ) : |
| (compareLaw ψLaw).expectation (fun a => (G.edgeLaw.iid (T+1)).expectation (fun e => f (fillCompare G a e))) = |
| (Construction.comparisonLaw G ψLaw).expectation f := by |
| simp only [compareLaw,Construction.comparisonLaw,expectation_sigma] |
| simp only [commonLaw,Construction.common,PrefixExperiment.commonLaw,expectation_product,expectation_sigma] |
| apply expectation_congr |
| intro ψ |
| apply expectation_congr |
| intro t |
| change (slotLaw.iid t.val).expectation (fun a => |
| (localCompareLaw t.val).expectation (fun z => (G.edgeLaw.iid (T+1)).expectation |
| (fun e => f (fillCompare G ⟨(ψ,⟨t,a⟩),z⟩ e)))) = _ |
| simp_rw [expectation_comm (localCompareLaw t.val) (G.edgeLaw.iid (T+1))] |
| dsimp +unfoldPartialApp only [fillCompare,fillCommon,fillPrefix,fresh] |
| simpa +unfoldPartialApp only [localCompareLaw,expectation_sigma,expectation_product,fillCompare,fillCommon,fillPrefix,fresh, |
| PrefixExperiment.atomLaw,Construction.bigMarginal,slotLaw] using |
| sample_prefix_fresh G.edgeLaw G.left slotLaw (by have := t.isLt; omega : t.val<T+1) |
| (fun a e => (localCompareLaw t.val).expectation (fun z => f ⟨(ψ,⟨t,a⟩),e,z⟩)) |
| |
| end DirectedFeedback.PacketSeeds |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.RankPackets |
| open RankGraph |
| |
| abbrev Shape (X Y : Type) (T N : Nat) := |
| (Σ t : Fin (T+1), (Fin t.val → X) → Fin N) ⊕ |
| (Σ t : Fin T, ((Fin t.val → X) × Y) → Fin N) |
| |
| instance shapeFintype {X Y : Type} [Fintype X] [Fintype Y] {T N : Nat} : |
| Fintype (Shape X Y T N) := by unfold Shape; infer_instance |
| |
| variable {W X Y : Type} {T N : Nat} |
| |
| def fill (s : Shape X Y T N) (a : Fin (T+1) → W) : Rank W W X Y T N := |
| match s with |
| | .inl ⟨t,f⟩ => vertex (.inl ⟨t,fun i => a (Fin.castLE (Nat.le_of_lt t.isLt) i)⟩) f |
| | .inr ⟨t,f⟩ => vertex (.inr ⟨t,(fun i => a (Fin.castLE (by have := t.isLt; omega) i)), |
| a ⟨t.val,by have := t.isLt; omega⟩⟩) f |
| |
| theorem fill_surjective [Nonempty W] : Function.Surjective |
| (fun z : Shape X Y T N × (Fin (T+1) → W) => fill z.1 z.2) := by |
| intro r |
| induction r using Quot.inductionOn with |
| | h d => |
| rcases d with ⟨⟨t,s⟩ | ⟨t,s,v⟩,f⟩ |
| · let a : Fin (T+1) → W := fun i => if h : i.val<t.val then s ⟨i.val,h⟩ |
| else Classical.choice inferInstance |
| refine ⟨(.inl ⟨t,f⟩,a),?_⟩ |
| have he : (fun i : Fin t.val => a (Fin.castLE (Nat.le_of_lt t.isLt) i))=s := by |
| funext i |
| simp only [a,Fin.castLE,dite_eq_left i.isLt] |
| exact congrArg (fun s' : Fin t.val → W => vertex (.inl ⟨t,s'⟩) f) he |
| · let a : Fin (T+1) → W := fun i => if h : i.val<t.val then s ⟨i.val,h⟩ else v |
| refine ⟨(.inr ⟨t,f⟩,a),?_⟩ |
| have he : (fun i : Fin t.val => a (Fin.castLE (by have := t.isLt; omega) i))=s := by |
| funext i |
| simp only [a,Fin.castLE,dite_eq_left i.isLt] |
| have hv : a ⟨t.val,by have := t.isLt; omega⟩=v := by simp [a] |
| have hp : ((fun i : Fin t.val => a (Fin.castLE (by have := t.isLt; omega) i)), |
| a ⟨t.val,by have := t.isLt; omega⟩)=(s,v) := Prod.ext he hv |
| exact congrArg (fun p : (Fin t.val → W) × W => vertex (.inr ⟨t,p⟩) f) hp |
| |
| theorem eval_fill (s : Shape X Y T N) (a : Fin (T+1) → W) |
| (lu : W → X) (lv : W → Y) : |
| eval lu lv (fill s a) = eval (lu ∘ a) (lv ∘ a) (fill s id) := by |
| rcases s with ⟨t,f⟩ | ⟨t,f⟩ <;> rfl |
| |
| end DirectedFeedback.RankPackets |
| |
| end |
| end |
| |
| end OAI |
| |
