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

full_name: Field.ofMinimalAxioms
code: /-- Define a `Field` structure on a Type by proving a minimized set of axioms.
Note that this uses the default definitions for `npow`, `nsmul`, `zsmul`, `div` and `sub`
See note [reducible non-instances]. -/
abbrev Field.ofMinimalAxioms (K : Type u)
    [Add K] [Mul K] [Neg K] [Inv K] [Zero K] [One K]
    (add_assoc : ∀ a b c : K, a + b + c = a + (b + c))
    (zero_add : ∀ a : K, 0 + a = a)
    (add_left_neg : ∀ a : K, -a + a = 0)
    (mul_assoc : ∀ a b c : K, a * b * c = a * (b * c))
    (mul_comm : ∀ a b : K, a * b = b * a)
    (one_mul : ∀ a : K, 1 * a = a)
    (mul_inv_cancel : ∀ a : K, a ≠ 0 → a * a⁻¹ = 1)
    (inv_zero : (0 : K)⁻¹ = 0)
    (left_distrib : ∀ a b c : K, a * (b + c) = a * b + a * c)
    (exists_pair_ne : ∃ x y : K, x ≠ y) : Field K 
goal: Field K
File: Mathlib/Algebra/Field/Power.lean

full_name: Odd.neg_zpow
code: theorem Odd.neg_zpow (h : Odd n) (a : α) : (-a) ^ n = -a ^ n 
goal: (-a) ^ n = -a ^ n

full_name: Odd.neg_one_zpow
code: theorem Odd.neg_one_zpow (h : Odd n) : (-1 : α) ^ n = -1 
goal: (-1) ^ n = -1
File: Mathlib/Algebra/Category/AlgebraCat/Monoidal.lean

full_name: AlgebraCat.instMonoidalCategory.tensorObj_carrier
code: /-- Auxiliary definition used to fight a timeout when building
`AlgebraCat.instMonoidalCategory`. -/
@[simps!]
noncomputable abbrev tensorObj (X Y : AlgebraCat.{u} R) : AlgebraCat.{u} R 
goal: ↑(AlgebraCat.instMonoidalCategory.tensorObj X Y) = TensorProduct R ↑X ↑Y

full_name: AlgebraCat.instMonoidalCategory.tensorObj
code: /-- Auxiliary definition used to fight a timeout when building
`AlgebraCat.instMonoidalCategory`. -/
@[simps!]
noncomputable abbrev tensorObj (X Y : AlgebraCat.{u} R) : AlgebraCat.{u} R 
goal: AlgebraCat R

full_name: AlgebraCat.instMonoidalCategory.tensorHom
code: /-- Auxiliary definition used to fight a timeout when building
`AlgebraCat.instMonoidalCategory`. -/
noncomputable abbrev tensorHom {W X Y Z : AlgebraCat.{u} R} (f : W ⟶ X) (g : Y ⟶ Z) :
    tensorObj W Y ⟶ tensorObj X Z 
goal: AlgebraCat.instMonoidalCategory.tensorObj W Y ⟶ AlgebraCat.instMonoidalCategory.tensorObj X Z

full_name: AlgebraCat.instMonoidalCategoryStruct
code: instance : MonoidalCategoryStruct (AlgebraCat.{u} R) 
goal: CategoryTheory.MonoidalCategoryStruct (AlgebraCat R)

full_name: AlgebraCat.forget₂_map_associator_hom
code: theorem forget₂_map_associator_hom (X Y Z : AlgebraCat.{u} R) :
    (forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).hom =
      (α_
        (forget₂ _ (ModuleCat R) |>.obj X)
        (forget₂ _ (ModuleCat R) |>.obj Y)
        (forget₂ _ (ModuleCat R) |>.obj Z)).hom 
goal: (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).hom =
  (α_ ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj X)
      ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj Y)
      ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj Z)).hom

full_name: AlgebraCat.forget₂_map_associator_inv
code: theorem forget₂_map_associator_inv (X Y Z : AlgebraCat.{u} R) :
    (forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).inv =
      (α_
        (forget₂ _ (ModuleCat R) |>.obj X)
        (forget₂ _ (ModuleCat R) |>.obj Y)
        (forget₂ _ (ModuleCat R) |>.obj Z)).inv 
goal: (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).inv =
  (α_ ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj X)
      ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj Y)
      ((CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj Z)).inv

full_name: AlgebraCat.instMonoidalCategory
code: noncomputable instance instMonoidalCategory : MonoidalCategory (AlgebraCat.{u} R) 
goal: CategoryTheory.MonoidalCategory (AlgebraCat R)

full_name: AlgebraCat.toModuleCatMonoidalFunctor
code: /-- `forget₂ (AlgebraCat R) (ModuleCat R)` as a monoidal functor. -/
def toModuleCatMonoidalFunctor : MonoidalFunctor (AlgebraCat.{u} R) (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalFunctor (AlgebraCat R) (ModuleCat R)

full_name: AlgebraCat.instFaithfulModuleCatToModuleCatMonoidalFunctor
code: instance : (toModuleCatMonoidalFunctor R).Faithful 
goal: (AlgebraCat.toModuleCatMonoidalFunctor R).Faithful
File: Mathlib/Algebra/Homology/TotalComplexSymmetry.lean

full_name: HomologicalComplex₂.totalFlipIsoX
code: /-- Auxiliary definition for `totalFlipIso`. -/
noncomputable def totalFlipIsoX (j : J) : (K.flip.total c).X j ≅ (K.total c).X j 
goal: (K.flip.total c).X j ≅ (K.total c).X j

full_name: HomologicalComplex₂.totalFlipIsoX_hom_D₁
code: @[reassoc]
lemma totalFlipIsoX_hom_D₁ (j j' : J) :
    (K.totalFlipIsoX c j).hom ≫ K.D₁ c j j' =
      K.flip.D₂ c j j' ≫ (K.totalFlipIsoX c j').hom 
goal: (K.totalFlipIsoX c j).hom ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIsoX c j').hom

full_name: HomologicalComplex₂.totalFlipIsoX_hom_D₂
code: @[reassoc]
lemma totalFlipIsoX_hom_D₂ (j j' : J) :
    (K.totalFlipIsoX c j).hom ≫ K.D₂ c j j' =
      K.flip.D₁ c j j' ≫ (K.totalFlipIsoX c j').hom 
goal: (K.totalFlipIsoX c j).hom ≫ K.D₂ c j j' = K.flip.D₁ c j j' ≫ (K.totalFlipIsoX c j').hom

full_name: HomologicalComplex₂.totalFlipIso
code: /-- The symmetry isomorphism `K.flip.total c ≅ K.total c` of the total complex of a
bicomplex when we have `[TotalComplexShapeSymmetry c₁ c₂ c]`. -/
noncomputable def totalFlipIso : K.flip.total c ≅ K.total c 
goal: K.flip.total c ≅ K.total c

full_name: HomologicalComplex₂.totalFlipIso_hom_f_D₁
code: @[reassoc]
lemma totalFlipIso_hom_f_D₁ (j j' : J) :
    (K.totalFlipIso c).hom.f j ≫ K.D₁ c j j' =
      K.flip.D₂ c j j' ≫ (K.totalFlipIso c).hom.f j' 
goal: (K.totalFlipIso c).hom.f j ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIso c).hom.f j'

full_name: HomologicalComplex₂.totalFlipIso_hom_f_D₂
code: @[reassoc]
lemma totalFlipIso_hom_f_D₂ (j j' : J) :
    (K.totalFlipIso c).hom.f j ≫ K.D₂ c j j' =
      K.flip.D₁ c j j' ≫ (K.totalFlipIso c).hom.f j' 
goal: (K.totalFlipIso c).hom.f j ≫ K.D₂ c j j' = K.flip.D₁ c j j' ≫ (K.totalFlipIso c).hom.f j'

full_name: HomologicalComplex₂.ιTotal_totalFlipIso_f_hom
code: @[reassoc (attr := simp)]
lemma ιTotal_totalFlipIso_f_hom
    (i₁ : I₁) (i₂ : I₂) (j : J) (h : ComplexShape.π c₂ c₁ c (i₂, i₁) = j) :
    K.flip.ιTotal c i₂ i₁ j h ≫ (K.totalFlipIso c).hom.f j =
      ComplexShape.σ c₁ c₂ c i₁ i₂ • K.ιTotal c i₁ i₂ j
        (by rw [← ComplexShape.π_symm c₁ c₂ c i₁ i₂, h]) 
goal: K.flip.ιTotal c i₂ i₁ j h ≫ (K.totalFlipIso c).hom.f j = c₁.σ c₂ c i₁ i₂ • K.ιTotal c i₁ i₂ j ⋯

full_name: HomologicalComplex₂.ιTotal_totalFlipIso_f_inv
code: @[reassoc (attr := simp)]
lemma ιTotal_totalFlipIso_f_inv
    (i₁ : I₁) (i₂ : I₂) (j : J) (h : ComplexShape.π c₁ c₂ c (i₁, i₂) = j) :
    K.ιTotal c i₁ i₂ j h ≫ (K.totalFlipIso c).inv.f j =
      ComplexShape.σ c₁ c₂ c i₁ i₂ • K.flip.ιTotal c i₂ i₁ j
        (by rw [ComplexShape.π_symm c₁ c₂ c i₁ i₂, h]) 
goal: K.ιTotal c i₁ i₂ j h ≫ (K.totalFlipIso c).inv.f j = c₁.σ c₂ c i₁ i₂ • K.flip.ιTotal c i₂ i₁ j ⋯

full_name: HomologicalComplex₂.instHasTotalFlip
code: instance : K.flip.flip.HasTotal c 
goal: K.flip.flip.HasTotal c

full_name: HomologicalComplex₂.flip_totalFlipIso
code: lemma flip_totalFlipIso : K.flip.totalFlipIso c = (K.totalFlipIso c).symm 
goal: K.flip.totalFlipIso c = (K.totalFlipIso c).symm
File: Mathlib/Algebra/Field/ULift.lean

full_name: ULift.instNNRatCast
code: instance instNNRatCast [NNRatCast α] : NNRatCast (ULift α) 
goal: NNRatCast (ULift.{u_1, u} α)

full_name: ULift.instRatCast
code: instance instRatCast [RatCast α] : RatCast (ULift α) 
goal: RatCast (ULift.{u_1, u} α)

full_name: ULift.up_nnratCast
code: @[simp, norm_cast] lemma up_nnratCast [NNRatCast α] (q : ℚ≥0) : up (q : α) = q 
goal: { down := ↑q } = ↑q

full_name: ULift.down_nnratCast
code: @[simp, norm_cast] lemma down_nnratCast [NNRatCast α] (q : ℚ≥0) : down (q : ULift α) = q 
goal: (↑q).down = ↑q

full_name: ULift.up_ratCast
code: @[simp, norm_cast] lemma up_ratCast [RatCast α] (q : ℚ) : up (q : α) = q 
goal: { down := ↑q } = ↑q

full_name: ULift.down_ratCast
code: @[simp, norm_cast] lemma down_ratCast [RatCast α] (q : ℚ) : down (q : ULift α) = q 
goal: (↑q).down = ↑q

full_name: ULift.divisionSemiring
code: instance divisionSemiring [DivisionSemiring α] : DivisionSemiring (ULift α) 
goal: DivisionSemiring (ULift.{u_1, u} α)

full_name: ULift.semifield
code: instance semifield [Semifield α] : Semifield (ULift α) 
goal: Semifield (ULift.{u_1, u} α)

full_name: ULift.divisionRing
code: instance divisionRing [DivisionRing α] : DivisionRing (ULift α) 
goal: DivisionRing (ULift.{u_1, u} α)

full_name: ULift.field
code: instance field [Field α] : Field (ULift α) 
goal: Field (ULift.{u_1, u} α)
File: Mathlib/Algebra/Field/Equiv.lean

full_name: MulEquiv.isField
code: protected theorem isField {A : Type*} (B : Type*) [Semiring A] [Semiring B] (hB : IsField B)
    (e : A ≃* B) : IsField A 
goal: IsField A
File: Mathlib/Algebra/DirectSum/Finsupp.lean

full_name: finsuppLEquivDirectSum
code: /-- The finitely supported functions `ι →₀ M` are in linear equivalence with the direct sum of
copies of M indexed by ι. -/
def finsuppLEquivDirectSum : (ι →₀ M) ≃ₗ[R] ⨁ _ : ι, M 
goal: (ι →₀ M) ≃ₗ[R] ⨁ (x : ι), M

full_name: finsuppLEquivDirectSum_single
code: @[simp]
theorem finsuppLEquivDirectSum_single (i : ι) (m : M) :
    finsuppLEquivDirectSum R M ι (Finsupp.single i m) = DirectSum.lof R ι _ i m 
goal: (finsuppLEquivDirectSum R M ι) (Finsupp.single i m) = (DirectSum.lof R ι (fun i => M) i) m

full_name: finsuppLEquivDirectSum_symm_lof
code: @[simp]
theorem finsuppLEquivDirectSum_symm_lof (i : ι) (m : M) :
    (finsuppLEquivDirectSum R M ι).symm (DirectSum.lof R ι _ i m) = Finsupp.single i m 
goal: (finsuppLEquivDirectSum R M ι).symm ((DirectSum.lof R ι (fun x => M) i) m) = Finsupp.single i m
File: Mathlib/Algebra/Tropical/Lattice.lean

full_name: instSupTropical
code: instance instSupTropical [Sup R] : Sup (Tropical R) 
goal: Sup (Tropical R)

full_name: instInfTropical
code: instance instInfTropical [Inf R] : Inf (Tropical R) 
goal: Inf (Tropical R)

full_name: instSemilatticeInfTropical
code: instance instSemilatticeInfTropical [SemilatticeInf R] : SemilatticeInf (Tropical R) 
goal: SemilatticeInf (Tropical R)

full_name: instSemilatticeSupTropical
code: instance instSemilatticeSupTropical [SemilatticeSup R] : SemilatticeSup (Tropical R) 
goal: SemilatticeSup (Tropical R)

full_name: instLatticeTropical
code: instance instLatticeTropical [Lattice R] : Lattice (Tropical R) 
goal: Lattice (Tropical R)

full_name: instSupSetTropical
code: instance [SupSet R] : SupSet (Tropical R) 
goal: SupSet (Tropical R)

full_name: instInfSetTropical
code: instance [InfSet R] : InfSet (Tropical R) 
goal: InfSet (Tropical R)

full_name: instConditionallyCompleteLatticeTropical
code: instance instConditionallyCompleteLatticeTropical [ConditionallyCompleteLattice R] :
    ConditionallyCompleteLattice (Tropical R) 
goal: ConditionallyCompleteLattice (Tropical R)

full_name: instConditionallyCompleteLinearOrderTropical
code: instance [ConditionallyCompleteLinearOrder R] : ConditionallyCompleteLinearOrder (Tropical R) 
goal: ConditionallyCompleteLinearOrder (Tropical R)
File: Mathlib/Algebra/Homology/CommSq.lean

full_name: CategoryTheory.CommSq.cokernelCofork
code: /-- The cokernel cofork attached to a commutative square in a preadditive category. -/
noncomputable abbrev CommSq.cokernelCofork (sq : CommSq f g inl inr) :
    CokernelCofork (biprod.lift f (-g)) 
goal: CategoryTheory.Limits.CokernelCofork (CategoryTheory.Limits.biprod.lift f (-g))

full_name: CategoryTheory.CommSq.isColimitEquivIsColimitCokernelCofork
code: /-- A commutative square in a preadditive category is a pushout square iff
the corresponding diagram `X₁ ⟶ X₂ ⊞ X₃ ⟶ X₄ ⟶ 0` makes `X₄` a cokernel. -/
noncomputable def CommSq.isColimitEquivIsColimitCokernelCofork (sq : CommSq f g inl inr) :
    IsColimit (PushoutCocone.mk _ _ sq.w) ≃ IsColimit sq.cokernelCofork 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk inl inr ⋯) ≃
  CategoryTheory.Limits.IsColimit sq.cokernelCofork

full_name: CategoryTheory.IsPushout.isColimitCokernelCofork
code: /-- The colimit cokernel cofork attached to a pushout square. -/
noncomputable def IsPushout.isColimitCokernelCofork (h : IsPushout f g inl inr) :
    IsColimit h.cokernelCofork 
goal: CategoryTheory.Limits.IsColimit ⋯.cokernelCofork

full_name: CategoryTheory.CommSq.kernelFork
code: /-- The kernel fork attached to a commutative square in a preadditive category. -/
noncomputable abbrev CommSq.kernelFork (sq : CommSq fst snd f g) :
    KernelFork (biprod.desc f (-g)) 
goal: CategoryTheory.Limits.KernelFork (CategoryTheory.Limits.biprod.desc f (-g))

full_name: CategoryTheory.CommSq.isLimitEquivIsLimitKernelFork
code: /-- A commutative square in a preadditive category is a pullback square iff
the corresponding diagram `0 ⟶ X₁ ⟶ X₂ ⊞ X₃ ⟶ X₄ ⟶ 0` makes `X₁` a kernel. -/
noncomputable def CommSq.isLimitEquivIsLimitKernelFork (sq : CommSq fst snd f g) :
    IsLimit (PullbackCone.mk _ _ sq.w) ≃ IsLimit sq.kernelFork 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk fst snd ⋯) ≃
  CategoryTheory.Limits.IsLimit sq.kernelFork

full_name: CategoryTheory.IsPullback.isLimitKernelFork
code: /-- The limit kernel fork attached to a pullback square. -/
noncomputable def IsPullback.isLimitKernelFork (h : IsPullback fst snd f g) :
    IsLimit h.kernelFork 
goal: CategoryTheory.Limits.IsLimit ⋯.kernelFork
File: Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean

full_name: GenContFract.contsAux_recurrence
code: theorem contsAux_recurrence {gp ppred pred : Pair K} (nth_s_eq : g.s.get? n = some gp)
    (nth_contsAux_eq : g.contsAux n = ppred)
    (succ_nth_contsAux_eq : g.contsAux (n + 1) = pred) :
    g.contsAux (n + 2) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩ 
goal: g.contsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }

full_name: GenContFract.conts_recurrenceAux
code: theorem conts_recurrenceAux {gp ppred pred : Pair K} (nth_s_eq : g.s.get? n = some gp)
    (nth_contsAux_eq : g.contsAux n = ppred)
    (succ_nth_contsAux_eq : g.contsAux (n + 1) = pred) :
    g.conts (n + 1) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩ 
goal: g.conts (n + 1) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }

full_name: GenContFract.conts_recurrence
code: /-- Shows that `Aₙ = bₙ * Aₙ₋₁ + aₙ * Aₙ₋₂` and `Bₙ = bₙ * Bₙ₋₁ + aₙ * Bₙ₋₂`. -/
theorem conts_recurrence {gp ppred pred : Pair K} (succ_nth_s_eq : g.s.get? (n + 1) = some gp)
    (nth_conts_eq : g.conts n = ppred) (succ_nth_conts_eq : g.conts (n + 1) = pred) :
    g.conts (n + 2) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩ 
goal: g.conts (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }

full_name: GenContFract.nums_recurrence
code: /-- Shows that `Aₙ = bₙ * Aₙ₋₁ + aₙ * Aₙ₋₂`. -/
theorem nums_recurrence {gp : Pair K} {ppredA predA : K}
    (succ_nth_s_eq : g.s.get? (n + 1) = some gp) (nth_num_eq : g.nums n = ppredA)
    (succ_nth_num_eq : g.nums (n + 1) = predA) :
    g.nums (n + 2) = gp.b * predA + gp.a * ppredA 
goal: g.nums (n + 2) = gp.b * predA + gp.a * ppredA

full_name: GenContFract.dens_recurrence
code: /-- Shows that `Bₙ = bₙ * Bₙ₋₁ + aₙ * Bₙ₋₂`. -/
theorem dens_recurrence {gp : Pair K} {ppredB predB : K}
    (succ_nth_s_eq : g.s.get? (n + 1) = some gp) (nth_den_eq : g.dens n = ppredB)
    (succ_nth_den_eq : g.dens (n + 1) = predB) :
    g.dens (n + 2) = gp.b * predB + gp.a * ppredB 
goal: g.dens (n + 2) = gp.b * predB + gp.a * ppredB
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

full_name: GenContFract.terminated_stable
code: /-- If a gcf terminated at position `n`, it also terminated at `m ≥ n`. -/
theorem terminated_stable (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.TerminatedAt m 
goal: g.TerminatedAt m

full_name: GenContFract.contsAux_stable_step_of_terminated
code: theorem contsAux_stable_step_of_terminated (terminatedAt_n : g.TerminatedAt n) :
    g.contsAux (n + 2) = g.contsAux (n + 1) 
goal: g.contsAux (n + 2) = g.contsAux (n + 1)

full_name: GenContFract.contsAux_stable_of_terminated
code: theorem contsAux_stable_of_terminated (n_lt_m : n < m) (terminatedAt_n : g.TerminatedAt n) :
    g.contsAux m = g.contsAux (n + 1) 
goal: g.contsAux m = g.contsAux (n + 1)

full_name: GenContFract.convs'Aux_stable_step_of_terminated
code: theorem convs'Aux_stable_step_of_terminated {s : Stream'.Seq <| Pair K}
    (terminatedAt_n : s.TerminatedAt n) : convs'Aux s (n + 1) = convs'Aux s n 
goal: GenContFract.convs'Aux s (n + 1) = GenContFract.convs'Aux s n

full_name: GenContFract.convs'Aux_stable_of_terminated
code: theorem convs'Aux_stable_of_terminated {s : Stream'.Seq <| Pair K} (n_le_m : n ≤ m)
    (terminatedAt_n : s.TerminatedAt n) : convs'Aux s m = convs'Aux s n 
goal: GenContFract.convs'Aux s m = GenContFract.convs'Aux s n

full_name: GenContFract.conts_stable_of_terminated
code: theorem conts_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.conts m = g.conts n 
goal: g.conts m = g.conts n

full_name: GenContFract.nums_stable_of_terminated
code: theorem nums_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.nums m = g.nums n 
goal: g.nums m = g.nums n

full_name: GenContFract.dens_stable_of_terminated
code: theorem dens_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.dens m = g.dens n 
goal: g.dens m = g.dens n

full_name: GenContFract.convs_stable_of_terminated
code: theorem convs_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.convs m = g.convs n 
goal: g.convs m = g.convs n

full_name: GenContFract.convs'_stable_of_terminated
code: theorem convs'_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.convs' m = g.convs' n 
goal: g.convs' m = g.convs' n
File: Mathlib/Algebra/ContinuedFractions/Computation/ApproximationCorollaries.lean

full_name: GenContFract.of_convs_eq_convs'
code: theorem of_convs_eq_convs' : (of v).convs = (of v).convs' 
goal: (GenContFract.of v).convs = (GenContFract.of v).convs'

full_name: GenContFract.convs_succ
code: /-- The recurrence relation for the convergents of the continued fraction expansion
of an element `v` of `K` in terms of the convergents of the inverse of its fractional part.
-/
theorem convs_succ (n : ℕ) :
    (of v).convs (n + 1) = ⌊v⌋ + 1 / (of (Int.fract v)⁻¹).convs n 
goal: (GenContFract.of v).convs (n + 1) = ↑⌊v⌋ + 1 / (GenContFract.of (Int.fract v)⁻¹).convs n

full_name: GenContFract.of_convergence_epsilon
code: theorem of_convergence_epsilon :
    ∀ ε > (0 : K), ∃ N : ℕ, ∀ n ≥ N, |v - (of v).convs n| < ε 
goal: ε > 0 → ∃ N, ∀ n ≥ N, |v - (GenContFract.of v).convs n| < ε

full_name: GenContFract.of_convergence
code: theorem of_convergence [TopologicalSpace K] [OrderTopology K] :
    Filter.Tendsto (of v).convs Filter.atTop <| 𝓝 v 
goal: Filter.Tendsto (GenContFract.of v).convs Filter.atTop (𝓝 v)
File: Mathlib/Algebra/ContinuedFractions/Determinant.lean

full_name: SimpContFract.determinant_aux
code: theorem determinant_aux (hyp : n = 0 ∨ ¬(↑s : GenContFract K).TerminatedAt (n - 1)) :
    ((↑s : GenContFract K).contsAux n).a * ((↑s : GenContFract K).contsAux (n + 1)).b -
      ((↑s : GenContFract K).contsAux n).b * ((↑s : GenContFract K).contsAux (n + 1)).a =
        (-1) ^ n 
goal: ((↑s).contsAux n).a * ((↑s).contsAux (n + 1)).b - ((↑s).contsAux n).b * ((↑s).contsAux (n + 1)).a = (-1) ^ n

full_name: SimpContFract.determinant
code: /-- The determinant formula `Aₙ * Bₙ₊₁ - Bₙ * Aₙ₊₁ = (-1)^(n + 1)`. -/
theorem determinant (not_terminatedAt_n : ¬(↑s : GenContFract K).TerminatedAt n) :
    (↑s : GenContFract K).nums n * (↑s : GenContFract K).dens (n + 1) -
      (↑s : GenContFract K).dens n * (↑s : GenContFract K).nums (n + 1) = (-1) ^ (n + 1) 
goal: (↑s).nums n * (↑s).dens (n + 1) - (↑s).dens n * (↑s).nums (n + 1) = (-1) ^ (n + 1)
File: Mathlib/Algebra/Group/Hom/CompTypeclasses.lean

full_name: MonoidHom.CompTriple
code: /-- Class of composing triples -/
class CompTriple  {M N P : Type*} [Monoid M] [Monoid N] [Monoid P]
  (φ : M →* N) (ψ : N →* P) (χ : outParam (M →* P)) : Prop where
  /-- The maps form a commuting triangle -/
  comp_eq : ψ.comp φ = χ
goal: Prop

full_name: MonoidHom.CompTriple.comp_eq
code: /-- Class of composing triples -/
class CompTriple  {M N P : Type*} [Monoid M] [Monoid N] [Monoid P]
  (φ : M →* N) (ψ : N →* P) (χ : outParam (M →* P)) : Prop where
  /-- The maps form a commuting triangle -/
  comp_eq : ψ.comp φ = χ
goal: ψ.comp φ = χ

full_name: MonoidHom.CompTriple.IsId.eq_id
code: /-- Class of Id maps -/
class IsId (σ : M →* M) : Prop where
  eq_id : σ = MonoidHom.id M
goal: σ = MonoidHom.id M

full_name: MonoidHom.CompTriple.IsId
code: /-- Class of Id maps -/
class IsId (σ : M →* M) : Prop where
  eq_id : σ = MonoidHom.id M
goal: Prop

full_name: MonoidHom.CompTriple.instIsId
code: instance instIsId {M : Type*} [Monoid M] : IsId (MonoidHom.id M) 
goal: MonoidHom.CompTriple.IsId (MonoidHom.id M)

full_name: MonoidHom.CompTriple.instIsIdOfIsIdCoe
code: instance {σ : M →* M} [h : _root_.CompTriple.IsId σ] : IsId σ  
goal: MonoidHom.CompTriple.IsId σ

full_name: MonoidHom.CompTriple.instComp_id
code: instance instComp_id {N P : Type*} [Monoid N] [Monoid P]
    {φ : N →* N} [IsId φ] {ψ : N →* P} :
    CompTriple φ ψ ψ 
goal: φ.CompTriple ψ ψ

full_name: MonoidHom.CompTriple.instId_comp
code: instance instId_comp {M N : Type*} [Monoid M] [Monoid N]
    {φ : M →* N} {ψ : N →* N} [IsId ψ] :
    CompTriple φ ψ φ 
goal: φ.CompTriple ψ φ

full_name: MonoidHom.CompTriple.comp_inv
code: lemma comp_inv {φ : M →* N} {ψ : N →* M} (h : Function.RightInverse φ ψ)
    {χ : M →* M} [IsId χ] :
    CompTriple φ ψ χ 
goal: φ.CompTriple ψ χ

full_name: MonoidHom.CompTriple.instRootCompTriple
code: instance instRootCompTriple {φ : M →* N} {ψ : N  →* P} {χ : M →* P} [κ : CompTriple φ ψ χ] :
    _root_.CompTriple φ ψ χ 
goal: CompTriple ⇑φ ⇑ψ ⇑χ

full_name: MonoidHom.CompTriple.comp
code: /-- `φ`, `ψ` and `ψ.comp φ` form a `MonoidHom.CompTriple`

  (to be used with care, because no simplification is done)-/
theorem comp {φ : M →* N} {ψ : N →* P} :
    CompTriple φ ψ (ψ.comp φ) 
goal: φ.CompTriple ψ (ψ.comp φ)

full_name: MonoidHom.CompTriple.comp_apply
code: lemma comp_apply
    {φ : M →* N} {ψ : N →* P} {χ : M →* P} (h : CompTriple φ ψ χ) (x : M) :
    ψ (φ x) = χ x 
goal: ψ (φ x) = χ x

full_name: MonoidHom.CompTriple.comp_assoc
code: @[simp]
theorem comp_assoc {Q : Type*} [Monoid Q]
    {φ₁ : M →* N} {φ₂ : N →* P} {φ₁₂ : M →* P}
    (κ : CompTriple φ₁ φ₂ φ₁₂)
    {φ₃ : P →* Q} {φ₂₃ : N →* Q} (κ' : CompTriple φ₂ φ₃ φ₂₃)
    {φ₁₂₃ : M →* Q} :
    CompTriple φ₁ φ₂₃ φ₁₂₃ ↔ CompTriple φ₁₂ φ₃ φ₁₂₃ 
goal: φ₁.CompTriple φ₂₃ φ₁₂₃ ↔ φ₁₂.CompTriple φ₃ φ₁₂₃
File: Mathlib/Algebra/Group/Submonoid/DistribMulAction.lean

full_name: Submonoid.distribMulAction
code: /-- The action by a submonoid is the action by the underlying monoid. -/
instance distribMulAction [AddMonoid α] [DistribMulAction M α] (S : Submonoid M) :
    DistribMulAction S α 
goal: DistribMulAction (↥S) α

full_name: Submonoid.mulDistribMulAction
code: /-- The action by a submonoid is the action by the underlying monoid. -/
instance mulDistribMulAction [Monoid α] [MulDistribMulAction M α] (S : Submonoid M) :
    MulDistribMulAction S α 
goal: MulDistribMulAction (↥S) α