ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Monoidal/Internal/Types.lean

full_name: MonTypeEquivalenceMon.monMonoid
code: instance monMonoid (A : Mon_ (Type u)) : Monoid A.X 
goal: Monoid A.X

full_name: MonTypeEquivalenceMon.functor
code: /-- Converting a monoid object in `Type` to a bundled monoid.
-/
noncomputable def functor : Mon_ (Type u) ⥤ MonCat.{u} 
goal: Mon_ (Type u) ⥤ MonCat

full_name: MonTypeEquivalenceMon.inverse
code: /-- Converting a bundled monoid to a monoid object in `Type`.
-/
noncomputable def inverse : MonCat.{u} ⥤ Mon_ (Type u) 
goal: MonCat ⥤ Mon_ (Type u)

full_name: monTypeEquivalenceMon
code: /-- The category of internal monoid objects in `Type`
is equivalent to the category of "native" bundled monoids.
-/
noncomputable def monTypeEquivalenceMon : Mon_ (Type u) ≌ MonCat.{u} 
goal: Mon_ (Type u) ≌ MonCat

full_name: monTypeEquivalenceMonForget
code: /-- The equivalence `Mon_ (Type u) ≌ MonCat.{u}`
is naturally compatible with the forgetful functors to `Type u`.
-/
noncomputable def monTypeEquivalenceMonForget :
    MonTypeEquivalenceMon.functor ⋙ forget MonCat ≅ Mon_.forget (Type u) 
goal: MonTypeEquivalenceMon.functor ⋙ CategoryTheory.forget MonCat ≅ Mon_.forget (Type u)

full_name: monTypeInhabited
code: noncomputable instance monTypeInhabited : Inhabited (Mon_ (Type u)) 
goal: Inhabited (Mon_ (Type u))

full_name: CommMonTypeEquivalenceCommMon.commMonCommMonoid
code: instance commMonCommMonoid (A : CommMon_ (Type u)) : CommMonoid A.X 
goal: CommMonoid A.X

full_name: CommMonTypeEquivalenceCommMon.functor
code: /-- Converting a commutative monoid object in `Type` to a bundled commutative monoid.
-/
noncomputable def functor : CommMon_ (Type u) ⥤ CommMonCat.{u} 
goal: CommMon_ (Type u) ⥤ CommMonCat

full_name: CommMonTypeEquivalenceCommMon.inverse
code: /-- Converting a bundled commutative monoid to a commutative monoid object in `Type`.
-/
noncomputable def inverse : CommMonCat.{u} ⥤ CommMon_ (Type u) 
goal: CommMonCat ⥤ CommMon_ (Type u)

full_name: commMonTypeEquivalenceCommMon
code: /-- The category of internal commutative monoid objects in `Type`
is equivalent to the category of "native" bundled commutative monoids.
-/
noncomputable def commMonTypeEquivalenceCommMon : CommMon_ (Type u) ≌ CommMonCat.{u} 
goal: CommMon_ (Type u) ≌ CommMonCat

full_name: commMonTypeEquivalenceCommMonForget
code: /-- The equivalences `Mon_ (Type u) ≌ MonCat.{u}` and `CommMon_ (Type u) ≌ CommMonCat.{u}`
are naturally compatible with the forgetful functors to `MonCat` and `Mon_ (Type u)`.
-/
noncomputable def commMonTypeEquivalenceCommMonForget :
    CommMonTypeEquivalenceCommMon.functor ⋙ forget₂ CommMonCat MonCat ≅
      CommMon_.forget₂Mon_ (Type u) ⋙ MonTypeEquivalenceMon.functor 
goal: CommMonTypeEquivalenceCommMon.functor ⋙ CategoryTheory.forget₂ CommMonCat MonCat ≅
  CommMon_.forget₂Mon_ (Type u) ⋙ MonTypeEquivalenceMon.functor

full_name: commMonTypeInhabited
code: noncomputable instance commMonTypeInhabited : Inhabited (CommMon_ (Type u)) 
goal: Inhabited (CommMon_ (Type u))
File: Mathlib/CategoryTheory/Balanced.lean

full_name: CategoryTheory.Balanced
code: /-- A category is called balanced if any morphism that is both monic and epic is an isomorphism. -/
class Balanced : Prop where
  isIso_of_mono_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f], IsIso f
goal: Prop

full_name: CategoryTheory.Balanced.isIso_of_mono_of_epi
code: /-- A category is called balanced if any morphism that is both monic and epic is an isomorphism. -/
class Balanced : Prop where
  isIso_of_mono_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f], IsIso f
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.isIso_of_mono_of_epi
code: theorem isIso_of_mono_of_epi [Balanced C] {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f] : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.isIso_iff_mono_and_epi
code: theorem isIso_iff_mono_and_epi [Balanced C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ Mono f ∧ Epi f 
goal: CategoryTheory.IsIso f ↔ CategoryTheory.Mono f ∧ CategoryTheory.Epi f

full_name: CategoryTheory.balanced_opposite
code: theorem balanced_opposite [Balanced C] : Balanced Cᵒᵖ 
goal: CategoryTheory.Balanced Cᵒᵖ
File: Mathlib/CategoryTheory/Bicategory/End.lean

full_name: CategoryTheory.EndMonoidal
code: /-- The endomorphisms of an object in a bicategory can be considered as a monoidal category. -/
def EndMonoidal (X : C) 
goal: Type u_3

full_name: CategoryTheory.instCategoryEndMonoidal
code: instance (X : C) : Category (EndMonoidal X) 
goal: CategoryTheory.Category.{u_2, u_3} (CategoryTheory.EndMonoidal X)

full_name: CategoryTheory.instInhabitedEndMonoidal
code: instance (X : C) : Inhabited (EndMonoidal X) 
goal: Inhabited (CategoryTheory.EndMonoidal X)

full_name: CategoryTheory.instMonoidalCategoryEndMonoidal
code: instance (X : C) : MonoidalCategory (EndMonoidal X) 
goal: CategoryTheory.MonoidalCategory (CategoryTheory.EndMonoidal X)
File: Mathlib/CategoryTheory/Monoidal/Rigid/FunctorCategory.lean

full_name: CategoryTheory.Monoidal.functorHasRightDual
code: instance functorHasRightDual [RightRigidCategory D] (F : C ⥤ D) : HasRightDual F 
goal: CategoryTheory.HasRightDual F

full_name: CategoryTheory.Monoidal.rightRigidFunctorCategory
code: instance rightRigidFunctorCategory [RightRigidCategory D] : RightRigidCategory (C ⥤ D) 
goal: CategoryTheory.RightRigidCategory (C ⥤ D)

full_name: CategoryTheory.Monoidal.functorHasLeftDual
code: instance functorHasLeftDual [LeftRigidCategory D] (F : C ⥤ D) : HasLeftDual F 
goal: CategoryTheory.HasLeftDual F

full_name: CategoryTheory.Monoidal.leftRigidFunctorCategory
code: instance leftRigidFunctorCategory [LeftRigidCategory D] : LeftRigidCategory (C ⥤ D) 
goal: CategoryTheory.LeftRigidCategory (C ⥤ D)

full_name: CategoryTheory.Monoidal.rigidFunctorCategory
code: instance rigidFunctorCategory [RigidCategory D] : RigidCategory (C ⥤ D) 
goal: CategoryTheory.RigidCategory (C ⥤ D)
File: Mathlib/CategoryTheory/ConcreteCategory/ReflectsIso.lean

full_name: CategoryTheory.instReflectsIsomorphismsForgetType
code: instance : (forget (Type u)).ReflectsIsomorphisms 
goal: (CategoryTheory.forget (Type u)).ReflectsIsomorphisms

full_name: CategoryTheory.reflectsIsomorphisms_forget₂
code: /-- A `forget₂ C D` forgetful functor between concrete categories `C` and `D`
where `forget C` reflects isomorphisms, itself reflects isomorphisms.
-/
theorem reflectsIsomorphisms_forget₂ [HasForget₂ C D] [(forget C).ReflectsIsomorphisms] :
    (forget₂ C D).ReflectsIsomorphisms 
goal: (CategoryTheory.forget₂ C D).ReflectsIsomorphisms
File: Mathlib/CategoryTheory/ConcreteCategory/Bundled.lean

full_name: CategoryTheory.Bundled.α
code: /-- `Bundled` is a type bundled with a type class instance for that type. Only
the type class is exposed as a parameter. -/
structure Bundled (c : Type u → Type v) : Type max (u + 1) v where
  /-- The underlying type of the bundled type -/
  α : Type u
  /-- The corresponding instance of the bundled type class -/
  str : c α := by infer_instance
goal: Type u

full_name: CategoryTheory.Bundled.str
code: /-- `Bundled` is a type bundled with a type class instance for that type. Only
the type class is exposed as a parameter. -/
structure Bundled (c : Type u → Type v) : Type max (u + 1) v where
  /-- The underlying type of the bundled type -/
  α : Type u
  /-- The corresponding instance of the bundled type class -/
  str : c α := by infer_instance
goal: c ↑self

full_name: CategoryTheory.Bundled
code: /-- `Bundled` is a type bundled with a type class instance for that type. Only
the type class is exposed as a parameter. -/
structure Bundled (c : Type u → Type v) : Type max (u + 1) v where
  /-- The underlying type of the bundled type -/
  α : Type u
  /-- The corresponding instance of the bundled type class -/
  str : c α := by infer_instance
goal: Type (max (u + 1) v)

full_name: CategoryTheory.Bundled.of
code: /-- A generic function for lifting a type equipped with an instance to a bundled object. -/
def of {c : Type u → Type v} (α : Type u) [str : c α] : Bundled c 
goal: CategoryTheory.Bundled c

full_name: CategoryTheory.Bundled.coeSort
code: instance coeSort : CoeSort (Bundled c) (Type u) 
goal: CoeSort (CategoryTheory.Bundled c) (Type u)

full_name: CategoryTheory.Bundled.coe_mk
code: theorem coe_mk (α) (str) : (@Bundled.mk c α str : Type u) = α 
goal: ↑{ α := α, str := str } = α

full_name: CategoryTheory.Bundled.map
code: /-- Map over the bundled structure -/
def map (f : ∀ {α}, c α → d α) (b : Bundled c) : Bundled d 
goal: CategoryTheory.Bundled d
File: Mathlib/CategoryTheory/ConcreteCategory/UnbundledHom.lean

full_name: CategoryTheory.UnbundledHom.hom_comp
code: /-- A class for unbundled homs used to define a category. `hom` must
take two types `α`, `β` and instances of the corresponding structures,
and return a predicate on `α → β`. -/
class UnbundledHom {c : Type u → Type u} (hom : ∀ ⦃α β⦄, c α → c β → (α → β) → Prop) : Prop where
  hom_id : ∀ {α} (ia : c α), hom ia ia id
  hom_comp : ∀ {α β γ} {Iα : c α} {Iβ : c β} {Iγ : c γ} {g : β → γ} {f : α → β} (_ : hom Iβ Iγ g)
      (_ : hom Iα Iβ f), hom Iα Iγ (g ∘ f)
goal: hom Iβ Iγ g → hom Iα Iβ f → hom Iα Iγ (g ∘ f)

full_name: CategoryTheory.UnbundledHom.hom_id
code: /-- A class for unbundled homs used to define a category. `hom` must
take two types `α`, `β` and instances of the corresponding structures,
and return a predicate on `α → β`. -/
class UnbundledHom {c : Type u → Type u} (hom : ∀ ⦃α β⦄, c α → c β → (α → β) → Prop) : Prop where
  hom_id : ∀ {α} (ia : c α), hom ia ia id
  hom_comp : ∀ {α β γ} {Iα : c α} {Iβ : c β} {Iγ : c γ} {g : β → γ} {f : α → β} (_ : hom Iβ Iγ g)
      (_ : hom Iα Iβ f), hom Iα Iγ (g ∘ f)
goal: hom ia ia id

full_name: CategoryTheory.UnbundledHom
code: /-- A class for unbundled homs used to define a category. `hom` must
take two types `α`, `β` and instances of the corresponding structures,
and return a predicate on `α → β`. -/
class UnbundledHom {c : Type u → Type u} (hom : ∀ ⦃α β⦄, c α → c β → (α → β) → Prop) : Prop where
  hom_id : ∀ {α} (ia : c α), hom ia ia id
  hom_comp : ∀ {α β γ} {Iα : c α} {Iβ : c β} {Iγ : c γ} {g : β → γ} {f : α → β} (_ : hom Iβ Iγ g)
      (_ : hom Iα Iβ f), hom Iα Iγ (g ∘ f)
goal: Prop

full_name: CategoryTheory.UnbundledHom.bundledHom
code: instance bundledHom : BundledHom fun α β (Iα : c α) (Iβ : c β) => Subtype (hom Iα Iβ) 
goal: CategoryTheory.BundledHom fun α β Iα Iβ => Subtype (hom Iα Iβ)

full_name: CategoryTheory.UnbundledHom.mkHasForget₂
code: /-- A custom constructor for forgetful functor
between concrete categories defined using `UnbundledHom`. -/
def mkHasForget₂ : HasForget₂ (Bundled c) (Bundled c') 
goal: CategoryTheory.HasForget₂ (CategoryTheory.Bundled c) (CategoryTheory.Bundled c')
File: Mathlib/CategoryTheory/Functor/Hom.lean

full_name: CategoryTheory.Functor.hom_map
code: /-- `Functor.hom` is the hom-pairing, sending `(X, Y)` to `X ⟶ Y`, contravariant in `X` and
covariant in `Y`. -/
@[simps]
def hom : Cᵒᵖ × C ⥤ Type v 
goal: ∀ {X Y : Cᵒᵖ × C} (f : X ⟶ Y) (h : Opposite.unop X.1 ⟶ X.2), (CategoryTheory.Functor.hom C).map f h = f.1.unop ≫ h ≫ f.2

full_name: CategoryTheory.Functor.hom_obj
code: /-- `Functor.hom` is the hom-pairing, sending `(X, Y)` to `X ⟶ Y`, contravariant in `X` and
covariant in `Y`. -/
@[simps]
def hom : Cᵒᵖ × C ⥤ Type v 
goal: (CategoryTheory.Functor.hom C).obj p = (Opposite.unop p.1 ⟶ p.2)

full_name: CategoryTheory.Functor.hom
code: /-- `Functor.hom` is the hom-pairing, sending `(X, Y)` to `X ⟶ Y`, contravariant in `X` and
covariant in `Y`. -/
@[simps]
def hom : Cᵒᵖ × C ⥤ Type v 
goal: Cᵒᵖ × C ⥤ Type v
File: Mathlib/CategoryTheory/Functor/OfSequence.lean

full_name: CategoryTheory.Functor.OfSequence.congr_f
code: lemma congr_f (i j : ℕ) (h : i = j) :
    f i = eqToHom (by rw [h]) ≫ f j ≫ eqToHom (by rw [h]) 
goal: f i =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (f j) (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.Functor.OfSequence.map
code: /-- The morphism `X i ⟶ X j` obtained by composing morphisms of
the form `X n ⟶ X (n + 1)` when `i ≤ j`. -/
def map : ∀ {X : ℕ → C} (_ : ∀ n, X n ⟶ X (n + 1)) (i j : ℕ), i ≤ j → (X i ⟶ X j)
  
goal: ((n : ℕ) → X n ⟶ X (n + 1)) → (i j : ℕ) → i ≤ j → (X i ⟶ X j)

full_name: CategoryTheory.Functor.OfSequence.map_id
code: lemma map_id (i : ℕ) : map f i i (by omega) = 𝟙 _ 
goal: CategoryTheory.Functor.OfSequence.map f i i ⋯ = CategoryTheory.CategoryStruct.id (X i)

full_name: CategoryTheory.Functor.OfSequence.map_le_succ
code: lemma map_le_succ (i : ℕ) : map f i (i + 1) (by omega) = f i 
goal: CategoryTheory.Functor.OfSequence.map f i (i + 1) ⋯ = f i

full_name: CategoryTheory.Functor.OfSequence.map_comp
code: @[reassoc]
lemma map_comp (i j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k) :
    map f i k (hij.trans hjk) = map f i j hij ≫ map f j k hjk 
goal: CategoryTheory.Functor.OfSequence.map f i k ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OfSequence.map f i j hij)
    (CategoryTheory.Functor.OfSequence.map f j k hjk)

full_name: CategoryTheory.Functor.ofSequence
code: /-- The functor `ℕ ⥤ C` constructed from a sequence of
morphisms `f : X n ⟶ X (n + 1)` for all `n : ℕ`. -/
@[simps obj]
def ofSequence : ℕ ⥤ C 
goal: CategoryTheory.Functor ℕ C

full_name: CategoryTheory.Functor.ofSequence_obj
code: /-- The functor `ℕ ⥤ C` constructed from a sequence of
morphisms `f : X n ⟶ X (n + 1)` for all `n : ℕ`. -/
@[simps obj]
def ofSequence : ℕ ⥤ C 
goal: ∀ (a : ℕ), (CategoryTheory.Functor.ofSequence f).obj a = X a

full_name: CategoryTheory.Functor.ofSequence_map_homOfLE_succ
code: @[simp]
lemma ofSequence_map_homOfLE_succ (n : ℕ) :
    (ofSequence f).map (homOfLE (Nat.le_add_right n 1)) = f n 
goal: (CategoryTheory.Functor.ofSequence f).map (CategoryTheory.homOfLE ⋯) = f n

full_name: CategoryTheory.NatTrans.ofSequence
code: /-- Constructor for natural transformations `F ⟶ G` in `ℕ ⥤ C` which takes as inputs
the morphisms `F.obj n ⟶ G.obj n` for all `n : ℕ` and the naturality condition only
for morphisms of the form `n ⟶ n + 1`. -/
@[simps app]
def ofSequence : F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.NatTrans.ofSequence_app
code: /-- Constructor for natural transformations `F ⟶ G` in `ℕ ⥤ C` which takes as inputs
the morphisms `F.obj n ⟶ G.obj n` for all `n : ℕ` and the naturality condition only
for morphisms of the form `n ⟶ n + 1`. -/
@[simps app]
def ofSequence : F ⟶ G 
goal: (CategoryTheory.NatTrans.ofSequence app naturality).app n = app n
File: Mathlib/Algebra/Polynomial/Identities.lean

full_name: Polynomial.powAddExpansion
code: /-- `(x + y)^n` can be expressed as `x^n + n*x^(n-1)*y + k * y^2` for some `k` in the ring.
-/
def powAddExpansion {R : Type*} [CommSemiring R] (x y : R) :
    ∀ n : ℕ, { k // (x + y) ^ n = x ^ n + n * x ^ (n - 1) * y + k * y ^ 2 }
  
goal: { k // (x + y) ^ n = x ^ n + ↑n * x ^ (n - 1) * y + k * y ^ 2 }

full_name: _private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.polyBinomAux1
code: private def polyBinomAux1 (x y : R) (e : ℕ) (a : R) :
    { k : R // a * (x + y) ^ e = a * (x ^ e + e * x ^ (e - 1) * y + k * y ^ 2) } 
goal: { k // a * (x + y) ^ e = a * (x ^ e + ↑e * x ^ (e - 1) * y + k * y ^ 2) }

full_name: _private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux2
code: private theorem poly_binom_aux2 (f : R[X]) (x y : R) :
    f.eval (x + y) =
      f.sum fun e a => a * (x ^ e + e * x ^ (e - 1) * y + (polyBinomAux1 x y e a).val * y ^ 2) 
goal: Polynomial.eval (x + y) f =
  f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)

full_name: _private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux3
code: private theorem poly_binom_aux3 (f : R[X]) (x y : R) :
    f.eval (x + y) =
      ((f.sum fun e a => a * x ^ e) + f.sum fun e a => a * e * x ^ (e - 1) * y) +
        f.sum fun e a => a * (polyBinomAux1 x y e a).val * y ^ 2 
goal: Polynomial.eval (x + y) f =
  ((f.sum fun e a => a * x ^ e) + f.sum fun e a => a * ↑e * x ^ (e - 1) * y) +
    f.sum fun e a => a * ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2

full_name: Polynomial.binomExpansion
code: /-- A polynomial `f` evaluated at `x + y` can be expressed as
the evaluation of `f` at `x`, plus `y` times the (polynomial) derivative of `f` at `x`,
plus some element `k : R` times `y^2`.
-/
def binomExpansion (f : R[X]) (x y : R) :
    { k : R // f.eval (x + y) = f.eval x + f.derivative.eval x * y + k * y ^ 2 } 
goal: { k // Polynomial.eval (x + y) f = Polynomial.eval x f + Polynomial.eval x (Polynomial.derivative f) * y + k * y ^ 2 }

full_name: Polynomial.powSubPowFactor
code: /-- `x^n - y^n` can be expressed as `z * (x - y)` for some `z` in the ring.
-/
def powSubPowFactor (x y : R) : ∀ i : ℕ, { z : R // x ^ i - y ^ i = z * (x - y) }
  
goal: { z // x ^ i - y ^ i = z * (x - y) }

full_name: Polynomial.evalSubFactor
code: /-- For any polynomial `f`, `f.eval x - f.eval y` can be expressed as `z * (x - y)`
for some `z` in the ring.
-/
def evalSubFactor (f : R[X]) (x y : R) : { z : R // f.eval x - f.eval y = z * (x - y) } 
goal: { z // Polynomial.eval x f - Polynomial.eval y f = z * (x - y) }
File: Mathlib/Algebra/Polynomial/Cardinal.lean

full_name: Polynomial.cardinal_mk_eq_max
code: @[simp]
theorem cardinal_mk_eq_max {R : Type u} [Semiring R] [Nontrivial R] : #(R[X]) = max #R ℵ₀ 
goal: #R[X] = max #R ℵ₀

full_name: Polynomial.cardinal_mk_le_max
code: theorem cardinal_mk_le_max {R : Type u} [Semiring R] : #(R[X]) ≤ max #R ℵ₀ 
goal: #R[X] ≤ max #R ℵ₀
File: Mathlib/Algebra/Polynomial/Module/FiniteDimensional.lean

full_name: Module.AEval.isTorsion_of_aeval_eq_zero
code: theorem isTorsion_of_aeval_eq_zero [CommSemiring R] [NoZeroDivisors R] [Semiring A] [Algebra R A]
    [AddCommMonoid M] [Module A M] [Module R M] [IsScalarTower R A M]
    {p : R[X]} (h : aeval a p = 0) (h' : p ≠ 0) :
    IsTorsion R[X] (AEval R M a) 
goal: Module.IsTorsion R[X] (Module.AEval R M a)

full_name: Module.AEval.isTorsion_of_finiteDimensional
code: theorem isTorsion_of_finiteDimensional [Field K] [Ring A] [Algebra K A]
    [AddCommGroup M] [Module A M] [Module K M] [IsScalarTower K A M] [FiniteDimensional K A] :
    IsTorsion K[X] (AEval K M a) 
goal: Module.IsTorsion K[X] (Module.AEval K M a)
File: Mathlib/Algebra/Polynomial/DenomsClearable.lean

full_name: DenomsClearable
code: /-- `denomsClearable` formalizes the property that `b ^ N * f (a / b)`
does not have denominators, if the inequality `f.natDegree ≤ N` holds.

The definition asserts the existence of an element `D` of `R` and an
element `bi = 1 / i b` of `K` such that clearing the denominators of
the fraction equals `i D`.
-/
def DenomsClearable (a b : R) (N : ℕ) (f : R[X]) (i : R →+* K) : Prop 
goal: Prop

full_name: denomsClearable_zero
code: theorem denomsClearable_zero (N : ℕ) (a : R) (bu : bi * i b = 1) : DenomsClearable a b N 0 i 
goal: DenomsClearable a b N 0 i

full_name: denomsClearable_C_mul_X_pow
code: theorem denomsClearable_C_mul_X_pow {N : ℕ} (a : R) (bu : bi * i b = 1) {n : ℕ} (r : R)
    (nN : n ≤ N) : DenomsClearable a b N (C r * X ^ n) i 
goal: DenomsClearable a b N (Polynomial.C r * Polynomial.X ^ n) i

full_name: DenomsClearable.add
code: theorem DenomsClearable.add {N : ℕ} {f g : R[X]} :
    DenomsClearable a b N f i → DenomsClearable a b N g i → DenomsClearable a b N (f + g) i 
goal: DenomsClearable a b N f i → DenomsClearable a b N g i → DenomsClearable a b N (f + g) i

full_name: denomsClearable_of_natDegree_le
code: theorem denomsClearable_of_natDegree_le (N : ℕ) (a : R) (bu : bi * i b = 1) :
    ∀ f : R[X], f.natDegree ≤ N → DenomsClearable a b N f i 
goal: f.natDegree ≤ N → DenomsClearable a b N f i

full_name: denomsClearable_natDegree
code: /-- If `i : R → K` is a ring homomorphism, `f` is a polynomial with coefficients in `R`,
`a, b` are elements of `R`, with `i b` invertible, then there is a `D ∈ R` such that
`b ^ f.natDegree * f (a / b)` equals `i D`. -/
theorem denomsClearable_natDegree (i : R →+* K) (f : R[X]) (a : R) (bu : bi * i b = 1) :
    DenomsClearable a b f.natDegree f i 
goal: DenomsClearable a b f.natDegree f i

full_name: one_le_pow_mul_abs_eval_div
code: /-- Evaluating a polynomial with integer coefficients at a rational number and clearing
denominators, yields a number greater than or equal to one.  The target can be any
`LinearOrderedField K`.
The assumption on `K` could be weakened to `LinearOrderedCommRing` assuming that the
image of the denominator is invertible in `K`. -/
theorem one_le_pow_mul_abs_eval_div {K : Type*} [LinearOrderedField K] {f : ℤ[X]} {a b : ℤ}
    (b0 : 0 < b) (fab : eval ((a : K) / b) (f.map (algebraMap ℤ K)) ≠ 0) :
    (1 : K) ≤ (b : K) ^ f.natDegree * |eval ((a : K) / b) (f.map (algebraMap ℤ K))| 
goal: 1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)|
File: Mathlib/Algebra/Polynomial/Degree/CardPowDegree.lean

full_name: Polynomial.cardPowDegree
code: /-- `cardPowDegree` is the absolute value on `𝔽_q[t]` sending `f` to `q ^ degree f`.

`cardPowDegree 0` is defined to be `0`. -/
noncomputable def cardPowDegree : AbsoluteValue Fq[X] ℤ 
goal: AbsoluteValue (Polynomial Fq) ℤ

full_name: Polynomial.cardPowDegree_apply
code: theorem cardPowDegree_apply [DecidableEq Fq] (p : Fq[X]) :
    cardPowDegree p = if p = 0 then 0 else (Fintype.card Fq : ℤ) ^ natDegree p 
goal: Polynomial.cardPowDegree p = if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree

full_name: Polynomial.cardPowDegree_zero
code: @[simp]
theorem cardPowDegree_zero : cardPowDegree (0 : Fq[X]) = 0 
goal: Polynomial.cardPowDegree 0 = 0

full_name: Polynomial.cardPowDegree_nonzero
code: @[simp]
theorem cardPowDegree_nonzero (p : Fq[X]) (hp : p ≠ 0) :
    cardPowDegree p = (Fintype.card Fq : ℤ) ^ p.natDegree 
goal: Polynomial.cardPowDegree p = ↑(Fintype.card Fq) ^ p.natDegree

full_name: Polynomial.cardPowDegree_isEuclidean
code: theorem cardPowDegree_isEuclidean : IsEuclidean (cardPowDegree : AbsoluteValue Fq[X] ℤ) 
goal: Polynomial.cardPowDegree.IsEuclidean
File: Mathlib/Algebra/Polynomial/PartialFractions.lean

full_name: div_eq_quo_add_rem_div_add_rem_div
code: /-- Let R be an integral domain and f, g₁, g₂ ∈ R[X]. Let g₁ and g₂ be monic and coprime.
Then, ∃ q, r₁, r₂ ∈ R[X] such that f / g₁g₂ = q + r₁/g₁ + r₂/g₂ and deg(r₁) < deg(g₁) and
deg(r₂) < deg(g₂).
-/
theorem div_eq_quo_add_rem_div_add_rem_div (f : R[X]) {g₁ g₂ : R[X]} (hg₁ : g₁.Monic)
    (hg₂ : g₂.Monic) (hcoprime : IsCoprime g₁ g₂) :
    ∃ q r₁ r₂ : R[X],
      r₁.degree < g₁.degree ∧
        r₂.degree < g₂.degree ∧ (f : K) / (↑g₁ * ↑g₂) = ↑q + ↑r₁ / ↑g₁ + ↑r₂ / ↑g₂ 
goal: ∃ q r₁ r₂, r₁.degree < g₁.degree ∧ r₂.degree < g₂.degree ∧ ↑f / (↑g₁ * ↑g₂) = ↑q + ↑r₁ / ↑g₁ + ↑r₂ / ↑g₂

full_name: div_eq_quo_add_sum_rem_div
code: /-- Let R be an integral domain and f ∈ R[X]. Let s be a finite index set.
Then, a fraction of the form f / ∏ (g i) can be rewritten as q + ∑ (r i) / (g i), where
deg(r i) < deg(g i), provided that the g i are monic and pairwise coprime.
-/
theorem div_eq_quo_add_sum_rem_div (f : R[X]) {ι : Type*} {g : ι → R[X]} {s : Finset ι}
    (hg : ∀ i ∈ s, (g i).Monic) (hcop : Set.Pairwise ↑s fun i j => IsCoprime (g i) (g j)) :
    ∃ (q : R[X]) (r : ι → R[X]),
      (∀ i ∈ s, (r i).degree < (g i).degree) ∧
        ((↑f : K) / ∏ i ∈ s, ↑(g i)) = ↑q + ∑ i ∈ s, (r i : K) / (g i : K) 
goal: ∃ q r, (∀ i ∈ s, (r i).degree < (g i).degree) ∧ ↑f / ∏ i ∈ s, ↑(g i) = ↑q + ∑ i ∈ s, ↑(r i) / ↑(g i)
File: Mathlib/Algebra/Polynomial/Monomial.lean

full_name: Polynomial.monomial_one_eq_iff
code: theorem monomial_one_eq_iff [Nontrivial R] {i j : ℕ} :
    (monomial i 1 : R[X]) = monomial j 1 ↔ i = j 
goal: (Polynomial.monomial i) 1 = (Polynomial.monomial j) 1 ↔ i = j

full_name: Polynomial.infinite
code: instance infinite [Nontrivial R] : Infinite R[X] 
goal: Infinite (Polynomial R)

full_name: Polynomial.card_support_le_one_iff_monomial
code: theorem card_support_le_one_iff_monomial {f : R[X]} :
    Finset.card f.support ≤ 1 ↔ ∃ n a, f = monomial n a 
goal: f.support.card ≤ 1 ↔ ∃ n a, f = (Polynomial.monomial n) a

full_name: Polynomial.ringHom_ext
code: theorem ringHom_ext {S} [Semiring S] {f g : R[X] →+* S} (h₁ : ∀ a, f (C a) = g (C a))
    (h₂ : f X = g X) : f = g 
goal: f = g

full_name: Polynomial.ringHom_ext'
code: @[ext high]
theorem ringHom_ext' {S} [Semiring S] {f g : R[X] →+* S} (h₁ : f.comp C = g.comp C)
    (h₂ : f X = g X) : f = g 
goal: f = g