ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ExceptCpsT.runCatch_bind_lift
@[simp] theorem runCatch_bind_lift [Monad m] (x : m α) (f : α → ExceptCpsT β m β) : runCatch (ExceptCpsT.lift x >>= f : ExceptCpsT β m β) = x >>= fun a => runCatch (f a) 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Monad m] (x : m α) (f : α → ExceptCpsT β m β)
Goal: (ExceptCpsT.lift x >>= f).runCatch = do
  let a ← x
  (f a).runCatch
-- ExceptCpsT.runCatch_bind_throw
@[simp] theorem runCatch_bind_throw [Monad m] (e : β) (f : α → ExceptCpsT β m β) : runCatch (throw e >>= f : ExceptCpsT β m β) = pure e 
Arguments: {m : Type u_1 → Type u_2} {β α : Type u_1} [Monad m] (e : β) (f : α → ExceptCpsT β m β)
Goal: (throw e >>= f).runCatch = pure e
-- ExceptT.ext
theorem ext {x y : ExceptT ε m α} (h : x.run = y.run) : x = y 
Arguments: {ε : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x y : ExceptT ε m α} (h : x.run = y.run)
Goal: x = y
-- ExceptT.run_pure
@[simp] theorem run_pure [Monad m] (x : α) : run (pure x : ExceptT ε m α) = pure (Except.ok x) 
Arguments: {m : Type u_1 → Type u_2} {α ε : Type u_1} [Monad m] (x : α)
Goal: (pure x).run = pure (Except.ok x)
-- ExceptT.run_lift
@[simp] theorem run_lift  [Monad.{u, v} m] (x : m α) : run (ExceptT.lift x : ExceptT ε m α) = (Except.ok <$> x : m (Except ε α)) 
Arguments: {m : Type u → Type v} {α ε : Type u} [Monad m] (x : m α)
Goal: (ExceptT.lift x).run = Except.ok <$> x
-- ExceptT.run_throw
@[simp] theorem run_throw [Monad m] : run (throw e : ExceptT ε m β) = pure (Except.error e) 
Arguments: {m : Type u_1 → Type u_2} {ε β : Type u_1} {e : ε} [Monad m]
Goal: (throw e).run = pure (Except.error e)
-- ExceptT.run_bind_lift
@[simp] theorem run_bind_lift [Monad m] [LawfulMonad m] (x : m α) (f : α → ExceptT ε m β) : run (ExceptT.lift x >>= f : ExceptT ε m β) = x >>= fun a => run (f a) 
Arguments: {m : Type u_1 → Type u_2} {α ε β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (f : α → ExceptT ε m β)
Goal: (ExceptT.lift x >>= f).run = do
  let a ← x
  (f a).run
-- ExceptT.bind_throw
@[simp] theorem bind_throw [Monad m] [LawfulMonad m] (f : α → ExceptT ε m β) : (throw e >>= f) = throw e 
Arguments: {m : Type u_1 → Type u_2} {α ε β : Type u_1} {e : ε} [Monad m] [LawfulMonad m] (f : α → ExceptT ε m β)
Goal: throw e >>= f = throw e
-- ExceptT.run_bind
theorem run_bind [Monad m] (x : ExceptT ε m α)
        : run (x >>= f : ExceptT ε m β)
          =
          run x >>= fun
                     | Except.ok x => run (f x)
                     | Except.error e => pure (Except.error e) 
Arguments: {m : Type u_1 → Type u_2} {ε α β : Type u_1} {f : α → ExceptT ε m β} [Monad m] (x : ExceptT ε m α)
Goal: (x >>= f).run = do
  let x ← x.run
  match x with
    | Except.ok x => (f x).run
    | Except.error e => pure (Except.error e)
-- ExceptT.lift_pure
@[simp] theorem lift_pure [Monad m] [LawfulMonad m] (a : α) : ExceptT.lift (pure a) = (pure a : ExceptT ε m α) 
Arguments: {m : Type u_1 → Type u_2} {α ε : Type u_1} [Monad m] [LawfulMonad m] (a : α)
Goal: ExceptT.lift (pure a) = pure a
-- ExceptT.run_map
@[simp] theorem run_map [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α)
    : (f <$> x).run = Except.map f <$> x.run 
Arguments: {m : Type u_1 → Type u_2} {α β ε : Type u_1} [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α)
Goal: (f <$> x).run = Except.map f <$> x.run
-- ExceptT.seq_eq
protected theorem seq_eq {α β ε : Type u} [Monad m] (mf : ExceptT ε m (α → β)) (x : ExceptT ε m α) : mf <*> x = mf >>= fun f => f <$> x 
Arguments: {m : Type u → Type u_1} {α β ε : Type u} [Monad m] (mf : ExceptT ε m (α → β)) (x : ExceptT ε m α)
Goal: (Seq.seq mf fun x_1 => x) = do
  let f ← mf
  f <$> x
-- ExceptT.bind_pure_comp
protected theorem bind_pure_comp [Monad m] (f : α → β) (x : ExceptT ε m α) : x >>= pure ∘ f = f <$> x 
Arguments: {m : Type u_1 → Type u_2} {α β ε : Type u_1} [Monad m] (f : α → β) (x : ExceptT ε m α)
Goal: x >>= pure ∘ f = f <$> x
-- ExceptT.seqLeft_eq
protected theorem seqLeft_eq {α β ε : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) : x <* y = const β <$> x <*> y 
Arguments: {α β ε : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β)
Goal: (SeqLeft.seqLeft x fun x => y) = Seq.seq (Function.const β <$> x) fun x => y
-- ExceptT.seqRight_eq
protected theorem seqRight_eq [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) : x *> y = const α id <$> x <*> y 
Arguments: {m : Type u_1 → Type u_2} {ε α β : Type u_1} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β)
Goal: (SeqRight.seqRight x fun x => y) = Seq.seq (Function.const α id <$> x) fun x => y
-- ReaderT.ext
theorem ext {x y : ReaderT ρ m α} (h : ∀ ctx, x.run ctx = y.run ctx) : x = y 
Arguments: {ρ : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x y : ReaderT ρ m α} (h : ∀ (ctx : ρ), x.run ctx = y.run ctx)
Goal: x = y
-- ReaderT.run_pure
@[simp] theorem run_pure [Monad m] (a : α) (ctx : ρ) : (pure a : ReaderT ρ m α).run ctx = pure a 
Arguments: {m : Type u_1 → Type u_2} {α ρ : Type u_1} [Monad m] (a : α) (ctx : ρ)
Goal: (pure a).run ctx = pure a
-- ReaderT.run_bind
@[simp] theorem run_bind [Monad m] (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) (ctx : ρ)
    : (x >>= f).run ctx = x.run ctx >>= λ a => (f a).run ctx 
Arguments: {m : Type u_1 → Type u_2} {ρ α β : Type u_1} [Monad m] (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) (ctx : ρ)
Goal: (x >>= f).run ctx = do
  let a ← x.run ctx
  (f a).run ctx
-- ReaderT.run_mapConst
@[simp] theorem run_mapConst [Monad m] (a : α) (x : ReaderT ρ m β) (ctx : ρ)
    : (Functor.mapConst a x).run ctx = Functor.mapConst a (x.run ctx) 
Arguments: {m : Type u_1 → Type u_2} {α ρ β : Type u_1} [Monad m] (a : α) (x : ReaderT ρ m β) (ctx : ρ)
Goal: (Functor.mapConst a x).run ctx = Functor.mapConst a (x.run ctx)
-- ReaderT.run_map
@[simp] theorem run_map [Monad m] (f : α → β) (x : ReaderT ρ m α) (ctx : ρ)
    : (f <$> x).run ctx = f <$> x.run ctx 
Arguments: {m : Type u_1 → Type u_2} {α β ρ : Type u_1} [Monad m] (f : α → β) (x : ReaderT ρ m α) (ctx : ρ)
Goal: (f <$> x).run ctx = f <$> x.run ctx
-- ReaderT.run_monadLift
@[simp] theorem run_monadLift [MonadLiftT n m] (x : n α) (ctx : ρ)
    : (monadLift x : ReaderT ρ m α).run ctx = (monadLift x : m α) 
Arguments: {n : Type u_1 → Type u_2} {m : Type u_1 → Type u_3} {α ρ : Type u_1} [MonadLiftT n m] (x : n α) (ctx : ρ)
Goal: (monadLift x).run ctx = monadLift x
-- ReaderT.run_monadMap
@[simp] theorem run_monadMap [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ)
    : (monadMap @f x : ReaderT ρ m α).run ctx = monadMap @f (x.run ctx) 
Arguments: {n : Type u → Type u_1} {m : Type u → Type u_2} {ρ α : Type u} [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ)
Goal: (monadMap f x).run ctx = monadMap f (x.run ctx)
-- ReaderT.run_read
@[simp] theorem run_read [Monad m] (ctx : ρ) : (ReaderT.read : ReaderT ρ m ρ).run ctx = pure ctx 
Arguments: {m : Type u_1 → Type u_2} {ρ : Type u_1} [Monad m] (ctx : ρ)
Goal: ReaderT.read.run ctx = pure ctx
-- ReaderT.run_seq
@[simp] theorem run_seq {α β : Type u} [Monad m] (f : ReaderT ρ m (α → β)) (x : ReaderT ρ m α) (ctx : ρ)
    : (f <*> x).run ctx = (f.run ctx <*> x.run ctx) 
Arguments: {m : Type u → Type u_1} {ρ α β : Type u} [Monad m] (f : ReaderT ρ m (α → β)) (x : ReaderT ρ m α) (ctx : ρ)
Goal: (Seq.seq f fun x_1 => x).run ctx = Seq.seq (f.run ctx) fun x_1 => x.run ctx
-- ReaderT.run_seqRight
@[simp] theorem run_seqRight [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ)
    : (x *> y).run ctx = (x.run ctx *> y.run ctx) 
Arguments: {m : Type u_1 → Type u_2} {ρ α β : Type u_1} [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ)
Goal: (SeqRight.seqRight x fun x => y).run ctx = SeqRight.seqRight (x.run ctx) fun x => y.run ctx
-- ReaderT.run_seqLeft
@[simp] theorem run_seqLeft [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ)
    : (x <* y).run ctx = (x.run ctx <* y.run ctx) 
Arguments: {m : Type u_1 → Type u_2} {ρ α β : Type u_1} [Monad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ)
Goal: (SeqLeft.seqLeft x fun x => y).run ctx = SeqLeft.seqLeft (x.run ctx) fun x => y.run ctx
-- StateT.ext
theorem ext {x y : StateT σ m α} (h : ∀ s, x.run s = y.run s) : x = y 
Arguments: {σ : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x y : StateT σ m α} (h : ∀ (s : σ), x.run s = y.run s)
Goal: x = y
-- StateT.run'_eq
@[simp] theorem run'_eq [Monad m] (x : StateT σ m α) (s : σ) : run' x s = (·.1) <$> run x s 
Arguments: {m : Type u_1 → Type u_2} {σ α : Type u_1} [Monad m] (x : StateT σ m α) (s : σ)
Goal: x.run' s = (fun x => x.fst) <$> x.run s
-- StateT.run_pure
@[simp] theorem run_pure [Monad m] (a : α) (s : σ) : (pure a : StateT σ m α).run s = pure (a, s) 
Arguments: {m : Type u_1 → Type u_2} {α σ : Type u_1} [Monad m] (a : α) (s : σ)
Goal: (pure a).run s = pure (a, s)
-- StateT.run_bind
@[simp] theorem run_bind [Monad m] (x : StateT σ m α) (f : α → StateT σ m β) (s : σ)
    : (x >>= f).run s = x.run s >>= λ p => (f p.1).run p.2 
Arguments: {m : Type u_1 → Type u_2} {σ α β : Type u_1} [Monad m] (x : StateT σ m α) (f : α → StateT σ m β) (s : σ)
Goal: (x >>= f).run s = do
  let p ← x.run s
  (f p.fst).run p.snd
-- StateT.run_map
@[simp] theorem run_map {α β σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ) : (f <$> x).run s = (fun (p : α × σ) => (f p.1, p.2)) <$> x.run s 
Arguments: {m : Type u → Type u_1} {α β σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ)
Goal: (f <$> x).run s = (fun p => (f p.fst, p.snd)) <$> x.run s
-- StateT.run_get
@[simp] theorem run_get [Monad m] (s : σ)    : (get : StateT σ m σ).run s = pure (s, s) 
Arguments: {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (s : σ)
Goal: get.run s = pure (s, s)
-- StateT.run_set
@[simp] theorem run_set [Monad m] (s s' : σ) : (set s' : StateT σ m PUnit).run s = pure (⟨⟩, s') 
Arguments: {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (s s' : σ)
Goal: (set s').run s = pure (PUnit.unit, s')
-- StateT.run_modify
@[simp] theorem run_modify [Monad m] (f : σ → σ) (s : σ) : (modify f : StateT σ m PUnit).run s = pure (⟨⟩, f s) 
Arguments: {m : Type u_1 → Type u_2} {σ : Type u_1} [Monad m] (f : σ → σ) (s : σ)
Goal: (modify f).run s = pure (PUnit.unit, f s)
-- StateT.run_modifyGet
@[simp] theorem run_modifyGet [Monad m] (f : σ → α × σ) (s : σ) : (modifyGet f : StateT σ m α).run s = pure ((f s).1, (f s).2) 
Arguments: {m : Type u_1 → Type u_2} {σ α : Type u_1} [Monad m] (f : σ → α × σ) (s : σ)
Goal: (modifyGet f).run s = pure ((f s).fst, (f s).snd)
-- StateT.run_lift
@[simp] theorem run_lift {α σ : Type u} [Monad m] (x : m α) (s : σ) : (StateT.lift x : StateT σ m α).run s = x >>= fun a => pure (a, s) 
Arguments: {m : Type u → Type u_1} {α σ : Type u} [Monad m] (x : m α) (s : σ)
Goal: (StateT.lift x).run s = do
  let a ← x
  pure (a, s)
-- StateT.run_bind_lift
@[simp] theorem run_bind_lift {α σ : Type u} [Monad m] [LawfulMonad m] (x : m α) (f : α → StateT σ m β) (s : σ) : (StateT.lift x >>= f).run s = x >>= fun a => (f a).run s 
Arguments: {m : Type u → Type u_1} {β α σ : Type u} [Monad m] [LawfulMonad m] (x : m α) (f : α → StateT σ m β) (s : σ)
Goal: (StateT.lift x >>= f).run s = do
  let a ← x
  (f a).run s
-- StateT.run_monadLift
@[simp] theorem run_monadLift {α σ : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ) : (monadLift x : StateT σ m α).run s = (monadLift x : m α) >>= fun a => pure (a, s) 
Arguments: {m : Type u → Type u_1} {n : Type u → Type u_2} {α σ : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ)
Goal: (monadLift x).run s = do
  let a ← monadLift x
  pure (a, s)
-- StateT.run_monadMap
@[simp] theorem run_monadMap [Monad m] [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ)
    : (monadMap @f x : StateT σ m α).run s = monadMap @f (x.run s) 
Arguments: {m : Type u → Type u_1} {n : Type u → Type u_2} {σ α : Type u} [Monad m] [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ)
Goal: (monadMap f x).run s = monadMap f (x.run s)
-- StateT.run_seq
@[simp] theorem run_seq {α β σ : Type u} [Monad m] [LawfulMonad m] (f : StateT σ m (α → β)) (x : StateT σ m α) (s : σ) : (f <*> x).run s = (f.run s >>= fun fs => (fun (p : α × σ) => (fs.1 p.1, p.2)) <$> x.run fs.2) 
Arguments: {m : Type u → Type u_1} {α β σ : Type u} [Monad m] [LawfulMonad m] (f : StateT σ m (α → β)) (x : StateT σ m α) (s : σ)
Goal: (Seq.seq f fun x_1 => x).run s = do
  let fs ← f.run s
  (fun p => (fs.fst p.fst, p.snd)) <$> x.run fs.snd
-- StateT.run_seqRight
@[simp] theorem run_seqRight [Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) : (x *> y).run s = (x.run s >>= fun p => y.run p.2) 
Arguments: {m : Type u_1 → Type u_2} {σ α β : Type u_1} [Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ)
Goal: (SeqRight.seqRight x fun x => y).run s = do
  let p ← x.run s
  y.run p.snd
-- StateT.run_seqLeft
@[simp] theorem run_seqLeft {α β σ : Type u} [Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) : (x <* y).run s = (x.run s >>= fun p => y.run p.2 >>= fun p' => pure (p.1, p'.2)) 
Arguments: {m : Type u → Type u_1} {α β σ : Type u} [Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ)
Goal: (SeqLeft.seqLeft x fun x => y).run s = do
  let p ← x.run s
  let p' ← y.run p.snd
  pure (p.fst, p'.snd)
-- StateT.seqRight_eq
theorem seqRight_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x *> y = const α id <$> x <*> y 
Arguments: {m : Type u_1 → Type u_2} {σ α β : Type u_1} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β)
Goal: (SeqRight.seqRight x fun x => y) = Seq.seq (Function.const α id <$> x) fun x => y
-- StateT.seqLeft_eq
theorem seqLeft_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x <* y = const β <$> x <*> y 
Arguments: {m : Type u_1 → Type u_2} {σ α β : Type u_1} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β)
Goal: (SeqLeft.seqLeft x fun x => y) = Seq.seq (Function.const β <$> x) fun x => y
-- sizeOf_default
@[simp] theorem sizeOf_default (n : α) : sizeOf n = 0 
Arguments: {α : Sort u_1} (n : α)
Goal: sizeOf n = 0
-- sizeOf_nat
@[simp] theorem sizeOf_nat (n : Nat) : sizeOf n = n 
Arguments: (n : Nat)
Goal: sizeOf n = n
-- sizeOf_thunk
@[simp] theorem sizeOf_thunk [SizeOf α] (f : Unit → α) : sizeOf f = sizeOf (f ()) 
Arguments: {α : Sort u_1} [SizeOf α] (f : Unit → α)
Goal: sizeOf f = sizeOf (f Unit.unit)
-- Unit.sizeOf
@[simp] theorem Unit.sizeOf (u : Unit) : sizeOf u = 1 
Arguments: (u : Unit)
Goal: sizeOf u = 1
-- Bool.sizeOf_eq_one
@[simp] theorem Bool.sizeOf_eq_one (b : Bool) : sizeOf b = 1 
Arguments: (b : Bool)
Goal: sizeOf b = 1
-- Lean.Name.anonymous.sizeOf_spec
@[simp] theorem Name.anonymous.sizeOf_spec : sizeOf anonymous = 1 
Goal: sizeOf Lean.Name.anonymous = 1
-- Lean.Name.str.sizeOf_spec
@[simp] theorem Name.str.sizeOf_spec (p : Name) (s : String) : sizeOf (str p s) = 1 + sizeOf p + sizeOf s 
Arguments: (p : Lean.Name) (s : String)
Goal: sizeOf (p.str s) = 1 + sizeOf p + sizeOf s
-- Lean.Name.num.sizeOf_spec
@[simp] theorem Name.num.sizeOf_spec (p : Name) (n : Nat) : sizeOf (num p n) = 1 + sizeOf p + sizeOf n 
Arguments: (p : Lean.Name) (n : Nat)
Goal: sizeOf (p.num n) = 1 + sizeOf p + sizeOf n
-- Acc.inv
theorem inv {x y : α} (h₁ : Acc r x) (h₂ : r y x) : Acc r y 
Arguments: {α : Sort u} {r : α → α → Prop} {x y : α} (h₁ : Acc r x) (h₂ : r y x)
Goal: Acc r y
-- WellFoundedRelation.wf
class WellFoundedRelation (α : Sort u) where
  rel : α → α → Prop
  wf  : WellFounded rel
Arguments: {α : Sort u} [self : WellFoundedRelation α]
Goal: WellFounded WellFoundedRelation.rel
-- WellFounded.apply
theorem apply {α : Sort u} {r : α → α → Prop} (wf : WellFounded r) (a : α) : Acc r a 
Arguments: {α : Sort u} {r : α → α → Prop} (wf : WellFounded r) (a : α)
Goal: Acc r a
-- WellFounded.induction
theorem induction {C : α → Prop} (a : α) (h : ∀ x, (∀ y, r y x → C y) → C x) : C a 
Arguments: {α : Sort u} {r : α → α → Prop} (hwf : WellFounded r) {C : α → Prop} (a : α) (h : ∀ (x : α), (∀ (y : α), r y x → C y) → C x)
Goal: C a
-- WellFounded.fixFEq
theorem fixFEq (x : α) (acx : Acc r x) : fixF F x acx = F x (fun (y : α) (p : r y x) => fixF F y (Acc.inv acx p)) 
Arguments: {α : Sort u} {r : α → α → Prop} {C : α → Sort v} (F : (x : α) → ((y : α) → r y x → C y) → C x) (x : α) (acx : Acc r x)
Goal: WellFounded.fixF F x acx = F x fun y p => WellFounded.fixF F y ⋯
-- WellFounded.fix_eq
theorem fix_eq (hwf : WellFounded r) (F : ∀ x, (∀ y, r y x → C y) → C x) (x : α) :
    fix hwf F x = F x (fun y _ => fix hwf F y) 
Arguments: {α : Sort u} {C : α → Sort v} {r : α → α → Prop} (hwf : WellFounded r) (F : (x : α) → ((y : α) → r y x → C y) → C x) (x : α)
Goal: hwf.fix F x = F x fun y x => hwf.fix F y
-- Subrelation.accessible
theorem accessible {a : α} (h₁ : Subrelation q r) (ac : Acc r a) : Acc q a 
Arguments: {α : Sort u} {r q : α → α → Prop} {a : α} (h₁ : Subrelation q r) (ac : Acc r a)
Goal: Acc q a
-- Subrelation.wf
theorem wf (h₁ : Subrelation q r) (h₂ : WellFounded r) : WellFounded q 
Arguments: {α : Sort u} {r q : α → α → Prop} (h₁ : Subrelation q r) (h₂ : WellFounded r)
Goal: WellFounded q
-- InvImage.accessible
theorem accessible {a : α} (f : α → β) (ac : Acc r (f a)) : Acc (InvImage r f) a 
Arguments: {α : Sort u} {β : Sort v} {r : β → β → Prop} {a : α} (f : α → β) (ac : Acc r (f a))
Goal: Acc (InvImage r f) a
-- InvImage.wf
theorem wf (f : α → β) (h : WellFounded r) : WellFounded (InvImage r f) 
Arguments: {α : Sort u} {β : Sort v} {r : β → β → Prop} (f : α → β) (h : WellFounded r)
Goal: WellFounded (InvImage r f)
-- TC.accessible
theorem accessible {z : α} (ac : Acc r z) : Acc (TC r) z 
Arguments: {α : Sort u} {r : α → α → Prop} {z : α} (ac : Acc r z)
Goal: Acc (TC r) z
-- TC.wf
theorem wf (h : WellFounded r) : WellFounded (TC r) 
Arguments: {α : Sort u} {r : α → α → Prop} (h : WellFounded r)
Goal: WellFounded (TC r)
-- Prod.lex_def
theorem lex_def (r : α → α → Prop) (s : β → β → Prop) {p q : α × β} :
    Prod.Lex r s p q ↔ r p.1 q.1 ∨ p.1 = q.1 ∧ s p.2 q.2 
Arguments: {α : Type u} {β : Type v} (r : α → α → Prop) (s : β → β → Prop) {p q : α × β}
Goal: Prod.Lex r s p q ↔ r p.fst q.fst ∨ p.fst = q.fst ∧ s p.snd q.snd
-- Prod.Lex.right'
theorem right' {a₁ : Nat} {b₁ : β} (h₁ : a₁ ≤ a₂) (h₂ : rb b₁ b₂) : Prod.Lex Nat.lt rb (a₁, b₁) (a₂, b₂) 
Arguments: {β : Type v} (rb : β → β → Prop) {a₂ : Nat} {b₂ : β} {a₁ : Nat} {b₁ : β} (h₁ : a₁ ≤ a₂) (h₂ : rb b₁ b₂)
Goal: Prod.Lex Nat.lt rb { fst := a₁, snd := b₁ } { fst := a₂, snd := b₂ }
-- Prod.lexAccessible
theorem lexAccessible {a : α} (aca : Acc ra a) (acb : (b : β) → Acc rb b) (b : β) : Acc (Prod.Lex ra rb) (a, b) 
Arguments: {α : Type u} {β : Type v} {ra : α → α → Prop} {rb : β → β → Prop} {a : α} (aca : Acc ra a) (acb : ∀ (b : β), Acc rb b) (b : β)
Goal: Acc (Prod.Lex ra rb) { fst := a, snd := b }
-- PSigma.lexNdepWf
theorem lexNdepWf {r  : α → α → Prop} {s : β → β → Prop} (ha : WellFounded r) (hb : WellFounded s) : WellFounded (lexNdep r s) 
Arguments: {α : Sort u} {β : Sort v} {r : α → α → Prop} {s : β → β → Prop} (ha : WellFounded r) (hb : WellFounded s)
Goal: WellFounded (PSigma.lexNdep r s)
-- PSigma.revLexAccessible
theorem revLexAccessible {b} (acb : Acc s b) (aca : (a : α) → Acc r a): (a : α) → Acc (RevLex r s) ⟨a, b⟩ 
Arguments: {α : Sort u} {β : Sort v} {r : α → α → Prop} {s : β → β → Prop} {b : β} (acb : Acc s b) (aca : ∀ (a : α), Acc r a) (a : α)
Goal: Acc (PSigma.RevLex r s) ⟨a, b⟩
-- PSigma.revLex
theorem revLex (ha : WellFounded r) (hb : WellFounded s) : WellFounded (RevLex r s) 
Arguments: {α : Sort u} {β : Sort v} {r : α → α → Prop} {s : β → β → Prop} (ha : WellFounded r) (hb : WellFounded s)
Goal: WellFounded (PSigma.RevLex r s)
-- PSigma.mkSkipLeft
theorem mkSkipLeft {α : Type u} {β : Type v} {b₁ b₂ : β} {s : β → β → Prop} (a₁ a₂ : α) (h : s b₁ b₂) : SkipLeft α s ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ 
Arguments: {α : Type u} {β : Type v} {b₁ b₂ : β} {s : β → β → Prop} (a₁ a₂ : α) (h : s b₁ b₂)
Goal: PSigma.SkipLeft α s ⟨a₁, b₁⟩ ⟨a₂, b₂⟩
-- monadLift_self
@[simp] theorem monadLift_self {m : Type u → Type v} (x : m α) : monadLift x = x 
Arguments: {α : Type u} {m : Type u → Type v} (x : m α)
Goal: monadLift x = x
-- LawfulFunctor.id_map
class LawfulFunctor (f : Type u → Type v) [Functor f] : Prop where
  map_const          : (Functor.mapConst : α → f β → f α) = Functor.map ∘ const β
  id_map   (x : f α) : id <$> x = x
  comp_map (g : α → β) (h : β → γ) (x : f α) : (h ∘ g) <$> x = h <$> g <$> x
Arguments: {f : Type u → Type v} [Functor f] [self : LawfulFunctor f] {α : Type u} (x : f α)
Goal: id <$> x = x
-- LawfulFunctor.map_const
class LawfulFunctor (f : Type u → Type v) [Functor f] : Prop where
  map_const          : (Functor.mapConst : α → f β → f α) = Functor.map ∘ const β
  id_map   (x : f α) : id <$> x = x
  comp_map (g : α → β) (h : β → γ) (x : f α) : (h ∘ g) <$> x = h <$> g <$> x
Arguments: {f : Type u → Type v} [Functor f] [self : LawfulFunctor f] {α β : Type u}
Goal: Functor.mapConst = Functor.map ∘ Function.const β
-- LawfulFunctor.comp_map
class LawfulFunctor (f : Type u → Type v) [Functor f] : Prop where
  map_const          : (Functor.mapConst : α → f β → f α) = Functor.map ∘ const β
  id_map   (x : f α) : id <$> x = x
  comp_map (g : α → β) (h : β → γ) (x : f α) : (h ∘ g) <$> x = h <$> g <$> x
Arguments: {f : Type u → Type v} [Functor f] [self : LawfulFunctor f] {α β γ : Type u} (g : α → β) (h : β → γ) (x : f α)
Goal: (h ∘ g) <$> x = h <$> g <$> x
-- id_map'
@[simp] theorem id_map' [Functor m] [LawfulFunctor m] (x : m α) : (fun a => a) <$> x = x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} [Functor m] [LawfulFunctor m] (x : m α)
Goal: (fun a => a) <$> x = x
-- LawfulApplicative.seqLeft_eq
class LawfulApplicative (f : Type u → Type v) [Applicative f] extends LawfulFunctor f : Prop where
  seqLeft_eq  (x : f α) (y : f β)     : x <* y = const β <$> x <*> y
  seqRight_eq (x : f α) (y : f β)     : x *> y = const α id <$> x <*> y
  pure_seq    (g : α → β) (x : f α)   : pure g <*> x = g <$> x
  map_pure    (g : α → β) (x : α)     : g <$> (pure x : f α) = pure (g x)
  seq_pure    {α β : Type u} (g : f (α → β)) (x : α) : g <*> pure x = (fun h => h x) <$> g
  seq_assoc   {α β γ : Type u} (x : f α) (g : f (α → β)) (h : f (β → γ)) : h <*> (g <*> x) = ((@comp α β γ) <$> h) <*> g <*> x
  comp_map g h x := (by
    repeat rw [← pure_seq]
    simp [seq_assoc, map_pure, seq_pure])
Arguments: {f : Type u → Type v} [Applicative f] [self : LawfulApplicative f] {α β : Type u} (x : f α) (y : f β)
Goal: (SeqLeft.seqLeft x fun x => y) = Seq.seq (Function.const β <$> x) fun x => y
-- LawfulApplicative.seq_pure
class LawfulApplicative (f : Type u → Type v) [Applicative f] extends LawfulFunctor f : Prop where
  seqLeft_eq  (x : f α) (y : f β)     : x <* y = const β <$> x <*> y
  seqRight_eq (x : f α) (y : f β)     : x *> y = const α id <$> x <*> y
  pure_seq    (g : α → β) (x : f α)   : pure g <*> x = g <$> x
  map_pure    (g : α → β) (x : α)     : g <$> (pure x : f α) = pure (g x)
  seq_pure    {α β : Type u} (g : f (α → β)) (x : α) : g <*> pure x = (fun h => h x) <$> g
  seq_assoc   {α β γ : Type u} (x : f α) (g : f (α → β)) (h : f (β → γ)) : h <*> (g <*> x) = ((@comp α β γ) <$> h) <*> g <*> x
  comp_map g h x := (by
    repeat rw [← pure_seq]
    simp [seq_assoc, map_pure, seq_pure])
Arguments: {f : Type u → Type v} [Applicative f] [self : LawfulApplicative f] {α β : Type u} (g : f (α → β)) (x : α)
Goal: (Seq.seq g fun x_1 => pure x) = (fun h => h x) <$> g