ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LawfulApplicative.seq_assoc
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 α) (g : f (α → β)) (h : f (β → γ))
Goal: (Seq.seq h fun x_1 => Seq.seq g fun x_2 => x) = Seq.seq (Seq.seq (Function.comp <$> h) fun x => g) fun x_1 => x
-- LawfulApplicative.map_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 : α → β) (x : α)
Goal: g <$> pure x = pure (g x)
-- LawfulApplicative.pure_seq
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 : α → β) (x : f α)
Goal: (Seq.seq (pure g) fun x_1 => x) = g <$> x
-- LawfulApplicative.seqRight_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: (SeqRight.seqRight x fun x => y) = Seq.seq (Function.const α id <$> x) fun x => y
-- pure_id_seq
@[simp] theorem pure_id_seq [Applicative f] [LawfulApplicative f] (x : f α) : pure id <*> x = x 
Arguments: {f : Type u_1 → Type u_2} {α : Type u_1} [Applicative f] [LawfulApplicative f] (x : f α)
Goal: (Seq.seq (pure id) fun x_1 => x) = x
-- LawfulMonad.bind_map
class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative m : Prop where
  bind_pure_comp (f : α → β) (x : m α) : x >>= (fun a => pure (f a)) = f <$> x
  bind_map       {α β : Type u} (f : m (α → β)) (x : m α) : f >>= (. <$> x) = f <*> x
  pure_bind      (x : α) (f : α → m β) : pure x >>= f = f x
  bind_assoc     (x : m α) (f : α → m β) (g : β → m γ) : x >>= f >>= g = x >>= fun x => f x >>= g
  map_pure g x    := (by rw [← bind_pure_comp, pure_bind])
  seq_pure g x    := (by rw [← bind_map]; simp [map_pure, bind_pure_comp])
  seq_assoc x g h := (by simp [← bind_pure_comp, ← bind_map, bind_assoc, pure_bind])
Arguments: {m : Type u → Type v} [Monad m] [self : LawfulMonad m] {α β : Type u} (f : m (α → β)) (x : m α)
Goal: (do
    let x_1 ← f
    x_1 <$> x) =
  Seq.seq f fun x_1 => x
-- LawfulMonad.pure_bind
class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative m : Prop where
  bind_pure_comp (f : α → β) (x : m α) : x >>= (fun a => pure (f a)) = f <$> x
  bind_map       {α β : Type u} (f : m (α → β)) (x : m α) : f >>= (. <$> x) = f <*> x
  pure_bind      (x : α) (f : α → m β) : pure x >>= f = f x
  bind_assoc     (x : m α) (f : α → m β) (g : β → m γ) : x >>= f >>= g = x >>= fun x => f x >>= g
  map_pure g x    := (by rw [← bind_pure_comp, pure_bind])
  seq_pure g x    := (by rw [← bind_map]; simp [map_pure, bind_pure_comp])
  seq_assoc x g h := (by simp [← bind_pure_comp, ← bind_map, bind_assoc, pure_bind])
Arguments: {m : Type u → Type v} [Monad m] [self : LawfulMonad m] {α β : Type u} (x : α) (f : α → m β)
Goal: pure x >>= f = f x
-- LawfulMonad.bind_pure_comp
class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative m : Prop where
  bind_pure_comp (f : α → β) (x : m α) : x >>= (fun a => pure (f a)) = f <$> x
  bind_map       {α β : Type u} (f : m (α → β)) (x : m α) : f >>= (. <$> x) = f <*> x
  pure_bind      (x : α) (f : α → m β) : pure x >>= f = f x
  bind_assoc     (x : m α) (f : α → m β) (g : β → m γ) : x >>= f >>= g = x >>= fun x => f x >>= g
  map_pure g x    := (by rw [← bind_pure_comp, pure_bind])
  seq_pure g x    := (by rw [← bind_map]; simp [map_pure, bind_pure_comp])
  seq_assoc x g h := (by simp [← bind_pure_comp, ← bind_map, bind_assoc, pure_bind])
Arguments: {m : Type u → Type v} [Monad m] [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α)
Goal: (do
    let a ← x
    pure (f a)) =
  f <$> x
-- LawfulMonad.bind_assoc
class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative m : Prop where
  bind_pure_comp (f : α → β) (x : m α) : x >>= (fun a => pure (f a)) = f <$> x
  bind_map       {α β : Type u} (f : m (α → β)) (x : m α) : f >>= (. <$> x) = f <*> x
  pure_bind      (x : α) (f : α → m β) : pure x >>= f = f x
  bind_assoc     (x : m α) (f : α → m β) (g : β → m γ) : x >>= f >>= g = x >>= fun x => f x >>= g
  map_pure g x    := (by rw [← bind_pure_comp, pure_bind])
  seq_pure g x    := (by rw [← bind_map]; simp [map_pure, bind_pure_comp])
  seq_assoc x g h := (by simp [← bind_pure_comp, ← bind_map, bind_assoc, pure_bind])
Arguments: {m : Type u → Type v} [Monad m] [self : LawfulMonad m] {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ)
Goal: x >>= f >>= g = x >>= fun x => f x >>= g
-- bind_pure
@[simp] theorem bind_pure [Monad m] [LawfulMonad m] (x : m α) : x >>= pure = x 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [LawfulMonad m] (x : m α)
Goal: x >>= pure = x
-- map_eq_pure_bind
theorem map_eq_pure_bind [Monad m] [LawfulMonad m] (f : α → β) (x : m α) : f <$> x = x >>= fun a => pure (f a) 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Monad m] [LawfulMonad m] (f : α → β) (x : m α)
Goal: f <$> x = do
  let a ← x
  pure (f a)
-- seq_eq_bind_map
theorem seq_eq_bind_map {α β : Type u} [Monad m] [LawfulMonad m] (f : m (α → β)) (x : m α) : f <*> x = f >>= (. <$> x) 
Arguments: {m : Type u → Type u_1} {α β : Type u} [Monad m] [LawfulMonad m] (f : m (α → β)) (x : m α)
Goal: (Seq.seq f fun x_1 => x) = do
  let x_1 ← f
  x_1 <$> x
-- bind_congr
theorem bind_congr [Bind m] {x : m α} {f g : α → m β} (h : ∀ a, f a = g a) : x >>= f = x >>= g 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Bind m] {x : m α} {f g : α → m β} (h : ∀ (a : α), f a = g a)
Goal: x >>= f = x >>= g
-- bind_pure_unit
@[simp] theorem bind_pure_unit [Monad m] [LawfulMonad m] {x : m PUnit} : (x >>= fun _ => pure ⟨⟩) = x 
Arguments: {m : Type u_1 → Type u_2} [Monad m] [LawfulMonad m] {x : m PUnit}
Goal: (do
    x
    pure PUnit.unit) =
  x
-- map_congr
theorem map_congr [Functor m] {x : m α} {f g : α → β} (h : ∀ a, f a = g a) : (f <$> x : m β) = g <$> x 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Functor m] {x : m α} {f g : α → β} (h : ∀ (a : α), f a = g a)
Goal: f <$> x = g <$> x
-- seq_eq_bind
theorem seq_eq_bind {α β : Type u} [Monad m] [LawfulMonad m] (mf : m (α → β)) (x : m α) : mf <*> x = mf >>= fun f => f <$> x 
Arguments: {m : Type u → Type u_1} {α β : Type u} [Monad m] [LawfulMonad m] (mf : m (α → β)) (x : m α)
Goal: (Seq.seq mf fun x_1 => x) = do
  let f ← mf
  f <$> x
-- seqRight_eq_bind
theorem seqRight_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x *> y = x >>= fun _ => y 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (y : m β)
Goal: (SeqRight.seqRight x fun x => y) = do
  let _ ← x
  y
-- seqLeft_eq_bind
theorem seqLeft_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x <* y = x >>= fun a => y >>= fun _ => pure a 
Arguments: {m : Type u_1 → Type u_2} {α β : Type u_1} [Monad m] [LawfulMonad m] (x : m α) (y : m β)
Goal: (SeqLeft.seqLeft x fun x => y) = do
  let a ← x
  let _ ← y
  pure a
-- LawfulMonad.mk'
theorem LawfulMonad.mk' (m : Type u → Type v) [Monad m]
    (id_map : ∀ {α} (x : m α), id <$> x = x)
    (pure_bind : ∀ {α β} (x : α) (f : α → m β), pure x >>= f = f x)
    (bind_assoc : ∀ {α β γ} (x : m α) (f : α → m β) (g : β → m γ),
      x >>= f >>= g = x >>= fun x => f x >>= g)
    (map_const : ∀ {α β} (x : α) (y : m β),
      Functor.mapConst x y = Function.const β x <$> y := by intros; rfl)
    (seqLeft_eq : ∀ {α β} (x : m α) (y : m β),
      x <* y = (x >>= fun a => y >>= fun _ => pure a) := by intros; rfl)
    (seqRight_eq : ∀ {α β} (x : m α) (y : m β), x *> y = (x >>= fun _ => y) := by intros; rfl)
    (bind_pure_comp : ∀ {α β} (f : α → β) (x : m α),
      x >>= (fun y => pure (f y)) = f <$> x := by intros; rfl)
    (bind_map : ∀ {α β} (f : m (α → β)) (x : m α), f >>= (. <$> x) = f <*> x := by intros; rfl)
    : LawfulMonad m 
Arguments: (m : Type u → Type v) [Monad m] (id_map : ∀ {α : Type u} (x : m α), id <$> x = x) (pure_bind : ∀ {α β : Type u} (x : α) (f : α → m β), pure x >>= f = f x) (bind_assoc : ∀ {α β γ : Type u} (x : m α) (f : α → m β) (g : β → m γ), x >>= f >>= g = x >>= fun x => f x >>= g) (map_const : ∀ {α β : Type u} (x : α) (y : m β), Functor.mapConst x y = Function.const β x <$> y := by intros; rfl) (seqLeft_eq :
  ∀ {α β : Type u} (x : m α) (y : m β),
    (SeqLeft.seqLeft x fun x => y) = do
      let a ← x
      let _ ← y
      pure a := by
  intros; rfl) (seqRight_eq :
  ∀ {α β : Type u} (x : m α) (y : m β),
    (SeqRight.seqRight x fun x => y) = do
      let _ ← x
      y := by
  intros; rfl) (bind_pure_comp :
  ∀ {α β : Type u} (f : α → β) (x : m α),
    (do
        let y ← x
        pure (f y)) =
      f <$> x := by
  intros; rfl) (bind_map :
  ∀ {α β : Type u} (f : m (α → β)) (x : m α),
    (do
        let x_1 ← f
        x_1 <$> x) =
      Seq.seq f fun x_1 => x := by
  intros; rfl)
Goal: LawfulMonad m
-- Id.map_eq
@[simp] theorem map_eq (x : Id α) (f : α → β) : f <$> x = f x 
Arguments: {α β : Type u_1} (x : Id α) (f : α → β)
Goal: f <$> x = f x
-- Id.bind_eq
@[simp] theorem bind_eq (x : Id α) (f : α → id β) : x >>= f = f x 
Arguments: {α β : Type u_1} (x : Id α) (f : α → id β)
Goal: x >>= f = f x
-- Id.pure_eq
@[simp] theorem pure_eq (a : α) : (pure a : Id α) = a 
Arguments: {α : Type u_1} (a : α)
Goal: pure a = a
-- Lean.Omega.and_not_not_of_not_or
theorem and_not_not_of_not_or (h : ¬ (p ∨ q)) : ¬ p ∧ ¬ q 
Arguments: {p q : Prop} (h : ¬(p ∨ q))
Goal: ¬p ∧ ¬q
-- Lean.Omega.Decidable.or_not_not_of_not_and
theorem Decidable.or_not_not_of_not_and [Decidable p] [Decidable q]
    (h : ¬ (p ∧ q)) : ¬ p ∨ ¬ q 
Arguments: {p q : Prop} [Decidable p] [Decidable q] (h : ¬(p ∧ q))
Goal: ¬p ∨ ¬q
-- Lean.Omega.Decidable.and_or_not_and_not_of_iff
theorem Decidable.and_or_not_and_not_of_iff {p q : Prop} [Decidable q] (h : p ↔ q) :
    (p ∧ q) ∨ (¬p ∧ ¬q) 
Arguments: {p q : Prop} [Decidable q] (h : p ↔ q)
Goal: p ∧ q ∨ ¬p ∧ ¬q
-- Lean.Omega.Decidable.not_iff_iff_and_not_or_not_and
theorem Decidable.not_iff_iff_and_not_or_not_and [Decidable a] [Decidable b] :
    (¬ (a ↔ b)) ↔ (a ∧ ¬ b) ∨ ((¬ a) ∧ b) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: ¬(a ↔ b) ↔ a ∧ ¬b ∨ ¬a ∧ b
-- Lean.Omega.Decidable.and_not_or_not_and_of_not_iff
theorem Decidable.and_not_or_not_and_of_not_iff [Decidable a] [Decidable b]
    (h : ¬ (a ↔ b)) : a ∧ ¬b ∨ ¬a ∧ b 
Arguments: {a b : Prop} [Decidable a] [Decidable b] (h : ¬(a ↔ b))
Goal: a ∧ ¬b ∨ ¬a ∧ b
-- Lean.Omega.Decidable.and_not_of_not_imp
theorem Decidable.and_not_of_not_imp [Decidable a] (h : ¬(a → b)) : a ∧ ¬b 
Arguments: {a b : Prop} [Decidable a] (h : ¬(a → b))
Goal: a ∧ ¬b
-- Lean.Omega.ite_disjunction
theorem ite_disjunction {α : Type u} {P : Prop} [Decidable P] {a b : α} :
    (P ∧ (if P then a else b) = a) ∨ (¬ P ∧ (if P then a else b) = b) 
Arguments: {α : Type u} {P : Prop} [Decidable P] {a b : α}
Goal: P ∧ (if P then a else b) = a ∨ ¬P ∧ (if P then a else b) = b
-- Lean.Omega.Coeffs.bmod_length
theorem bmod_length (x : Coeffs) (m : Nat) : (bmod x m).length ≤ x.length 
Arguments: (x : Lean.Omega.Coeffs) (m : Nat)
Goal: (x.bmod m).length ≤ x.length
-- Lean.Omega.Coeffs.dvd_bmod_dot_sub_dot_bmod
theorem dvd_bmod_dot_sub_dot_bmod (m : Nat) (xs ys : Coeffs) :
    (m : Int) ∣ bmod_dot_sub_dot_bmod m xs ys 
Arguments: (m : Nat) (xs ys : Lean.Omega.Coeffs)
Goal: ↑m ∣ Lean.Omega.Coeffs.bmod_dot_sub_dot_bmod m xs ys
-- Lean.Omega.Coeffs.get_of_length_le
theorem get_of_length_le {i : Nat} {xs : Coeffs} (h : length xs ≤ i) : get xs i = 0 
Arguments: {i : Nat} {xs : Lean.Omega.Coeffs} (h : xs.length ≤ i)
Goal: xs.get i = 0
-- Lean.Omega.Coeffs.dot_set_left
theorem dot_set_left (xs ys : Coeffs) (i : Nat) (z : Int) :
    dot (set xs i z) ys = dot xs ys + (z - get xs i) * get ys i 
Arguments: (xs ys : Lean.Omega.Coeffs) (i : Nat) (z : Int)
Goal: (xs.set i z).dot ys = xs.dot ys + (z - xs.get i) * ys.get i
-- Lean.Omega.Coeffs.dot_sdiv_left
theorem dot_sdiv_left (xs ys : Coeffs) {d : Int} (h : d ∣ xs.gcd) :
    dot (xs.sdiv d) ys = (dot xs ys) / d 
Arguments: (xs ys : Lean.Omega.Coeffs) {d : Int} (h : d ∣ ↑xs.gcd)
Goal: (xs.sdiv d).dot ys = xs.dot ys / d
-- Lean.Omega.Coeffs.dot_smul_left
theorem dot_smul_left (xs ys : Coeffs) (i : Int) : dot (i * xs) ys = i * dot xs ys 
Arguments: (xs ys : Lean.Omega.Coeffs) (i : Int)
Goal: Lean.Omega.Coeffs.dot (i * xs) ys = i * xs.dot ys
-- Lean.Omega.Coeffs.dot_distrib_left
theorem dot_distrib_left (xs ys zs : Coeffs) : (xs + ys).dot zs = xs.dot zs + ys.dot zs 
Arguments: (xs ys zs : Lean.Omega.Coeffs)
Goal: (xs + ys).dot zs = xs.dot zs + ys.dot zs
-- Lean.Omega.Coeffs.sub_eq_add_neg
theorem sub_eq_add_neg (xs ys : Coeffs) : xs - ys = xs + -ys 
Arguments: (xs ys : Lean.Omega.Coeffs)
Goal: xs - ys = xs + -ys
-- Lean.Omega.Coeffs.combo_eq_smul_add_smul
theorem combo_eq_smul_add_smul (a : Int) (xs : Coeffs) (b : Int) (ys : Coeffs) :
    combo a xs b ys = (a * xs) + (b * ys) 
Arguments: (a : Int) (xs : Lean.Omega.Coeffs) (b : Int) (ys : Lean.Omega.Coeffs)
Goal: Lean.Omega.Coeffs.combo a xs b ys = a * xs + b * ys
-- Lean.Omega.Coeffs.gcd_dvd_dot_left
theorem gcd_dvd_dot_left (xs ys : Coeffs) : (gcd xs : Int) ∣ dot xs ys 
Arguments: (xs ys : Lean.Omega.Coeffs)
Goal: ↑xs.gcd ∣ xs.dot ys
-- Lean.Omega.Coeffs.map_length
theorem map_length {xs : Coeffs} : (xs.map f).length ≤ xs.length 
Arguments: {f : Int → Int} {xs : Lean.Omega.Coeffs}
Goal: (Lean.Omega.Coeffs.map f xs).length ≤ xs.length
-- Lean.Omega.Coeffs.dot_nil_right
theorem dot_nil_right {xs : Coeffs} : dot xs .nil = 0 
Arguments: {xs : Lean.Omega.Coeffs}
Goal: xs.dot [] = 0
-- Lean.Omega.Coeffs.get_nil
theorem get_nil : get .nil i = 0 
Arguments: {i : Nat}
Goal: Lean.Omega.Coeffs.get [] i = 0
-- Lean.Omega.Coeffs.dot_neg_left
theorem dot_neg_left (xs ys : IntList) : dot (-xs) ys = -dot xs ys 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: Lean.Omega.Coeffs.dot (-xs) ys = -Lean.Omega.Coeffs.dot xs ys
-- Lean.Omega.Int.ofNat_pow
theorem ofNat_pow (a b : Nat) : ((a ^ b : Nat) : Int) = (a : Int) ^ b 
Arguments: (a b : Nat)
Goal: ↑(a ^ b) = ↑a ^ b
-- Lean.Omega.Int.pos_pow_of_pos
theorem pos_pow_of_pos (a : Int) (b : Nat) (h : 0 < a) : 0 < a ^ b 
Arguments: (a : Int) (b : Nat) (h : 0 < a)
Goal: 0 < a ^ b
-- Lean.Omega.Int.ofNat_pos
theorem ofNat_pos {a : Nat} : 0 < (a : Int) ↔ 0 < a 
Arguments: {a : Nat}
Goal: 0 < ↑a ↔ 0 < a
-- Lean.Omega.Int.ofNat_pos_of_pos
theorem ofNat_pos_of_pos {a : Nat} (h : 0 < a) : 0 < (a : Int) 
Arguments: {a : Nat} (h : 0 < a)
Goal: 0 < ↑a
-- Lean.Omega.Int.natCast_ofNat
theorem natCast_ofNat {x : Nat} :
    @Nat.cast Int instNatCastInt (no_index (OfNat.ofNat x)) = OfNat.ofNat x 
Arguments: {x : Nat}
Goal: ↑(OfNat.ofNat x) = OfNat.ofNat x
-- Lean.Omega.Int.ofNat_lt_of_lt
theorem ofNat_lt_of_lt {x y : Nat} (h : x < y) : (x : Int) < (y : Int) 
Arguments: {x y : Nat} (h : x < y)
Goal: ↑x < ↑y
-- Lean.Omega.Int.ofNat_le_of_le
theorem ofNat_le_of_le {x y : Nat} (h : x ≤ y) : (x : Int) ≤ (y : Int) 
Arguments: {x y : Nat} (h : x ≤ y)
Goal: ↑x ≤ ↑y
-- Lean.Omega.Int.ofNat_shiftLeft_eq
theorem ofNat_shiftLeft_eq {x y : Nat} : (x <<< y : Int) = (x : Int) * (2 ^ y : Nat) 
Arguments: {x y : Nat}
Goal: ↑(x <<< y) = ↑x * ↑(2 ^ y)
-- Lean.Omega.Int.ofNat_shiftRight_eq_div_pow
theorem ofNat_shiftRight_eq_div_pow {x y : Nat} : (x >>> y : Int) = (x : Int) / (2 ^ y : Nat) 
Arguments: {x y : Nat}
Goal: ↑(x >>> y) = ↑x / ↑(2 ^ y)
-- Lean.Omega.Int.emod_ofNat_nonneg
theorem emod_ofNat_nonneg {x : Nat} {y : Int} : 0 ≤ (x : Int) % y 
Arguments: {x : Nat} {y : Int}
Goal: 0 ≤ ↑x % y
-- Lean.Omega.Int.lt_of_not_ge
theorem lt_of_not_ge {x y : Int} (h : ¬ (x ≤ y)) : y < x 
Arguments: {x y : Int} (h : ¬x ≤ y)
Goal: y < x
-- Lean.Omega.Int.lt_of_not_le
theorem lt_of_not_le {x y : Int} (h : ¬ (x ≤ y)) : y < x 
Arguments: {x y : Int} (h : ¬x ≤ y)
Goal: y < x
-- Lean.Omega.Int.not_le_of_lt
theorem not_le_of_lt {x y : Int} (h : y < x) : ¬ (x ≤ y) 
Arguments: {x y : Int} (h : y < x)
Goal: ¬x ≤ y
-- Lean.Omega.Int.lt_le_asymm
theorem lt_le_asymm {x y : Int} (h₁ : y < x) (h₂ : x ≤ y) : False 
Arguments: {x y : Int} (h₁ : y < x) (h₂ : x ≤ y)
Goal: False
-- Lean.Omega.Int.le_lt_asymm
theorem le_lt_asymm {x y : Int} (h₁ : y ≤ x) (h₂ : x < y) : False 
Arguments: {x y : Int} (h₁ : y ≤ x) (h₂ : x < y)
Goal: False
-- Lean.Omega.Int.le_of_not_gt
theorem le_of_not_gt {x y : Int} (h : ¬ (y > x)) : y ≤ x 
Arguments: {x y : Int} (h : ¬y > x)
Goal: y ≤ x
-- Lean.Omega.Int.not_lt_of_ge
theorem not_lt_of_ge {x y : Int} (h : y ≥ x) : ¬ (y < x) 
Arguments: {x y : Int} (h : y ≥ x)
Goal: ¬y < x
-- Lean.Omega.Int.le_of_not_lt
theorem le_of_not_lt {x y : Int} (h : ¬ (x < y)) : y ≤ x 
Arguments: {x y : Int} (h : ¬x < y)
Goal: y ≤ x
-- Lean.Omega.Int.not_lt_of_le
theorem not_lt_of_le {x y : Int} (h : y ≤ x) : ¬ (x < y) 
Arguments: {x y : Int} (h : y ≤ x)
Goal: ¬x < y
-- Lean.Omega.Int.add_congr
theorem add_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a + c = b + d 
Arguments: {a b c d : Int} (h₁ : a = b) (h₂ : c = d)
Goal: a + c = b + d
-- Lean.Omega.Int.mul_congr
theorem mul_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a * c = b * d 
Arguments: {a b c d : Int} (h₁ : a = b) (h₂ : c = d)
Goal: a * c = b * d
-- Lean.Omega.Int.mul_congr_left
theorem mul_congr_left {a b : Int} (h₁ : a = b)  (c : Int) : a * c = b * c 
Arguments: {a b : Int} (h₁ : a = b) (c : Int)
Goal: a * c = b * c
-- Lean.Omega.Int.sub_congr
theorem sub_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a - c = b - d 
Arguments: {a b c d : Int} (h₁ : a = b) (h₂ : c = d)
Goal: a - c = b - d
-- Lean.Omega.Int.neg_congr
theorem neg_congr {a b : Int} (h₁ : a = b) : -a = -b 
Arguments: {a b : Int} (h₁ : a = b)
Goal: -a = -b
-- Lean.Omega.Int.lt_of_gt
theorem lt_of_gt {x y : Int} (h : x > y) : y < x 
Arguments: {x y : Int} (h : x > y)
Goal: y < x
-- Lean.Omega.Int.le_of_ge
theorem le_of_ge {x y : Int} (h : x ≥ y) : y ≤ x 
Arguments: {x y : Int} (h : x ≥ y)
Goal: y ≤ x
-- Lean.Omega.Int.ofNat_sub_eq_zero
theorem ofNat_sub_eq_zero {b a : Nat} (h : ¬ b ≤ a) : ((a - b : Nat) : Int) = 0 
Arguments: {b a : Nat} (h : ¬b ≤ a)
Goal: ↑(a - b) = 0
-- Lean.Omega.Int.ofNat_sub_dichotomy
theorem ofNat_sub_dichotomy {a b : Nat} :
    b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0 
Arguments: {a b : Nat}
Goal: b ≤ a ∧ ↑(a - b) = ↑a - ↑b ∨ a < b ∧ ↑(a - b) = 0
-- Lean.Omega.Int.ofNat_congr
theorem ofNat_congr {a b : Nat} (h : a = b) : (a : Int) = (b : Int) 
Arguments: {a b : Nat} (h : a = b)
Goal: ↑a = ↑b
-- Lean.Omega.Int.ofNat_sub_sub
theorem ofNat_sub_sub {a b c : Nat} : ((a - b - c : Nat) : Int) = ((a - (b + c) : Nat) : Int) 
Arguments: {a b c : Nat}
Goal: ↑(a - b - c) = ↑(a - (b + c))
-- Lean.Omega.Int.ofNat_min
theorem ofNat_min (a b : Nat) : ((min a b : Nat) : Int) = min (a : Int) (b : Int) 
Arguments: (a b : Nat)
Goal: ↑(min a b) = min ↑a ↑b
-- Lean.Omega.Int.ofNat_max
theorem ofNat_max (a b : Nat) : ((max a b : Nat) : Int) = max (a : Int) (b : Int) 
Arguments: (a b : Nat)
Goal: ↑(max a b) = max ↑a ↑b
-- Lean.Omega.Int.ofNat_natAbs
theorem ofNat_natAbs (a : Int) : (a.natAbs : Int) = if 0 ≤ a then a else -a 
Arguments: (a : Int)
Goal: ↑a.natAbs = if 0 ≤ a then a else -a
-- Lean.Omega.Int.natAbs_dichotomy
theorem natAbs_dichotomy {a : Int} : 0 ≤ a ∧ a.natAbs = a ∨ a < 0 ∧ a.natAbs = -a 
Arguments: {a : Int}
Goal: 0 ≤ a ∧ ↑a.natAbs = a ∨ a < 0 ∧ ↑a.natAbs = -a
-- Lean.Omega.Int.neg_le_natAbs
theorem neg_le_natAbs {a : Int} : -a ≤ a.natAbs 
Arguments: {a : Int}
Goal: -a ≤ ↑a.natAbs
-- Lean.Omega.Int.add_le_iff_le_sub
theorem add_le_iff_le_sub (a b c : Int) : a + b ≤ c ↔ a ≤ c - b 
Arguments: (a b c : Int)
Goal: a + b ≤ c ↔ a ≤ c - b
-- Lean.Omega.Int.le_add_iff_sub_le
theorem le_add_iff_sub_le (a b c : Int) : a ≤ b + c ↔ a - c ≤ b 
Arguments: (a b c : Int)
Goal: a ≤ b + c ↔ a - c ≤ b
-- Lean.Omega.Int.add_le_zero_iff_le_neg
theorem add_le_zero_iff_le_neg (a b : Int) : a + b ≤ 0 ↔ a ≤ - b 
Arguments: (a b : Int)
Goal: a + b ≤ 0 ↔ a ≤ -b
-- Lean.Omega.Int.add_le_zero_iff_le_neg'
theorem add_le_zero_iff_le_neg' (a b : Int) : a + b ≤ 0 ↔ b ≤ -a 
Arguments: (a b : Int)
Goal: a + b ≤ 0 ↔ b ≤ -a
-- Lean.Omega.Int.add_nonnneg_iff_neg_le
theorem add_nonnneg_iff_neg_le (a b : Int) : 0 ≤ a + b ↔ -b ≤ a 
Arguments: (a b : Int)
Goal: 0 ≤ a + b ↔ -b ≤ a
-- Lean.Omega.Int.add_nonnneg_iff_neg_le'
theorem add_nonnneg_iff_neg_le' (a b : Int) : 0 ≤ a + b ↔ -a ≤ b 
Arguments: (a b : Int)
Goal: 0 ≤ a + b ↔ -a ≤ b
-- Lean.Omega.Int.ofNat_fst_mk
theorem ofNat_fst_mk {β} {x : Nat} {y : β} : (Prod.mk x y).fst = (x : Int) 
Arguments: {β : Type u_1} {x : Nat} {y : β}
Goal: ↑(x, y).fst = ↑x
-- Lean.Omega.Int.ofNat_snd_mk
theorem ofNat_snd_mk {α} {x : α} {y : Nat} : (Prod.mk x y).snd = (y : Int) 
Arguments: {α : Type u_1} {x : α} {y : Nat}
Goal: ↑(x, y).snd = ↑y
-- Lean.Omega.Nat.lt_of_gt
theorem lt_of_gt {x y : Nat} (h : x > y) : y < x 
Arguments: {x y : Nat} (h : x > y)
Goal: y < x
-- Lean.Omega.Nat.le_of_ge
theorem le_of_ge {x y : Nat} (h : x ≥ y) : y ≤ x 
Arguments: {x y : Nat} (h : x ≥ y)
Goal: y ≤ x
-- Lean.Omega.Fin.ne_iff_lt_or_gt
theorem ne_iff_lt_or_gt {i j : Fin n} : i ≠ j ↔ i < j ∨ i > j 
Arguments: {n : Nat} {i j : Fin n}
Goal: i ≠ j ↔ i < j ∨ i > j
-- Lean.Omega.Fin.lt_or_gt_of_ne
protected theorem lt_or_gt_of_ne {i j : Fin n} (h : i ≠ j) : i < j ∨ i > j 
Arguments: {n : Nat} {i j : Fin n} (h : i ≠ j)
Goal: i < j ∨ i > j
-- Lean.Omega.Fin.not_le
theorem not_le {i j : Fin n} : ¬ i ≤ j ↔ j < i 
Arguments: {n : Nat} {i j : Fin n}
Goal: ¬i ≤ j ↔ j < i
-- Lean.Omega.Fin.not_lt
theorem not_lt {i j : Fin n} : ¬ i < j ↔ j ≤ i 
Arguments: {n : Nat} {i j : Fin n}
Goal: ¬i < j ↔ j ≤ i
-- Lean.Omega.Fin.lt_of_not_le
protected theorem lt_of_not_le {i j : Fin n} (h : ¬ i ≤ j) : j < i 
Arguments: {n : Nat} {i j : Fin n} (h : ¬i ≤ j)
Goal: j < i
-- Lean.Omega.Fin.le_of_not_lt
protected theorem le_of_not_lt {i j : Fin n} (h : ¬ i < j) : j ≤ i 
Arguments: {n : Nat} {i j : Fin n} (h : ¬i < j)
Goal: j ≤ i