ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
/--
A sufficient condition for `ModifyWF` is that the new element compares equal to the original.
-/
theorem ModifyWF.of_eq {t : RBSet α cmp}
    (H : ∀ {x}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x) : ModifyWF t cut f
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
@[reassoc (attr := simp)]
theorem limitConstTerminal_inv_π {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C]
    {j : J} :
    limitConstTerminal.inv ≫ limit.π ((CategoryTheory.Functor.const J).obj (⊤_ C)) j =
      terminal.from _
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_diff_Ioo_same (h : a < b) : Ico a b \ Ioo a b = {a}
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- We have that `J(a^e | b) = J(a | b)^e`. -/
theorem pow_left (a : ℤ) (e b : ℕ) : J(a ^ e | b) = J(a | b) ^ e
-- Mathlib/LinearAlgebra/Basis.lean
theorem coe_map : (b.map f : ι → M') = f ∘ b
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem mem_comap (S : NonUnitalSubalgebra R B) (f : F) (x : A) : x ∈ comap f S ↔ f x ∈ S
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem zpow_eq_one (h : IsPrimitiveRoot ζ k) : ζ ^ (k : ℤ) = 1
-- Mathlib/Order/Hom/Basic.lean
/-- The composition of two bundled monotone functions. -/
@[simps (config := .asFn)]
def comp (g : β →o γ) (f : α →o β) : α →o γ
-- Mathlib/RingTheory/Discriminant.lean
/-- If `K` and `L` are fields and `IsScalarTower R K L`, and `b : ι → L` satisfies
` ∀ i, IsIntegral R (b i)`, then `IsIntegral R (discr K b)`. -/
theorem discr_isIntegral {b : ι → L} (h : ∀ i, IsIntegral R (b i)) : IsIntegral R (discr K b)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma derivative_addPolynomial_slope {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁)
    (h₂ : W.Equation x₂ y₂) (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    derivative (W.addPolynomial x₁ y₁ <| W.slope x₁ x₂ y₁ y₂) =
      -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂)) +
          (X - C x₂) * (X - C (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂)))
-- Mathlib/Data/FinEnum.lean
@[simp]
theorem Finset.mem_enum [DecidableEq α] (s : Finset α) (xs : List α) :
    s ∈ Finset.enum xs ↔ ∀ x ∈ s, x ∈ xs
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem norm_condexpIndL1_le (x : G) : ‖condexpIndL1 hm μ s x‖ ≤ (μ s).toReal * ‖x‖
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inter_union_diff (s t : Set α) : s ∩ t ∪ s \ t = s
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem rightUnitor_naturality {f g : a ⟶ b} (η : f ⟶ g) :
    η ▷ 𝟙 b ≫ (ρ_ g).hom = (ρ_ f).hom ≫ η
-- Mathlib/Topology/Homeomorph.lean
theorem toEquiv_injective : Function.Injective (toEquiv : X ≃ₜ Y → X ≃ Y)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem ae_sum_iff [Countable ι] {μ : ι → Measure α} {p : α → Prop} :
    (∀ᵐ x ∂sum μ, p x) ↔ ∀ i, ∀ᵐ x ∂μ i, p x
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem mem_carrier {s : NonUnitalStarSubalgebra R A} {x : A} : x ∈ s.carrier ↔ x ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_max_sub_left (a b c : Nat) : max (a - b) (a - c) = a - min b c
-- Mathlib/Algebra/Polynomial/BigOperators.lean
theorem natDegree_prod_of_monic (h : ∀ i ∈ s, (f i).Monic) :
    (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree
-- Mathlib/RingTheory/PowerSeries/Basic.lean
/-- Split off the constant coefficient. -/
theorem eq_shift_mul_X_add_const (φ : R⟦X⟧) :
    φ = (mk fun p => coeff R (p + 1) φ) * X + C R (constantCoeff R φ)
-- Mathlib/Data/List/Iterate.lean
theorem get_iterate (f : α → α) (a : α) (n : ℕ) (i : Fin (iterate f a n).length) :
    get (iterate f a n) i = f^[↑i] a
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem measurableSet_preimage (hf : MeasurableEmbedding f) {s : Set β} :
    MeasurableSet (f ⁻¹' s) ↔ MeasurableSet (s ∩ range f)
-- Mathlib/Data/Complex/Determinant.lean
/-- The determinant of `conjAe`, as a linear equiv. -/
@[simp]
theorem linearEquiv_det_conjAe : LinearEquiv.det conjAe.toLinearEquiv = -1
-- Mathlib/Order/Hom/Basic.lean
theorem eq_iff_eq {a b} : f a = f b ↔ a = b
-- Mathlib/Order/GaloisConnection.lean
theorem u_inf_l [SemilatticeInf α] [SemilatticeInf β] (gi : GaloisCoinsertion l u) (a b : α) :
    u (l a ⊓ l b) = a ⊓ b
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem liftEquiv_id_apply : liftEquiv M (RingHom.id K) p j = j
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem Ioo_ae_eq_Ioc : Ioo a b =ᵐ[μ] Ioc a b
-- Mathlib/Order/Bounds/Basic.lean
theorem BddAbove.image2_bddBelow : BddAbove s → BddAbove t → BddBelow (Set.image2 f s t)
-- Mathlib/Analysis/CstarAlgebra/Unitization.lean
lemma opNNNorm_mul_flip_apply (a : E) : ‖(mul 𝕜 E).flip a‖₊ = ‖a‖₊
-- Mathlib/Order/Basic.lean
theorem lt_of_le_of_ne' : a ≤ b → b ≠ a → a < b
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem findExistsOneDivLT_spec (hi : ¬s ≤[i] 0) :
    ExistsOneDivLT s i (findExistsOneDivLT s i)
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMaxOn.comp_antitone (hf : IsLocalMaxOn f s a) {g : β → γ} (hg : Antitone g) :
    IsLocalMinOn (g ∘ f) s a
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem IsBlock.iff_top (B : Set X) :
    IsBlock G B ↔ IsBlock (⊤ : Subgroup G) B
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The zeroth cyclotomic polyomial is `1`. -/
@[simp]
theorem cyclotomic_zero (R : Type*) [Ring R] : cyclotomic 0 R = 1
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem measure_add_measure_compl₀ {s : Set α} (hs : NullMeasurableSet s μ) :
    μ s + μ sᶜ = μ univ
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
/-- Map a kernel cone on the difference of two morphisms to the equalizer fork. -/
@[simps! pt]
def forkOfKernelFork (c : KernelFork (f - g)) : Fork f g
-- Mathlib/CategoryTheory/GradedObject.lean
@[simp, nolint simpNF]
theorem zero_apply [HasZeroMorphisms C] (β : Type w) (X Y : GradedObject β C) (b : β) :
    (0 : X ⟶ Y) b = 0
-- Mathlib/Algebra/Algebra/Defs.lean
lemma commute_algebraMap_right (r : R) (x : A) : Commute x (algebraMap R A r)
-- Mathlib/Order/WellFounded.lean
protected theorem isAsymm (h : WellFounded r) : IsAsymm α r
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
theorem HigherFacesVanish.on_Γ₀_summand_id (K : ChainComplex C ℕ) (n : ℕ) :
    @HigherFacesVanish C _ _ (Γ₀.obj K) _ n (n + 1)
      (((Γ₀.splitting K).cofan _).inj (Splitting.IndexSet.id (op [n + 1])))
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem indicatorConstLp_inj {s t : Set α} (hs : MeasurableSet s) (hsμ : μ s ≠ ∞)
    (ht : MeasurableSet t) (htμ : μ t ≠ ∞) {c : E} (hc : c ≠ 0) :
    indicatorConstLp p hs hsμ c = indicatorConstLp p ht htμ c ↔ s =ᵐ[μ] t
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
theorem hasStrictDerivAt_exp_smul_const' (x : 𝔸) (t : 𝕂) :
    HasStrictDerivAt (fun u : 𝕂 => exp 𝕂 (u • x)) (x * exp 𝕂 (t • x)) t
-- Mathlib/Deprecated/Subgroup.lean
/-- The normal closure of a set is a subgroup. -/
theorem normalClosure.isSubgroup (s : Set G) : IsSubgroup (normalClosure s)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ici_mem_nhds (h : a < b) : Ici a ∈ 𝓝 b
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem rangeS_algebraMap {R A : Type*} [CommSemiring R] [CommSemiring A] [Algebra R A]
    (S : Subalgebra R A) : (algebraMap S A).rangeS = S.toSubsemiring
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma evalEval_polynomial (x y : R) : W.polynomial.evalEval x y =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)
-- Mathlib/Data/Nat/Digits.lean
theorem ofDigits_cons {b hd} {tl : List ℕ} :
    ofDigits b (hd :: tl) = hd + b * ofDigits b tl
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorAdd_zero_add_hom_app (a : A) (X : C) :
    (shiftFunctorAdd C 0 a).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ ((shiftFunctorZero C A).inv.app X)⟦a⟧'
-- Mathlib/Order/Filter/Cocardinal.lean
theorem frequently_cocardinal {p : α → Prop} :
    (∃ᶠ x in cocardinal α hreg, p x) ↔ c ≤ # { x | p x }
-- Mathlib/MeasureTheory/MeasurableSpace/Card.lean
theorem self_subset_generateMeasurableRec (s : Set (Set α)) (i : ω₁) :
    s ⊆ generateMeasurableRec s i
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasDerivAt.norm_sq {f : ℝ → F} {f' : F} {x : ℝ} (hf : HasDerivAt f f' x) :
    HasDerivAt (‖f ·‖ ^ 2) (2 * Inner.inner (f x) f') x
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem span_singleton_neg (x : α) : (span {-x} : Ideal α) = span {x}
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
theorem coprod.triangle (X Y : C) :
    (coprod.associator X (⊥_ C) Y).hom ≫ coprod.map (𝟙 X) (coprod.leftUnitor Y).hom =
      coprod.map (coprod.rightUnitor X).hom (𝟙 Y)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem id_apply (a : α) : CompleteLatticeHom.id α a = a
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasStrictDerivAt_rpow_const {x p : ℝ} (hx : x ≠ 0 ∨ 1 ≤ p) :
    HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
-- Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean
@[fun_prop]
theorem IsBoundedBilinearMap.differentiable (h : IsBoundedBilinearMap 𝕜 b) : Differentiable 𝕜 b
-- Mathlib/RingTheory/ClassGroup.lean
theorem ClassGroup.mk0_integralRep [IsDedekindDomain R]
    (I : (FractionalIdeal R⁰ (FractionRing R))ˣ) :
    ClassGroup.mk0 ⟨ClassGroup.integralRep I, ClassGroup.integralRep_mem_nonZeroDivisors I.ne_zero⟩
      = ClassGroup.mk I
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
@[simp]
theorem Gamma_ofNat_eq_factorial (n : ℕ) [(n + 1).AtLeastTwo] :
    Gamma (no_index (OfNat.ofNat (n + 1) : ℂ)) = n !
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- If `colimit (F ⋙ coyoneda.obj (op d)) ≅ PUnit` for all `d : D`, then `F` is cofinal.
-/
theorem cofinal_of_colimit_comp_coyoneda_iso_pUnit
    (I : ∀ d, colimit (F ⋙ coyoneda.obj (op d)) ≅ PUnit) : Final F
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arcsin_one : arcsin 1 = π / 2
-- Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean
@[reassoc (attr := simp)]
lemma mappingConeHomOfDegreewiseSplitIso_inv_comp_triangle_mor₃ :
    (mappingConeHomOfDegreewiseSplitIso S σ).inv ≫
      (mappingCone.triangle (homOfDegreewiseSplit S σ)).mor₃ = -S.g⟦(1 : ℤ)⟧'
-- Mathlib/RingTheory/Polynomial/Dickson.lean
private theorem two_mul_C_half_eq_one [Invertible (2 : R)] : 2 * C (⅟ 2 : R) = 1
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_hasFPowerSeriesOnBall : HasFPowerSeriesOnBall (exp 𝕂) (expSeries 𝕂 𝔸) 0 ∞
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
theorem eq_affineCombination_of_mem_affineSpan_of_fintype [Fintype ι] {p1 : P} {p : ι → P}
    (h : p1 ∈ affineSpan k (Set.range p)) :
    ∃ w : ι → k, ∑ i, w i = 1 ∧ p1 = Finset.univ.affineCombination k p w
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem repr_injective :
    Injective (repr : OrthonormalBasis ι 𝕜 E → E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι)
-- Mathlib/Data/Multiset/Antidiagonal.lean
@[simp]
theorem antidiagonal_coe' (l : List α) : @antidiagonal α l = revzip (powersetAux' l)
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
@[simp low]
theorem summable_unop {f : β → αᵐᵒᵖ} : (Summable fun a ↦ unop (f a)) ↔ Summable f
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem generate_sieve (S : Sieve X) : generate S = S
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem natDegree_derivative_le (p : R[X]) : p.derivative.natDegree ≤ p.natDegree - 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_insert_of_mem {l : List α} (h : a ∈ l) : a ∈ l.insert b
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
@[simp]
theorem refl_toLinearEquiv : refl R A = LinearEquiv.refl R A
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_equiv' (e : ι ≃ ι') {f : ι' → A} {g : ι → A} (h : f ∘ e = g) :
    AlgebraicIndependent R g ↔ AlgebraicIndependent R f
-- Mathlib/MeasureTheory/Group/Pointwise.lean
theorem MeasurableSet.const_smul₀ {G₀ α : Type*} [GroupWithZero G₀] [Zero α]
    [MulActionWithZero G₀ α] [MeasurableSpace G₀] [MeasurableSpace α] [MeasurableSMul G₀ α]
    [MeasurableSingletonClass α] {s : Set α} (hs : MeasurableSet s) (a : G₀) :
    MeasurableSet (a • s)
-- Mathlib/Data/Real/Hyperreal.lean
theorem omega_pos : 0 < ω
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
/-- A tagged prepartition is a prepartition enriched with a tagged point for each box of the
prepartition. For simplicity we require that `tag` is defined for all boxes in `ι → ℝ` but
we will use only the values of `tag` on the boxes of the partition. -/
structure TaggedPrepartition (I : Box ι) extends Prepartition I where
  /-- Choice of tagged point of each box in this prepartition:
    we extend this to a total function, on all boxes in `ι → ℝ`. -/
  tag : Box ι → ι → ℝ
  /-- Each tagged point belongs to `I` -/
  tag_mem_Icc : ∀ J, tag J ∈ Box.Icc I
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem IntegrableOn.locallyIntegrableOn (hf : IntegrableOn f s μ) : LocallyIntegrableOn f s μ
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem find?_replicate_of_length_pos (h : 0 < n) : find? p (replicate n a) = if p a then some a else none
-- Mathlib/Order/Filter/Basic.lean
theorem frequently_imp_distrib_left {f : Filter α} [NeBot f] {p : Prop} {q : α → Prop} :
    (∃ᶠ x in f, p → q x) ↔ p → ∃ᶠ x in f, q x
-- Mathlib/RingTheory/Valuation/Quotient.lean
@[simp]
theorem comap_onQuot_eq (J : Ideal R) (v : AddValuation (R ⧸ J) Γ₀) :
    (v.comap (Ideal.Quotient.mk J)).onQuot (v.self_le_supp_comap J) = v
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq_zero_iff_of_nonneg {f : α → ℝ} (hf : 0 ≤ f) (hfi : Integrable f μ) :
    ∫ x, f x ∂μ = 0 ↔ f =ᵐ[μ] 0
-- Mathlib/GroupTheory/EckmannHilton.lean
/-- If a type carries two unital binary operations that distribute over each other,
then these operations are associative.

In fact, they give a commutative monoid structure, see `eckmann_hilton.CommMonoid`. -/
theorem mul_assoc : Std.Associative m₂
-- Mathlib/Analysis/Complex/PhragmenLindelof.lean
/-- **Phragmen-Lindelöf principle** in the fourth quadrant. Let `f : ℂ → E` be a function such that

* `f` is differentiable in the open fourth quadrant and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * (abs z) ^ c)` on the open fourth quadrant
  for some `A`, `B`, and `c < 2`;
* `f` is equal to zero on the boundary of the fourth quadrant.

Then `f` is equal to zero on the closed fourth quadrant. -/
theorem eq_zero_on_quadrant_IV (hd : DiffContOnCl ℂ f (Ioi 0 ×ℂ Iio 0))
    (hB : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 (Ioi 0 ×ℂ Iio 0)] fun z => expR (B * abs z ^ c))
    (hre : ∀ x : ℝ, 0 ≤ x → f x = 0) (him : ∀ x : ℝ, x ≤ 0 → f (x * I) = 0) :
    EqOn f 0 {z | 0 ≤ z.re ∧ z.im ≤ 0}
-- Mathlib/Data/Set/Lattice.lean
theorem inter_eq_iInter {s₁ s₂ : Set α} : s₁ ∩ s₂ = ⋂ b : Bool, cond b s₁ s₂
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_singleton_right : image₂ f s {b} = s.image fun a => f a b
-- Mathlib/Data/Complex/Exponential.lean
theorem sin_le_one : sin x ≤ 1
-- Mathlib/Order/Closure.lean
/-- If `c` is a closure operator on `α` and `e` an order-isomorphism
between `α` and `β` then `e ∘ c ∘ e⁻¹` is a closure operator on `β`. -/
@[simps apply]
def conjBy {α β} [Preorder α] [Preorder β] (c : ClosureOperator α)
    (e : α ≃o β) : ClosureOperator β
-- Mathlib/Topology/Instances/AddCircle.lean
theorem addOrderOf_coe_rat {q : ℚ} : addOrderOf (↑(↑q * p) : AddCircle p) = q.den
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp, norm_cast]
theorem coe_mul (z w : 𝔻) : ↑(z * w) = (z * w : ℂ)
-- Mathlib/NumberTheory/FLT/Three.lean
/-- To prove `FermatLastTheoremFor 3`, it is enough to prove `FermatLastTheoremForThreeGen`. -/
lemma FermatLastTheoremForThree_of_FermatLastTheoremThreeGen :
    FermatLastTheoremForThreeGen hζ → FermatLastTheoremFor 3
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem norm_embedding_of_isReal {w : InfinitePlace K} (hw : IsReal w) (x : K) :
    ‖embedding_of_isReal hw x‖ = w x
-- .lake/packages/lean4/src/lean/Init/Data/Range.lean
theorem Membership.mem.upper {i : Nat} {r : Std.Range} (h : i ∈ r) : i < r.stop
-- Mathlib/Analysis/Convex/Extreme.lean
lemma image_extremePoints (f : L) (s : Set E) :
    f '' extremePoints 𝕜 s = extremePoints 𝕜 (f '' s)
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem id_eval (v) : id.eval v = pure v
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
@[simp]
lemma preNormEDS'_one : preNormEDS' b c d 1 = 1
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
/-- Finite wide pullbacks are finite limits, so if `C` has all finite limits,
it also has finite wide pullbacks
-/
theorem hasFiniteWidePullbacks_of_hasFiniteLimits [HasFiniteLimits C] : HasFiniteWidePullbacks C
-- Mathlib/Tactic/NormNum/Prime.lean
theorem isNat_minFac_4 : {n n' k : ℕ} →
    IsNat n n' → MinFacHelper n' k → (k * k).ble n' = false → IsNat (minFac n) n'
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
nonrec theorem ContMDiffAt.clm_prodMap {g : M → F₁ →L[𝕜] F₃} {f : M → F₂ →L[𝕜] F₄} {x : M}
    (hg : ContMDiffAt I 𝓘(𝕜, F₁ →L[𝕜] F₃) n g x) (hf : ContMDiffAt I 𝓘(𝕜, F₂ →L[𝕜] F₄) n f x) :
    ContMDiffAt I 𝓘(𝕜, F₁ × F₂ →L[𝕜] F₃ × F₄) n (fun x => (g x).prodMap (f x)) x
-- Mathlib/RingTheory/Ideal/Quotient.lean
@[simp]
theorem mk_eq_mk (x : R) : (Submodule.Quotient.mk x : R ⧸ I) = mk I x
-- Mathlib/RingTheory/Ideal/Pointwise.lean
@[simp]
theorem pointwise_smul_toAddSubGroup (a : M) (S : Ideal R)
    (ha : Function.Surjective fun r : R => a • r)  :
    (a • S).toAddSubgroup = a • S.toAddSubgroup
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem aevalTower_C (x : R) : aevalTower g y (C x) = g x
-- Mathlib/Algebra/Ring/Commute.lean
theorem lie_def (x y : R) : ⁅x, y⁆ = x * y - y * x
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
@[reassoc (attr := simp)]
lemma whiskerRight_fst {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : C) :
    (f ▷ Y) ≫ fst _ _ = fst _ _ ≫ f
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast]
theorem coe_sub (h : q ≤ p) : ((p - q : ℚ≥0) : ℚ) = p - q
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
theorem isTree_iff_existsUnique_path :
    G.IsTree ↔ Nonempty V ∧ ∀ v w : V, ∃! p : G.Walk v w, p.IsPath
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem self_trans_inv (e : Perm α) : e.trans e⁻¹ = 1
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_add_nat (a : α) (n : ℕ) : ⌊a + n⌋ = ⌊a⌋ + n
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSet_eq_stopping_time_of_countable [Countable ι] [TopologicalSpace ι]
    [MeasurableSpace ι] [BorelSpace ι] [OrderTopology ι] [MeasurableSingletonClass ι]
    [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = π ω}
-- Mathlib/Data/Seq/WSeq.lean
theorem liftRel_join.lem (R : α → β → Prop) {S T} {U : WSeq α → WSeq β → Prop}
    (ST : LiftRel (LiftRel R) S T)
    (HU :
      ∀ s1 s2,
        (∃ s t S T,
            s1 = append s (join S) ∧
              s2 = append t (join T) ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) →
          U s1 s2)
    {a} (ma : a ∈ destruct (join S)) : ∃ b, b ∈ destruct (join T) ∧ LiftRelO R U a b
-- Mathlib/GroupTheory/Perm/Finite.lean
theorem perm_mapsTo_inl_iff_mapsTo_inr {m n : Type*} [Finite m] [Finite n] (σ : Perm (m ⊕ n)) :
    Set.MapsTo σ (Set.range Sum.inl) (Set.range Sum.inl) ↔
      Set.MapsTo σ (Set.range Sum.inr) (Set.range Sum.inr)
-- Mathlib/Analysis/Normed/MulAction.lean
theorem norm_smul (r : α) (x : β) : ‖r • x‖ = ‖r‖ * ‖x‖
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem uniformContinuous_lift' [T0Space β] (f : α → β) : UniformContinuous (lift' f)
-- Mathlib/Data/PFun.lean
@[simp]
theorem prodLift_fst_comp_snd_comp (f : α →. γ) (g : β →. δ) :
    prodLift (f.comp ((Prod.fst : α × β → α) : α × β →. α))
        (g.comp ((Prod.snd : α × β → β) : α × β →. β)) =
      prodMap f g
-- Mathlib/Data/Set/Function.lean
theorem EqOn.comp_right (hg : t.EqOn g₁ g₂) (hf : s.MapsTo f t) : s.EqOn (g₁ ∘ f) (g₂ ∘ f)
-- Mathlib/Order/GaloisConnection.lean
theorem u_comm_of_l_comm {X : Type*} [PartialOrder X] {Y : Type*} [Preorder Y] {Z : Type*}
    [Preorder Z] {W : Type*} [Preorder W] {lYX : X → Y} {uXY : Y → X}
    (hXY : GaloisConnection lYX uXY) {lWZ : Z → W} {uZW : W → Z} (hZW : GaloisConnection lWZ uZW)
    {lWY : Y → W} {uYW : W → Y} (hWY : GaloisConnection lWY uYW) {lZX : X → Z} {uXZ : Z → X}
    (hXZ : GaloisConnection lZX uXZ) (h : ∀ x, lWZ (lZX x) = lWY (lYX x)) {w : W} :
    uXZ (uZW w) = uXY (uYW w)
-- Mathlib/Algebra/Field/Basic.lean
@[simp] lemma toDual_ratCast [RatCast α] (n : ℚ) : toDual (n : α) = n
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_top : Icc a ⊤ = Ici a
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mem_map {f : α → β} : ∀ {l : List α}, b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem list_cycles_perm_list_cycles {α : Type*} [Finite α] {l₁ l₂ : List (Perm α)}
    (h₀ : l₁.prod = l₂.prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
    (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem fundSystem_mk (i : Fin (rank K)) :
    Additive.ofMul ⟦fundSystem K i⟧ = (basisModTorsion K i)
-- Mathlib/Probability/Martingale/Basic.lean
theorem submartingale_iff_condexp_sub_nonneg [IsFiniteMeasure μ] {f : ι → Ω → ℝ} :
    Submartingale f ℱ μ ↔
      Adapted ℱ f ∧ (∀ i, Integrable (f i) μ) ∧ ∀ i j, i ≤ j → 0 ≤ᵐ[μ] μ[f j - f i|ℱ i]
-- Mathlib/Topology/Homeomorph.lean
theorem preimage_interior (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' interior s = interior (h ⁻¹' s)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- Given a partial homeomorphism `e` from a space `α` into `H`, if its source covers the whole
space `α`, then the induced charted space structure on `α` is `HasGroupoid G` for any structure
groupoid `G` which is closed under restrictions. -/
theorem singleton_hasGroupoid (h : e.source = Set.univ) (G : StructureGroupoid H)
    [ClosedUnderRestriction G] : @HasGroupoid _ _ _ _ (e.singletonChartedSpace h) G
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma val_wcovBy_val : s.1 ⩿ t.1 ↔ s ⩿ t
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem eq_orderOf : k = orderOf ζ
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem copy_eq (f : Ω^ N X x) {g : (I^N) → X} (h : g = f) : copy f g h = f
-- Mathlib/Init/Classical.lean
@[elab_as_elim] theorem cases_true_false (p : Prop → Prop)
    (h1 : p True) (h2 : p False) (a : Prop) : p a
-- Mathlib/Deprecated/Group.lean
theorem Multiplicative.isGroupHom [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) :
    @IsGroupHom (Multiplicative α) (Multiplicative β) _ _ f
-- Mathlib/Algebra/Module/DedekindDomain.lean
/-- A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules where `p i` are factors of `(⊤ : Submodule R M).annihilator` and
`e i` are their multiplicities. -/
theorem isInternal_prime_power_torsion [Module.Finite R M] (hM : Module.IsTorsion R M) :
    DirectSum.IsInternal fun p : (factors (⊤ : Submodule R M).annihilator).toFinset =>
      torsionBySet R M (p ^ (factors (⊤ : Submodule R M).annihilator).count ↑p : Ideal R)
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem inclusion_injective {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) :
    Function.Injective <| inclusion h
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem Kernel.indep_iSup_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s κ μα)
    (hf : ∀ t, p t → tᶜ ∈ f)
    (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a)) (hns_univ : ∀ n, ∃ a, n ∈ ns a) :
    Indep (⨆ n, s n) (limsup s f) κ μα
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem iterate_pos_le_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x ≤ x + n * m ↔ f x ≤ x + m
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_Ico_eq_integral_Ioo' (hx : μ {x} = 0) :
    ∫ t in Ico x y, f t ∂μ = ∫ t in Ioo x y, f t ∂μ