| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.OutputDef |
| import OAI.Computability.DirectedFeedback.RankGraph.LastBias |
| |
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical |
| open scoped Classical |
| open scoped Classical BigOperators |
| open scoped BigOperators |
| open scoped BigOperators |
| open DirectedFeedback.SourceProbability |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped BigOperators |
| open scoped BigOperators |
| open scoped BigOperators |
| open scoped Classical |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Pivotal Ranks |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
|
|
| theorem parameterized_soundness {D : ℕ} (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) |
| (hsound : G.Sound P.theta) |
| (F : Finset (OutputVertex (M := P.M) G R.law)) |
| (hF : FeedbackR (OutputArc G R.law hYX fiber) F) : |
| (D:ℝ) < totalDeletionCost G R.law D (8*((D:ℝ)+1)) P.K (fun v => decide (v ∈ F)) := by |
| apply weighted_soundness (J := P.J) G R.law hYX fiber hproj D (8*((D:ℝ)+1)) P.K |
| R.eta R.rho (lastBias P.M/1000) P.theta (Nat.cast_nonneg _) (by positivity) |
| (by exact_mod_cast P.K_pos) R.eta_pos.le P.gamma_pos |
| · exact_mod_cast P.M_eq |
| · exact R.accuracy |
| · exact R.spreads |
| · exact R.rho_alphabet |
| · exact R.rho_nonneg |
| · exact P.full_error R.rho R.rho_small |
| · exact P.J_pos |
| · exact P.junta |
| · exact P.product_error R.rho R.rho_small |
| · exact hsound |
| · exact hF |
|
|
| theorem parameterized_completeness {D : ℕ} (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) |
| (ellU : U → X) (ellV : V → Y) (hscore : 1-(P.theta:ℝ) ≤ G.score ellU ellV) : |
| ∃ F : Finset (OutputVertex (M := P.M) G R.law), |
| FeedbackR (OutputArc G R.law hYX fiber) F ∧ |
| totalDeletionCost G R.law D (8*((D:ℝ)+1)) P.K (fun v => decide (v ∈ F)) ≤ 4 := by |
| refine ⟨labelFeedback (M := P.M) G R.law hYX fiber ellU ellV, |
| labelFeedback_spec G R.law hYX fiber ellU ellV, ?_⟩ |
| rw [labelFeedback_indicator] |
| have hh := weighted_completeness (M := P.M) G R.law hYX fiber ellU ellV hproj |
| D (8*((D:ℝ)+1)) P.K (by positivity) (by exact_mod_cast P.K_pos.le) |
| have hloss : (P.K:ℝ)*(1-G.score ellU ellV) ≤ (P.K:ℝ)*P.theta := |
| mul_le_mul_of_nonneg_left (by linarith) (Nat.cast_nonneg _) |
| linarith [P.fullChernoff,P.Ktheta] |
|
|
| end DirectedFeedback.Construction |
| |
| open scoped Classical BigOperators |
| namespace DirectedFeedback |
| |
| def Rational (x : ℝ) : Prop := ∃ q : ℚ, x = q |
| namespace Rational |
|
|
| theorem rat (q : ℚ) : Rational (q:ℝ) := ⟨q,rfl⟩ |
| theorem nat (n : ℕ) : Rational (n:ℝ) := ⟨n,by simp⟩ |
| theorem zero : Rational 0 := ⟨0,by simp⟩ |
| theorem one : Rational 1 := ⟨1,by simp⟩ |
| theorem add {x y : ℝ} (hx : Rational x) (hy : Rational y) : Rational (x+y) := by |
| obtain ⟨a,rfl⟩ := hx |
| exact ⟨a+b,by simp⟩ |
| theorem sub {x y : ℝ} (hx : Rational x) (hy : Rational y) : Rational (x-y) := by |
| obtain ⟨a,rfl⟩ := hx |
| exact ⟨a-b,by simp⟩ |
| theorem mul {x y : ℝ} (hx : Rational x) (hy : Rational y) : Rational (x*y) := by |
| obtain ⟨a,rfl⟩ := hx |
| exact ⟨a*b,by simp⟩ |
| theorem inv {x : ℝ} (hx : Rational x) : Rational x⁻¹ := by |
| obtain ⟨a,rfl⟩ := hx |
| exact ⟨a⁻¹,by simp⟩ |
| theorem div {x y : ℝ} (hx : Rational x) (hy : Rational y) : Rational (x/y) := by |
| simpa only [div_eq_mul_inv] using hx.mul hy.inv |
| theorem pow {x : ℝ} (hx : Rational x) (n : ℕ) : Rational (x^n) := by |
| obtain ⟨a,rfl⟩ := hx |
| exact ⟨a^n,by simp⟩ |
| theorem sum {I : Type*} (s : Finset I) (f : I → ℝ) (h : ∀ i ∈ s, Rational (f i)) : |
| Rational (∑ i ∈ s, f i) := by |
| induction s using Finset.induction_on with |
| | empty => simpa using zero |
| | @insert a s ha ih => |
| rw [Finset.sum_insert ha] |
| exact (h a (by simp)).add (ih (fun i hi => h i (by simp [hi]))) |
| theorem prod {I : Type*} (s : Finset I) (f : I → ℝ) (h : ∀ i ∈ s, Rational (f i)) : |
| Rational (∏ i ∈ s, f i) := by |
| induction s using Finset.induction_on with |
| | empty => simpa using one |
| | @insert a s ha ih => |
| rw [Finset.prod_insert ha] |
| exact (h a (by simp)).mul (ih (fun i hi => h i (by simp [hi]))) |
| end Rational |
| end DirectedFeedback |
| |
| namespace DirectedFeedback.SourceProbability.FiniteDistribution |
| open DirectedFeedback |
| variable {I J : Type*} [Fintype I] [Fintype J] |
| def RationalMass (μ : FiniteDistribution I) : Prop := ∀ i, Rational (μ.weight i) |
|
|
| theorem RationalMass.uniform [Nonempty I] : RationalMass (uniform I) := |
| fun _ => Rational.one.div (Rational.nat _) |
|
|
| theorem RationalMass.product {μ : FiniteDistribution I} {ν : FiniteDistribution J} |
| (hμ : μ.RationalMass) (hν : ν.RationalMass) : (μ.product ν).RationalMass := |
| fun x => (hμ x.1).mul (hν x.2) |
|
|
| theorem RationalMass.sigma {F : I → Type*} [∀ i, Fintype (F i)] |
| {μ : FiniteDistribution I} {ν : ∀ i, FiniteDistribution (F i)} |
| (hμ : μ.RationalMass) (hν : ∀ i, (ν i).RationalMass) : (μ.sigma ν).RationalMass := |
| fun x => (hμ x.1).mul (hν x.1 x.2) |
|
|
| theorem RationalMass.iid {μ : FiniteDistribution I} (hμ : μ.RationalMass) (n : ℕ) : |
| (μ.iid n).RationalMass := by |
| intro x |
| change Rational (∏ i : Fin n, μ.weight (x i)) |
| exact Rational.prod _ _ (fun i _ => hμ (x i)) |
|
|
| theorem RationalMass.table {μ : I → FiniteDistribution J} |
| (hμ : ∀ i, (μ i).RationalMass) : (table μ).RationalMass := |
| fun x => Rational.prod _ _ (fun i _ => hμ i (x i)) |
|
|
| theorem RationalMass.pushforward {μ : FiniteDistribution I} (hμ : μ.RationalMass) |
| (f : I → J) : (μ.pushforward f).RationalMass := by |
| intro j |
| apply Rational.sum |
| intro i _ |
| split_ifs |
| · exact hμ i |
| · exact Rational.zero |
|
|
| end DirectedFeedback.SourceProbability.FiniteDistribution |
| |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution 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 : ℕ} [NeZero M] [NeZero T] |
|
|
| omit [NeZero M] [NeZero T] [Nonempty X] in |
| theorem subsetLaw_rational (i : Fin M) : (subsetLaw (X:=X) i).RationalMass := by |
| apply RationalMass.table |
| intro _ b |
| change Rational (if b then bias i else 1-bias i) |
| have hp : Rational (bias i) := (Rational.nat 2).inv.pow _ |
| split_ifs |
| · exact hp |
| · exact Rational.one.sub hp |
|
|
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| (hG : G.edgeLaw.RationalMass) (hψ : ψLaw.RationalMass) |
| include hG hψ |
|
|
| omit [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] in |
| theorem common_rational : (common (M:=M) G ψLaw).RationalMass := by |
| apply hψ.product |
| apply RationalMass.uniform.sigma |
| intro t |
| apply RationalMass.iid |
| exact (hG.pushforward G.left).product (RationalMass.uniform.sigma (fun i => subsetLaw_rational i)) |
|
|
| omit [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] [NeZero T] in |
| theorem fullLaw_rational : (fullLaw (M:=M) G ψLaw).RationalMass := by |
| apply hψ.product |
| apply RationalMass.iid |
| exact (hG.pushforward G.left).product (RationalMass.uniform.sigma (fun i => subsetLaw_rational i)) |
|
|
| omit [Fintype V] [Fintype Y] [Nonempty Y] in |
| theorem bigLaw_rational : (bigLaw (M:=M) G ψLaw).RationalMass := by |
| apply (common_rational G ψLaw hG hψ).product |
| exact (hG.pushforward G.left).product (RationalMass.uniform.sigma (fun _ => RationalMass.uniform)) |
|
|
| omit [Nonempty X] in |
| theorem smallLaw_rational : (smallLaw (M:=M) G ψLaw).RationalMass := by |
| apply (common_rational G ψLaw hG hψ).product |
| exact (hG.pushforward G.right).product (RationalMass.uniform.sigma (fun _ => RationalMass.uniform)) |
|
|
| omit [Fintype V] [Nonempty X] [Nonempty Y] in |
| theorem comparisonLaw_rational : (comparisonLaw (M:=M) G ψLaw).RationalMass := by |
| apply (common_rational G ψLaw hG hψ).sigma |
| intro d |
| apply hG.product |
| 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₁ < |
| first | exact Rational.one.sub ((Rational.nat 2).mul hp) |
| | exact hp.pow 2 | exact hp.mul h1 | exact Rational.zero |
|
|
| theorem vertexCost_rational (D H K : ℕ) |
| (v : OutputVertex (M:=M) G ψLaw) : Rational (vertexCost G ψLaw D H K v) := by |
| rcases v with r | (d | d) |
| · exact (Rational.nat D).add Rational.one |
| · rcases d with d | (d | d) |
| · exact (Rational.nat H).mul (fullLaw_rational G ψLaw hG hψ d.val) |
| · exact (Rational.nat _).mul (bigLaw_rational G ψLaw hG hψ d.val) |
| · exact (Rational.nat _).mul (smallLaw_rational G ψLaw hG hψ d.val) |
| · exact (Rational.nat K).mul (comparisonLaw_rational G ψLaw hG hψ d.val) |
|
|
| end DirectedFeedback.Construction |
| |
| open scoped Classical BigOperators |
| namespace DirectedFeedback |
| |
| namespace Digraph |
| |
| theorem dfvs_le_iff (G : Digraph) (k : ℕ) : |
| G.dfvs ≤ k ↔ ∃ F : Finset (Fin G.n), G.Feedback F ∧ F.card ≤ k := by |
| constructor |
| · intro hk |
| obtain ⟨F,hF,hcard⟩ := Nat.find_spec |
| (show ∃ k : ℕ, ∃ F : Finset (Fin G.n), G.Feedback F ∧ F.card = k from |
| ⟨G.n,Finset.univ,by intro r c _ |
| exact ⟨F,hF,hcard.trans_le hk⟩ |
| · rintro ⟨F,hF,hcard⟩ |
| exact (Nat.find_min' _ ⟨F,hF,rfl⟩).trans hcard |
| |
| theorem dfvs_attained (G : Digraph) : |
| ∃ F : Finset (Fin G.n), G.Feedback F ∧ F.card = G.dfvs := by |
| exact Nat.find_spec |
| (show ∃ k : ℕ, ∃ F : Finset (Fin G.n), G.Feedback F ∧ F.card = k from |
| ⟨G.n,Finset.univ,by intro r c _; exact ⟨0,Finset.mem_univ _⟩,by simp⟩) |
| |
| end Digraph |
| |
| def graphOfRelation {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) : Digraph where |
| n := Fintype.card V |
| arcs := ((Finset.univ : Finset (Fin (Fintype.card V) × Fin (Fintype.card V))).filter |
| (fun e => R ((Fintype.equivFin V).symm e.1) ((Fintype.equivFin V).symm e.2))).toList |
| loopless := by |
| intro e he heq |
| simp only [Finset.mem_toList,Finset.mem_filter,Finset.mem_univ,true_and] at he |
| rw [heq] at he |
| exact hR _ he |
| nodup := Finset.nodup_toList _ |
| |
| @[simp] theorem graphOfRelation_mem {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (a b : Fin (Fintype.card V)) : |
| (a,b) ∈ (graphOfRelation R hR).arcs ↔ |
| R ((Fintype.equivFin V).symm a) ((Fintype.equivFin V).symm b) := by |
| change (a,b) ∈ ((Finset.univ : Finset (Fin (Fintype.card V) × Fin (Fintype.card V))).filter |
| (fun e => R ((Fintype.equivFin V).symm e.1) ((Fintype.equivFin V).symm e.2))).toList ↔ _ |
| rw [Finset.mem_toList,Finset.mem_filter] |
| simp only [Finset.mem_univ,true_and] |
| |
| theorem graphOfRelation_feedback {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (F : Finset V) (hF : FeedbackR R F) : |
| (graphOfRelation R hR).Feedback (F.map (Fintype.equivFin V).toEmbedding) := by |
| intro n c hc |
| obtain ⟨i,hi⟩ := hF n ((Fintype.equivFin V).symm ∘ c) |
| ((Fintype.equivFin V).symm.injective.comp hc.1) |
| (fun i => (graphOfRelation_mem R hR _ _).mp (hc.2 i)) |
| refine ⟨i,Finset.mem_map.mpr ⟨_,hi,?_⟩⟩ |
| exact (Fintype.equivFin V).apply_symm_apply _ |
| |
| theorem relation_feedback_of_graph {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (F : Finset (Fin (Fintype.card V))) |
| (hF : (graphOfRelation R hR).Feedback F) : |
| FeedbackR R (F.map (Fintype.equivFin V).symm.toEmbedding) := by |
| intro n c hcinj hc |
| obtain ⟨i,hi⟩ := hF n ((Fintype.equivFin V) ∘ c) ⟨ |
| ((Fintype.equivFin V).injective.comp hcinj),fun i => by |
| apply (graphOfRelation_mem R hR _ _).mpr |
| change R ((Fintype.equivFin V).symm ((Fintype.equivFin V) (c i))) |
| ((Fintype.equivFin V).symm ((Fintype.equivFin V) (c (i+1)))) |
| simpa only [Equiv.symm_apply_apply] using hc i⟩ |
| refine ⟨i,Finset.mem_map.mpr ⟨_,hi,?_⟩⟩ |
| exact (Fintype.equivFin V).symm_apply_apply _ |
| |
| theorem graphOfRelation_dfvs_le_iff {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (k : ℕ) : |
| (graphOfRelation R hR).dfvs ≤ k ↔ ∃ F : Finset V, FeedbackR R F ∧ F.card ≤ k := by |
| rw [Digraph.dfvs_le_iff] |
| change (∃ F : Finset (Fin (Fintype.card V)), (graphOfRelation R hR).Feedback F ∧ F.card ≤ k) ↔ _ |
| constructor |
| · rintro ⟨F,hF,hcard⟩ |
| exact ⟨F.map (Fintype.equivFin V).symm.toEmbedding, |
| relation_feedback_of_graph R hR F hF,by simpa using hcard⟩ |
| · rintro ⟨F,hF,hcard⟩ |
| exact ⟨F.map (Fintype.equivFin V).toEmbedding, |
| graphOfRelation_feedback R hR F hF,by simpa using hcard⟩ |
| |
| theorem cloneRel_irrefl {V : Type} (R : V → V → Prop) (hR : ∀ v, ¬R v v) (c : V → ℕ) : |
| ∀ v, ¬cloneRel R c v v := fun v => hR v.1 |
| |
| def roundedGraph {V : Type} [Fintype V] (R : V → V → Prop) (hR : ∀ v, ¬R v v) |
| (w : V → ℚ) : Digraph := |
| graphOfRelation (cloneRel R (roundCopies (Fintype.card V) w)) (cloneRel_irrefl R hR _) |
| |
| theorem roundedGraph_yes {V : Type} [Fintype V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (w : V → ℚ) (hw : ∀ v, 0 ≤ w v) |
| (hyes : ∃ F : Finset V, FeedbackR R F ∧ (∑ v ∈ F, w v) ≤ 4) : |
| (roundedGraph R hR w).dfvs ≤ 5*Fintype.card V := by |
| obtain ⟨F,hF,hcost⟩ := hyes |
| obtain ⟨Q,hQ,hcard⟩ := rounded_clone_completeness R w hw F hF 4 hcost |
| rw [roundedGraph,graphOfRelation_dfvs_le_iff] |
| refine ⟨Q,hQ,?_⟩ |
| have hh : (Q.card:ℚ) ≤ 5*Fintype.card V := by linarith |
| exact_mod_cast hh |
| |
| theorem roundedGraph_no {V : Type} [Fintype V] [Nonempty V] (R : V → V → Prop) |
| (hR : ∀ v, ¬R v v) (w : V → ℚ) (b : ℚ) |
| (hno : ∀ F : Finset V, FeedbackR R F → b < ∑ v ∈ F, w v) : |
| (Fintype.card V : ℚ)*b < (roundedGraph R hR w).dfvs := by |
| obtain ⟨Q,hQ,hcard⟩ := (graphOfRelation_dfvs_le_iff |
| (cloneRel R (roundCopies (Fintype.card V) w)) (cloneRel_irrefl R hR _) |
| (roundedGraph R hR w).dfvs).mp le_rfl |
| have hb := rounded_clone_soundness R w (Fintype.card V) Fintype.card_pos b hno Q hQ |
| exact hb.trans_le (by exact_mod_cast hcard) |
| |
| end DirectedFeedback |
| |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Pivotal Ranks |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {D : ℕ} (P : Parameters D) (R : RankParameters P X) |
| (G : Game U V E X Y) (hG : G.edgeLaw.RationalMass) |
| |
| def rationalCost (v : OutputVertex (M := P.M) G R.law) : ℚ := |
| (vertexCost_rational G R.law hG R.rational D (8*(D+1)) P.K v).choose |
| |
| theorem rationalCost_cast (v : OutputVertex (M := P.M) G R.law) : |
| (rationalCost P R G hG v : ℝ) = vertexCost G R.law D (8*((D:ℝ)+1)) P.K v := by |
| have h := (vertexCost_rational G R.law hG R.rational D (8*(D+1)) P.K v).choose_spec |
| exact h.symm.trans (by congr 1; push_cast; rfl) |
| |
| theorem rationalCost_pos (v : OutputVertex (M := P.M) G R.law) : |
| 0 < rationalCost P R G hG v := by |
| have hp := vertexCost_pos G R.law (D:ℝ) (8*((D:ℝ)+1)) P.K |
| (Nat.cast_nonneg _) (by positivity) (by exact_mod_cast P.K_pos) v |
| rw [← rationalCost_cast P R G hG v] at hp |
| exact_mod_cast hp |
| |
| theorem cost_sum (F : Finset (OutputVertex (M := P.M) G R.law)) : |
| ((∑ v ∈ F, rationalCost P R G hG v : ℚ) : ℝ) = |
| totalDeletionCost G R.law D (8*((D:ℝ)+1)) P.K (fun v => decide (v ∈ F)) := by |
| simp [totalDeletionCost, ← rationalCost_cast P R G hG] |
| |
| instance parameterized_output_nonempty : Nonempty (OutputVertex (M := P.M) G R.law) := by |
| obtain ⟨w⟩ := (fullLaw (M := P.M) G R.law).support_nonempty |
| exact ⟨.inr (.inl (.inl w))⟩ |
| |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| |
| def unweightedInstance : GapInstance where |
| graph := roundedGraph (OutputArc G R.law hYX fiber) (output_loopless G R.law hYX fiber) |
| (rationalCost P R G hG) |
| k := 5 * Fintype.card (OutputVertex (M := P.M) G R.law) |
| k_pos := Nat.mul_pos (by decide) Fintype.card_pos |
| |
| theorem unweighted_yes (hproj : ∀ e x, (fiber e x).1 = G.project e x) |
| (ellU : U → X) (ellV : V → Y) (hscore : 1-(P.theta:ℝ) ≤ G.score ellU ellV) : |
| (unweightedInstance P R G hG hYX fiber).graph.dfvs ≤ |
| (unweightedInstance P R G hG hYX fiber).k := by |
| apply roundedGraph_yes _ (output_loopless G R.law hYX fiber) _ |
| · intro v; exact (rationalCost_pos P R G hG v).le |
| obtain ⟨F,hF,hcost⟩ := parameterized_completeness P R G hYX fiber hproj ellU ellV hscore |
| refine ⟨F,hF,?_⟩ |
| rw [← cost_sum P R G hG F] at hcost |
| exact_mod_cast hcost |
| |
| theorem unweighted_no (hproj : ∀ e x, (fiber e x).1 = G.project e x) |
| (hsound : G.Sound P.theta) (A : ℝ) (hA : 5*A ≤ D) : |
| A * ((unweightedInstance P R G hG hYX fiber).k : ℝ) < |
| ((unweightedInstance P R G hG hYX fiber).graph.dfvs : ℝ) := by |
| have hn := roundedGraph_no (OutputArc G R.law hYX fiber) |
| (output_loopless G R.law hYX fiber) (rationalCost P R G hG) (D:ℚ) (by |
| intro F hF |
| have hc := parameterized_soundness P R G hYX fiber hproj hsound F hF |
| rw [← cost_sum P R G hG F] at hc |
| exact_mod_cast hc) |
| have hh : (Fintype.card (OutputVertex (M := P.M) G R.law):ℝ)*D < |
| ((unweightedInstance P R G hG hYX fiber).graph.dfvs : ℝ) := by |
| exact_mod_cast hn |
| apply lt_of_le_of_lt _ hh |
| change A * ((5*Fintype.card (OutputVertex (M := P.M) G R.law):ℕ):ℝ) ≤ _ |
| push_cast |
| nlinarith [Nat.cast_nonneg (α:=ℝ) (Fintype.card (OutputVertex (M := P.M) G R.law)), |
| mul_le_mul_of_nonneg_right hA (Nat.cast_nonneg (α:=ℝ) |
| (Fintype.card (OutputVertex (M := P.M) G R.law)))] |
| |
| end DirectedFeedback.Construction |
| |
| end |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback |
| open SourceProbability SourceProbability.FiniteDistribution |
| open Games Construction |
| open DFVSGames.Explicit DFVSGames.Explicit.MachineOutputContract |
| |
| namespace UGBridge |
| variable {U V E Q : Type} [Fintype U] [Fintype V] [Fintype E] [Fintype Q] |
| [Nonempty E] [Nonempty Q] |
| |
| def game (G : BipartiteGame U V E Q) : Game U V E (Q × Bool) Q where |
| edgeLaw := uniform E |
| left := G.left |
| right := G.right |
| project := fun e a => G.permutation e a.1 |
| |
| def fiber (G : BipartiteGame U V E Q) (e : E) : (Q × Bool) ≃ Q × Bool := |
| Equiv.prodCongr (G.permutation e) (Equiv.refl Bool) |
| |
| omit [Fintype U] [Fintype V] [Fintype Q] [Nonempty Q] in |
| theorem fiber_project (G : BipartiteGame U V E Q) (e : E) (a : Q × Bool) : |
| (fiber G e a).1 = (game G).project e a := rfl |
| |
| omit [Nonempty Q] in |
| theorem alphabet_card : Fintype.card Q ≤ Fintype.card (Q × Bool) := by simp; omega |
| |
| omit [Fintype U] [Fintype V] [Fintype Q] [Nonempty Q] in |
| theorem rational (G : BipartiteGame U V E Q) : (game G).edgeLaw.RationalMass := |
| RationalMass.uniform |
| |
| omit [Fintype U] [Fintype V] [Fintype Q] [Nonempty Q] in |
| theorem score_eq [DecidableEq Q] (G : BipartiteGame U V E Q) (a : U → Q × Bool) (b : V → Q) : |
| (game G).score a b = (G.satisfiedCount (fun u => (a u).1) b : ℝ)/Fintype.card E := by |
| unfold Game.score game |
| rw [probability_uniform] |
| congr 1 |
| rw [Finset.card_filter] |
| simp only [BipartiteGame.satisfiedCount, decide_eq_true_eq] |
| |
| end UGBridge |
| |
| namespace SourceInstance |
| variable {ε δ : ℝ} (R : BinaryGapReduction ε δ) (input : List Bool) |
| |
| abbrev UG := (R.simpleBipartite input).toBipartiteGame |
| abbrev Left := {v : Fin (R.construct input).vertices // (R.simpleBipartite input).side v = false} |
| abbrev Right := {v : Fin (R.construct input).vertices // (R.simpleBipartite input).side v = true} |
| abbrev Edge := Fin (R.construct input).constraints.length |
| |
| instance edge_nonempty : Nonempty (Edge R input) := |
| ⟨⟨0,R.occurrence_count_positive input⟩⟩ |
| instance label_nonempty : Nonempty (Fin R.alphabet) := |
| ⟨⟨0,lt_of_lt_of_le (by decide : 0 < 2) R.alphabetAtLeastTwo⟩⟩ |
| |
| def game := UGBridge.game (UG R input) |
| def fiber := UGBridge.fiber (UG R input) |
| |
| theorem correct (yes : DFVSGames.BinaryLanguage.language input) : |
| ∃ a b, 1-ε ≤ (game R input).score a b := by |
| obtain ⟨l,hl⟩ := R.completeness input yes |
| refine ⟨fun u => (l u.val,false),fun v => l v.val,?_⟩ |
| rw [game,UGBridge.score_eq] |
| have hc := (R.simpleBipartite input).toBipartiteGame_count l |
| have hc' : (UG R input).satisfiedCount (fun u => l u.val) (fun v => l v.val) = |
| DFVSGames.Foundations.Target.countSatisfied l (R.construct input).constraints := by |
| simpa only [UG,BipartiteGame.satisfiedCount] using hc |
| rw [hc'] |
| simpa only [Fintype.card_fin] using hl |
| |
| theorem sound (no : ¬DFVSGames.BinaryLanguage.language input) : |
| (game R input).Sound δ := by |
| intro a b |
| rw [game,UGBridge.score_eq] |
| have hc := (R.simpleBipartite input).toBipartiteGame_count_merge (fun u => (a u).1) b |
| have hc' : (UG R input).satisfiedCount (fun u => (a u).1) b = |
| DFVSGames.Foundations.Target.countSatisfied |
| ((R.simpleBipartite input).mergeLabelings (fun u => (a u).1) b) |
| (R.construct input).constraints := by |
| simpa only [UG,BipartiteGame.satisfiedCount] using hc |
| rw [hc'] |
| simpa only [Fintype.card_fin] using |
| R.soundness input no ((R.simpleBipartite input).mergeLabelings (fun u => (a u).1) b) |
| |
| end SourceInstance |
| |
| namespace FromUG |
| variable {D : ℕ} (P : Parameters D) |
| (S : BinaryGapReduction P.theta P.theta) |
| (R : RankParameters P (Fin S.alphabet × Bool)) |
| |
| def instanceOf (input : List Bool) : GapInstance := |
| unweightedInstance P R (SourceInstance.game S input) (UGBridge.rational _) |
| UGBridge.alphabet_card (SourceInstance.fiber S input) |
| |
| theorem yes (input : List Bool) (h : DFVSGames.BinaryLanguage.language input) : |
| (instanceOf P S R input).graph.dfvs ≤ (instanceOf P S R input).k := by |
| obtain ⟨a,b,hscore⟩ := SourceInstance.correct S input h |
| exact unweighted_yes P R _ _ _ _ (UGBridge.fiber_project _) a b hscore |
| |
| theorem no (A : ℝ) (hA : 5*A ≤ D) (input : List Bool) |
| (h : ¬DFVSGames.BinaryLanguage.language input) : |
| A*((instanceOf P S R input).k:ℝ) < ((instanceOf P S R input).graph.dfvs:ℝ) := |
| unweighted_no P R _ _ _ _ (UGBridge.fiber_project _) (SourceInstance.sound S input h) A hA |
| |
| theorem exists_correct_map (A : ℝ) : |
| ∃ f : List Bool → GapInstance, |
| (∀ input, DFVSGames.BinaryLanguage.language input → (f input).graph.dfvs ≤ (f input).k) ∧ |
| (∀ input, ¬DFVSGames.BinaryLanguage.language input → A*((f input).k:ℝ) < ((f input).graph.dfvs:ℝ)) := by |
| obtain ⟨D,hD⟩ := exists_nat_ge (5*A) |
| obtain ⟨P⟩ := exists_parameters D |
| obtain ⟨S⟩ := DFVSGames.theorem11 P.theta P.theta |
| (by exact_mod_cast P.theta_pos) P.theta_half (by exact_mod_cast P.theta_pos) P.theta_half |
| obtain ⟨R⟩ := exists_rankParameters P (Fin S.alphabet × Bool) |
| exact ⟨instanceOf P S R,yes P S R,no P S R A hD⟩ |
| |
| end FromUG |
| end DirectedFeedback |
| |
| end |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.FullGame |
| open DFVSGames.Foundations DFVSGames.Foundations.Target |
| open DFVSGames.Explicit.MachineOutputContract |
| open SourceProbability SourceProbability.FiniteDistribution Games |
| |
| variable {q : Nat} |
| |
| abbrev Edge (I : Instance q) := Fin I.constraints.length |
| instance edge_nonempty (I : Instance q) : Nonempty (Edge I) := ⟨⟨0,I.constraintCount_positive⟩⟩ |
| instance vertex_nonempty (I : Instance q) : Nonempty (Fin I.vertices) := |
| ⟨(I.constraints[0]'I.constraintCount_positive).source⟩ |
|
|
| def game (I : Instance q) : Game (Fin I.vertices) (Fin I.vertices) (Edge I) (Fin q × Bool) (Fin q) where |
| edgeLaw := uniform (Edge I) |
| left e := I.constraints[e].source |
| right e := I.constraints[e].target |
| project e a := (permutationEquiv I.constraints[e].permutation) a.1 |
|
|
| def fiber (I : Instance q) (e : Edge I) : (Fin q × Bool) ≃ (Fin q × Bool) := |
| Equiv.prodCongr (permutationEquiv I.constraints[e].permutation) (Equiv.refl Bool) |
| |
| theorem fiber_project (I : Instance q) (e : Edge I) (a : Fin q × Bool) : |
| (fiber I e a).1=(game I).project e a := rfl |
|
|
| variable {ε δ : ℝ} (R : BinaryGapReduction ε δ) (input : List Bool) |
| |
| theorem score_restrict (a : Fin (R.construct input).vertices → Fin R.alphabet × Bool) |
| (b : Fin (R.construct input).vertices → Fin R.alphabet) : |
| (game (R.construct input)).score a b = (SourceInstance.game R input).score |
| (fun u => a u.val) (fun v => b v.val) := rfl |
|
|
| theorem completeness (h : DFVSGames.BinaryLanguage.language input) : |
| ∃ a b, 1-ε ≤ (game (R.construct input)).score a b := by |
| obtain ⟨l,hl⟩ := R.completeness input h |
| refine ⟨fun u => (l u,false),l,?_⟩ |
| rw [score_restrict,SourceInstance.game,UGBridge.score_eq] |
| have hc := (R.simpleBipartite input).toBipartiteGame_count l |
| have hc' : (SourceInstance.UG R input).satisfiedCount (fun u => l u.val) (fun v => l v.val) = |
| countSatisfied l (R.construct input).constraints := by |
| simpa only [SourceInstance.UG,DFVSGames.Explicit.BipartiteGame.satisfiedCount] using hc |
| rw [hc'] |
| simpa only [Fintype.card_fin] using hl |
|
|
| theorem soundness (h : ¬DFVSGames.BinaryLanguage.language input) : |
| (game (R.construct input)).Sound δ := by |
| intro a b |
| rw [score_restrict] |
| exact SourceInstance.sound R input h _ _ |
|
|
| end DirectedFeedback.FullGame |
| |
| end |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.GameRead |
| open BoundedExpr BoundedExpr.UnaryRead |
| open DFVSGames.Foundations DFVSGames.Foundations.Target DFVSGames.Foundations.Complexity |
| open DFVSGames.Explicit.MachineOutputContract |
|
|
| variable (q : Nat) [NeZero q] |
| def n (x : List Bool) : Nat := max 1 (word x 0) |
| def m (x : List Bool) : Nat := max 1 (word x 2) |
| def field (x : List Bool) (e j : Nat) : Nat := word x (3+e*(q+2)+j) |
| def left (x : List Bool) (e : Nat) : Nat := field q x e 0 % n x |
| def right (x : List Bool) (e : Nat) : Nat := field q x e 1 % n x |
| def table (x : List Bool) (e : Nat) : Fin q → Fin q := fun i => |
| ⟨field q x e (2+i.val)%q,Nat.mod_lt _ (NeZero.pos q)⟩ |
| def asPerm (f : Fin q → Fin q) : Equiv.Perm (Fin q) := |
| if h : Function.Bijective f then Equiv.ofBijective f h else Equiv.refl _ |
| def perm (x : List Bool) (e : Nat) : Equiv.Perm (Fin q) := asPerm q (table q x e) |
| def fiber (x : List Bool) (e : Nat) : (Fin q × Bool) ≃ (Fin q × Bool) := |
| Equiv.prodCongr (perm q x e) (Equiv.refl Bool) |
| |
| theorem n_pos (x : List Bool) : 0<n x := by unfold n |
| theorem m_pos (x : List Bool) : 0 < m x := by unfold m |
|
|
| theorem n_def (r : Nat) : Def (r:=r) (fun x _ => n x) := (Def.lit 1).max (word_def (Def.lit 0)) |
| theorem m_def (r : Nat) : Def (r:=r) (fun x _ => m x) := (Def.lit 1).max (word_def (Def.lit 2)) |
| omit [NeZero q] in |
| theorem field_def {r : Nat} {e j : List Bool → (Fin r → Nat) → Nat} (he : Def e) (hj : Def j) : |
| Def (fun x a => field q x (e x a) (j x a)) := |
| word_def (((Def.lit 3).add (he.mul (Def.lit (q+2)))).add hj) |
| omit [NeZero q] in |
| theorem left_def {r : Nat} {e : List Bool → (Fin r → Nat) → Nat} (he : Def e) : |
| Def (fun x a => left q x (e x a)) := (field_def q he (Def.lit 0)).mod (n_def r) |
| omit [NeZero q] in |
| theorem right_def {r : Nat} {e : List Bool → (Fin r → Nat) → Nat} (he : Def e) : |
| Def (fun x a => right q x (e x a)) := (field_def q he (Def.lit 1)).mod (n_def r) |
| theorem table_def {r : Nat} {e : List Bool → (Fin r → Nat) → Nat} (he : Def e) : |
| FDef (fun x a => table q x (e x a)) := by |
| apply FDef.pi |
| intro i |
| have h := FDef.ofNat ((field_def q he (Def.lit (2+i.val))).mod (Def.lit q)) q id (⟨0,NeZero.pos q⟩ : Fin q) |
| apply h.congr |
| intro x a |
| simp [table,Nat.mod_lt _ (NeZero.pos q)] |
| theorem perm_def {r : Nat} {e : List Bool → (Fin r → Nat) → Nat} (he : Def e) : |
| FDef (fun x a => perm q x (e x a)) := (table_def q he).map (asPerm q) |
| theorem fiber_def {r : Nat} {e : List Bool → (Fin r → Nat) → Nat} (he : Def e) : |
| FDef (fun x a => fiber q x (e x a)) := (perm_def q he).map (fun p => Equiv.prodCongr p (Equiv.refl Bool)) |
| |
| omit [NeZero q] in |
| lemma word_game (I : Instance q) (j : Nat) : |
| word (gameBits I) j=(gameWords I)[j]?.getD 0 := word_encoded _ _ |
|
|
| omit [NeZero q] in |
| theorem n_encoded (I : Instance q) : n (gameBits I)=I.vertices := by |
| rw [n,word_game] |
| have hp : 0<I.vertices := Fintype.card_pos_iff.mpr (FullGame.vertex_nonempty I) |> (by simpa using ·) |
| simp only [gameWords,List.getElem?_append,List.length_cons,List.length_nil,List.getElem?_cons_zero] |
| simp |
| omega |
| |
| omit [NeZero q] in |
| theorem m_encoded (I : Instance q) : m (gameBits I)=I.constraints.length := by |
| rw [m,word_game] |
| simp only [gameWords,List.getElem?_append,List.length_cons,List.length_nil,List.getElem?_cons_succ, |
| List.getElem?_cons_zero] |
| simp |
| exact Nat.succ_le_of_lt I.constraintCount_positive |
| |
| lemma get_flatMap {A : Type} (f : A → List Nat) (L : Nat) (hL : ∀ a,(f a).length=L) |
| (as : List A) (e : Fin as.length) (j : Nat) (hj : j<L) : |
| (as.flatMap f)[e.val*L+j]?.getD 0=(f as[e])[j]?.getD 0 := by |
| induction as with |
| | nil => exact e.elim0 |
| | cons a as ih => |
| refine Fin.cases ?_ (fun e => ?_) e |
| · simp only [Fin.val_zero,zero_mul,zero_add,List.flatMap_cons] |
| rw [List.getElem?_append_left (by simpa [hL] using hj)] |
| rfl |
| · simp only [Fin.val_succ,List.flatMap_cons] |
| rw [List.getElem?_append_right (by rw [hL]; nlinarith)] |
| rw [hL] |
| have he : (e.val+1)*L+j-L=e.val*L+j := by rw [add_mul,one_mul]; omega |
| rw [he] |
| exact ih e |
| |
| omit [NeZero q] in |
| theorem field_encoded (I : Instance q) (e : FullGame.Edge I) (j : Nat) (hj : j<q+2) : |
| field q (gameBits I) e.val j=(constraintWords I.constraints[e])[j]?.getD 0 := by |
| rw [field,word_game] |
| simp only [gameWords] |
| rw [List.getElem?_append_right (by simp only [List.length_cons,List.length_nil]; omega)] |
| simp only [List.length_cons,List.length_nil] |
| have he : 3+e.val*(q+2)+j-(0+1+1+1)=e.val*(q+2)+j := by omega |
| rw [he] |
| apply get_flatMap constraintWords (q+2) _ I.constraints e j hj |
| intro a |
| simp [constraintWords,tableWords] |
| |
| omit [NeZero q] in |
| theorem left_encoded (I : Instance q) (e : FullGame.Edge I) : |
| left q (gameBits I) e.val=I.constraints[e].source.val := by |
| rw [left,field_encoded q I e 0 (by omega),n_encoded] |
| simp only [constraintWords,List.getElem?_append,List.length_cons,List.length_nil, |
| List.getElem?_cons_zero,Option.getD_some,show (0:Nat)<0+1+1 by omega,ite_true] |
| exact Nat.mod_eq_of_lt I.constraints[e].source.isLt |
| |
| omit [NeZero q] in |
| theorem right_encoded (I : Instance q) (e : FullGame.Edge I) : |
| right q (gameBits I) e.val=I.constraints[e].target.val := by |
| rw [right,field_encoded q I e 1 (by omega),n_encoded] |
| simp only [constraintWords,List.getElem?_append,List.length_cons,List.length_nil, |
| List.getElem?_cons_succ,List.getElem?_cons_zero,Option.getD_some,show (1:Nat)<0+1+1 by omega,ite_true] |
| exact Nat.mod_eq_of_lt I.constraints[e].target.isLt |
| |
| theorem table_encoded (I : Instance q) (e : FullGame.Edge I) : |
| table q (gameBits I) e.val=permutationEquiv I.constraints[e].permutation := by |
| funext i |
| apply Fin.ext |
| change field q (gameBits I) e.val (2+i.val)%q= _ |
| rw [field_encoded q I e (2+i.val) (by have := i.isLt; omega)] |
| unfold constraintWords |
| rw [List.getElem?_append_right (by simp)] |
| have he : 2+i.val-[I.constraints[e].source.val,I.constraints[e].target.val].length=i.val := by simp |
| rw [he] |
| have hi : i.val<(tableWords I.constraints[e].permutation).length := by simp |
| rw [List.getElem?_eq_getElem hi] |
| simp only [Option.getD_some,tableWords,List.getElem_map,Vector.getElem_toList] |
| exact Nat.mod_eq_of_lt (I.constraints[e].permutation.images[i]).isLt |
| |
| theorem perm_encoded (I : Instance q) (e : FullGame.Edge I) : |
| perm q (gameBits I) e.val=permutationEquiv I.constraints[e].permutation := by |
| rw [perm,table_encoded] |
| apply Equiv.ext |
| intro i |
| simp [asPerm] |
| |
| theorem fiber_encoded (I : Instance q) (e : FullGame.Edge I) : |
| fiber q (gameBits I) e.val=FullGame.fiber I e := by |
| rw [fiber,perm_encoded] |
| rfl |
| |
| end DirectedFeedback.GameRead |
| |
| end |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.PotentialCover |
| |
| variable {L B I : Type} [Fintype L] [Fintype B] |
| |
| def fullFibers (p : L → B) (F : Finset L) : Finset B := |
| Finset.univ.filter (fun b => ∀ a, p a=b → a ∈ F) |
| |
| @[simp] theorem mem_fullFibers (p : L → B) (F : Finset L) (b : B) : |
| b ∈ fullFibers p F ↔ ∀ a, p a=b → a ∈ F := by simp [fullFibers] |
| |
| theorem feedback_project (p : L → B) (R : B → B → Prop) (S : L → L → Prop) |
| (hcover : ∀ a b, R (p a) (p b) → S a b) (F : Finset L) |
| (hF : FeedbackR S F) : FeedbackR R (fullFibers p F) := by |
| intro n f hinj harc |
| by_contra hn |
| have hex (i) : ∃ a, p a=f i ∧ a ∉ F := by |
| have hi : f i ∉ fullFibers p F := fun h => hn ⟨i,h⟩ |
| obtain ⟨a,ha⟩ := not_forall.mp ((mem_fullFibers p F (f i)).not.mp hi) |
| exact ⟨a,Classical.not_imp.mp ha⟩ |
| choose g hg using hex |
| have hginj : Function.Injective g := by |
| intro i j hij |
| apply hinj |
| rw [← (hg i).1,← (hg j).1,hij] |
| obtain ⟨i,hi⟩ := hF n g hginj (fun i => hcover _ _ (by |
| rw [(hg i).1,(hg (i+1)).1] |
| exact harc i)) |
| exact (hg i).2 hi |
| |
| def fiberCount (p : L → B) (b : B) : Nat := (Finset.univ.filter (fun a => p a=b)).card |
| |
| theorem fullFibers_cost_le (p : L → B) (F : Finset L) : |
| ∑ b ∈ fullFibers p F, fiberCount p b ≤ F.card := by |
| have he : ∑ b ∈ fullFibers p F, fiberCount p b = |
| (Finset.univ.filter (fun a => p a ∈ fullFibers p F)).card := by |
| simp only [fiberCount,Finset.card_filter] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro a _ |
| simp |
| rw [he] |
| exact Finset.card_le_card (by |
| intro a ha |
| exact (mem_fullFibers p F (p a)).mp ((Finset.mem_filter.mp ha).2) a rfl) |
| |
| theorem weight_le_card (p : L → B) (w : B → ℝ) (C : Nat) |
| (hw : ∀ b, C*w b ≤ fiberCount p b) (F : Finset L) : |
| C * (∑ b ∈ fullFibers p F, w b) ≤ F.card := by |
| rw [Finset.mul_sum] |
| calc |
| _ ≤ ∑ b ∈ fullFibers p F, (fiberCount p b : ℝ) := |
| Finset.sum_le_sum (fun b _ => hw b) |
| _ = ((∑ b ∈ fullFibers p F, fiberCount p b : Nat) : ℝ) := by simp |
| _ ≤ F.card := by exact_mod_cast fullFibers_cost_le p F |
| |
| def Arc (deleted : I → L → Prop) (potential : I → L → ℚ) (a b : L) : Prop := |
| a ≠ b ∧ ∀ i, ¬deleted i a → ¬deleted i b → potential i a < potential i b |
| |
| omit [Fintype L] in |
| theorem irrefl (d : I → L → Prop) (q : I → L → ℚ) (a : L) : ¬Arc d q a a := |
| fun h => h.1 rfl |
| |
| theorem deleted_feedback (d : I → L → Prop) (q : I → L → ℚ) (i : I) : |
| FeedbackR (Arc d q) (Finset.univ.filter (d i)) := by |
| intro n f _ ha |
| by_contra hn |
| have hs (j) : ¬d i (f j) := by intro h; exact hn ⟨j,by simp [h]⟩ |
| have hi (j) : q i (f j) < q i (f (j+1)) := (ha j).2 i (hs _) (hs _) |
| have hsum := Finset.sum_lt_sum_of_nonempty Finset.univ_nonempty (fun j _ => hi j) |
| have he : (∑ j : Fin (n+1), q i (f (j+1))) = ∑ j : Fin (n+1), q i (f j) := by |
| exact Fintype.sum_equiv (Equiv.addRight (1 : Fin (n+1))) _ _ (fun _ => rfl) |
| rw [he] at hsum |
| exact (lt_irrefl _ hsum) |
| |
| omit [Fintype L] [Fintype B] in |
| theorem covers (p : L → B) (R : B → B → Prop) (d : I → B → Prop) (q : I → B → ℚ) |
| (hirr : ∀ b, ¬R b b) |
| (hinc : ∀ i a b, R a b → ¬d i a → ¬d i b → q i a < q i b) |
| {a b : L} (h : R (p a) (p b)) : |
| Arc (fun i a => d i (p a)) (fun i a => q i (p a)) a b := by |
| refine ⟨?_,fun i => hinc i _ _ h⟩ |
| intro he |
| subst b |
| exact hirr _ h |
| |
| end DirectedFeedback.PotentialCover |
| |
| end |
| |
| end OAI |
| |
