ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FreeAddSemigroup.lift_comp_of'
@[to_additive (attr := simp)]
theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f 
Arguments: {α : Type u} {β : Type v} [AddSemigroup β] (f : AddHom (FreeAddSemigroup α) β)
Goal: FreeAddSemigroup.lift (⇑f ∘ FreeAddSemigroup.of) = f
-- FreeSemigroup.lift_comp_of'
@[to_additive (attr := simp)]
theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f 
Arguments: {α : Type u} {β : Type v} [Semigroup β] (f : FreeSemigroup α →ₙ* β)
Goal: FreeSemigroup.lift (⇑f ∘ FreeSemigroup.of) = f
-- FreeSemigroup.lift_of_mul
@[to_additive]
theorem lift_of_mul (x y) : lift f (of x * y) = f x * lift f y 
Arguments: {α : Type u} {β : Type v} [Semigroup β] (f : α → β) (x : α) (y : FreeSemigroup α)
Goal: (FreeSemigroup.lift f) (FreeSemigroup.of x * y) = f x * (FreeSemigroup.lift f) y
-- FreeAddSemigroup.lift_of_add
@[to_additive]
theorem lift_of_mul (x y) : lift f (of x * y) = f x * lift f y 
Arguments: {α : Type u} {β : Type v} [AddSemigroup β] (f : α → β) (x : α) (y : FreeAddSemigroup α)
Goal: (FreeAddSemigroup.lift f) (FreeAddSemigroup.of x + y) = f x + (FreeAddSemigroup.lift f) y
-- FreeAddSemigroup.map_of
@[to_additive (attr := simp)]
theorem map_of (x) : map f (of x) = of (f x) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : α)
Goal: (FreeAddSemigroup.map f) (FreeAddSemigroup.of x) = FreeAddSemigroup.of (f x)
-- FreeSemigroup.map_of
@[to_additive (attr := simp)]
theorem map_of (x) : map f (of x) = of (f x) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : α)
Goal: (FreeSemigroup.map f) (FreeSemigroup.of x) = FreeSemigroup.of (f x)
-- FreeAddSemigroup.length_map
@[to_additive (attr := simp)]
theorem length_map (x) : (map f x).length = x.length 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : FreeAddSemigroup α)
Goal: ((FreeAddSemigroup.map f) x).length = x.length
-- FreeSemigroup.length_map
@[to_additive (attr := simp)]
theorem length_map (x) : (map f x).length = x.length 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : FreeSemigroup α)
Goal: ((FreeSemigroup.map f) x).length = x.length
-- FreeSemigroup.map_pure
@[to_additive (attr := simp)]
theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeSemigroup β) = pure (f x) 
Arguments: {α β : Type u} (f : α → β) (x : α)
Goal: f <$> pure x = pure (f x)
-- FreeAddSemigroup.map_pure
@[to_additive (attr := simp)]
theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeSemigroup β) = pure (f x) 
Arguments: {α β : Type u} (f : α → β) (x : α)
Goal: f <$> pure x = pure (f x)
-- FreeSemigroup.map_mul'
@[to_additive (attr := simp)]
theorem map_mul' (f : α → β) (x y : FreeSemigroup α) : f <$> (x * y) = f <$> x * f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeSemigroup α)
Goal: f <$> (x * y) = f <$> x * f <$> y
-- FreeAddSemigroup.map_add'
@[to_additive (attr := simp)]
theorem map_mul' (f : α → β) (x y : FreeSemigroup α) : f <$> (x * y) = f <$> x * f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeAddSemigroup α)
Goal: f <$> (x + y) = f <$> x + f <$> y
-- FreeSemigroup.pure_bind
@[to_additive (attr := simp)]
theorem pure_bind (f : α → FreeSemigroup β) (x) : pure x >>= f = f x 
Arguments: {α β : Type u} (f : α → FreeSemigroup β) (x : α)
Goal: pure x >>= f = f x
-- FreeAddSemigroup.pure_bind
@[to_additive (attr := simp)]
theorem pure_bind (f : α → FreeSemigroup β) (x) : pure x >>= f = f x 
Arguments: {α β : Type u} (f : α → FreeAddSemigroup β) (x : α)
Goal: pure x >>= f = f x
-- FreeSemigroup.mul_bind
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
    x * y >>= f = (x >>= f) * (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeSemigroup β) (x y : FreeSemigroup α)
Goal: x * y >>= f = (x >>= f) * (y >>= f)
-- FreeAddSemigroup.add_bind
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
    x * y >>= f = (x >>= f) * (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeAddSemigroup β) (x y : FreeAddSemigroup α)
Goal: x + y >>= f = (x >>= f) + (y >>= f)
-- FreeAddSemigroup.pure_seq
@[to_additive (attr := simp)]
theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x 
Arguments: {α β : Type u} {f : α → β} {x : FreeAddSemigroup α}
Goal: (Seq.seq (pure f) fun x_1 => x) = f <$> x
-- FreeSemigroup.pure_seq
@[to_additive (attr := simp)]
theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x 
Arguments: {α β : Type u} {f : α → β} {x : FreeSemigroup α}
Goal: (Seq.seq (pure f) fun x_1 => x) = f <$> x
-- FreeSemigroup.mul_seq
@[to_additive (attr := simp)]
theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
    f * g <*> x = (f <*> x) * (g <*> x) 
Arguments: {α β : Type u} {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α}
Goal: (Seq.seq (f * g) fun x_1 => x) = (Seq.seq f fun x_1 => x) * Seq.seq g fun x_1 => x
-- FreeAddSemigroup.add_seq
@[to_additive (attr := simp)]
theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
    f * g <*> x = (f <*> x) * (g <*> x) 
Arguments: {α β : Type u} {f g : FreeAddSemigroup (α → β)} {x : FreeAddSemigroup α}
Goal: (Seq.seq (f + g) fun x_1 => x) = (Seq.seq f fun x_1 => x) + Seq.seq g fun x_1 => x
-- FreeAddSemigroup.traverse_pure
@[to_additive (attr := simp)]
theorem traverse_pure (x) : traverse F (pure x : FreeSemigroup α) = pure <$> F x 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) (x : α)
Goal: traverse F (pure x) = pure <$> F x
-- FreeSemigroup.traverse_pure
@[to_additive (attr := simp)]
theorem traverse_pure (x) : traverse F (pure x : FreeSemigroup α) = pure <$> F x 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) (x : α)
Goal: traverse F (pure x) = pure <$> F x
-- FreeAddSemigroup.traverse_pure'
@[to_additive (attr := simp)]
theorem traverse_pure' : traverse F ∘ pure = fun x ↦ (pure <$> F x : m (FreeSemigroup β)) 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β)
Goal: traverse F ∘ pure = fun x => pure <$> F x
-- FreeSemigroup.traverse_pure'
@[to_additive (attr := simp)]
theorem traverse_pure' : traverse F ∘ pure = fun x ↦ (pure <$> F x : m (FreeSemigroup β)) 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β)
Goal: traverse F ∘ pure = fun x => pure <$> F x
-- FreeAddSemigroup.traverse_add
@[to_additive (attr := simp)]
theorem traverse_mul (x y : FreeSemigroup α) :
    traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) [LawfulApplicative m] (x y : FreeAddSemigroup α)
Goal: traverse F (x + y) = Seq.seq ((fun x x_1 => x + x_1) <$> traverse F x) fun x => traverse F y
-- FreeSemigroup.traverse_mul
@[to_additive (attr := simp)]
theorem traverse_mul (x y : FreeSemigroup α) :
    traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) [LawfulApplicative m] (x y : FreeSemigroup α)
Goal: traverse F (x * y) = Seq.seq ((fun x x_1 => x * x_1) <$> traverse F x) fun x => traverse F y
-- FreeAddSemigroup.traverse_add'
@[to_additive (attr := simp)]
theorem traverse_mul' :
    Function.comp (traverse F) ∘ (HMul.hMul : FreeSemigroup α → FreeSemigroup α → FreeSemigroup α) =
      fun x y ↦ (· * ·) <$> traverse F x <*> traverse F y 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) [LawfulApplicative m]
Goal: Function.comp (traverse F) ∘ HAdd.hAdd = fun x y =>
  Seq.seq ((fun x x_1 => x + x_1) <$> traverse F x) fun x => traverse F y
-- FreeSemigroup.traverse_mul'
@[to_additive (attr := simp)]
theorem traverse_mul' :
    Function.comp (traverse F) ∘ (HMul.hMul : FreeSemigroup α → FreeSemigroup α → FreeSemigroup α) =
      fun x y ↦ (· * ·) <$> traverse F x <*> traverse F y 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) [LawfulApplicative m]
Goal: Function.comp (traverse F) ∘ HMul.hMul = fun x y =>
  Seq.seq ((fun x x_1 => x * x_1) <$> traverse F x) fun x => traverse F y
-- FreeSemigroup.traverse_eq
@[to_additive (attr := simp)]
theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) (x : FreeSemigroup α)
Goal: FreeSemigroup.traverse F x = traverse F x
-- FreeAddSemigroup.traverse_eq
@[to_additive (attr := simp)]
theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x 
Arguments: {α β : Type u} {m : Type u → Type u} [Applicative m] (F : α → m β) (x : FreeAddSemigroup α)
Goal: FreeAddSemigroup.traverse F x = traverse F x
-- FreeAddSemigroup.add_map_seq
@[to_additive (attr := simp, nolint simpNF)]
theorem mul_map_seq (x y : FreeSemigroup α) :
    ((· * ·) <$> x <*> y : Id (FreeSemigroup α)) = (x * y : FreeSemigroup α) 
Arguments: {α : Type u} (x y : FreeAddSemigroup α)
Goal: (Seq.seq ((fun x x_1 => x + x_1) <$> x) fun x => y) = x + y
-- FreeSemigroup.mul_map_seq
@[to_additive (attr := simp, nolint simpNF)]
theorem mul_map_seq (x y : FreeSemigroup α) :
    ((· * ·) <$> x <*> y : Id (FreeSemigroup α)) = (x * y : FreeSemigroup α) 
Arguments: {α : Type u} (x y : FreeSemigroup α)
Goal: (Seq.seq ((fun x x_1 => x * x_1) <$> x) fun x => y) = x * y
-- FreeMagma.toFreeSemigroup_of
@[to_additive (attr := simp)]
theorem toFreeSemigroup_of (x : α) : toFreeSemigroup (of x) = FreeSemigroup.of x 
Arguments: {α : Type u} (x : α)
Goal: FreeMagma.toFreeSemigroup (FreeMagma.of x) = FreeSemigroup.of x
-- FreeAddMagma.toFreeAddSemigroup_of
@[to_additive (attr := simp)]
theorem toFreeSemigroup_of (x : α) : toFreeSemigroup (of x) = FreeSemigroup.of x 
Arguments: {α : Type u} (x : α)
Goal: FreeAddMagma.toFreeAddSemigroup (FreeAddMagma.of x) = FreeAddSemigroup.of x
-- FreeMagma.toFreeSemigroup_comp_of
@[to_additive (attr := simp)]
theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of 
Arguments: {α : Type u}
Goal: ⇑FreeMagma.toFreeSemigroup ∘ FreeMagma.of = FreeSemigroup.of
-- FreeAddMagma.toFreeAddSemigroup_comp_of
@[to_additive (attr := simp)]
theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of 
Arguments: {α : Type u}
Goal: ⇑FreeAddMagma.toFreeAddSemigroup ∘ FreeAddMagma.of = FreeAddSemigroup.of
-- FreeMagma.toFreeSemigroup_comp_map
@[to_additive]
theorem toFreeSemigroup_comp_map (f : α → β) :
    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup 
Arguments: {α : Type u} {β : Type v} (f : α → β)
Goal: FreeMagma.toFreeSemigroup.comp (FreeMagma.map f) = (FreeSemigroup.map f).comp FreeMagma.toFreeSemigroup
-- FreeAddMagma.toFreeAddSemigroup_comp_map
@[to_additive]
theorem toFreeSemigroup_comp_map (f : α → β) :
    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup 
Arguments: {α : Type u} {β : Type v} (f : α → β)
Goal: FreeAddMagma.toFreeAddSemigroup.comp (FreeAddMagma.map f) =
  (FreeAddSemigroup.map f).comp FreeAddMagma.toFreeAddSemigroup
-- FreeAddMagma.toFreeAddSemigroup_map
@[to_additive]
theorem toFreeSemigroup_map (f : α → β) (x : FreeMagma α) :
    toFreeSemigroup (map f x) = FreeSemigroup.map f (toFreeSemigroup x) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : FreeAddMagma α)
Goal: FreeAddMagma.toFreeAddSemigroup ((FreeAddMagma.map f) x) = (FreeAddSemigroup.map f) (FreeAddMagma.toFreeAddSemigroup x)
-- FreeMagma.toFreeSemigroup_map
@[to_additive]
theorem toFreeSemigroup_map (f : α → β) (x : FreeMagma α) :
    toFreeSemigroup (map f x) = FreeSemigroup.map f (toFreeSemigroup x) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (x : FreeMagma α)
Goal: FreeMagma.toFreeSemigroup ((FreeMagma.map f) x) = (FreeSemigroup.map f) (FreeMagma.toFreeSemigroup x)
-- FreeAddMagma.length_toFreeAddSemigroup
@[to_additive (attr := simp)]
theorem length_toFreeSemigroup (x : FreeMagma α) : (toFreeSemigroup x).length = x.length 
Arguments: {α : Type u} (x : FreeAddMagma α)
Goal: (FreeAddMagma.toFreeAddSemigroup x).length = x.length
-- FreeMagma.length_toFreeSemigroup
@[to_additive (attr := simp)]
theorem length_toFreeSemigroup (x : FreeMagma α) : (toFreeSemigroup x).length = x.length 
Arguments: {α : Type u} (x : FreeMagma α)
Goal: (FreeMagma.toFreeSemigroup x).length = x.length
-- Thunk.get_pure
@[simp] theorem get_pure {α} (x : α) : (Thunk.pure x).get = x 
Arguments: {α : Type u_1} (x : α)
Goal: (Thunk.pure x).get = x
-- Thunk.get_mk
@[simp] theorem get_mk {α} (f : Unit → α) : (Thunk.mk f).get = f () 
Arguments: {α : Type u_1} (f : Unit → α)
Goal: { fn := f }.get = f ()
-- Thunk.prod_get_fst
@[simp] theorem prod_get_fst {a : Thunk α} {b : Thunk β} : (prod a b).get.1 = a.get 
Arguments: {α : Type u} {β : Type v} {a : Thunk α} {b : Thunk β}
Goal: (a.prod b).get.fst = a.get
-- Thunk.prod_get_snd
@[simp] theorem prod_get_snd {a : Thunk α} {b : Thunk β} : (prod a b).get.2 = b.get 
Arguments: {α : Type u} {β : Type v} {a : Thunk α} {b : Thunk β}
Goal: (a.prod b).get.snd = b.get
-- Thunk.add_get
@[simp] theorem add_get [Add α] {a b : Thunk α} : (a + b).get = a.get + b.get 
Arguments: {α : Type u} [Add α] {a b : Thunk α}
Goal: (a + b).get = a.get + b.get
-- IsSemiringHom.map_add
structure IsSemiringHom {α : Type u} {β : Type v} [Semiring α] [Semiring β] (f : α → β) : Prop where
    map_zero : f 0 = 0
    map_one : f 1 = 1
    map_add : ∀ x y, f (x + y) = f x + f y
    map_mul : ∀ x y, f (x * y) = f x * f y
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (self : IsSemiringHom f) (x y : α)
Goal: f (x + y) = f x + f y
-- IsSemiringHom.map_mul
structure IsSemiringHom {α : Type u} {β : Type v} [Semiring α] [Semiring β] (f : α → β) : Prop where
    map_zero : f 0 = 0
    map_one : f 1 = 1
    map_add : ∀ x y, f (x + y) = f x + f y
    map_mul : ∀ x y, f (x * y) = f x * f y
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (self : IsSemiringHom f) (x y : α)
Goal: f (x * y) = f x * f y
-- IsSemiringHom.map_one
structure IsSemiringHom {α : Type u} {β : Type v} [Semiring α] [Semiring β] (f : α → β) : Prop where
    map_zero : f 0 = 0
    map_one : f 1 = 1
    map_add : ∀ x y, f (x + y) = f x + f y
    map_mul : ∀ x y, f (x * y) = f x * f y
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (self : IsSemiringHom f)
Goal: f 1 = 1
-- IsSemiringHom.map_zero
structure IsSemiringHom {α : Type u} {β : Type v} [Semiring α] [Semiring β] (f : α → β) : Prop where
    map_zero : f 0 = 0
    map_one : f 1 = 1
    map_add : ∀ x y, f (x + y) = f x + f y
    map_mul : ∀ x y, f (x * y) = f x * f y
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (self : IsSemiringHom f)
Goal: f 0 = 0
-- IsSemiringHom.id
theorem id : IsSemiringHom (@id α) 
Arguments: {α : Type u} [Semiring α]
Goal: IsSemiringHom id
-- IsSemiringHom.comp
theorem comp (hf : IsSemiringHom f) {γ} [Semiring γ] {g : β → γ} (hg : IsSemiringHom g) :
    IsSemiringHom (g ∘ f) 
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (hf : IsSemiringHom f) {γ : Type u_1} [Semiring γ] {g : β → γ} (hg : IsSemiringHom g)
Goal: IsSemiringHom (g ∘ f)
-- IsSemiringHom.to_isAddMonoidHom
theorem to_isAddMonoidHom (hf : IsSemiringHom f) : IsAddMonoidHom f 
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (hf : IsSemiringHom f)
Goal: IsAddMonoidHom f
-- IsSemiringHom.to_isMonoidHom
theorem to_isMonoidHom (hf : IsSemiringHom f) : IsMonoidHom f 
Arguments: {α : Type u} {β : Type v} [Semiring α] [Semiring β] {f : α → β} (hf : IsSemiringHom f)
Goal: IsMonoidHom f
-- IsRingHom.map_mul
structure IsRingHom {α : Type u} {β : Type v} [Ring α] [Ring β] (f : α → β) : Prop where
    map_one : f 1 = 1
    map_mul : ∀ x y, f (x * y) = f x * f y
    map_add : ∀ x y, f (x + y) = f x + f y
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (self : IsRingHom f) (x y : α)
Goal: f (x * y) = f x * f y
-- IsRingHom.map_add
structure IsRingHom {α : Type u} {β : Type v} [Ring α] [Ring β] (f : α → β) : Prop where
    map_one : f 1 = 1
    map_mul : ∀ x y, f (x * y) = f x * f y
    map_add : ∀ x y, f (x + y) = f x + f y
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (self : IsRingHom f) (x y : α)
Goal: f (x + y) = f x + f y
-- IsRingHom.map_one
structure IsRingHom {α : Type u} {β : Type v} [Ring α] [Ring β] (f : α → β) : Prop where
    map_one : f 1 = 1
    map_mul : ∀ x y, f (x * y) = f x * f y
    map_add : ∀ x y, f (x + y) = f x + f y
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (self : IsRingHom f)
Goal: f 1 = 1
-- IsRingHom.of_semiring
theorem of_semiring {f : α → β} (H : IsSemiringHom f) : IsRingHom f 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (H : IsSemiringHom f)
Goal: IsRingHom f
-- IsRingHom.map_zero
theorem map_zero (hf : IsRingHom f) : f 0 = 0 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (hf : IsRingHom f)
Goal: f 0 = 0
-- IsRingHom.map_neg
theorem map_neg (hf : IsRingHom f) : f (-x) = -f x 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} {x : α} (hf : IsRingHom f)
Goal: f (-x) = -f x
-- IsRingHom.map_sub
theorem map_sub (hf : IsRingHom f) : f (x - y) = f x - f y 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} {x y : α} (hf : IsRingHom f)
Goal: f (x - y) = f x - f y
-- IsRingHom.id
theorem id : IsRingHom (@id α) 
Arguments: {α : Type u} [Ring α]
Goal: IsRingHom id
-- IsRingHom.comp
theorem comp (hf : IsRingHom f) {γ} [Ring γ] {g : β → γ} (hg : IsRingHom g) : IsRingHom (g ∘ f) 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (hf : IsRingHom f) {γ : Type u_1} [Ring γ] {g : β → γ} (hg : IsRingHom g)
Goal: IsRingHom (g ∘ f)
-- IsRingHom.to_isSemiringHom
theorem to_isSemiringHom (hf : IsRingHom f) : IsSemiringHom f 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (hf : IsRingHom f)
Goal: IsSemiringHom f
-- IsRingHom.to_isAddGroupHom
theorem to_isAddGroupHom (hf : IsRingHom f) : IsAddGroupHom f 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] {f : α → β} (hf : IsRingHom f)
Goal: IsAddGroupHom f
-- RingHom.coe_of
@[simp]
theorem coe_of {f : α → β} (hf : IsSemiringHom f) : ⇑(of hf) = f 
Arguments: {α : Type u} {β : Type v} {rα : Semiring α} {rβ : Semiring β} {f : α → β} (hf : IsSemiringHom f)
Goal: ⇑(RingHom.of hf) = f
-- RingHom.to_isSemiringHom
theorem to_isSemiringHom (f : α →+* β) : IsSemiringHom f 
Arguments: {α : Type u} {β : Type v} {rα : Semiring α} {rβ : Semiring β} (f : α →+* β)
Goal: IsSemiringHom ⇑f
-- RingHom.to_isRingHom
theorem to_isRingHom {α γ} [Ring α] [Ring γ] (g : α →+* γ) : IsRingHom g 
Arguments: {α : Type u_1} {γ : Type u_2} [Ring α] [Ring γ] (g : α →+* γ)
Goal: IsRingHom ⇑g
-- Lean.Meta.FastSubsingleton.inst
class FastSubsingleton (α : Sort u) : Prop where
    [inst : Subsingleton α]
Arguments: {α : Sort u} [self : Lean.Meta.FastSubsingleton α]
Goal: Subsingleton α
-- Lean.Meta.FastIsEmpty.inst
class FastIsEmpty (α : Sort u) : Prop where
  [inst : IsEmpty α]
Arguments: {α : Sort u} [self : Lean.Meta.FastIsEmpty α]
Goal: IsEmpty α
-- Lean.Meta.FastSubsingleton.elim
protected theorem FastSubsingleton.elim {α : Sort u} [h : FastSubsingleton α] : (a b : α) → a = b 
Arguments: {α : Sort u} [h : Lean.Meta.FastSubsingleton α] (a b : α)
Goal: a = b
-- IsSubfield.inv_mem
structure IsSubfield extends IsSubring S : Prop where
  inv_mem : ∀ {x : F}, x ∈ S → x⁻¹ ∈ S
Arguments: {F : Type u_1} [Field F] {S : Set F} (self : IsSubfield S) {x : F}
Goal: x ∈ S → x⁻¹ ∈ S
-- IsSubfield.div_mem
theorem IsSubfield.div_mem {S : Set F} (hS : IsSubfield S) {x y : F} (hx : x ∈ S) (hy : y ∈ S) :
    x / y ∈ S 
Arguments: {F : Type u_1} [Field F] {S : Set F} (hS : IsSubfield S) {x y : F} (hx : x ∈ S) (hy : y ∈ S)
Goal: x / y ∈ S
-- IsSubfield.pow_mem
theorem IsSubfield.pow_mem {a : F} {n : ℤ} {s : Set F} (hs : IsSubfield s) (h : a ∈ s) :
    a ^ n ∈ s 
Arguments: {F : Type u_1} [Field F] {a : F} {n : ℤ} {s : Set F} (hs : IsSubfield s) (h : a ∈ s)
Goal: a ^ n ∈ s
-- Univ.isSubfield
theorem Univ.isSubfield : IsSubfield (@Set.univ F) 
Arguments: {F : Type u_1} [Field F]
Goal: IsSubfield Set.univ
-- Preimage.isSubfield
theorem Preimage.isSubfield {K : Type*} [Field K] (f : F →+* K) {s : Set K} (hs : IsSubfield s) :
    IsSubfield (f ⁻¹' s) 
Arguments: {F : Type u_1} [Field F] {K : Type u_2} [Field K] (f : F →+* K) {s : Set K} (hs : IsSubfield s)
Goal: IsSubfield (⇑f ⁻¹' s)
-- Image.isSubfield
theorem Image.isSubfield {K : Type*} [Field K] (f : F →+* K) {s : Set F} (hs : IsSubfield s) :
    IsSubfield (f '' s) 
Arguments: {F : Type u_1} [Field F] {K : Type u_2} [Field K] (f : F →+* K) {s : Set F} (hs : IsSubfield s)
Goal: IsSubfield (⇑f '' s)
-- Range.isSubfield
theorem Range.isSubfield {K : Type*} [Field K] (f : F →+* K) : IsSubfield (Set.range f) 
Arguments: {F : Type u_1} [Field F] {K : Type u_2} [Field K] (f : F →+* K)
Goal: IsSubfield (Set.range ⇑f)
-- Field.ring_closure_subset
theorem ring_closure_subset : Ring.closure S ⊆ closure S 
Arguments: {F : Type u_1} [Field F] {S : Set F}
Goal: Ring.closure S ⊆ Field.closure S
-- Field.closure.isSubmonoid
theorem closure.isSubmonoid : IsSubmonoid (closure S) 
Arguments: {F : Type u_1} [Field F] {S : Set F}
Goal: IsSubmonoid (Field.closure S)
-- Field.closure.isSubfield
theorem closure.isSubfield : IsSubfield (closure S) 
Arguments: {F : Type u_1} [Field F] {S : Set F}
Goal: IsSubfield (Field.closure S)
-- Field.mem_closure
theorem mem_closure {a : F} (ha : a ∈ S) : a ∈ closure S 
Arguments: {F : Type u_1} [Field F] {S : Set F} {a : F} (ha : a ∈ S)
Goal: a ∈ Field.closure S
-- Field.subset_closure
theorem subset_closure : S ⊆ closure S 
Arguments: {F : Type u_1} [Field F] {S : Set F}
Goal: S ⊆ Field.closure S
-- Field.closure_subset
theorem closure_subset {T : Set F} (hT : IsSubfield T) (H : S ⊆ T) : closure S ⊆ T 
Arguments: {F : Type u_1} [Field F] {S T : Set F} (hT : IsSubfield T) (H : S ⊆ T)
Goal: Field.closure S ⊆ T
-- Field.closure_subset_iff
theorem closure_subset_iff {s t : Set F} (ht : IsSubfield t) : closure s ⊆ t ↔ s ⊆ t 
Arguments: {F : Type u_1} [Field F] {s t : Set F} (ht : IsSubfield t)
Goal: Field.closure s ⊆ t ↔ s ⊆ t
-- Field.closure_mono
theorem closure_mono {s t : Set F} (H : s ⊆ t) : closure s ⊆ closure t 
Arguments: {F : Type u_1} [Field F] {s t : Set F} (H : s ⊆ t)
Goal: Field.closure s ⊆ Field.closure t
-- isSubfield_iUnion_of_directed
theorem isSubfield_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set F}
    (hs : ∀ i, IsSubfield (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubfield (⋃ i, s i) 
Arguments: {F : Type u_1} [Field F] {ι : Type u_2} [Nonempty ι] {s : ι → Set F} (hs : ∀ (i : ι), IsSubfield (s i)) (directed : ∀ (i j : ι), ∃ k, s i ⊆ s k ∧ s j ⊆ s k)
Goal: IsSubfield (⋃ i, s i)
-- IsSubfield.inter
theorem IsSubfield.inter {S₁ S₂ : Set F} (hS₁ : IsSubfield S₁) (hS₂ : IsSubfield S₂) :
    IsSubfield (S₁ ∩ S₂) 
Arguments: {F : Type u_1} [Field F] {S₁ S₂ : Set F} (hS₁ : IsSubfield S₁) (hS₂ : IsSubfield S₂)
Goal: IsSubfield (S₁ ∩ S₂)
-- IsSubfield.iInter
theorem IsSubfield.iInter {ι : Sort*} {S : ι → Set F} (h : ∀ y : ι, IsSubfield (S y)) :
    IsSubfield (Set.iInter S) 
Arguments: {F : Type u_1} [Field F] {ι : Sort u_2} {S : ι → Set F} (h : ∀ (y : ι), IsSubfield (S y))
Goal: IsSubfield (Set.iInter S)
-- IsAddHom.map_add
structure IsAddHom {α β : Type*} [Add α] [Add β] (f : α → β) : Prop where
    map_add : ∀ x y, f (x + y) = f x + f y
Arguments: {α : Type u_1} {β : Type u_2} [Add α] [Add β] {f : α → β} (self : IsAddHom f) (x y : α)
Goal: f (x + y) = f x + f y
-- IsMulHom.map_mul
@[to_additive]
structure IsMulHom {α β : Type*} [Mul α] [Mul β] (f : α → β) : Prop where
    map_mul : ∀ x y, f (x * y) = f x * f y
Arguments: {α : Type u_1} {β : Type u_2} [Mul α] [Mul β] {f : α → β} (self : IsMulHom f) (x y : α)
Goal: f (x * y) = f x * f y
-- IsAddHom.id
@[to_additive "The identity map preserves addition"]
theorem id : IsMulHom (id : α → α) 
Arguments: {α : Type u} [Add α]
Goal: IsAddHom id
-- IsMulHom.id
@[to_additive "The identity map preserves addition"]
theorem id : IsMulHom (id : α → α) 
Arguments: {α : Type u} [Mul α]
Goal: IsMulHom id