lean/OAI/NumberTheory/Jacobsthal/Probability/MovingMarkedWindow.lean

import Mathlib.Probability.Kernel.WithDensity
import OAI.NumberTheory.Jacobsthal.Partitions.BeginningWindowTransport

namespace OAI

namespace Erdos970

section

namespace Erdos970Dependency.MarkedVisits
open Filter Set MeasureTheory ProbabilityTheory
open scoped Topology ProbabilityTheory ENNReal
open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw
open NumberTheoryLean.InitialRegeneration NumberTheoryLean.TransitionKernels
open NumberTheoryLean.KernelPotential
open AbsorptionCutoff.Renewal

noncomputable def rawFirstMarkedBeginning : Kernel OddCost OddCost :=
  (potential Kernel.id (cycleBranchKernel false)).withDensity (fun _ y => nextMarkWeight y)

lemma nextMarkWeight_ne_top (z : OddCost) : nextMarkWeight z ≠ ∞ :=
  measure_ne_top (cycleBranchKernel true z) univ

instance rawFirstMarkedBeginning_isSFiniteKernel : IsSFiniteKernel rawFirstMarkedBeginning := by
  unfold rawFirstMarkedBeginning
  exact Kernel.IsSFiniteKernel.withDensity _ (fun _ y => nextMarkWeight_ne_top y)

lemma rawFirstMarkedBeginning_apply (z : OddCost) :
    rawFirstMarkedBeginning z =
      Measure.sum (fun n : ℕ => ((cycleBranchKernel false ^ n) z).withDensity nextMarkWeight) := by
  rw [rawFirstMarkedBeginning,Kernel.withDensity_apply _ (f := fun _ y : OddCost => nextMarkWeight y) (nextMarkWeight_measurable.comp measurable_snd),
    potential,Kernel.sum_apply]
  simp only [Kernel.id_comp]
  exact withDensity_sum _ _

lemma rawFirstMarkedBeginning_increment (z : OddCost) (hz : z ∈ returnSet) :
    (rawFirstMarkedBeginning z).map (fun y => y.2-z.2) = firstMarkWaitingLaw := by
  rw [rawFirstMarkedBeginning_apply,
    Measure.map_sum (f := fun y : OddCost => y.2-z.2) (measurable_snd.sub measurable_const).aemeasurable]
  change actualWaitingLaw z = firstMarkWaitingLaw
  rw [actualWaitingLaw_eq z hz,firstMarkWaitingLaw,actualWaitingLaw_eq]
  norm_num [returnSet,NumberTheoryLean.PairedHitting.pairedRegeneration,NumberTheoryLean.RegenerationTails.regenerationState]

lemma rawFirstMarkedBeginning_mass (z : OddCost) (hz : z ∈ returnSet) :
    rawFirstMarkedBeginning z univ = 1 := by
  have he := congrArg (fun μ : Measure ℝ => μ univ) (rawFirstMarkedBeginning_increment z hz)
  rw [Measure.map_apply (f := fun y : OddCost => y.2-z.2) (measurable_snd.sub measurable_const) MeasurableSet.univ,preimage_univ] at he
  exact he.trans measure_univ

lemma rawFirstMarkedBeginning_ae_regeneration (z : OddCost) (hz : z ∈ returnSet) :
    ∀ᵐ y ∂rawFirstMarkedBeginning z, y ∈ returnSet := by
  rw [rawFirstMarkedBeginning_apply,Measure.ae_sum_iff]
  intro n
  exact (withDensity_absolutelyContinuous _ _).ae_le (cycleBranch_pow_ae_regeneration false n z hz)

lemma rawFirstMarkedBeginning_cost_integral (z : OddCost) (hz : z ∈ returnSet)
    {F : ℝ → ℝ≥0∞} (hF : Measurable F) :
    (∫⁻ y, F y.2 ∂rawFirstMarkedBeginning z) = ∫⁻ G, F (z.2+G) ∂firstMarkWaitingLaw := by
  rw [← rawFirstMarkedBeginning_increment z hz,
    lintegral_map (g := fun y : OddCost => y.2-z.2) (f := fun G : ℝ => F (z.2+G))
      (hF.comp (measurable_const.add measurable_id)) (measurable_snd.sub measurable_const)]
  apply lintegral_congr
  intro y
  congr 1
  ring

noncomputable def initialMarkedBeginning : Kernel EvenState OddCost :=
  rawFirstMarkedBeginning ∘ₖ delayedRegeneration

instance initialMarkedBeginning_isMarkovKernel : IsMarkovKernel initialMarkedBeginning := by
  constructor
  intro s
  constructor
  rw [initialMarkedBeginning,Kernel.comp_apply' _ _ _ MeasurableSet.univ]
  have he : (fun z => rawFirstMarkedBeginning z univ) =ᵐ[delayedRegeneration s] fun _ => 1 := by
    filter_upwards [delayedRegeneration_ae_regeneration s] with z hz
    exact rawFirstMarkedBeginning_mass z hz
  rw [lintegral_congr_ae he]
  simp

lemma initialMarkedBeginning_ae_regeneration (s : EvenState) :
    ∀ᵐ z ∂initialMarkedBeginning s, z ∈ returnSet := by
  rw [initialMarkedBeginning]
  apply Kernel.ae_comp_of_ae_ae returnSet_measurable
  filter_upwards [delayedRegeneration_ae_regeneration s] with z hz
  exact rawFirstMarkedBeginning_ae_regeneration z hz

noncomputable def initialMarkedCostLaw (s : EvenState) : Measure ℝ :=
  (initialMarkedBeginning s).map Prod.snd

instance initialMarkedCostLaw_isProbabilityMeasure (s : EvenState) : IsProbabilityMeasure (initialMarkedCostLaw s) :=
  (Measure.isProbabilityMeasure_map_iff measurable_snd.aemeasurable).mpr inferInstance

lemma initialMarkedCostLaw_eq (s : EvenState) :
    initialMarkedCostLaw s = delayedCostLaw s ∗ firstMarkWaitingLaw := by
  apply Measure.ext_of_lintegral
  intro F hF
  rw [initialMarkedCostLaw,lintegral_map hF measurable_snd,initialMarkedBeginning,
    Kernel.lintegral_comp _ _ _ (g := fun z : OddCost => F z.2) (hF.comp measurable_snd),
    Measure.lintegral_conv hF,delayedCostLaw,
    lintegral_map (g := Prod.snd) (f := fun x : ℝ => ∫⁻ y, F (x+y) ∂firstMarkWaitingLaw)
      ((hF.comp measurable_add).lintegral_prod_right') measurable_snd]
  apply lintegral_congr_ae
  filter_upwards [delayedRegeneration_ae_regeneration s] with z hz
  exact rawFirstMarkedBeginning_cost_integral z hz hF

lemma firstMarkWaiting_nonneg : ∀ᵐ G ∂firstMarkWaitingLaw, 0 ≤ G := by
  rw [firstMarkWaitingLaw,actualWaitingLaw_eq _ (by norm_num [returnSet,
    NumberTheoryLean.PairedHitting.pairedRegeneration,NumberTheoryLean.RegenerationTails.regenerationState])]
  exact Measure.ae_smul_measure unmarkedPotential_ae_nonneg _

lemma initialMarkedCost_nonneg (s : EvenState) : ∀ᵐ D ∂initialMarkedCostLaw s, 0 ≤ D := by
  rw [initialMarkedCostLaw_eq]
  have hd : ∀ᵐ T ∂delayedCostLaw s, 0 ≤ T := by
    rw [delayedCostLaw]
    exact (ae_map_iff measurable_snd.aemeasurable measurableSet_Ici).mpr (delayedRegeneration_cost_nonneg s)
  simpa only [zero_add] using conv_ae_lower hd firstMarkWaiting_nonneg

lemma costTransform_mono {μ : Measure ℝ} (hμ : ∀ᵐ G ∂μ, 0 ≤ G) {a b : ℝ} (hab : a ≤ b) :
    costTransform μ a ≤ costTransform μ b := by
  apply lintegral_mono_ae
  filter_upwards [hμ] with G hG
  exact ENNReal.ofReal_le_ofReal (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_right hab hG))

theorem initialMarkedCost_uniform_exponential (S : ℝ) : ∃ eta B : ℝ, 0 < eta ∧ 0 ≤ B ∧
    ∀ s : EvenState, s.1 ≤ S → costTransform (initialMarkedCostLaw s) eta ≤ ENNReal.ofReal B := by
  obtain ⟨a,A,ha,hA,hDelay⟩ := delayedCostLaw_uniform_exponential S
  obtain ⟨b,hb,hWait,_⟩ := marked_waiting_common_exponential_moment
  let eta := min a b
  have heta : 0 < eta := lt_min ha hb
  have hW : costTransform firstMarkWaitingLaw eta < ∞ :=
    (costTransform_mono firstMarkWaiting_nonneg (min_le_right a b)).trans_lt hWait
  let W : ℝ := (costTransform firstMarkWaitingLaw eta).toReal
  have hWreal : costTransform firstMarkWaitingLaw eta = ENNReal.ofReal W :=
    (ENNReal.ofReal_toReal hW.ne).symm
  refine ⟨eta,A*W,heta,mul_nonneg hA ENNReal.toReal_nonneg,?_⟩
  intro s hs
  have hd : ∀ᵐ T ∂delayedCostLaw s, 0 ≤ T := by
    rw [delayedCostLaw]
    exact (ae_map_iff measurable_snd.aemeasurable measurableSet_Ici).mpr (delayedRegeneration_cost_nonneg s)
  rw [initialMarkedCostLaw_eq,costTransform_conv,hWreal,ENNReal.ofReal_mul hA]
  exact mul_le_mul_left ((costTransform_mono hd (min_le_left a b)).trans (hDelay s hs)) _

end Erdos970Dependency.MarkedVisits

end

section

namespace Erdos970Dependency.MarkedVisits
open Filter Set MeasureTheory ProbabilityTheory
open scoped Topology ProbabilityTheory ENNReal
open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw
open NumberTheoryLean.TransitionKernels NumberTheoryLean.KernelPotential

noncomputable def initialBeginningReg : Kernel EvenState RegCost :=
  initialMarkedBeginning.comapRight (MeasurableEmbedding.subtype_coe returnSet_measurable)

instance initialBeginningReg_isMarkovKernel : IsMarkovKernel initialBeginningReg := by
  apply Kernel.IsMarkovKernel.comapRight
  intro s
  have he := (ae_mem_iff_measure_eq (μ := initialMarkedBeginning s)
    returnSet_measurable.nullMeasurableSet).mp (initialMarkedBeginning_ae_regeneration s)
  rw [measure_univ] at he
  convert! he using 1
  congr 1
  ext y
  simp

lemma initialBeginningReg_map_state (s : EvenState) :
    (initialBeginningReg s).map (Subtype.val : RegCost → OddCost) = initialMarkedBeginning s := by
  calc
    _ = (initialMarkedBeginning s).restrict returnSet := by
      change (((initialMarkedBeginning s).comap (Subtype.val : RegCost → OddCost)).map Subtype.val) = _
      exact map_comap_subtype_coe (μ := initialMarkedBeginning s) returnSet_measurable
    _ = _ := Measure.restrict_eq_self_of_ae_mem (initialMarkedBeginning_ae_regeneration s)

lemma initialBeginningReg_cost_law (s : EvenState) :
    (initialBeginningReg s).map beginningCost = initialMarkedCostLaw s := by
  rw [initialMarkedCostLaw,← initialBeginningReg_map_state s,
    Measure.map_map measurable_snd measurable_subtype_coe]
  rfl

lemma beginningBelow_shift (t v : ℝ) : beginningBelow t (v-t) = beginningBelow 0 v := by
  unfold beginningBelow
  congr 1
  ext z
  simp only [mem_preimage,mem_Iio,relativeBeginningCost,sub_zero]
  constructor <;> intro h <;> linarith

lemma beginningOver_shift (t v H : ℝ) : beginningOver t (v-t) H = beginningOver 0 v H := by
  unfold beginningOver
  congr 1
  ext z
  simp only [mem_preimage,mem_Ioi,relativeBeginningCost,sub_zero]
  constructor <;> intro h <;> linarith

lemma beginningWindow_shift (t v H : ℝ) : beginningWindow t (v-t) H = beginningWindow 0 v H := by
  unfold beginningWindow
  congr 1
  ext z
  simp only [mem_preimage,mem_Icc,relativeBeginningCost,sub_zero]
  constructor <;> rintro ⟨h1,h2⟩ <;> constructor <;> linarith

lemma absoluteBeginningOvershoot_eq (z : RegCost) (v H : ℝ) :
    (potential (beginningOver 0 v H) (beginningBelow 0 v)) z univ =
      beginningOvershoot z (v-beginningCost z) H := by
  rw [beginningOvershoot,beginningOver_shift,beginningBelow_shift]

lemma absoluteBeginningWindowHit_eq (z : RegCost) (v H : ℝ) :
    (potential (beginningWindow 0 v H) (beginningBelow 0 v)) z univ =
      beginningWindowHit z (v-beginningCost z) H := by
  rw [beginningWindowHit,beginningWindow_shift,beginningBelow_shift]

noncomputable def markedWindowSuccess (v H : ℝ) (z : RegCost) : ℝ≥0∞ :=
  if beginningCost z < v then (potential (beginningWindow 0 v H) (beginningBelow 0 v)) z univ
  else if beginningCost z ≤ v+H then 1 else 0

noncomputable def markedWindowFailure (v H : ℝ) (z : RegCost) : ℝ≥0∞ :=
  if beginningCost z < v then (potential (beginningOver 0 v H) (beginningBelow 0 v)) z univ
  else if beginningCost z ≤ v+H then 0 else 1

lemma markedWindowSuccess_measurable (v H : ℝ) : Measurable (markedWindowSuccess v H) := by
  unfold markedWindowSuccess
  exact Measurable.ite (measurableSet_lt beginningCost_measurable measurable_const)
    ((potential _ _).measurable_coe MeasurableSet.univ)
    (Measurable.ite (measurableSet_le beginningCost_measurable measurable_const) measurable_const measurable_const)

lemma markedWindowFailure_measurable (v H : ℝ) : Measurable (markedWindowFailure v H) := by
  unfold markedWindowFailure
  exact Measurable.ite (measurableSet_lt beginningCost_measurable measurable_const)
    ((potential _ _).measurable_coe MeasurableSet.univ)
    (Measurable.ite (measurableSet_le beginningCost_measurable measurable_const) measurable_const measurable_const)

lemma markedWindow_partition (z : RegCost) (v H : ℝ) (hH : 0 ≤ H) :
    markedWindowSuccess v H z+markedWindowFailure v H z = 1 := by
  unfold markedWindowSuccess markedWindowFailure
  by_cases hz : beginningCost z < v
  · rw [ite_eq_left hz,ite_eq_left hz,absoluteBeginningOvershoot_eq,absoluteBeginningWindowHit_eq]
    exact beginningWindow_partition z (by linarith) hH
  · rw [ite_eq_right hz,ite_eq_right hz]
    split_ifs <;> simp

noncomputable def initialMarkedWindowSuccess (s : EvenState) (v H : ℝ) : ℝ≥0∞ :=
  ∫⁻ z, markedWindowSuccess v H z ∂initialBeginningReg s

noncomputable def initialMarkedWindowFailure (s : EvenState) (v H : ℝ) : ℝ≥0∞ :=
  ∫⁻ z, markedWindowFailure v H z ∂initialBeginningReg s

lemma initialMarkedWindow_partition (s : EvenState) (v H : ℝ) (hH : 0 ≤ H) :
    initialMarkedWindowSuccess s v H+initialMarkedWindowFailure s v H = 1 := by
  rw [initialMarkedWindowSuccess,initialMarkedWindowFailure,
    ← lintegral_add_left (markedWindowSuccess_measurable v H)]
  simp only [markedWindow_partition _ v H hH,lintegral_const,measure_univ,mul_one]

lemma cost_tail_le_transform (μ : Measure ℝ) {eta : ℝ} (heta : 0 ≤ eta) (v : ℝ) :
    μ (Ici v) ≤ ENNReal.ofReal (Real.exp (-eta*v))*costTransform μ eta := by
  calc
    _ = ∫⁻ G, (Ici v).indicator (fun _ => (1:ℝ≥0∞)) G ∂μ := by
      rw [lintegral_indicator measurableSet_Ici]; simp
    _ ≤ ∫⁻ G, ENNReal.ofReal (Real.exp (-eta*v))*ENNReal.ofReal (Real.exp (eta*G)) ∂μ := by
      apply lintegral_mono
      intro G
      by_cases hG : G ∈ Ici v
      · rw [indicator_of_mem hG]
        change (1:ℝ≥0∞) ≤ ENNReal.ofReal (Real.exp (-eta*v))*ENNReal.ofReal (Real.exp (eta*G))
        rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,← Real.exp_add]
        have he : (1:ℝ) ≤ Real.exp (-eta*v+eta*G) := Real.one_le_exp_iff.mpr (by change v≤G at hG; nlinarith)
        simpa only [ENNReal.ofReal_one] using ENNReal.ofReal_le_ofReal he
      · rw [indicator_of_notMem hG]; exact zero_le
    _ = _ := lintegral_const_mul' _ _ ENNReal.ofReal_ne_top

lemma initialMarkedWindowFailure_le (s : EvenState) (v H R : ℝ)
    (hTail : ∀ z : RegCost, ∀ u : ℝ, 0 < u → beginningOvershoot z u H ≤ ENNReal.ofReal R) :
    initialMarkedWindowFailure s v H ≤ ENNReal.ofReal R+initialMarkedCostLaw s (Ici v) := by
  have hp (z : RegCost) : markedWindowFailure v H z ≤ ENNReal.ofReal R+
      (beginningCost ⁻¹' Ici v).indicator (fun _ => (1:ℝ≥0∞)) z := by
    by_cases hz : beginningCost z < v
    · rw [markedWindowFailure,ite_eq_left hz,absoluteBeginningOvershoot_eq,
        indicator_of_notMem (show z ∉ beginningCost ⁻¹' Ici v from not_le_of_gt hz),add_zero]
      exact hTail z _ (by linarith)
    · rw [indicator_of_mem (show z ∈ beginningCost ⁻¹' Ici v from le_of_not_gt hz),
        markedWindowFailure,ite_eq_right hz]
      split_ifs
      · exact zero_le
      · exact le_add_left le_rfl
  calc
    _ ≤ ∫⁻ z, ENNReal.ofReal R+(beginningCost ⁻¹' Ici v).indicator (fun _ => (1:ℝ≥0∞)) z ∂initialBeginningReg s :=
      lintegral_mono hp
    _ = ENNReal.ofReal R+initialBeginningReg s (beginningCost ⁻¹' Ici v) := by
      rw [lintegral_add_left measurable_const,lintegral_const,measure_univ,mul_one,
        lintegral_indicator (beginningCost_measurable measurableSet_Ici)]
      simp
    _ = _ := by
      rw [← initialBeginningReg_cost_law s,Measure.map_apply beginningCost_measurable measurableSet_Ici]

theorem initialMarkedWindow_exponential (S : ℝ) : ∃ eta C eta0 B : ℝ,
    0 < eta ∧ 0 < C ∧ 0 < eta0 ∧ 0 ≤ B ∧ ∀ s : EvenState, s.1 ≤ S → ∀ v H : ℝ,
      0 ≤ H → initialMarkedWindowFailure s v H ≤
        ENNReal.ofReal (C*Real.exp (-eta*H)+B*Real.exp (-eta0*v)) := by
  obtain ⟨eta,C,heta,hC,hTail⟩ := beginningWindow_exponential
  obtain ⟨eta0,B,heta0,hB,hDelay⟩ := initialMarkedCost_uniform_exponential S
  refine ⟨eta,C,eta0,B,heta,hC,heta0,hB,?_⟩
  intro s hs v H hH
  calc
    _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+initialMarkedCostLaw s (Ici v) :=
      initialMarkedWindowFailure_le s v H _ (fun z u hu => (hTail z u H hu hH).1)
    _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+
      ENNReal.ofReal (Real.exp (-eta0*v))*costTransform (initialMarkedCostLaw s) eta0 :=
      add_le_add le_rfl (cost_tail_le_transform _ heta0.le v)
    _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+ENNReal.ofReal (Real.exp (-eta0*v))*ENNReal.ofReal B :=
      add_le_add le_rfl (mul_le_mul_right (hDelay s hs) _)
    _ = _ := by rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,mul_comm (Real.exp (-eta0*v)),
      ← ENNReal.ofReal_add (mul_nonneg hC.le (Real.exp_pos _).le) (mul_nonneg hB (Real.exp_pos _).le)]

end Erdos970Dependency.MarkedVisits

end

section

namespace Erdos970Dependency.MarkedVisits
open Filter Set MeasureTheory ProbabilityTheory
open scoped Topology ProbabilityTheory ENNReal
open NumberTheoryLean.TransitionKernels

lemma exponential_decay_tendsto {eta : ℝ} (heta : 0 < eta) (C : ℝ) :
    Tendsto (fun H : ℝ => C*Real.exp (-eta*H)) atTop (𝓝 0) := by
  have he : Tendsto (fun H : ℝ => Real.exp (-eta*H)) atTop (𝓝 0) := by
    simpa only [Function.comp_def,id_eq,neg_mul] using
      Real.tendsto_exp_neg_atTop_nhds_zero.comp (Tendsto.const_mul_atTop heta tendsto_id)
  simpa only [mul_zero] using he.const_mul C

theorem moving_marked_window_capture {eps : ℝ} (heps : 0 < eps) :
    ∃ rho : ℝ, 10 < rho ∧ ∀ K : ℝ, 0 < K →
      ∀ᶠ w : ℝ in atTop, 3 ≤ w ∧ ∀ r : ℝ, w ≤ r → ∀ s : EvenState,
        199/100 ≤ s.1 → s.1 ≤ 23/10 →
        initialMarkedWindowFailure s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) ≤
          ENNReal.ofReal eps ∧
        1-ENNReal.ofReal eps ≤
          initialMarkedWindowSuccess s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) := by
  obtain ⟨eta,C,eta0,B,heta,_hC,heta0,_hB,hBound⟩ := initialMarkedWindow_exponential (23/10)
  have hHalf : 0 < eps/2 := by positivity
  obtain ⟨H,hH,hSmall⟩ := ((eventually_gt_atTop (0:ℝ)).and
    ((tendsto_order.mp (exponential_decay_tendsto heta C)).2 (eps/2) hHalf)).exists
  obtain ⟨V,hV⟩ := eventually_atTop.mp
    ((tendsto_order.mp (exponential_decay_tendsto heta0 B)).2 (eps/2) hHalf)
  let rho : ℝ := 10*Real.exp H
  have hrho : 10 < rho := by
    have he := Real.one_lt_exp_iff.mpr hH
    dsimp [rho]
    linarith
  have hWidth : Real.log (rho/10) = H := by
    dsimp [rho]
    rw [mul_div_cancel_left₀ _ (by norm_num : (10:ℝ) ≠ 0),Real.log_exp]
  refine ⟨rho,hrho,?_⟩
  intro K hK
  filter_upwards [moving_window_cost_threshold hK (by linarith : 0 < rho) V] with w hw
  refine ⟨hw.1,?_⟩
  intro r hr s _hs0 hs1
  have hFailure : initialMarkedWindowFailure s
      (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) ≤ ENNReal.ofReal eps := by
    rw [hWidth]
    apply (hBound s hs1 _ H hH.le).trans
    apply ENNReal.ofReal_le_ofReal
    have htail := hV _ (hw.2 r hr)
    linarith
  refine ⟨hFailure,?_⟩
  apply tsub_le_iff_right.mpr
  have hp := initialMarkedWindow_partition s (Real.log (r/(rho*K*(Real.log w)^2)))
    (Real.log (rho/10)) (by rw [hWidth]; exact hH.le)
  calc
    1 = initialMarkedWindowSuccess s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10))+
        initialMarkedWindowFailure s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) := hp.symm
    _ ≤ _ := add_le_add le_rfl hFailure

end Erdos970Dependency.MarkedVisits

end

end Erdos970

end OAI