ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Turing.TM2.stmts_supportsStmt
theorem stmts_supportsStmt {M : Λ → Stmt₂} {S : Finset Λ} {q : Stmt₂} (ss : Supports M S) :
    some q ∈ stmts M S → SupportsStmt S q 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [Inhabited Λ] {M : Λ → Turing.TM2.Stmt Γ Λ σ} {S : Finset Λ} {q : Turing.TM2.Stmt Γ Λ σ} (ss : Turing.TM2.Supports M S)
Goal: some q ∈ Turing.TM2.stmts M S → Turing.TM2.SupportsStmt S q
-- Turing.TM2.step_supports
theorem step_supports (M : Λ → Stmt₂) {S : Finset Λ} (ss : Supports M S) :
    ∀ {c c' : Cfg₂}, c' ∈ step M c → c.l ∈ Finset.insertNone S → c'.l ∈ Finset.insertNone S
  
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [Inhabited Λ] (M : Λ → Turing.TM2.Stmt Γ Λ σ) {S : Finset Λ} (ss : Turing.TM2.Supports M S) {c c' : Turing.TM2.Cfg Γ Λ σ}
Goal: c' ∈ Turing.TM2.step M c → c.l ∈ Finset.insertNone S → c'.l ∈ Finset.insertNone S
-- Turing.TM2to1.stk_nth_val
theorem stk_nth_val {K : Type*} {Γ : K → Type*} {L : ListBlank (∀ k, Option (Γ k))} {k S} (n)
    (hL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse) :
    L.nth n k = S.reverse.get? n 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {L : Turing.ListBlank ((k : K) → Option (Γ k))} {k : K} {S : List (Γ k)} (n : ℕ) (hL : Turing.ListBlank.map (Turing.proj k) L = Turing.ListBlank.mk (List.map some S).reverse)
Goal: L.nth n k = S.reverse.get? n
-- Turing.TM2to1.addBottom_map
theorem addBottom_map (L : ListBlank (∀ k, Option (Γ k))) :
    (addBottom L).map ⟨Prod.snd, by rfl⟩ = L 
Arguments: {K : Type u_1} {Γ : K → Type u_2} (L : Turing.ListBlank ((k : K) → Option (Γ k)))
Goal: Turing.ListBlank.map { f := Prod.snd, map_pt' := ⋯ } (Turing.TM2to1.addBottom L) = L
-- Turing.TM2to1.addBottom_modifyNth
theorem addBottom_modifyNth (f : (∀ k, Option (Γ k)) → ∀ k, Option (Γ k))
    (L : ListBlank (∀ k, Option (Γ k))) (n : ℕ) :
    (addBottom L).modifyNth (fun a ↦ (a.1, f a.2)) n = addBottom (L.modifyNth f n) 
Arguments: {K : Type u_1} {Γ : K → Type u_2} (f : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k)) (L : Turing.ListBlank ((k : K) → Option (Γ k))) (n : ℕ)
Goal: Turing.ListBlank.modifyNth (fun a => (a.1, f a.2)) n (Turing.TM2to1.addBottom L) =
  Turing.TM2to1.addBottom (Turing.ListBlank.modifyNth f n L)
-- Turing.TM2to1.addBottom_nth_snd
theorem addBottom_nth_snd (L : ListBlank (∀ k, Option (Γ k))) (n : ℕ) :
    ((addBottom L).nth n).2 = L.nth n 
Arguments: {K : Type u_1} {Γ : K → Type u_2} (L : Turing.ListBlank ((k : K) → Option (Γ k))) (n : ℕ)
Goal: ((Turing.TM2to1.addBottom L).nth n).2 = L.nth n
-- Turing.TM2to1.addBottom_nth_succ_fst
theorem addBottom_nth_succ_fst (L : ListBlank (∀ k, Option (Γ k))) (n : ℕ) :
    ((addBottom L).nth (n + 1)).1 = false 
Arguments: {K : Type u_1} {Γ : K → Type u_2} (L : Turing.ListBlank ((k : K) → Option (Γ k))) (n : ℕ)
Goal: ((Turing.TM2to1.addBottom L).nth (n + 1)).1 = false
-- Turing.TM2to1.addBottom_head_fst
theorem addBottom_head_fst (L : ListBlank (∀ k, Option (Γ k))) : (addBottom L).head.1 = true 
Arguments: {K : Type u_1} {Γ : K → Type u_2} (L : Turing.ListBlank ((k : K) → Option (Γ k)))
Goal: (Turing.TM2to1.addBottom L).head.1 = true
-- Turing.TM2to1.supports_run
theorem supports_run (S : Finset Λ) {k : K} (s : StAct₂ k) (q : Stmt₂) :
    TM2.SupportsStmt S (stRun s q) ↔ TM2.SupportsStmt S q 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (S : Finset Λ) {k : K} (s : Turing.TM2to1.StAct k) (q : Turing.TM2.Stmt Γ Λ σ)
Goal: Turing.TM2.SupportsStmt S (Turing.TM2to1.stRun s q) ↔ Turing.TM2.SupportsStmt S q
-- Turing.TM2to1.step_run
theorem step_run {k : K} (q : Stmt₂) (v : σ) (S : ∀ k, List (Γ k)) : ∀ s : StAct₂ k,
    TM2.stepAux (stRun s q) v S = TM2.stepAux q (stVar v (S k) s) (update S k (stWrite v (S k) s))
  
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {k : K} (q : Turing.TM2.Stmt Γ Λ σ) (v : σ) (S : (k : K) → List (Γ k)) (s : Turing.TM2to1.StAct k)
Goal: Turing.TM2.stepAux (Turing.TM2to1.stRun s q) v S =
  Turing.TM2.stepAux q (Turing.TM2to1.stVar v (S k) s) (Function.update S k (Turing.TM2to1.stWrite v (S k) s))
-- Turing.TM2to1.trNormal_run
theorem trNormal_run {k : K} (s : StAct₂ k) (q : Stmt₂) :
    trNormal (stRun s q) = goto fun _ _ ↦ go k s q 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {k : K} (s : Turing.TM2to1.StAct k) (q : Turing.TM2.Stmt Γ Λ σ)
Goal: Turing.TM2to1.trNormal (Turing.TM2to1.stRun s q) = Turing.TM1.Stmt.goto fun x x => Turing.TM2to1.Λ'.go k s q
-- Turing.TM2to1.trStmts₁_run
theorem trStmts₁_run {k : K} {s : StAct₂ k} {q : Stmt₂} :
    trStmts₁ (stRun s q) = {go k s q, ret q} ∪ trStmts₁ q 
Arguments: {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {k : K} {s : Turing.TM2to1.StAct k} {q : Turing.TM2.Stmt Γ Λ σ}
Goal: Turing.TM2to1.trStmts₁ (Turing.TM2to1.stRun s q) =
  {Turing.TM2to1.Λ'.go k s q, Turing.TM2to1.Λ'.ret q} ∪ Turing.TM2to1.trStmts₁ q
-- Turing.TM2to1.tr_respects_aux₂
theorem tr_respects_aux₂ {k : K} {q : Stmt₂₁} {v : σ} {S : ∀ k, List (Γ k)}
    {L : ListBlank (∀ k, Option (Γ k))}
    (hL : ∀ k, L.map (proj k) = ListBlank.mk ((S k).map some).reverse) (o : StAct₂ k) :
    let v' := stVar v (S k) o
    let Sk' := stWrite v (S k) o
    let S' := update S k Sk'
    ∃ L' : ListBlank (∀ k, Option (Γ k)),
      (∀ k, L'.map (proj k) = ListBlank.mk ((S' k).map some).reverse) ∧
        TM1.stepAux (trStAct q o) v
            ((Tape.move Dir.right)^[(S k).length] (Tape.mk' ∅ (addBottom L))) =
          TM1.stepAux q v' ((Tape.move Dir.right)^[(S' k).length] (Tape.mk' ∅ (addBottom L'))) 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {k : K} {q : Turing.TM1.Stmt Turing.TM2to1.Γ' Turing.TM2to1.Λ' σ} {v : σ} {S : (k : K) → List (Γ k)} {L : Turing.ListBlank ((k : K) → Option (Γ k))} (hL : ∀ (k : K), Turing.ListBlank.map (Turing.proj k) L = Turing.ListBlank.mk (List.map some (S k)).reverse) (o : Turing.TM2to1.StAct k)
Goal: let v' := Turing.TM2to1.stVar v (S k) o;
let Sk' := Turing.TM2to1.stWrite v (S k) o;
let S' := Function.update S k Sk';
∃ L',
  (∀ (k : K), Turing.ListBlank.map (Turing.proj k) L' = Turing.ListBlank.mk (List.map some (S' k)).reverse) ∧
    Turing.TM1.stepAux (Turing.TM2to1.trStAct q o) v
        ((Turing.Tape.move Turing.Dir.right)^[(S k).length] (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L))) =
      Turing.TM1.stepAux q v'
        ((Turing.Tape.move Turing.Dir.right)^[(S' k).length] (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L')))
-- Turing.TM2to1.tr_respects_aux₁
theorem tr_respects_aux₁ {k} (o q v) {S : List (Γ k)} {L : ListBlank (∀ k, Option (Γ k))}
    (hL : L.map (proj k) = ListBlank.mk (S.map some).reverse) (n) (H : n ≤ S.length) :
    Reaches₀ (TM1.step (tr M)) ⟨some (go k o q), v, Tape.mk' ∅ (addBottom L)⟩
      ⟨some (go k o q), v, (Tape.move Dir.right)^[n] (Tape.mk' ∅ (addBottom L))⟩ 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) {k : K} (o : Turing.TM2to1.StAct k) (q : Turing.TM2.Stmt Γ Λ σ) (v : σ) {S : List (Γ k)} {L : Turing.ListBlank ((k : K) → Option (Γ k))} (hL : Turing.ListBlank.map (Turing.proj k) L = Turing.ListBlank.mk (List.map some S).reverse) (n : ℕ) (H : n ≤ S.length)
Goal: Turing.Reaches₀ (Turing.TM1.step (Turing.TM2to1.tr M))
  { l := some (Turing.TM2to1.Λ'.go k o q), var := v, Tape := Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L) }
  { l := some (Turing.TM2to1.Λ'.go k o q), var := v,
    Tape := (Turing.Tape.move Turing.Dir.right)^[n] (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L)) }
-- Turing.TM2to1.tr_respects_aux₃
theorem tr_respects_aux₃ {q v} {L : ListBlank (∀ k, Option (Γ k))} (n) : Reaches₀ (TM1.step (tr M))
    ⟨some (ret q), v, (Tape.move Dir.right)^[n] (Tape.mk' ∅ (addBottom L))⟩
    ⟨some (ret q), v, Tape.mk' ∅ (addBottom L)⟩ 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) {q : Turing.TM2.Stmt Γ Λ σ} {v : σ} {L : Turing.ListBlank ((k : K) → Option (Γ k))} (n : ℕ)
Goal: Turing.Reaches₀ (Turing.TM1.step (Turing.TM2to1.tr M))
  { l := some (Turing.TM2to1.Λ'.ret q), var := v,
    Tape := (Turing.Tape.move Turing.Dir.right)^[n] (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L)) }
  { l := some (Turing.TM2to1.Λ'.ret q), var := v, Tape := Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom L) }
-- Turing.TM2to1.tr_respects_aux
theorem tr_respects_aux {q v T k} {S : ∀ k, List (Γ k)}
    (hT : ∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse) (o : StAct₂ k)
    (IH : ∀ {v : σ} {S : ∀ k : K, List (Γ k)} {T : ListBlank (∀ k, Option (Γ k))},
      (∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse) →
      ∃ b, TrCfg (TM2.stepAux q v S) b ∧
        Reaches (TM1.step (tr M)) (TM1.stepAux (trNormal q) v (Tape.mk' ∅ (addBottom T))) b) :
    ∃ b, TrCfg (TM2.stepAux (stRun o q) v S) b ∧ Reaches (TM1.step (tr M))
      (TM1.stepAux (trNormal (stRun o q)) v (Tape.mk' ∅ (addBottom T))) b 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) {q : Turing.TM2.Stmt Γ Λ σ} {v : σ} {T : Turing.ListBlank ((i : K) → Option (Γ i))} {k : K} {S : (k : K) → List (Γ k)} (hT : ∀ (k : K), Turing.ListBlank.map (Turing.proj k) T = Turing.ListBlank.mk (List.map some (S k)).reverse) (o : Turing.TM2to1.StAct k) (IH :
  ∀ {v : σ} {S : (k : K) → List (Γ k)} {T : Turing.ListBlank ((k : K) → Option (Γ k))},
    (∀ (k : K), Turing.ListBlank.map (Turing.proj k) T = Turing.ListBlank.mk (List.map some (S k)).reverse) →
      ∃ b,
        Turing.TM2to1.TrCfg (Turing.TM2.stepAux q v S) b ∧
          Turing.Reaches (Turing.TM1.step (Turing.TM2to1.tr M))
            (Turing.TM1.stepAux (Turing.TM2to1.trNormal q) v (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom T))) b)
Goal: ∃ b,
  Turing.TM2to1.TrCfg (Turing.TM2.stepAux (Turing.TM2to1.stRun o q) v S) b ∧
    Turing.Reaches (Turing.TM1.step (Turing.TM2to1.tr M))
      (Turing.TM1.stepAux (Turing.TM2to1.trNormal (Turing.TM2to1.stRun o q)) v
        (Turing.Tape.mk' ∅ (Turing.TM2to1.addBottom T)))
      b
-- Turing.TM2to1.tr_respects
theorem tr_respects : Respects (TM2.step M) (TM1.step (tr M)) TrCfg 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ)
Goal: Turing.Respects (Turing.TM2.step M) (Turing.TM1.step (Turing.TM2to1.tr M)) Turing.TM2to1.TrCfg
-- Turing.TM2to1.trCfg_init
theorem trCfg_init (k) (L : List (Γ k)) : TrCfg (TM2.init k L) (TM1.init (trInit k L) : Cfg₂₁) 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} [Inhabited Λ] {σ : Type u_4} [Inhabited σ] (k : K) (L : List (Γ k))
Goal: Turing.TM2to1.TrCfg (Turing.TM2.init k L) (Turing.TM1.init (Turing.TM2to1.trInit k L))
-- Turing.TM2to1.tr_eval_dom
theorem tr_eval_dom (k) (L : List (Γ k)) :
    (TM1.eval (tr M) (trInit k L)).Dom ↔ (TM2.eval M k L).Dom 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} [Inhabited Λ] {σ : Type u_4} [Inhabited σ] (M : Λ → Turing.TM2.Stmt Γ Λ σ) (k : K) (L : List (Γ k))
Goal: (Turing.TM1.eval (Turing.TM2to1.tr M) (Turing.TM2to1.trInit k L)).Dom ↔ (Turing.TM2.eval M k L).Dom
-- Turing.TM2to1.tr_eval
theorem tr_eval (k) (L : List (Γ k)) {L₁ L₂} (H₁ : L₁ ∈ TM1.eval (tr M) (trInit k L))
    (H₂ : L₂ ∈ TM2.eval M k L) :
    ∃ (S : ∀ k, List (Γ k)) (L' : ListBlank (∀ k, Option (Γ k))),
      addBottom L' = L₁ ∧
        (∀ k, L'.map (proj k) = ListBlank.mk ((S k).map some).reverse) ∧ S k = L₂ 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} [Inhabited Λ] {σ : Type u_4} [Inhabited σ] (M : Λ → Turing.TM2.Stmt Γ Λ σ) (k : K) (L : List (Γ k)) {L₁ : Turing.ListBlank Turing.TM2to1.Γ'} {L₂ : List (Γ k)} (H₁ : L₁ ∈ Turing.TM1.eval (Turing.TM2to1.tr M) (Turing.TM2to1.trInit k L)) (H₂ : L₂ ∈ Turing.TM2.eval M k L)
Goal: ∃ S L',
  Turing.TM2to1.addBottom L' = L₁ ∧
    (∀ (k : K), Turing.ListBlank.map (Turing.proj k) L' = Turing.ListBlank.mk (List.map some (S k)).reverse) ∧ S k = L₂
-- Turing.TM2to1.tr_supports
theorem tr_supports {S} (ss : TM2.Supports M S) : TM1.Supports (tr M) (trSupp M S) 
Arguments: {K : Type u_1} [DecidableEq K] {Γ : K → Type u_2} {Λ : Type u_3} [Inhabited Λ] {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) {S : Finset Λ} (ss : Turing.TM2.Supports M S)
Goal: Turing.TM1.Supports (Turing.TM2to1.tr M) (Turing.TM2to1.trSupp M S)
-- MeasureTheory.hitting_def
theorem hitting_def [Preorder ι] [InfSet ι] (u : ι → Ω → β) (s : Set β) (n m : ι) :
    hitting u s n m =
    fun x => if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i : ι | u i x ∈ s}) else m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [Preorder ι] [InfSet ι] (u : ι → Ω → β) (s : Set β) (n m : ι)
Goal: MeasureTheory.hitting u s n m = fun x =>
  if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i | u i x ∈ s}) else m
-- MeasureTheory.hitting_of_lt
theorem hitting_of_lt {m : ι} (h : m < n) : hitting u s n m ω = m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m : ι} (h : m < n)
Goal: MeasureTheory.hitting u s n m ω = m
-- MeasureTheory.hitting_le
theorem hitting_le {m : ι} (ω : Ω) : hitting u s n m ω ≤ m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n m : ι} (ω : Ω)
Goal: MeasureTheory.hitting u s n m ω ≤ m
-- MeasureTheory.not_mem_of_lt_hitting
theorem not_mem_of_lt_hitting {m k : ι} (hk₁ : k < hitting u s n m ω) (hk₂ : n ≤ k) :
    u k ω ∉ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m k : ι} (hk₁ : k < MeasureTheory.hitting u s n m ω) (hk₂ : n ≤ k)
Goal: u k ω ∉ s
-- MeasureTheory.hitting_eq_end_iff
theorem hitting_eq_end_iff {m : ι} : hitting u s n m ω = m ↔
    (∃ j ∈ Set.Icc n m, u j ω ∈ s) → sInf (Set.Icc n m ∩ {i : ι | u i ω ∈ s}) = m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m : ι}
Goal: MeasureTheory.hitting u s n m ω = m ↔ (∃ j ∈ Set.Icc n m, u j ω ∈ s) → sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) = m
-- MeasureTheory.hitting_of_le
theorem hitting_of_le {m : ι} (hmn : m ≤ n) : hitting u s n m ω = m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m : ι} (hmn : m ≤ n)
Goal: MeasureTheory.hitting u s n m ω = m
-- MeasureTheory.le_hitting
theorem le_hitting {m : ι} (hnm : n ≤ m) (ω : Ω) : n ≤ hitting u s n m ω 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n m : ι} (hnm : n ≤ m) (ω : Ω)
Goal: n ≤ MeasureTheory.hitting u s n m ω
-- MeasureTheory.le_hitting_of_exists
theorem le_hitting_of_exists {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    n ≤ hitting u s n m ω 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s)
Goal: n ≤ MeasureTheory.hitting u s n m ω
-- MeasureTheory.hitting_mem_Icc
theorem hitting_mem_Icc {m : ι} (hnm : n ≤ m) (ω : Ω) : hitting u s n m ω ∈ Set.Icc n m 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n m : ι} (hnm : n ≤ m) (ω : Ω)
Goal: MeasureTheory.hitting u s n m ω ∈ Set.Icc n m
-- MeasureTheory.hitting_mem_set
theorem hitting_mem_set [IsWellOrder ι (· < ·)] {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    u (hitting u s n m ω) ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} [IsWellOrder ι fun x x_1 => x < x_1] {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s)
Goal: u (MeasureTheory.hitting u s n m ω) ω ∈ s
-- MeasureTheory.hitting_mem_set_of_hitting_lt
theorem hitting_mem_set_of_hitting_lt [IsWellOrder ι (· < ·)] {m : ι} (hl : hitting u s n m ω < m) :
    u (hitting u s n m ω) ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} [IsWellOrder ι fun x x_1 => x < x_1] {m : ι} (hl : MeasureTheory.hitting u s n m ω < m)
Goal: u (MeasureTheory.hitting u s n m ω) ω ∈ s
-- MeasureTheory.hitting_le_of_mem
theorem hitting_le_of_mem {m : ι} (hin : n ≤ i) (him : i ≤ m) (his : u i ω ∈ s) :
    hitting u s n m ω ≤ i 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n i : ι} {ω : Ω} {m : ι} (hin : n ≤ i) (him : i ≤ m) (his : u i ω ∈ s)
Goal: MeasureTheory.hitting u s n m ω ≤ i
-- MeasureTheory.hitting_le_iff_of_exists
theorem hitting_le_iff_of_exists [IsWellOrder ι (· < ·)] {m : ι}
    (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n i : ι} {ω : Ω} [IsWellOrder ι fun x x_1 => x < x_1] {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s)
Goal: MeasureTheory.hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s
-- MeasureTheory.hitting_le_iff_of_lt
theorem hitting_le_iff_of_lt [IsWellOrder ι (· < ·)] {m : ι} (i : ι) (hi : i < m) :
    hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} [IsWellOrder ι fun x x_1 => x < x_1] {m : ι} (i : ι) (hi : i < m)
Goal: MeasureTheory.hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s
-- MeasureTheory.hitting_lt_iff
theorem hitting_lt_iff [IsWellOrder ι (· < ·)] {m : ι} (i : ι) (hi : i ≤ m) :
    hitting u s n m ω < i ↔ ∃ j ∈ Set.Ico n i, u j ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} [IsWellOrder ι fun x x_1 => x < x_1] {m : ι} (i : ι) (hi : i ≤ m)
Goal: MeasureTheory.hitting u s n m ω < i ↔ ∃ j ∈ Set.Ico n i, u j ω ∈ s
-- MeasureTheory.hitting_eq_hitting_of_exists
theorem hitting_eq_hitting_of_exists {m₁ m₂ : ι} (h : m₁ ≤ m₂)
    (h' : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s) : hitting u s n m₁ ω = hitting u s n m₂ ω 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m₁ m₂ : ι} (h : m₁ ≤ m₂) (h' : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s)
Goal: MeasureTheory.hitting u s n m₁ ω = MeasureTheory.hitting u s n m₂ ω
-- MeasureTheory.hitting_mono
theorem hitting_mono {m₁ m₂ : ι} (hm : m₁ ≤ m₂) : hitting u s n m₁ ω ≤ hitting u s n m₂ ω 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n : ι} {ω : Ω} {m₁ m₂ : ι} (hm : m₁ ≤ m₂)
Goal: MeasureTheory.hitting u s n m₁ ω ≤ MeasureTheory.hitting u s n m₂ ω
-- MeasureTheory.hitting_isStoppingTime
theorem hitting_isStoppingTime [ConditionallyCompleteLinearOrder ι] [IsWellOrder ι (· < ·)]
    [Countable ι] [TopologicalSpace β] [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    {f : Filtration ι m} {u : ι → Ω → β} {s : Set β} {n n' : ι} (hu : Adapted f u)
    (hs : MeasurableSet s) : IsStoppingTime f (hitting u s n n') 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [ConditionallyCompleteLinearOrder ι] [IsWellOrder ι fun x x_1 => x < x_1] [Countable ι] [TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β] {f : MeasureTheory.Filtration ι m} {u : ι → Ω → β} {s : Set β} {n n' : ι} (hu : MeasureTheory.Adapted f u) (hs : MeasurableSet s)
Goal: MeasureTheory.IsStoppingTime f (MeasureTheory.hitting u s n n')
-- MeasureTheory.stoppedValue_hitting_mem
theorem stoppedValue_hitting_mem [ConditionallyCompleteLinearOrder ι] [IsWellOrder ι (· < ·)]
    {u : ι → Ω → β} {s : Set β} {n m : ι} {ω : Ω} (h : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    stoppedValue u (hitting u s n m) ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrder ι] [IsWellOrder ι fun x x_1 => x < x_1] {u : ι → Ω → β} {s : Set β} {n m : ι} {ω : Ω} (h : ∃ j ∈ Set.Icc n m, u j ω ∈ s)
Goal: MeasureTheory.stoppedValue u (MeasureTheory.hitting u s n m) ω ∈ s
-- MeasureTheory.isStoppingTime_hitting_isStoppingTime
theorem isStoppingTime_hitting_isStoppingTime [ConditionallyCompleteLinearOrder ι]
    [IsWellOrder ι (· < ·)] [Countable ι] [TopologicalSpace ι] [OrderTopology ι]
    [FirstCountableTopology ι] [TopologicalSpace β] [PseudoMetrizableSpace β] [MeasurableSpace β]
    [BorelSpace β] {f : Filtration ι m} {u : ι → Ω → β} {τ : Ω → ι} (hτ : IsStoppingTime f τ)
    {N : ι} (hτbdd : ∀ x, τ x ≤ N) {s : Set β} (hs : MeasurableSet s) (hf : Adapted f u) :
    IsStoppingTime f fun x => hitting u s (τ x) N x 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [ConditionallyCompleteLinearOrder ι] [IsWellOrder ι fun x x_1 => x < x_1] [Countable ι] [TopologicalSpace ι] [OrderTopology ι] [FirstCountableTopology ι] [TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β] {f : MeasureTheory.Filtration ι m} {u : ι → Ω → β} {τ : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) {N : ι} (hτbdd : ∀ (x : Ω), τ x ≤ N) {s : Set β} (hs : MeasurableSet s) (hf : MeasureTheory.Adapted f u)
Goal: MeasureTheory.IsStoppingTime f fun x => MeasureTheory.hitting u s (τ x) N x
-- MeasureTheory.hitting_eq_sInf
theorem hitting_eq_sInf (ω : Ω) : hitting u s ⊥ ⊤ ω = sInf {i : ι | u i ω ∈ s} 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [CompleteLattice ι] {u : ι → Ω → β} {s : Set β} (ω : Ω)
Goal: MeasureTheory.hitting u s ⊥ ⊤ ω = sInf {i | u i ω ∈ s}
-- MeasureTheory.hitting_bot_le_iff
theorem hitting_bot_le_iff {i n : ι} {ω : Ω} (hx : ∃ j, j ≤ n ∧ u j ω ∈ s) :
    hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [ConditionallyCompleteLinearOrderBot ι] [IsWellOrder ι fun x x_1 => x < x_1] {u : ι → Ω → β} {s : Set β} {i n : ι} {ω : Ω} (hx : ∃ j ≤ n, u j ω ∈ s)
Goal: MeasureTheory.hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s
-- MeasureTheory.condexp_indep_eq
theorem condexp_indep_eq (hle₁ : m₁ ≤ m) (hle₂ : m₂ ≤ m) [SigmaFinite (μ.trim hle₂)]
    (hf : StronglyMeasurable[m₁] f) (hindp : Indep m₁ m₂ μ) : μ[f|m₂] =ᵐ[μ] fun _ => μ[f] 
Arguments: {Ω : Type u_1} {E : Type u_2} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {m₁ m₂ m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f : Ω → E} (hle₁ : m₁ ≤ m) (hle₂ : m₂ ≤ m) [MeasureTheory.SigmaFinite (μ.trim hle₂)] (hf : MeasureTheory.StronglyMeasurable f) (hindp : ProbabilityTheory.Indep m₁ m₂ μ)
Goal: μ[f|m₂] =ᵐ[μ] fun x => ∫ (x : Ω), f x ∂μ
-- ProbabilityTheory.Kernel.measurable_kernel_prod_mk_left_of_finite
theorem measurable_kernel_prod_mk_left_of_finite {t : Set (α × β)} (ht : MeasurableSet t)
    (hκs : ∀ a, IsFiniteMeasure (κ a)) : Measurable fun a => κ a (Prod.mk a ⁻¹' t) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {t : Set (α × β)} (ht : MeasurableSet t) (hκs : ∀ (a : α), MeasureTheory.IsFiniteMeasure (κ a))
Goal: Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)
-- ProbabilityTheory.Kernel.measurable_kernel_prod_mk_left
theorem measurable_kernel_prod_mk_left [IsSFiniteKernel κ] {t : Set (α × β)}
    (ht : MeasurableSet t) : Measurable fun a => κ a (Prod.mk a ⁻¹' t) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {t : Set (α × β)} (ht : MeasurableSet t)
Goal: Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)