ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Aesop.Script.LazyStep.tacticBuilders_ne
structure LazyStep where
  preState : Meta.SavedState
  preGoal : MVarId
    tacticBuilders : Array TacticBuilder
  tacticBuilders_ne : 0 < tacticBuilders.size := by simp
  postState : Meta.SavedState
  postGoals : Array MVarId
Arguments: (self : Aesop.Script.LazyStep)
Goal: 0 < self.tacticBuilders.size
-- Aesop.BuiltinRules.not_intro
@[aesop (rule_sets := [builtin]) safe 0]
theorem not_intro (h : P → False) : ¬ P 
Arguments: {P : Prop} (h : P → False)
Goal: ¬P
-- Aesop.BuiltinRules.empty_false
@[aesop (rule_sets := [builtin]) norm destruct]
theorem empty_false (h : Empty) : False 
Arguments: (h : Empty)
Goal: False
-- Aesop.BuiltinRules.pEmpty_false
@[aesop (rule_sets := [builtin]) norm destruct]
theorem pEmpty_false (h : PEmpty) : False 
Arguments: (h : PEmpty)
Goal: False
-- Aesop.BuiltinRules.heq_iff_eq
@[aesop (rule_sets := [builtin]) norm simp]
theorem heq_iff_eq (x y : α) : HEq x y ↔ x = y 
Arguments: {α : Sort u_1} (x y : α)
Goal: HEq x y ↔ x = y
-- ForInStep.bind_done
@[simp] theorem ForInStep.bind_done [Monad m] (a : α) (f : α → m (ForInStep α)) :
    (ForInStep.done a).bind (m := m) f = pure (.done a) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] (a : α) (f : α → m (ForInStep α))
Goal: (ForInStep.done a).bind f = pure (ForInStep.done a)
-- ForInStep.bind_yield
@[simp] theorem ForInStep.bind_yield [Monad m] (a : α) (f : α → m (ForInStep α)) :
    (ForInStep.yield a).bind (m := m) f = f a 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] (a : α) (f : α → m (ForInStep α))
Goal: (ForInStep.yield a).bind f = f a
-- ForInStep.run_done
@[simp] theorem ForInStep.run_done : (ForInStep.done a).run = a 
Goal: ∀ {α : Type u_1} {a : α}, (ForInStep.done a).run = a
-- ForInStep.run_yield
@[simp] theorem ForInStep.run_yield : (ForInStep.yield a).run = a 
Goal: ∀ {α : Type u_1} {a : α}, (ForInStep.yield a).run = a
-- ForInStep.bindList_nil
@[simp] theorem ForInStep.bindList_nil [Monad m] (f : α → β → m (ForInStep β))
    (s : ForInStep β) : s.bindList f [] = pure s 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (s : ForInStep β)
Goal: ForInStep.bindList f [] s = pure s
-- ForInStep.bindList_cons
@[simp] theorem ForInStep.bindList_cons [Monad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (a l) :
    s.bindList f (a::l) = s.bind fun b => f a b >>= (·.bindList f l) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (s : ForInStep β) (a : α) (l : List α)
Goal: ForInStep.bindList f (a :: l) s =
  s.bind fun b => do
    let x ← f a b
    ForInStep.bindList f l x
-- ForInStep.done_bindList
@[simp] theorem ForInStep.done_bindList [Monad m]
    (f : α → β → m (ForInStep β)) (a l) :
    (ForInStep.done a).bindList f l = pure (.done a) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (a : β) (l : List α)
Goal: ForInStep.bindList f l (ForInStep.done a) = pure (ForInStep.done a)
-- ForInStep.bind_yield_bindList
@[simp] theorem ForInStep.bind_yield_bindList [Monad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (l) :
    (s.bind fun a => (yield a).bindList f l) = s.bindList f l 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (s : ForInStep β) (l : List α)
Goal: (s.bind fun a => ForInStep.bindList f l (ForInStep.yield a)) = ForInStep.bindList f l s
-- ForInStep.bind_bindList_assoc
@[simp] theorem ForInStep.bind_bindList_assoc [Monad m] [LawfulMonad m]
    (f : β → m (ForInStep β)) (g : α → β → m (ForInStep β)) (s : ForInStep β) (l) :
    s.bind f >>= (·.bindList g l) = s.bind fun b => f b >>= (·.bindList g l)  
Arguments: {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] [LawfulMonad m] (f : β → m (ForInStep β)) (g : α → β → m (ForInStep β)) (s : ForInStep β) (l : List α)
Goal: (do
    let x ← s.bind f
    ForInStep.bindList g l x) =
  s.bind fun b => do
    let x ← f b
    ForInStep.bindList g l x
-- ForInStep.bindList_cons'
theorem ForInStep.bindList_cons' [Monad m] [LawfulMonad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (a l) :
    s.bindList f (a::l) = s.bind (f a) >>= (·.bindList f l) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → β → m (ForInStep β)) (s : ForInStep β) (a : α) (l : List α)
Goal: ForInStep.bindList f (a :: l) s = do
  let x ← s.bind (f a)
  ForInStep.bindList f l x
-- ForInStep.bindList_append
@[simp] theorem ForInStep.bindList_append [Monad m] [LawfulMonad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (l₁ l₂) :
    s.bindList f (l₁ ++ l₂) = s.bindList f l₁ >>= (·.bindList f l₂) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → β → m (ForInStep β)) (s : ForInStep β) (l₁ l₂ : List α)
Goal: ForInStep.bindList f (l₁ ++ l₂) s = do
  let x ← ForInStep.bindList f l₁ s
  ForInStep.bindList f l₂ x
-- Function.id_def
theorem Function.id_def : @id α = fun x => x 
Arguments: {α : Sort u_1}
Goal: id = fun x => x
-- heq_iff_eq
theorem heq_iff_eq : HEq a b ↔ a = b 
Goal: ∀ {α : Sort u_1} {a b : α}, HEq a b ↔ a = b
-- eq_rec_constant
@[simp] theorem eq_rec_constant {α : Sort _} {a a' : α} {β : Sort _} (y : β) (h : a = a') :
    (@Eq.rec α a (fun α _ => β) y a' h) = y 
Arguments: {α : Sort u_1} {a a' : α} {β : Sort u_2} (y : β) (h : a = a')
Goal: h ▸ y = y
-- congrArg₂
theorem congrArg₂ (f : α → β → γ) {x x' : α} {y y' : β}
    (hx : x = x') (hy : y = y') : f x y = f x' y' 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β → γ) {x x' : α} {y y' : β} (hx : x = x') (hy : y = y')
Goal: f x y = f x' y'
-- congrFun₂
theorem congrFun₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
    {f g : ∀ a b, γ a b} (h : f = g) (a : α) (b : β a) :
    f a b = g a b 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {f g : (a : α) → (b : β a) → γ a b} (h : f = g) (a : α) (b : β a)
Goal: f a b = g a b
-- congrFun₃
theorem congrFun₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
      {f g : ∀ a b c, δ a b c} (h : f = g) (a : α) (b : β a) (c : γ a b) :
    f a b c = g a b c 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {f g : (a : α) → (b : β a) → (c : γ a b) → δ a b c} (h : f = g) (a : α) (b : β a) (c : γ a b)
Goal: f a b c = g a b c
-- funext₂
theorem funext₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
    {f g : ∀ a b, γ a b} (h : ∀ a b, f a b = g a b) : f = g 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {f g : (a : α) → (b : β a) → γ a b} (h : ∀ (a : α) (b : β a), f a b = g a b)
Goal: f = g
-- funext₃
theorem funext₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
    {f g : ∀ a b c, δ a b c} (h : ∀ a b c, f a b c = g a b c) : f = g 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {f g : (a : α) → (b : β a) → (c : γ a b) → δ a b c} (h : ∀ (a : α) (b : β a) (c : γ a b), f a b c = g a b c)
Goal: f = g
-- Function.funext_iff
theorem Function.funext_iff {β : α → Sort u} {f₁ f₂ : ∀ x : α, β x} : f₁ = f₂ ↔ ∀ a, f₁ a = f₂ a 
Arguments: {α : Sort u_1} {β : α → Sort u} {f₁ f₂ : (x : α) → β x}
Goal: f₁ = f₂ ↔ ∀ (a : α), f₁ a = f₂ a
-- ne_of_apply_ne
theorem ne_of_apply_ne {α β : Sort _} (f : α → β) {x y : α} : f x ≠ f y → x ≠ y 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) {x y : α}
Goal: f x ≠ f y → x ≠ y
-- Eq.congr
protected theorem Eq.congr (h₁ : x₁ = y₁) (h₂ : x₂ = y₂) : x₁ = x₂ ↔ y₁ = y₂ 
Goal: ∀ {α : Sort u_1} {x₁ y₁ x₂ y₂ : α}, x₁ = y₁ → x₂ = y₂ → (x₁ = x₂ ↔ y₁ = y₂)
-- Eq.congr_left
theorem Eq.congr_left {x y z : α} (h : x = y) : x = z ↔ y = z 
Arguments: {α : Sort u_1} {x y z : α} (h : x = y)
Goal: x = z ↔ y = z
-- Eq.congr_right
theorem Eq.congr_right {x y z : α} (h : x = y) : z = x ↔ z = y 
Arguments: {α : Sort u_1} {x y z : α} (h : x = y)
Goal: z = x ↔ z = y
-- heq_of_cast_eq
theorem heq_of_cast_eq : ∀ (e : α = β) (_ : cast e a = a'), HEq a a'
  
Arguments: {α β : Sort u_1} {a : α} {a' : β} (e : α = β)
Goal: cast e a = a' → HEq a a'
-- cast_eq_iff_heq
theorem cast_eq_iff_heq : cast e a = a' ↔ HEq a a' 
Goal: ∀ {a a_1 : Sort u_1} {e : a = a_1} {a_2 : a} {a' : a_1}, cast e a_2 = a' ↔ HEq a_2 a'
-- eqRec_eq_cast
theorem eqRec_eq_cast {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    @Eq.rec α a motive x a' e = cast (e ▸ rfl) x 
Arguments: {α : Sort u_1} {a : α} {motive : (a' : α) → a = a' → Sort u_2} (x : motive a ⋯) {a' : α} (e : a = a')
Goal: e ▸ x = cast ⋯ x
-- eqRec_heq_self
theorem eqRec_heq_self {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    HEq (@Eq.rec α a motive x a' e) x 
Arguments: {α : Sort u_1} {a : α} {motive : (a' : α) → a = a' → Sort u_2} (x : motive a ⋯) {a' : α} (e : a = a')
Goal: HEq (e ▸ x) x
-- eqRec_heq_iff_heq
@[simp]
theorem eqRec_heq_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') {β : Sort _} (y : β) :
    HEq (@Eq.rec α a motive x a' e) y ↔ HEq x y 
Arguments: {α : Sort u_1} {a : α} {motive : (a' : α) → a = a' → Sort u_2} (x : motive a ⋯) {a' : α} (e : a = a') {β : Sort u_2} (y : β)
Goal: HEq (e ▸ x) y ↔ HEq x y
-- heq_eqRec_iff_heq
@[simp]
theorem heq_eqRec_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') {β : Sort _} (y : β) :
    HEq y (@Eq.rec α a motive x a' e) ↔ HEq y x 
Arguments: {α : Sort u_1} {a : α} {motive : (a' : α) → a = a' → Sort u_2} (x : motive a ⋯) {a' : α} (e : a = a') {β : Sort u_2} (y : β)
Goal: HEq y (e ▸ x) ↔ HEq y x
-- ne_of_mem_of_not_mem
theorem ne_of_mem_of_not_mem (h : a ∈ s) : b ∉ s → a ≠ b 
Arguments: {α : Type u_1} {β : Type u_2} [Membership α β] {s : β} {a b : α} (h : a ∈ s)
Goal: ¬b ∈ s → a ≠ b
-- ne_of_mem_of_not_mem'
theorem ne_of_mem_of_not_mem' (h : a ∈ s) : a ∉ t → s ≠ t 
Arguments: {α : Type u_1} {β : Type u_2} [Membership α β] {s t : β} {a : α} (h : a ∈ s)
Goal: ¬a ∈ t → s ≠ t
-- not_nonempty_empty
@[simp] theorem not_nonempty_empty  : ¬Nonempty Empty 
Goal: ¬Nonempty Empty
-- not_nonempty_pempty
@[simp] theorem not_nonempty_pempty : ¬Nonempty PEmpty 
Goal: ¬Nonempty PEmpty
-- eq_iff_true_of_subsingleton
theorem eq_iff_true_of_subsingleton [Subsingleton α] (x y : α) : x = y ↔ True 
Arguments: {α : Sort u_1} [Subsingleton α] (x y : α)
Goal: x = y ↔ True
-- subsingleton_of_forall_eq
theorem subsingleton_of_forall_eq (x : α) (h : ∀ y, y = x) : Subsingleton α 
Arguments: {α : Sort u_1} (x : α) (h : ∀ (y : α), y = x)
Goal: Subsingleton α
-- subsingleton_iff_forall_eq
theorem subsingleton_iff_forall_eq (x : α) : Subsingleton α ↔ ∀ y, y = x 
Arguments: {α : Sort u_1} (x : α)
Goal: Subsingleton α ↔ ∀ (y : α), y = x
-- congr_eqRec
theorem congr_eqRec {β : α → Sort _} (f : (x : α) → β x → γ) (h : x = x') (y : β x) :
  f x' (Eq.rec y h) = f x y 
Arguments: {α : Sort u_1} {γ : Sort u_2} {x x' : α} {β : α → Sort u_3} (f : (x : α) → β x → γ) (h : x = x') (y : β x)
Goal: f x' (h ▸ y) = f x y
-- _private.«.lake».packages.batteries.Batteries.WF.0.Acc.recC_intro
private theorem recC_intro {motive : (a : α) → Acc r a → Sort v}
    (intro : (x : α) → (h : ∀ (y : α), r y x → Acc r y) →
     ((y : α) → (hr : r y x) → motive y (h y hr)) → motive x (intro x h))
    {a : α} (h : ∀ (y : α), r y a → Acc r y) :
    recC intro (Acc.intro _ h) = intro a h (fun y hr => recC intro (h y hr)) 
Arguments: {α : Sort u_1} {r : α → α → Prop} {motive : (a : α) → Acc r a → Sort v} (intro : (x : α) → (h : ∀ (y : α), r y x → Acc r y) → ((y : α) → (hr : r y x) → motive y ⋯) → motive x ⋯) {a : α} (h : ∀ (y : α), r y a → Acc r y)
Goal: Acc.recC intro ⋯ = intro a h fun y hr => Acc.recC intro ⋯
-- _private.«.lake».packages.batteries.Batteries.WF.0.Acc.rec_eq_recC
@[csimp] private theorem rec_eq_recC : @Acc.rec = @Acc.recC 
Goal: @Acc.rec = @Acc.recC
-- _private.«.lake».packages.batteries.Batteries.WF.0.Acc.ndrec_eq_ndrecC
@[csimp] private theorem ndrec_eq_ndrecC : @Acc.ndrec = @Acc.ndrecC 
Goal: @Acc.ndrec = @Acc.ndrecC
-- _private.«.lake».packages.batteries.Batteries.WF.0.Acc.ndrecOn_eq_ndrecOnC
@[csimp] private theorem ndrecOn_eq_ndrecOnC : @Acc.ndrecOn = @Acc.ndrecOnC 
Goal: @Acc.ndrecOn = @Acc.ndrecOnC
-- _private.«.lake».packages.batteries.Batteries.WF.0.WellFounded.fixF_eq_fixFC
@[csimp] private theorem fixF_eq_fixFC : @fixF = @fixFC 
Goal: @WellFounded.fixF = @WellFounded.fixFC
-- _private.«.lake».packages.batteries.Batteries.WF.0.WellFounded.fix_eq_fixC
@[csimp] private theorem fix_eq_fixC : @fix = @fixC 
Goal: @WellFounded.fix = @WellFounded.fixC
-- Aesop.Array.size_modify
theorem size_modify (a : Array α) (i : Nat) (f : α → α) :
    (a.modify i f).size = a.size 
Arguments: {α : Type u_1} (a : Array α) (i : Nat) (f : α → α)
Goal: (a.modify i f).size = a.size
-- PartialEquivBEq.symm
class PartialEquivBEq (α) [BEq α] : Prop where
    symm : (a : α) == b → b == a
    trans : (a : α) == b → b == c → a == c
Arguments: {α : Type u_1} [BEq α] [self : PartialEquivBEq α] {a b : α}
Goal: (a == b) = true → (b == a) = true
-- PartialEquivBEq.trans
class PartialEquivBEq (α) [BEq α] : Prop where
    symm : (a : α) == b → b == a
    trans : (a : α) == b → b == c → a == c
Arguments: {α : Type u_1} [BEq α] [self : PartialEquivBEq α] {a b c : α}
Goal: (a == b) = true → (b == c) = true → (a == c) = true
-- Aesop.LocalRuleSet.simprocsArrayNonempty
structure LocalRuleSet extends BaseRuleSet where
    simpTheoremsArray : Array (Name × SimpTheorems)
    simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size
    simprocsArray : Array (Name × Simprocs)
    simprocsArrayNonempty : 0 < simprocsArray.size
    localNormSimpRules : Array LocalNormSimpRule
Arguments: (self : Aesop.LocalRuleSet)
Goal: 0 < self.simprocsArray.size
-- Aesop.LocalRuleSet.simpTheoremsArrayNonempty
structure LocalRuleSet extends BaseRuleSet where
    simpTheoremsArray : Array (Name × SimpTheorems)
    simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size
    simprocsArray : Array (Name × Simprocs)
    simprocsArrayNonempty : 0 < simprocsArray.size
    localNormSimpRules : Array LocalNormSimpRule
Arguments: (self : Aesop.LocalRuleSet)
Goal: 0 < self.simpTheoremsArray.size
-- SatisfiesM.of_true
theorem of_true [Applicative m] [LawfulApplicative m] {x : m α}
    (h : ∀ a, p a) : SatisfiesM p x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p : α → Prop} [Applicative m] [LawfulApplicative m] {x : m α} (h : ∀ (a : α), p a)
Goal: SatisfiesM p x
-- SatisfiesM.trivial
protected theorem trivial [Applicative m] [LawfulApplicative m] {x : m α} :
  SatisfiesM (fun _ => True) x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} [Applicative m] [LawfulApplicative m] {x : m α}
Goal: SatisfiesM (fun x => True) x
-- SatisfiesM.imp
theorem imp [Functor m] [LawfulFunctor m] {x : m α}
    (h : SatisfiesM p x) (H : ∀ {a}, p a → q a) : SatisfiesM q x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p q : α → Prop} [Functor m] [LawfulFunctor m] {x : m α} (h : SatisfiesM p x) (H : ∀ {a : α}, p a → q a)
Goal: SatisfiesM q x
-- SatisfiesM.map
protected theorem map [Functor m] [LawfulFunctor m] {x : m α}
    (hx : SatisfiesM p x) (hf : ∀ {a}, p a → q (f a)) : SatisfiesM q (f <$> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p : α → Prop}
Goal: ∀ {α_1 : Type u_1} {q : α_1 → Prop} {f : α → α_1} [inst : Functor m] [inst_1 : LawfulFunctor m] {x : m α},
  SatisfiesM p x → (∀ {a : α}, p a → q (f a)) → SatisfiesM q (f <$> x)
-- SatisfiesM.map_post
theorem map_post [Functor m] [LawfulFunctor m] {x : m α}
    (hx : SatisfiesM p x) : SatisfiesM (fun b => ∃ a, p a ∧ b = f a) (f <$> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p : α → Prop}
Goal: ∀ {α_1 : Type u_1} {f : α → α_1} [inst : Functor m] [inst_1 : LawfulFunctor m] {x : m α},
  SatisfiesM p x → SatisfiesM (fun b => ∃ a, p a ∧ b = f a) (f <$> x)
-- SatisfiesM.map_pre
theorem map_pre [Functor m] [LawfulFunctor m] {x : m α}
    (hx : SatisfiesM (fun a => p (f a)) x) : SatisfiesM p (f <$> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1}
Goal: ∀ {α_1 : Type u_1} {p : α_1 → Prop} {f : α → α_1} [inst : Functor m] [inst_1 : LawfulFunctor m] {x : m α},
  SatisfiesM (fun a => p (f a)) x → SatisfiesM p (f <$> x)
-- SatisfiesM.mapConst
protected theorem mapConst [Functor m] [LawfulFunctor m] {x : m α}
    (hx : SatisfiesM q x) (ha : ∀ {b}, q b → p a) : SatisfiesM p (Functor.mapConst a x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {q : α → Prop}
Goal: ∀ {α_1 : Type u_1} {p : α_1 → Prop} {a : α_1} [inst : Functor m] [inst_1 : LawfulFunctor m] {x : m α},
  SatisfiesM q x → (∀ {b : α}, q b → p a) → SatisfiesM p (Functor.mapConst a x)
-- SatisfiesM.pure
protected theorem pure [Applicative m] [LawfulApplicative m]
    (h : p a) : SatisfiesM (m := m) p (pure a) 
Arguments: {m : Type u_1 → Type u_2}
Goal: ∀ {α : Type u_1} {p : α → Prop} {a : α} [inst : Applicative m] [inst_1 : LawfulApplicative m],
  p a → SatisfiesM p (pure a)
-- SatisfiesM.seq
protected theorem seq [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM p₁ f) (hx : SatisfiesM p₂ x)
    (H : ∀ {f a}, p₁ f → p₂ a → q (f a)) : SatisfiesM q (f <*> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1}
Goal: ∀ {α_1 : Type u_1} {p₁ : (α → α_1) → Prop} {f : m (α → α_1)} {p₂ : α → Prop} {q : α_1 → Prop} [inst : Applicative m]
  [inst_1 : LawfulApplicative m] {x : m α},
  SatisfiesM p₁ f →
    SatisfiesM p₂ x → (∀ {f : α → α_1} {a : α}, p₁ f → p₂ a → q (f a)) → SatisfiesM q (Seq.seq f fun x_1 => x)
-- SatisfiesM.seq_post
protected theorem seq_post [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM p₁ f) (hx : SatisfiesM p₂ x) :
    SatisfiesM (fun c => ∃ f a, p₁ f ∧ p₂ a ∧ c = f a) (f <*> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1}
Goal: ∀ {α_1 : Type u_1} {p₁ : (α → α_1) → Prop} {f : m (α → α_1)} {p₂ : α → Prop} [inst : Applicative m]
  [inst_1 : LawfulApplicative m] {x : m α},
  SatisfiesM p₁ f → SatisfiesM p₂ x → SatisfiesM (fun c => ∃ f a, p₁ f ∧ p₂ a ∧ c = f a) (Seq.seq f fun x_1 => x)
-- SatisfiesM.seq_pre
protected theorem seq_pre [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM (fun f => ∀ {a}, p₂ a → q (f a)) f) (hx : SatisfiesM p₂ x) :
    SatisfiesM q (f <*> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p₂ : α → Prop}
Goal: ∀ {α_1 : Type u_1} {q : α_1 → Prop} {f : m (α → α_1)} [inst : Applicative m] [inst_1 : LawfulApplicative m] {x : m α},
  SatisfiesM (fun f => ∀ {a : α}, p₂ a → q (f a)) f → SatisfiesM p₂ x → SatisfiesM q (Seq.seq f fun x_1 => x)
-- SatisfiesM.seq_pre'
protected theorem seq_pre' [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM p₁ f) (hx : SatisfiesM (fun a => ∀ {f}, p₁ f → q (f a)) x) :
    SatisfiesM q (f <*> x) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1}
Goal: ∀ {α_1 : Type u_1} {p₁ : (α → α_1) → Prop} {f : m (α → α_1)} {q : α_1 → Prop} [inst : Applicative m]
  [inst_1 : LawfulApplicative m] {x : m α},
  SatisfiesM p₁ f → SatisfiesM (fun a => ∀ {f : α → α_1}, p₁ f → q (f a)) x → SatisfiesM q (Seq.seq f fun x_1 => x)
-- SatisfiesM.seqLeft
protected theorem seqLeft [Applicative m] [LawfulApplicative m] {x : m α}
    (hx : SatisfiesM p₁ x) (hy : SatisfiesM p₂ y)
    (H : ∀ {a b}, p₁ a → p₂ b → q a) : SatisfiesM q (x <* y) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p₁ : α → Prop}
Goal: ∀ {a : Type u_1} {p₂ : a → Prop} {y : m a} {q : α → Prop} [inst : Applicative m] [inst_1 : LawfulApplicative m]
  {x : m α},
  SatisfiesM p₁ x →
    SatisfiesM p₂ y → (∀ {a_1 : α} {b : a}, p₁ a_1 → p₂ b → q a_1) → SatisfiesM q (SeqLeft.seqLeft x fun x => y)
-- SatisfiesM.seqRight
protected theorem seqRight [Applicative m] [LawfulApplicative m] {x : m α}
    (hx : SatisfiesM p₁ x) (hy : SatisfiesM p₂ y)
    (H : ∀ {a b}, p₁ a → p₂ b → q b) : SatisfiesM q (x *> y) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} {p₁ : α → Prop}
Goal: ∀ {a : Type u_1} {p₂ : a → Prop} {y : m a} {q : a → Prop} [inst : Applicative m] [inst_1 : LawfulApplicative m]
  {x : m α},
  SatisfiesM p₁ x →
    SatisfiesM p₂ y → (∀ {a_1 : α} {b : a}, p₁ a_1 → p₂ b → q b) → SatisfiesM q (SeqRight.seqRight x fun x => y)
-- SatisfiesM.bind
protected theorem bind [Monad m] [LawfulMonad m] {f : α → m β}
    (hx : SatisfiesM p x) (hf : ∀ a, p a → SatisfiesM q (f a)) :
    SatisfiesM q (x >>= f) 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} {p : α → Prop} {x : m α} {q : β → Prop} [Monad m] [LawfulMonad m] {f : α → m β} (hx : SatisfiesM p x) (hf : ∀ (a : α), p a → SatisfiesM q (f a))
Goal: SatisfiesM q (x >>= f)
-- SatisfiesM.bind_pre
protected theorem bind_pre [Monad m] [LawfulMonad m] {f : α → m β}
    (hx : SatisfiesM (fun a => SatisfiesM q (f a)) x) :
    SatisfiesM q (x >>= f) 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} {q : β → Prop} {x : m α} [Monad m] [LawfulMonad m] {f : α → m β} (hx : SatisfiesM (fun a => SatisfiesM q (f a)) x)
Goal: SatisfiesM q (x >>= f)
-- SatisfiesM_Id_eq
@[simp] theorem SatisfiesM_Id_eq : SatisfiesM (m := Id) p x ↔ p x 
Goal: ∀ {type : Type u_1} {p : type → Prop} {x : Id type}, SatisfiesM p x ↔ p x
-- SatisfiesM_Option_eq
@[simp] theorem SatisfiesM_Option_eq : SatisfiesM (m := Option) p x ↔ ∀ a, x = some a → p a 
Goal: ∀ {α : Type u_1} {p : α → Prop} {x : Option α}, SatisfiesM p x ↔ ∀ (a : α), x = some a → p a
-- SatisfiesM_Except_eq
@[simp] theorem SatisfiesM_Except_eq : SatisfiesM (m := Except ε) p x ↔ ∀ a, x = .ok a → p a 
Arguments: {ε : Type u_1}
Goal: ∀ {α : Type u_2} {p : α → Prop} {x : Except ε α}, SatisfiesM p x ↔ ∀ (a : α), x = Except.ok a → p a
-- SatisfiesM_ReaderT_eq
@[simp] theorem SatisfiesM_ReaderT_eq [Monad m] :
    SatisfiesM (m := ReaderT ρ m) p x ↔ ∀ s, SatisfiesM p (x s) 
Arguments: {m : Type u_1 → Type u_2} {ρ : Type u_1}
Goal: ∀ {α : Type u_1} {p : α → Prop} {x : ReaderT ρ m α} [inst : Monad m], SatisfiesM p x ↔ ∀ (s : ρ), SatisfiesM p (x s)
-- SatisfiesM_StateRefT_eq
theorem SatisfiesM_StateRefT_eq [Monad m] :
    SatisfiesM (m := StateRefT' ω σ m) p x ↔ ∀ s, SatisfiesM p (x s) 
Arguments: {m : Type → Type} {ω σ : Type}
Goal: ∀ {α : Type} {p : α → Prop} {x : StateRefT' ω σ m α} [inst : Monad m],
  SatisfiesM p x ↔ ∀ (s : ST.Ref ω σ), SatisfiesM p (x s)
-- SatisfiesM_StateT_eq
@[simp] theorem SatisfiesM_StateT_eq [Monad m] [LawfulMonad m] :
    SatisfiesM (m := StateT ρ m) (α := α) p x ↔ ∀ s, SatisfiesM (m := m) (p ·.1) (x s) 
Arguments: {m : Type u_1 → Type u_2} {α ρ : Type u_1} {p : α → Prop} {x : StateT ρ m α} [Monad m] [LawfulMonad m]
Goal: SatisfiesM p x ↔ ∀ (s : ρ), SatisfiesM (fun x => p x.fst) (x s)
-- SatisfiesM_ExceptT_eq
@[simp] theorem SatisfiesM_ExceptT_eq [Monad m] [LawfulMonad m] :
    SatisfiesM (m := ExceptT ρ m) (α := α) p x ↔ SatisfiesM (m := m) (∀ a, · = .ok a → p a) x 
Arguments: {m : Type u_1 → Type u_2} {α ρ : Type u_1} {p : α → Prop} {x : ExceptT ρ m α} [Monad m] [LawfulMonad m]
Goal: SatisfiesM p x ↔ SatisfiesM (fun x => ∀ (a : α), x = Except.ok a → p a) x
-- Ordering.swap_swap
@[simp] theorem swap_swap {o : Ordering} : o.swap.swap = o 
Arguments: {o : Ordering}
Goal: o.swap.swap = o
-- Ordering.swap_inj
@[simp] theorem swap_inj {o₁ o₂ : Ordering} : o₁.swap = o₂.swap ↔ o₁ = o₂ 
Arguments: {o₁ o₂ : Ordering}
Goal: o₁.swap = o₂.swap ↔ o₁ = o₂
-- Ordering.swap_then
theorem swap_then (o₁ o₂ : Ordering) : (o₁.then o₂).swap = o₁.swap.then o₂.swap 
Arguments: (o₁ o₂ : Ordering)
Goal: (o₁.then o₂).swap = o₁.swap.then o₂.swap
-- Ordering.then_eq_lt
theorem then_eq_lt {o₁ o₂ : Ordering} : o₁.then o₂ = lt ↔ o₁ = lt ∨ o₁ = eq ∧ o₂ = lt 
Arguments: {o₁ o₂ : Ordering}
Goal: o₁.then o₂ = Ordering.lt ↔ o₁ = Ordering.lt ∨ o₁ = Ordering.eq ∧ o₂ = Ordering.lt
-- Ordering.then_eq_eq
theorem then_eq_eq {o₁ o₂ : Ordering} : o₁.then o₂ = eq ↔ o₁ = eq ∧ o₂ = eq 
Arguments: {o₁ o₂ : Ordering}
Goal: o₁.then o₂ = Ordering.eq ↔ o₁ = Ordering.eq ∧ o₂ = Ordering.eq
-- Ordering.then_eq_gt
theorem then_eq_gt {o₁ o₂ : Ordering} : o₁.then o₂ = gt ↔ o₁ = gt ∨ o₁ = eq ∧ o₂ = gt 
Arguments: {o₁ o₂ : Ordering}
Goal: o₁.then o₂ = Ordering.gt ↔ o₁ = Ordering.gt ∨ o₁ = Ordering.eq ∧ o₂ = Ordering.gt