ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/NeZero.lean

full_name: NeZero
code: /-- A type-class version of `n ≠ 0`.  -/
class NeZero (n : R) : Prop where
  /-- The proposition that `n` is not zero. -/
  out : n ≠ 0
goal: Prop

full_name: NeZero.out
code: /-- A type-class version of `n ≠ 0`.  -/
class NeZero (n : R) : Prop where
  /-- The proposition that `n` is not zero. -/
  out : n ≠ 0
goal: n ≠ 0

full_name: NeZero.ne
code: theorem NeZero.ne (n : R) [h : NeZero n] : n ≠ 0 
goal: n ≠ 0

full_name: NeZero.ne'
code: theorem NeZero.ne' (n : R) [h : NeZero n] : 0 ≠ n 
goal: 0 ≠ n

full_name: neZero_iff
code: theorem neZero_iff {n : R} : NeZero n ↔ n ≠ 0 
goal: NeZero n ↔ n ≠ 0

full_name: neZero_zero_iff_false
code: @[simp] lemma neZero_zero_iff_false {α : Type*} [Zero α] : NeZero (0 : α) ↔ False 
goal: NeZero 0 ↔ False

full_name: not_neZero
code: theorem not_neZero {n : R} : ¬NeZero n ↔ n = 0 
goal: ¬NeZero n ↔ n = 0

full_name: eq_zero_or_neZero
code: theorem eq_zero_or_neZero (a : R) : a = 0 ∨ NeZero a 
goal: a = 0 ∨ NeZero a

full_name: zero_ne_one
code: @[simp] lemma zero_ne_one [One α] [NeZero (1 : α)] : (0 : α) ≠ 1 
goal: 0 ≠ 1

full_name: one_ne_zero
code: @[simp] lemma one_ne_zero [One α] [NeZero (1 : α)] : (1 : α) ≠ 0 
goal: 1 ≠ 0

full_name: ne_zero_of_eq_one
code: lemma ne_zero_of_eq_one [One α] [NeZero (1 : α)] {a : α} (h : a = 1) : a ≠ 0 
goal: a ≠ 0

full_name: two_ne_zero
code: @[field_simps]
lemma two_ne_zero [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0 
goal: 2 ≠ 0

full_name: three_ne_zero
code: @[field_simps]
lemma three_ne_zero [OfNat α 3] [NeZero (3 : α)] : (3 : α) ≠ 0 
goal: 3 ≠ 0

full_name: four_ne_zero
code: @[field_simps]
lemma four_ne_zero [OfNat α 4] [NeZero (4 : α)] : (4 : α) ≠ 0 
goal: 4 ≠ 0

full_name: zero_ne_one'
code: lemma zero_ne_one' [One α] [NeZero (1 : α)] : (0 : α) ≠ 1 
goal: 0 ≠ 1

full_name: one_ne_zero'
code: lemma one_ne_zero' [One α] [NeZero (1 : α)] : (1 : α) ≠ 0 
goal: 1 ≠ 0

full_name: two_ne_zero'
code: lemma two_ne_zero' [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0 
goal: 2 ≠ 0

full_name: three_ne_zero'
code: lemma three_ne_zero' [OfNat α 3] [NeZero (3 : α)] : (3 : α) ≠ 0 
goal: 3 ≠ 0

full_name: four_ne_zero'
code: lemma four_ne_zero' [OfNat α 4] [NeZero (4 : α)] : (4 : α) ≠ 0 
goal: 4 ≠ 0

full_name: NeZero.succ
code: instance succ {n : ℕ} : NeZero (n + 1) 
goal: NeZero (n + 1)

full_name: NeZero.of_pos
code: theorem of_pos [Preorder M] [Zero M] (h : 0 < x) : NeZero x 
goal: NeZero x

full_name: Nat.pos_of_neZero
code: lemma Nat.pos_of_neZero (n : ℕ) [NeZero n] : 0 < n 
goal: 0 < n
File: Mathlib/Algebra/PUnitInstances/Order.lean

full_name: PUnit.canonicallyOrderedAddCommMonoid
code: instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit 
goal: CanonicallyOrderedAddCommMonoid PUnit.{u_1 + 1}

full_name: PUnit.linearOrderedCancelAddCommMonoid
code: instance linearOrderedCancelAddCommMonoid : LinearOrderedCancelAddCommMonoid PUnit 
goal: LinearOrderedCancelAddCommMonoid PUnit.{u_1 + 1}

full_name: PUnit.instLinearOrderedAddCommMonoidWithTop
code: instance : LinearOrderedAddCommMonoidWithTop PUnit 
goal: LinearOrderedAddCommMonoidWithTop PUnit.{u_1 + 1}
File: Mathlib/Algebra/PUnitInstances/Algebra.lean

full_name: PUnit.addCommGroup
code: @[to_additive]
instance commGroup : CommGroup PUnit 
goal: AddCommGroup PUnit.{u_1 + 1}

full_name: PUnit.commGroup
code: @[to_additive]
instance commGroup : CommGroup PUnit 
goal: CommGroup PUnit.{u_1 + 1}

full_name: PUnit.instOne
code: @[to_additive] instance : One PUnit 
goal: One PUnit.{1}

full_name: PUnit.instZero
code: @[to_additive] instance : One PUnit 
goal: Zero PUnit.{1}

full_name: PUnit.instMul_mathlib
code: @[to_additive] instance : Mul PUnit 
goal: Mul PUnit.{1}

full_name: PUnit.instAdd_mathlib
code: @[to_additive] instance : Mul PUnit 
goal: Add PUnit.{1}

full_name: PUnit.instDiv_mathlib
code: @[to_additive] instance : Div PUnit 
goal: Div PUnit.{1}

full_name: PUnit.instSub_mathlib
code: @[to_additive] instance : Div PUnit 
goal: Sub PUnit.{1}

full_name: PUnit.instNeg
code: @[to_additive] instance : Inv PUnit 
goal: Neg PUnit.{1}

full_name: PUnit.instInv
code: @[to_additive] instance : Inv PUnit 
goal: Inv PUnit.{1}

full_name: PUnit.zero_eq
code: @[to_additive (attr := simp, nolint simpNF)]
theorem one_eq : (1 : PUnit) = unit 
goal: 0 = PUnit.unit

full_name: PUnit.one_eq
code: @[to_additive (attr := simp, nolint simpNF)]
theorem one_eq : (1 : PUnit) = unit 
goal: 1 = PUnit.unit

full_name: PUnit.mul_eq
code: @[to_additive]
theorem mul_eq {x y : PUnit} : x * y = unit 
goal: x * y = PUnit.unit

full_name: PUnit.add_eq
code: @[to_additive]
theorem mul_eq {x y : PUnit} : x * y = unit 
goal: x + y = PUnit.unit

full_name: PUnit.sub_eq
code: @[to_additive (attr := simp)]
theorem div_eq {x y : PUnit} : x / y = unit 
goal: x - y = PUnit.unit

full_name: PUnit.div_eq
code: @[to_additive (attr := simp)]
theorem div_eq {x y : PUnit} : x / y = unit 
goal: x / y = PUnit.unit

full_name: PUnit.inv_eq
code: @[to_additive (attr := simp)]
theorem inv_eq {x : PUnit} : x⁻¹ = unit 
goal: x⁻¹ = PUnit.unit

full_name: PUnit.neg_eq
code: @[to_additive (attr := simp)]
theorem inv_eq {x : PUnit} : x⁻¹ = unit 
goal: -x = PUnit.unit

full_name: PUnit.commRing
code: instance commRing : CommRing PUnit 
goal: CommRing PUnit.{u_1 + 1}

full_name: PUnit.cancelCommMonoidWithZero
code: instance cancelCommMonoidWithZero : CancelCommMonoidWithZero PUnit 
goal: CancelCommMonoidWithZero PUnit.{u_1 + 1}

full_name: PUnit.normalizedGCDMonoid
code: instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit 
goal: NormalizedGCDMonoid PUnit.{u_1 + 1}

full_name: PUnit.gcd_eq
code: theorem gcd_eq {x y : PUnit} : gcd x y = unit 
goal: gcd x y = PUnit.unit

full_name: PUnit.lcm_eq
code: theorem lcm_eq {x y : PUnit} : lcm x y = unit 
goal: lcm x y = PUnit.unit

full_name: PUnit.norm_unit_eq
code: @[simp]
theorem norm_unit_eq {x : PUnit} : normUnit x = 1 
goal: normUnit x = 1
File: Mathlib/Algebra/PUnitInstances/Module.lean

full_name: PUnit.smul
code: @[to_additive]
instance smul : SMul R PUnit 
goal: SMul R PUnit.{u_3 + 1}

full_name: PUnit.vadd
code: @[to_additive]
instance smul : SMul R PUnit 
goal: VAdd R PUnit.{u_3 + 1}

full_name: PUnit.vadd_eq
code: @[to_additive (attr := simp)]
theorem smul_eq {R : Type*} (y : PUnit) (r : R) : r • y = unit 
goal: r +ᵥ y = PUnit.unit

full_name: PUnit.smul_eq
code: @[to_additive (attr := simp)]
theorem smul_eq {R : Type*} (y : PUnit) (r : R) : r • y = unit 
goal: r • y = PUnit.unit

full_name: PUnit.instIsCentralVAdd
code: @[to_additive]
instance : IsCentralScalar R PUnit 
goal: IsCentralVAdd R PUnit.{u_3 + 1}

full_name: PUnit.instIsCentralScalar
code: @[to_additive]
instance : IsCentralScalar R PUnit 
goal: IsCentralScalar R PUnit.{u_3 + 1}

full_name: PUnit.instSMulCommClass
code: @[to_additive]
instance : SMulCommClass R S PUnit 
goal: SMulCommClass R S PUnit.{u_3 + 1}

full_name: PUnit.instVAddCommClass
code: @[to_additive]
instance : SMulCommClass R S PUnit 
goal: VAddCommClass R S PUnit.{u_3 + 1}

full_name: PUnit.instIsScalarTowerOfSMul
code: @[to_additive]
instance instIsScalarTowerOfSMul [SMul R S] : IsScalarTower R S PUnit 
goal: IsScalarTower R S PUnit.{u_3 + 1}

full_name: PUnit.instIsScalarTowerOfVAdd
code: @[to_additive]
instance instIsScalarTowerOfSMul [SMul R S] : IsScalarTower R S PUnit 
goal: VAddAssocClass R S PUnit.{u_3 + 1}

full_name: PUnit.smulWithZero
code: instance smulWithZero [Zero R] : SMulWithZero R PUnit 
goal: SMulWithZero R PUnit.{1}

full_name: PUnit.mulAction
code: instance mulAction [Monoid R] : MulAction R PUnit 
goal: MulAction R PUnit.{u_3 + 1}

full_name: PUnit.distribMulAction
code: instance distribMulAction [Monoid R] : DistribMulAction R PUnit 
goal: DistribMulAction R PUnit.{u_3 + 1}

full_name: PUnit.mulDistribMulAction
code: instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit 
goal: MulDistribMulAction R PUnit.{u_3 + 1}

full_name: PUnit.mulSemiringAction
code: instance mulSemiringAction [Semiring R] : MulSemiringAction R PUnit 
goal: MulSemiringAction R PUnit.{u_3 + 1}

full_name: PUnit.mulActionWithZero
code: instance mulActionWithZero [MonoidWithZero R] : MulActionWithZero R PUnit 
goal: MulActionWithZero R PUnit.{1}

full_name: PUnit.module
code: instance module [Semiring R] : Module R PUnit 
goal: Module R PUnit.{u_3 + 1}
File: Mathlib/Algebra/Category/AlgebraCat/Symmetric.lean

full_name: AlgebraCat.instBraidedCategory
code: instance : BraidedCategory (AlgebraCat.{u} R) 
goal: CategoryTheory.BraidedCategory (AlgebraCat R)

full_name: AlgebraCat.toModuleCatBraidedFunctor
code: /-- `forget₂ (AlgebraCat R) (ModuleCat R)` as a braided functor. -/
@[simps toMonoidalFunctor]
def toModuleCatBraidedFunctor : BraidedFunctor (AlgebraCat.{u} R) (ModuleCat.{u} R) 
goal: CategoryTheory.BraidedFunctor (AlgebraCat R) (ModuleCat R)

full_name: AlgebraCat.toModuleCatBraidedFunctor_toMonoidalFunctor
code: /-- `forget₂ (AlgebraCat R) (ModuleCat R)` as a braided functor. -/
@[simps toMonoidalFunctor]
def toModuleCatBraidedFunctor : BraidedFunctor (AlgebraCat.{u} R) (ModuleCat.{u} R) 
goal: (AlgebraCat.toModuleCatBraidedFunctor R).toMonoidalFunctor = AlgebraCat.toModuleCatMonoidalFunctor R

full_name: AlgebraCat.instFaithfulModuleCatToModuleCatBraidedFunctor
code: instance : (toModuleCatBraidedFunctor R).Faithful 
goal: (AlgebraCat.toModuleCatBraidedFunctor R).Faithful

full_name: AlgebraCat.instSymmetricCategory
code: instance instSymmetricCategory : SymmetricCategory (AlgebraCat.{u} R) 
goal: CategoryTheory.SymmetricCategory (AlgebraCat R)
File: Mathlib/Algebra/Homology/HomotopyCategory/HomologicalFunctor.lean

full_name: HomotopyCategory.instIsHomologicalIntUpHomologyFunctor
code: instance (n : ℤ) : (homologyFunctor C (ComplexShape.up ℤ) n).IsHomological 
goal: (HomotopyCategory.homologyFunctor C (ComplexShape.up ℤ) n).IsHomological
File: Mathlib/Algebra/Homology/ConcreteCategory.lean

full_name: HomologicalComplex.cyclesMk
code: /-- Constructor for cycles of a homological complex in a concrete category. -/
noncomputable def cyclesMk {i : ι} (x : (forget₂ C Ab).obj (K.X i)) (j : ι) (hj : c.next i = j)
    (hx : ((forget₂ C Ab).map (K.d i j)) x = 0) :
    (forget₂ C Ab).obj (K.cycles i) 
goal: ↑((CategoryTheory.forget₂ C Ab).obj (K.cycles i))

full_name: HomologicalComplex.i_cyclesMk
code: @[simp]
lemma i_cyclesMk {i : ι} (x : (forget₂ C Ab).obj (K.X i)) (j : ι) (hj : c.next i = j)
    (hx : ((forget₂ C Ab).map (K.d i j)) x = 0) :
    ((forget₂ C Ab).map (K.iCycles i)) (K.cyclesMk x j hj hx) = x 
goal: ((CategoryTheory.forget₂ C Ab).map (K.iCycles i)) (K.cyclesMk x j hj hx) = x

full_name: CategoryTheory.ShortComplex.ShortExact.δ_apply'
code: lemma δ_apply' (x₃ : (forget₂ C Ab).obj (S.X₃.homology i))
    (x₂ : (forget₂ C Ab).obj (S.X₂.opcycles i))
    (x₁ : (forget₂ C Ab).obj (S.X₁.cycles j))
    (h₂ : (forget₂ C Ab).map (HomologicalComplex.opcyclesMap S.g i) x₂ =
      (forget₂ C Ab).map (S.X₃.homologyι i) x₃)
    (h₁ : (forget₂ C Ab).map (HomologicalComplex.cyclesMap S.f j) x₁ =
      (forget₂ C Ab).map (S.X₂.opcyclesToCycles i j) x₂) :
    (forget₂ C Ab).map (hS.δ i j hij) x₃ = (forget₂ C Ab).map (S.X₁.homologyπ j) x₁ 
goal: ((CategoryTheory.forget₂ C Ab).map (hS.δ i j hij)) x₃ = ((CategoryTheory.forget₂ C Ab).map (S.X₁.homologyπ j)) x₁

full_name: CategoryTheory.ShortComplex.ShortExact.δ_apply
code: lemma δ_apply (x₃ : (forget₂ C Ab).obj (S.X₃.X i))
    (hx₃ : (forget₂ C Ab).map (S.X₃.d i j) x₃ = 0)
    (x₂ : (forget₂ C Ab).obj (S.X₂.X i)) (hx₂ : (forget₂ C Ab).map (S.g.f i) x₂ = x₃)
    (x₁ : (forget₂ C Ab).obj (S.X₁.X j))
    (hx₁ : (forget₂ C Ab).map (S.f.f j) x₁ = (forget₂ C Ab).map (S.X₂.d i j) x₂)
    (k : ι) (hk : c.next j = k) :
    (forget₂ C Ab).map (hS.δ i j hij)
      ((forget₂ C Ab).map (S.X₃.homologyπ i) (S.X₃.cyclesMk x₃ j (c.next_eq' hij) hx₃)) =
        (forget₂ C Ab).map (S.X₁.homologyπ j) (S.X₁.cyclesMk x₁ k hk (by
          have := hS.mono_f
          apply (Preadditive.mono_iff_injective (S.f.f k)).1 inferInstance
          erw [← forget₂_comp_apply, ← HomologicalComplex.Hom.comm, forget₂_comp_apply, hx₁,
            ← forget₂_comp_apply, HomologicalComplex.d_comp_d, Functor.map_zero, map_zero,
            AddMonoidHom.zero_apply])) 
goal: ((CategoryTheory.forget₂ C Ab).map (hS.δ i j hij))
    (((CategoryTheory.forget₂ C Ab).map (S.X₃.homologyπ i)) (S.X₃.cyclesMk x₃ j ⋯ hx₃)) =
  ((CategoryTheory.forget₂ C Ab).map (S.X₁.homologyπ j)) (S.X₁.cyclesMk x₁ k hk ⋯)
File: Mathlib/Algebra/Homology/HomotopyCategory/SingleFunctors.lean

full_name: CochainComplex.singleFunctors
code: /-- The collection of all single functors `C ⥤ CochainComplex C ℤ` along with
their compatibilites with shifts. (This definition has purposely no `simps`
attribute, as the generated lemmas would not be very useful.) -/
noncomputable def singleFunctors : SingleFunctors C (CochainComplex C ℤ) ℤ 
goal: CategoryTheory.SingleFunctors C (CochainComplex C ℤ) ℤ

full_name: CochainComplex.instAdditiveIntFunctorSingleFunctors
code: instance (n : ℤ) : ((singleFunctors C).functor n).Additive 
goal: ((CochainComplex.singleFunctors C).functor n).Additive

full_name: CochainComplex.singleFunctor
code: /-- The single functor `C ⥤ CochainComplex C ℤ` which sends `X` to the complex
consisting of `X` in degree `n : ℤ` and zero otherwise.
(This is definitionally equal to `HomologicalComplex.single C (up ℤ) n`,
but `singleFunctor C n` is the preferred term when interactions with shifts are relevant.) -/
noncomputable abbrev singleFunctor (n : ℤ) 
goal: C ⥤ CochainComplex C ℤ

full_name: HomotopyCategory.singleFunctors
code: /-- The collection of all single functors `C ⥤ HomotopyCategory C (ComplexShape.up ℤ))`
for `n : ℤ` along with their compatibilites with shifts. -/
noncomputable def singleFunctors : SingleFunctors C (HomotopyCategory C (ComplexShape.up ℤ)) ℤ 
goal: CategoryTheory.SingleFunctors C (HomotopyCategory C (ComplexShape.up ℤ)) ℤ

full_name: HomotopyCategory.singleFunctor
code: /-- The single functor `C ⥤ HomotopyCategory C (ComplexShape.up ℤ)`
which sends `X` to the complex consisting of `X` in degree `n : ℤ` and zero otherwise. -/
noncomputable abbrev singleFunctor (n : ℤ) :
    C ⥤ HomotopyCategory C (ComplexShape.up ℤ) 
goal: C ⥤ HomotopyCategory C (ComplexShape.up ℤ)

full_name: HomotopyCategory.instAdditiveIntUpSingleFunctor
code: instance (n : ℤ) : (singleFunctor C n).Additive 
goal: (HomotopyCategory.singleFunctor C n).Additive

full_name: HomotopyCategory.singleFunctorsPostcompQuotientIso
code: /-- The isomorphism given by the very definition of `singleFunctors C`. -/
noncomputable def singleFunctorsPostcompQuotientIso :
    singleFunctors C ≅
      (CochainComplex.singleFunctors C).postcomp (HomotopyCategory.quotient _ _) 
goal: HomotopyCategory.singleFunctors C ≅
  (CochainComplex.singleFunctors C).postcomp (HomotopyCategory.quotient C (ComplexShape.up ℤ))

full_name: HomotopyCategory.singleFunctorPostcompQuotientIso
code: /-- `HomotopyCategory.singleFunctor C n` is induced by `CochainComplex.singleFunctor C n`. -/
noncomputable def singleFunctorPostcompQuotientIso (n : ℤ) :
    singleFunctor C n ≅ CochainComplex.singleFunctor C n ⋙ quotient _ _ 
goal: HomotopyCategory.singleFunctor C n ≅ CochainComplex.singleFunctor C n ⋙ HomotopyCategory.quotient C (ComplexShape.up ℤ)
File: Mathlib/Algebra/Homology/HomologicalComplexAbelian.lean

full_name: HomologicalComplex.instNormalEpiCategory
code: noncomputable instance : NormalEpiCategory (HomologicalComplex C c) 
goal: CategoryTheory.NormalEpiCategory (HomologicalComplex C c)

full_name: HomologicalComplex.instNormalMonoCategory
code: noncomputable instance : NormalMonoCategory (HomologicalComplex C c) 
goal: CategoryTheory.NormalMonoCategory (HomologicalComplex C c)

full_name: HomologicalComplex.instAbelian
code: noncomputable instance : Abelian (HomologicalComplex C c) 
goal: CategoryTheory.Abelian (HomologicalComplex C c)

full_name: HomologicalComplex.exact_of_degreewise_exact
code: lemma exact_of_degreewise_exact (hS : ∀ (i : ι), (S.map (eval C c i)).Exact) :
    S.Exact 
goal: S.Exact

full_name: HomologicalComplex.shortExact_of_degreewise_shortExact
code: lemma shortExact_of_degreewise_shortExact
    (hS : ∀ (i : ι), (S.map (eval C c i)).ShortExact) :
    S.ShortExact 
goal: S.ShortExact

full_name: HomologicalComplex.exact_iff_degreewise_exact
code: lemma exact_iff_degreewise_exact :
    S.Exact ↔ ∀ (i : ι), (S.map (eval C c i)).Exact 
goal: S.Exact ↔ ∀ (i : ι), (S.map (HomologicalComplex.eval C c i)).Exact

full_name: HomologicalComplex.shortExact_iff_degreewise_shortExact
code: lemma shortExact_iff_degreewise_shortExact :
    S.ShortExact ↔ ∀ (i : ι), (S.map (eval C c i)).ShortExact 
goal: S.ShortExact ↔ ∀ (i : ι), (S.map (HomologicalComplex.eval C c i)).ShortExact
File: Mathlib/Algebra/Homology/Factorizations/Basic.lean

full_name: CochainComplex.degreewiseEpiWithInjectiveKernel
code: /-- A morphism of cochain complexes `φ` in an abelian category satisfies
`degreewiseEpiWithInjectiveKernel φ` if for any `i : ℤ`, the morphism
`φ.f i` is an epimorphism with an injective kernel. -/
def degreewiseEpiWithInjectiveKernel : MorphismProperty (CochainComplex C ℤ) 
goal: CategoryTheory.MorphismProperty (CochainComplex C ℤ)

full_name: CochainComplex.instIsMultiplicativeIntDegreewiseEpiWithInjectiveKernel
code: instance : (degreewiseEpiWithInjectiveKernel (C := C)).IsMultiplicative 
goal: CochainComplex.degreewiseEpiWithInjectiveKernel.IsMultiplicative
File: Mathlib/Algebra/Homology/Linear.lean

full_name: HomologicalComplex.instSMulHom
code: instance : SMul R (X ⟶ Y) 
goal: SMul R (X ⟶ Y)

full_name: HomologicalComplex.smul_f_apply
code: @[simp]
lemma smul_f_apply (r : R) (f : X ⟶ Y) (n : ι) : (r • f).f n = r • f.f n 
goal: (r • f).f n = r • f.f n

full_name: HomologicalComplex.units_smul_f_apply
code: @[simp]
lemma units_smul_f_apply (r : Rˣ) (f : X ⟶ Y) (n : ι) : (r • f).f n = r • f.f n 
goal: (r • f).f n = r • f.f n

full_name: HomologicalComplex.instModuleHom
code: instance (X Y : HomologicalComplex C c) : Module R (X ⟶ Y) 
goal: Module R (X ⟶ Y)

full_name: HomologicalComplex.instLinear
code: instance : Linear R (HomologicalComplex C c) 
goal: CategoryTheory.Linear R (HomologicalComplex C c)

full_name: CategoryTheory.Functor.mapHomologicalComplex_linear
code: instance CategoryTheory.Functor.mapHomologicalComplex_linear
    (F : C ⥤ D) [F.Additive] [Functor.Linear R F] (c : ComplexShape ι) :
  Functor.Linear R (F.mapHomologicalComplex c) 
goal: CategoryTheory.Functor.Linear R (F.mapHomologicalComplex c)
File: Mathlib/Algebra/Homology/Refinements.lean

full_name: HomologicalComplex.eq_liftCycles_homologyπ_up_to_refinements
code: lemma eq_liftCycles_homologyπ_up_to_refinements {A : C} {i : ι} (γ : A ⟶ K.homology i)
    (j : ι) (hj : c.next i = j) :
    ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (z : A' ⟶ K.X i) (hz : z ≫ K.d i j = 0),
      π ≫ γ = K.liftCycles z j hj hz ≫ K.homologyπ i 
goal: ∃ A' π, ∃ (_ : CategoryTheory.Epi π), ∃ z, ∃ (hz : z ≫ K.d i j = 0), π ≫ γ = K.liftCycles z j hj hz ≫ K.homologyπ i
File: Mathlib/Algebra/Homology/Functor.lean

full_name: HomologicalComplex.asFunctor
code: /-- A complex of functors gives a functor to complexes. -/
@[simps obj map]
def asFunctor {T : Type*} [Category T] (C : HomologicalComplex (T ⥤ V) c) :
    T ⥤ HomologicalComplex V c 
goal: T ⥤ HomologicalComplex V c

full_name: HomologicalComplex.asFunctor_obj
code: /-- A complex of functors gives a functor to complexes. -/
@[simps obj map]
def asFunctor {T : Type*} [Category T] (C : HomologicalComplex (T ⥤ V) c) :
    T ⥤ HomologicalComplex V c 
goal: C.asFunctor.obj t = { X := fun i => (C.X i).obj t, d := fun i j => (C.d i j).app t, shape := ⋯, d_comp_d' := ⋯ }

full_name: HomologicalComplex.asFunctor_map
code: /-- A complex of functors gives a functor to complexes. -/
@[simps obj map]
def asFunctor {T : Type*} [Category T] (C : HomologicalComplex (T ⥤ V) c) :
    T ⥤ HomologicalComplex V c 
goal: ∀ {X Y : T} (h : X ⟶ Y), C.asFunctor.map h = { f := fun i => (C.X i).map h, comm' := ⋯ }

full_name: HomologicalComplex.complexOfFunctorsToFunctorToComplex_map_app_f
code: /-- The functorial version of `HomologicalComplex.asFunctor`. -/
@[simps]
def complexOfFunctorsToFunctorToComplex {T : Type*} [Category T] :
    HomologicalComplex (T ⥤ V) c ⥤ T ⥤ HomologicalComplex V c 
goal: ∀ {X Y : HomologicalComplex (T ⥤ V) c} (f : X ⟶ Y) (t : T) (i : ι),
  ((HomologicalComplex.complexOfFunctorsToFunctorToComplex.map f).app t).f i = (f.f i).app t

full_name: HomologicalComplex.complexOfFunctorsToFunctorToComplex
code: /-- The functorial version of `HomologicalComplex.asFunctor`. -/
@[simps]
def complexOfFunctorsToFunctorToComplex {T : Type*} [Category T] :
    HomologicalComplex (T ⥤ V) c ⥤ T ⥤ HomologicalComplex V c 
goal: HomologicalComplex (T ⥤ V) c ⥤ T ⥤ HomologicalComplex V c

full_name: HomologicalComplex.complexOfFunctorsToFunctorToComplex_obj
code: /-- The functorial version of `HomologicalComplex.asFunctor`. -/
@[simps]
def complexOfFunctorsToFunctorToComplex {T : Type*} [Category T] :
    HomologicalComplex (T ⥤ V) c ⥤ T ⥤ HomologicalComplex V c 
goal: HomologicalComplex.complexOfFunctorsToFunctorToComplex.obj C = C.asFunctor
File: Mathlib/Algebra/Field/Rat.lean

full_name: Rat.instField
code: instance instField : Field ℚ 
goal: Field ℚ

full_name: Rat.instDivisionRing
code: instance instDivisionRing : DivisionRing ℚ 
goal: DivisionRing ℚ
File: Mathlib/Algebra/Field/Opposite.lean

full_name: MulOpposite.instNNRatCast
code: @[to_additive] instance instNNRatCast [NNRatCast α] : NNRatCast αᵐᵒᵖ 
goal: NNRatCast αᵐᵒᵖ

full_name: AddOpposite.instNNRatCast
code: @[to_additive] instance instNNRatCast [NNRatCast α] : NNRatCast αᵐᵒᵖ 
goal: NNRatCast αᵃᵒᵖ

full_name: MulOpposite.instRatCast
code: @[to_additive] instance instRatCast [RatCast α] : RatCast αᵐᵒᵖ 
goal: RatCast αᵐᵒᵖ

full_name: AddOpposite.instRatCast
code: @[to_additive] instance instRatCast [RatCast α] : RatCast αᵐᵒᵖ 
goal: RatCast αᵃᵒᵖ

full_name: MulOpposite.op_nnratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma op_nnratCast [NNRatCast α] (q : ℚ≥0) : op (q : α) = q 
goal: MulOpposite.op ↑q = ↑q

full_name: AddOpposite.op_nnratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma op_nnratCast [NNRatCast α] (q : ℚ≥0) : op (q : α) = q 
goal: AddOpposite.op ↑q = ↑q

full_name: MulOpposite.unop_nnratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma unop_nnratCast [NNRatCast α] (q : ℚ≥0) : unop (q : αᵐᵒᵖ) = q 
goal: MulOpposite.unop ↑q = ↑q

full_name: AddOpposite.unop_nnratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma unop_nnratCast [NNRatCast α] (q : ℚ≥0) : unop (q : αᵐᵒᵖ) = q 
goal: AddOpposite.unop ↑q = ↑q

full_name: MulOpposite.op_ratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma op_ratCast [RatCast α] (q : ℚ) : op (q : α) = q 
goal: MulOpposite.op ↑q = ↑q

full_name: AddOpposite.op_ratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma op_ratCast [RatCast α] (q : ℚ) : op (q : α) = q 
goal: AddOpposite.op ↑q = ↑q

full_name: MulOpposite.unop_ratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma unop_ratCast [RatCast α] (q : ℚ) : unop (q : αᵐᵒᵖ) = q 
goal: MulOpposite.unop ↑q = ↑q

full_name: AddOpposite.unop_ratCast
code: @[to_additive (attr := simp, norm_cast)]
lemma unop_ratCast [RatCast α] (q : ℚ) : unop (q : αᵐᵒᵖ) = q 
goal: AddOpposite.unop ↑q = ↑q

full_name: MulOpposite.instDivisionSemiring
code: instance instDivisionSemiring [DivisionSemiring α] : DivisionSemiring αᵐᵒᵖ 
goal: DivisionSemiring αᵐᵒᵖ

full_name: MulOpposite.instDivisionRing
code: instance instDivisionRing [DivisionRing α] : DivisionRing αᵐᵒᵖ 
goal: DivisionRing αᵐᵒᵖ

full_name: MulOpposite.instSemifield
code: instance instSemifield [Semifield α] : Semifield αᵐᵒᵖ 
goal: Semifield αᵐᵒᵖ

full_name: MulOpposite.instField
code: instance instField [Field α] : Field αᵐᵒᵖ 
goal: Field αᵐᵒᵖ

full_name: AddOpposite.instDivisionSemiring
code: instance instDivisionSemiring [DivisionSemiring α] : DivisionSemiring αᵃᵒᵖ 
goal: DivisionSemiring αᵃᵒᵖ

full_name: AddOpposite.instDivisionRing
code: instance instDivisionRing [DivisionRing α] : DivisionRing αᵃᵒᵖ 
goal: DivisionRing αᵃᵒᵖ

full_name: AddOpposite.instSemifield
code: instance instSemifield [Semifield α] : Semifield αᵃᵒᵖ 
goal: Semifield αᵃᵒᵖ

full_name: AddOpposite.instField
code: instance instField [Field α] : Field αᵃᵒᵖ 
goal: Field αᵃᵒᵖ