ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivWithinAt.comp_hasFDerivWithinAt {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} {s t} (x)
    (hh : HasDerivWithinAt h₂ h₂' t (f x)) (hf : HasFDerivWithinAt f f' s x) (hst : MapsTo f s t) :
    HasFDerivWithinAt (h₂ ∘ f) (h₂' • f') s x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_add_int_mul_pi (x : ℝ) (n : ℤ) : sin (x + n * π) = (-1) ^ n * sin x
-- Mathlib/Analysis/Fourier/FourierTransform.lean
/-- The Fourier transform satisfies `∫ 𝓕 f * g = ∫ f * 𝓕 g`, i.e., it is self-adjoint.
Version where the multiplication is replaced by a general bilinear form `M`. -/
theorem integral_bilin_fourierIntegral_eq_flip
    {f : V → E} {g : W → F} (M : E →L[ℂ] F →L[ℂ] G) (he : Continuous e)
    (hL : Continuous fun p : V × W ↦ L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
    ∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν =
      ∫ x, M (f x) (fourierIntegral e ν L.flip g x) ∂μ
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma mk_point {P : PointClass R} (h : W'.NonsingularLift P) : (mk h).point = P
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- If `I` is initial, then `I ⨯ X` is isomorphic to it. -/
@[simps! hom]
noncomputable def isInitialMul (X : C) [HasBinaryProduct I X] (hI : IsInitial I) : I ⨯ X ≅ I
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem inf_inf_sdiff (x y : α) : x ⊓ y ⊓ x \ y = ⊥
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast]
theorem coe_pow (r : ℝ≥0) (n : ℕ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n
-- Mathlib/RingTheory/Finiteness.lean
lemma exists_fin' [Finite R M] : ∃ (n : ℕ) (f : (Fin n → R) →ₗ[R] M), Surjective f
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.right_le_of_le_left (hf : ConcaveOn 𝕜 s f) {x y z : E} (hx : x ∈ s) (hy : y ∈ s)
    (hz : z ∈ openSegment 𝕜 x y) (hxz : f z ≤ f x) : f y ≤ f z
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
theorem IsSRGWith.card_neighborFinset_union_eq {v w : V} (h : G.IsSRGWith n k ℓ μ) :
    (G.neighborFinset v ∪ G.neighborFinset w).card =
      2 * k - Fintype.card (G.commonNeighbors v w)
-- Mathlib/Order/PrimeIdeal.lean
theorem _root_.Order.Ideal.PrimePair.F_isPrime (IF : Ideal.PrimePair P) : IsPrime IF.F
-- Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
/-- The adjoint is maximal in the sense that it contains every formal adjoint. -/
theorem IsFormalAdjoint.le_adjoint (h : T.IsFormalAdjoint S) : S ≤ T†
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_left_left_iff {x y z : R} : IsRelPrime (y * z + x) y ↔ IsRelPrime x y
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
lemma W_iff_isLocallyBijective :
    J.W f ↔ Presheaf.IsLocallyInjective J f ∧ Presheaf.IsLocallySurjective J f
-- Mathlib/Data/Multiset/Fold.lean
theorem le_smul_dedup [DecidableEq α] (s : Multiset α) : ∃ n : ℕ, s ≤ n • dedup s
-- Mathlib/Data/Multiset/Bind.lean
@[simp] lemma mem_product : ∀ {p : α × β}, p ∈ @product α β s t ↔ p.1 ∈ s ∧ p.2 ∈ t
-- .lake/packages/batteries/Batteries/Data/Rat/Basic.lean
theorem Rat.normalize.den_nz {num : Int} {den g : Nat} (den_nz : den ≠ 0)
    (e : g = num.natAbs.gcd den) : den / g ≠ 0
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
@[simp]
theorem lTensorOne_symm_apply (n : N) : N.lTensorOne.symm n = 1 ⊗ₜ[R] n
-- Mathlib/Analysis/Convex/Segment.lean
theorem image_update_segment (i : ι) (x₁ x₂ : π i) (y : ∀ i, π i) :
    update y i '' [x₁ -[𝕜] x₂] = [update y i x₁ -[𝕜] update y i x₂]
-- Mathlib/CategoryTheory/Dialectica/Monoidal.lean
theorem leftUnitor_naturality {X Y : Dial C} (f : X ⟶ Y) :
    (𝟙 (𝟙_ (Dial C)) ⊗ f) ≫ (λ_ Y).hom = (λ_ X).hom ≫ f
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
/-- The type of continuous maps which map zero to zero.

Note that one should never use the structure projection `ContinuousMapZero.toContinuousMap` and
instead favor the coercion `(↑) : C(X, R)₀ → C(X, R)` available from the instance of
`ContinuousMapClass`. All the instances on `C(X, R)₀` from `C(X, R)` passes through this coercion,
not the structure projection. Of course, the two are definitionally equal, but not reducibly so. -/
structure ContinuousMapZero (X R : Type*) [Zero X] [Zero R] [TopologicalSpace X]
    [TopologicalSpace R] extends C(X, R) where
  map_zero' : toContinuousMap 0 = 0
-- Mathlib/Analysis/Convolution.lean
/-- The convolution is continuous if one function is integrable and the other is bounded and
continuous. -/
theorem _root_.BddAbove.continuous_convolution_right_of_integrable
    [FirstCountableTopology G] [SecondCountableTopologyEither G E']
    (hbg : BddAbove (range fun x => ‖g x‖)) (hf : Integrable f μ) (hg : Continuous g) :
    Continuous (f ⋆[L, μ] g)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
lemma continuousOn_inv_iff : ContinuousOn f⁻¹ s ↔ ContinuousOn f s
-- Mathlib/Logic/Equiv/Defs.lean
protected theorem bijective (e : α ≃ β) : Bijective e
-- Mathlib/MeasureTheory/Function/ContinuousMapDense.lean
/-- Continuous functions are dense in `MeasureTheory.Lp`, `1 ≤ p < ∞`. This theorem assumes that
the domain is a compact space because otherwise `ContinuousMap.toLp` is undefined. Use
`BoundedContinuousFunction.toLp_denseRange` if the domain is not a compact space.  -/
theorem toLp_denseRange [CompactSpace α] [μ.WeaklyRegular] [IsFiniteMeasure μ] :
    DenseRange (toLp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ)
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fast_fib_eq (n : ℕ) : fastFib n = fib n
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem filter_sub [∀ i, AddGroup (β i)] (p : ι → Prop) [DecidablePred p] (f g : Π₀ i, β i) :
    (f - g).filter p = f.filter p - g.filter p
-- Mathlib/LinearAlgebra/Ray.lean
/-- A vector is in the same ray as a positive multiple of itself. -/
lemma sameRay_pos_smul_right (v : M) (ha : 0 < a) : SameRay R v (a • v)
-- Mathlib/Data/Set/Function.lean
theorem InjOn.comp (hg : InjOn g t) (hf : InjOn f s) (h : MapsTo f s t) : InjOn (g ∘ f) s
-- Mathlib/Data/Int/Bitwise.lean
theorem bitwise_diff : (bitwise fun a b => a && not b) = ldiff
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_union_Ioo_eq_Ioo (h₁ : a ≤ b) (h₂ : b < c) : Ioc a b ∪ Ioo b c = Ioo a c
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem succ_mul_succ_eq (a b : Nat) : succ a * succ b = a * b + a + b + 1
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem eq_div_of_mul_eq_right {a b c : R} (ha : a ≠ 0) (h : a * b = c) : b = c / a
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem measurableSet_image (hf : MeasurableEmbedding f) :
    MeasurableSet (f '' s) ↔ MeasurableSet s
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_coe (s : Finset α) (t : α → Set β) : ⋃ x ∈ (↑s : Set α), t x = ⋃ x ∈ s, t x
-- Mathlib/Order/Filter/AtTopBot.lean
theorem disjoint_atTop_principal_Iic [Preorder α] [NoMaxOrder α] (x : α) :
    Disjoint atTop (𝓟 (Iic x))
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem exists_measurable_superset_iff_measure_eq_zero :
    (∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = 0) ↔ μ s = 0
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@[simp]
theorem adjugate_fin_one (A : Matrix (Fin 1) (Fin 1) α) : adjugate A = 1
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma existsUnique_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∃! a, p a) ↔ ∃! b, q b
-- Mathlib/Data/DFinsupp/Basic.lean
/-- The `DFinsupp` version of `Finsupp.comp_liftAddHom`,-/
theorem comp_liftAddHom {δ : Type*} [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] [AddCommMonoid δ]
    (g : γ →+ δ) (f : ∀ i, β i →+ γ) :
    g.comp (liftAddHom (β := β) f) = liftAddHom (β := β) fun a => g.comp (f a)
-- Mathlib/Topology/Compactification/OnePoint.lean
lemma continuous_iff_from_nat {Y : Type*} [TopologicalSpace Y] (f : OnePoint ℕ → Y) :
    Continuous f ↔ Tendsto (fun x : ℕ ↦ f x) atTop (𝓝 (f ∞))
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem ball_inter_right (x : β) (V W : Set (β × β)) : ball x (V ∩ W) ⊆ ball x W
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma isEquivalent_smoothingFn_sub_self (i : α) :
    (fun (n : ℕ) => ε (b i * n) - ε n) ~[atTop] fun n => -log (b i) / (log n)^2
-- Mathlib/Data/Finsupp/WellFounded.lean
protected theorem wellFoundedLT [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
    WellFoundedLT (α →₀ N)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem lift'_comp_uniformity : ((𝓤 α).lift' fun s : Set (α × α) => s ○ s) = 𝓤 α
-- Mathlib/Topology/Bornology/Constructions.lean
theorem isBounded_image_subtype_val {p : α → Prop} {s : Set { x // p x }} :
    IsBounded (Subtype.val '' s) ↔ IsBounded s
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem tsupport_subset_symm_image_closedBall :
    tsupport f ⊆ (extChartAt I c).symm '' (closedBall (extChartAt I c c) f.rOut ∩ range I)
-- Mathlib/Data/ZMod/Basic.lean
theorem cast_sub_one {R : Type*} [Ring R] {n : ℕ} (k : ZMod n) :
    (cast (k - 1 : ZMod n) : R) = (if k = 0 then (n : R) else cast k) - 1
-- Mathlib/Data/Nat/Squarefree.lean
theorem squarefree_pow_iff {n k : ℕ} (hn : n ≠ 1) (hk : k ≠ 0) :
    Squarefree (n ^ k) ↔ Squarefree n ∧ k = 1
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem dZero_ker_eq_invariants : LinearMap.ker (dZero A) = invariants A.ρ
-- Mathlib/Data/Multiset/Basic.lean
theorem count_map {α β : Type*} (f : α → β) (s : Multiset α) [DecidableEq β] (b : β) :
    count b (map f s) = card (s.filter fun a => b = f a)
-- Mathlib/Data/List/Sublists.lean
theorem nodup_sublistsLen (n : ℕ) {l : List α} (h : Nodup l) : (sublistsLen n l).Nodup
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem mem_find (x : X) : x ∈ K (K.find x)
-- Mathlib/Algebra/Module/Torsion.lean
/-- The torsion submodule is always a torsion module. -/
theorem torsion_isTorsion : Module.IsTorsion R (torsion R M)
-- Mathlib/Algebra/Order/Monovary.lean
lemma Monovary.pow_right₀ (hg : 0 ≤ g) (hfg : Monovary f g) (n : ℕ) : Monovary f (g ^ n)
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem normSq_neg : normSq (-a) = normSq a
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem lengthParity_simple (i : B) :
    cs.lengthParity (s i) = Multiplicative.ofAdd 1
-- Mathlib/Topology/Bornology/Basic.lean
@[simp]
theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
    IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i)
-- Mathlib/FieldTheory/Perfect.lean
theorem iterateFrobeniusEquiv_eq_pow : iterateFrobeniusEquiv R p n = frobeniusEquiv R p ^ n
-- Mathlib/Data/Nat/PartENat.lean
@[elab_as_elim]
protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma homologyMap_comm :
    homologyMap φ ≫ h₂.homologyIso.hom = h₁.homologyIso.hom ≫ γ.φH
-- Mathlib/Data/Nat/Bits.lean
theorem div2_bit1 (n) : div2 (2 * n + 1) = n
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem zero_eval (v) : zero.eval v = pure [0]
-- Mathlib/Algebra/Jordan/Basic.lean
private theorem aux2 {a b c : A} :
    ⁅L a, L (a * a)⁆ + ⁅L a, L (b * b)⁆ + ⁅L a, L (c * c)⁆ +
    ⁅L a, 2 • L (a * b)⁆ + ⁅L a, 2 • L (c * a)⁆ + ⁅L a, 2 • L (b * c)⁆ +
    (⁅L b, L (a * a)⁆ + ⁅L b, L (b * b)⁆ + ⁅L b, L (c * c)⁆ +
    ⁅L b, 2 • L (a * b)⁆ + ⁅L b, 2 • L (c * a)⁆ + ⁅L b, 2 • L (b * c)⁆) +
    (⁅L c, L (a * a)⁆ + ⁅L c, L (b * b)⁆ + ⁅L c, L (c * c)⁆ +
    ⁅L c, 2 • L (a * b)⁆ + ⁅L c, 2 • L (c * a)⁆ + ⁅L c, 2 • L (b * c)⁆)
    =
    ⁅L a, L (b * b)⁆ + ⁅L b, L (a * a)⁆ + 2 • (⁅L a, L (a * b)⁆ + ⁅L b, L (a * b)⁆) +
    (⁅L a, L (c * c)⁆ + ⁅L c, L (a * a)⁆ + 2 • (⁅L a, L (c * a)⁆ + ⁅L c, L (c * a)⁆)) +
    (⁅L b, L (c * c)⁆ + ⁅L c, L (b * b)⁆ + 2 • (⁅L b, L (b * c)⁆ + ⁅L c, L (b * c)⁆)) +
    (2 • ⁅L a, L (b * c)⁆ + 2 • ⁅L b, L (c * a)⁆ + 2 • ⁅L c, L (a * b)⁆)
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem setFinite [Module.Finite R M] {b : Set M}
    (h : LinearIndependent R fun x : b => (x : M)) : b.Finite
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Subsemigroup M) : Set M) = ∅
-- Mathlib/Data/PNat/Prime.lean
theorem gcd_dvd_right (n m : ℕ+) : gcd n m ∣ m
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- The product of `f i` over `i ∈ {a}` equals `f a`. -/
@[to_additive "The sum of `f i` over `i ∈ {a}` equals `f a`."]
theorem finprod_mem_singleton : (∏ᶠ i ∈ ({a} : Set α), f i) = f a
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
@[simp (high)]
theorem coe_id (V : SemiNormedGrp₁) : ⇑(𝟙 V) = id
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem integral_const_mul (a : ℂ) (f : ℂ → ℂ) (c : ℂ) (R : ℝ) :
    (∮ z in C(c, R), a * f z) = a * ∮ z in C(c, R), f z
-- Mathlib/Topology/Constructions.lean
theorem isClosedMap_toDual : IsClosedMap (toDual : X → Xᵒᵈ)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem darts_takeUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).darts ⊆ p.darts
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp, norm_cast]
theorem edist_lt_coe {x y : α} {c : ℝ≥0} : edist x y < c ↔ nndist x y < c
-- Mathlib/Algebra/Order/AddTorsor.lean
@[to_additive]
theorem smul_lt_smul_of_le_of_lt [LE G] [Preorder P] [SMul G P] [IsOrderedCancelSMul G P]
    {a b : G} {c d : P} (h₁ : a ≤ b) (h₂ : c < d) :
  a • c < b • d
-- Mathlib/Algebra/AddTorsor.lean
@[simp]
theorem snd_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').2 = p₁.2 -ᵥ p₂.2
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeries_def (k : ℕ) : derivedSeries R L k = derivedSeriesOfIdeal R L k ⊤
-- Mathlib/CategoryTheory/Extensive.lean
theorem FinitaryExtensive.isVanKampen_finiteCoproducts_Fin [FinitaryExtensive C] {n : ℕ}
    {F : Discrete (Fin n) ⥤ C} {c : Cocone F} (hc : IsColimit c) : IsVanKampenColimit c
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem continuum_add_nat (n : ℕ) : 𝔠 + n = 𝔠
-- Mathlib/Data/Bool/Basic.lean
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
/-- The determinant of a unit matrix is itself a unit. -/
@[simps]
def det : GL n R →* Rˣ
-- Mathlib/Data/Set/Lattice.lean
theorem image_iUnion₂ (f : α → β) (s : ∀ i, κ i → Set α) :
    (f '' ⋃ (i) (j), s i j) = ⋃ (i) (j), f '' s i j
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
/-- Integrating against the Dirac measure is equal to the delta distribution. -/
@[simp]
theorem integralCLM_dirac_eq_delta (x : E) : integralCLM 𝕜 (dirac x) = delta 𝕜 F x
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem le_smul_caratheodory (a : ℝ≥0∞) (m : OuterMeasure α) :
    m.caratheodory ≤ (a • m).caratheodory
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem derivative_X_pow (n : ℕ) : derivative (X ^ n : R[X]) = C (n : R) * X ^ (n - 1)
-- Mathlib/Algebra/Group/Invertible/Basic.lean
theorem Commute.invOf_left [Monoid α] {a b : α} [Invertible b] (h : Commute b a) :
    Commute (⅟ b) a
-- Mathlib/RingTheory/IsAdjoinRoot.lean
/-- Unicity of `liftHom`: a map that agrees on `h.root` agrees with `liftHom` everywhere. -/
theorem eq_liftHom (h : IsAdjoinRoot S f) (g : S →ₐ[R] T) (hroot : g h.root = x) :
    g = h.liftHom x hx'
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem prod_span_singleton {ι : Type*} (s : Finset ι) (I : ι → R) :
    (∏ i ∈ s, Ideal.span ({I i} : Set R)) = Ideal.span {∏ i ∈ s, I i}
-- Mathlib/Algebra/QuaternionBasis.lean
/-- A `QuaternionAlgebra.Basis` implies an `AlgHom` from the quaternions. -/
@[simps!]
def liftHom : ℍ[R,c₁,c₂] →ₐ[R] A
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Expressing uniform convergence using `edist`. -/
theorem tendstoUniformly_iff {ι : Type*} {F : ι → β → α} {f : β → α} {p : Filter ι} :
    TendstoUniformly F f p ↔ ∀ ε > 0, ∀ᶠ n in p, ∀ x, edist (f x) (F n x) < ε
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
/-- Note that the name is to match `CanonicallyOrderedCommSemiring.mul_pos`. -/
@[simp] lemma _root_.CanonicallyOrderedCommSemiring.prod_pos [Nontrivial R] :
    0 < ∏ i ∈ s, f i ↔ (∀ i ∈ s, (0 : R) < f i)
-- Mathlib/Data/ENNReal/Operations.lean
theorem not_lt_top {x : ℝ≥0∞} : ¬x < ∞ ↔ x = ∞
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
lemma coeff_det_one_add_X_smul_one (M : Matrix n n R) :
    (det (1 + (X : R[X]) • M.map C)).coeff 1 = trace M
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
@[simp]
protected theorem mul_inv_cancel (φ : k⟦X⟧) (h : constantCoeff k φ ≠ 0) : φ * φ⁻¹ = 1
-- Mathlib/CategoryTheory/ComposableArrows.lean
/-- The map `ComposableArrows C m → ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n
-- Mathlib/Data/Int/Order/Units.lean
@[simp]
theorem units_mul_self (u : ℤˣ) : u * u = 1
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp] theorem snd_natCast (n : ℕ) : (n : X q).snd = (0 : ZMod q)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_uIcc (ha : a ≠ 0) (b c : α) :
    (· * a) ⁻¹' [[b, c]] = [[b / a, c / a]]
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Bounded.to_lt : ∀ {t : Ordnode α} {x y : α}, Bounded t x y → x < y
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff {a : M} {S : Subsemiring R} {x : R} : a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smoothWithinAt_id : SmoothWithinAt I I (id : M → M) s x
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffAt.continuousAt (hf : ContMDiffAt I I' n f x) : ContinuousAt f x
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem swap_swap_eq : swap ∘ swap = @id (α ⊕ β)
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
theorem multiequalizer_ext {I : MulticospanIndex.{w} C} [HasMultiequalizer I]
    [PreservesLimit I.multicospan (forget C)] (x y : ↑(multiequalizer I))
    (h : ∀ t : I.L, Multiequalizer.ι I t x = Multiequalizer.ι I t y) : x = y
-- Mathlib/Algebra/Homology/ComplexShape.lean
/-- The complex shape where only differentials from each `X.i` to itself are allowed.

This is mostly only useful so we can describe the relation of "related in `k` steps" below.
-/
@[simps]
def refl (ι : Type*) : ComplexShape ι
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousMultilinearMap.curryRight_norm (f : ContinuousMultilinearMap 𝕜 Ei G) :
    ‖f.curryRight‖ = ‖f‖
-- Mathlib/Tactic/Ring/Basic.lean
theorem zero_mul (b : R) : 0 * b = 0
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem isPrincipal_inv (I : FractionalIdeal R₁⁰ K) [Submodule.IsPrincipal (I : Submodule R₁ K)]
    (h : I ≠ 0) : Submodule.IsPrincipal I⁻¹.1
-- Mathlib/Data/PEquiv.lean
theorem ofSet_eq_some_self_iff {s : Set α} {_ : DecidablePred (· ∈ s)} {a : α} :
    ofSet s a = some a ↔ a ∈ s
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagram_l : D.diagram.L = (D.J × D.J)
-- Mathlib/Order/Heyting/Basic.lean
theorem le_compl_iff_disjoint_right : a ≤ bᶜ ↔ Disjoint a b
-- Mathlib/Order/CompleteLattice.lean
theorem unary_relation_sInf_iff {α : Type*} (s : Set (α → Prop)) {a : α} :
    sInf s a ↔ ∀ r : α → Prop, r ∈ s → r a
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem measure_mul_measure_eq (s t : Set G) (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    μ' s * ν' t = ν' s * μ' t
-- Mathlib/LinearAlgebra/Matrix/Gershgorin.lean
/-- **Gershgorin's circle theorem**: for any eigenvalue `μ` of a square matrix `A`, there exists an
index `k` such that `μ` lies in the closed ball of center the diagonal term `A k k` and of
radius the sum of the norms `∑ j ≠ k, ‖A k j‖. -/
theorem eigenvalue_mem_ball {μ : K} (hμ : Module.End.HasEigenvalue (Matrix.toLin' A) μ) :
    ∃ k, μ ∈ Metric.closedBall (A k k) (∑ j ∈ Finset.univ.erase k, ‖A k j‖)
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
@[simp]
theorem circulant_inj [AddGroup n] {v w : n → α} : circulant v = circulant w ↔ v = w
-- Mathlib/Algebra/DualNumber.lean
@[simp]
theorem eps_mul_eps [Semiring R] : (ε * ε : R[ε]) = 0
-- Mathlib/ModelTheory/Complexity.lean
theorem IsQF.castLE {h : l ≤ n} (hφ : IsQF φ) : (φ.castLE h).IsQF
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
protected theorem HasGradientAt.continuousOn {f' : F → F} (h : ∀ x ∈ s, HasGradientAt f (f' x) x) :
    ContinuousOn f s
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem Nonempty.of_mul_right : (s * t).Nonempty → t.Nonempty
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem localTriv_continuousLinearMapAt {b : B} (hb : b ∈ Z.baseSet i) :
    (Z.localTriv i).continuousLinearMapAt R b = Z.coordChange (Z.indexAt b) i b
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma RightResolution.mk_surjective (R : Φ.RightResolution X₂) :
    ∃ (X₁ : C₁) (w : X₂ ⟶ Φ.functor.obj X₁) (hw : W₂ w), R = RightResolution.mk w hw
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
lemma isSimple_of_isAtom (I : LieIdeal R L) (hI : IsAtom I) : IsSimple R I
-- Mathlib/Topology/MetricSpace/Gluing.lean
/-- A disjoint union of complete metric spaces is complete. -/
protected theorem completeSpace [∀ i, CompleteSpace (E i)] : CompleteSpace (Σi, E i)
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factors_iff {X Y : C} (P : Subobject Y) (f : X ⟶ Y) :
    P.Factors f ↔ (representative.obj P).Factors f
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem HasFDerivAtFilter.sub_const (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun x => f x - c) f' x L
-- Mathlib/Topology/Instances/ENNReal.lean
theorem isOpen_Ico_zero : IsOpen (Ico 0 b)
-- Mathlib/Data/List/Palindrome.lean
theorem reverse_eq {l : List α} (p : Palindrome l) : reverse l = l
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Only assumes left strict covariance. -/
@[to_additive "Only assumes left strict covariance"]
theorem Left.mul_lt_mul [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α} (h₁ : a < b) (h₂ : c < d) :
    a * c < b * d
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[mono]
theorem ae_mono (h : μ ≤ ν) : ae μ ≤ ae ν
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem map_id : map id = (id : Germ l β → Germ l β)
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
theorem IsTerminal.strict_hom_ext (hI : IsTerminal I) {A : C} (f g : I ⟶ A) : f = g
-- Mathlib/Data/ENNReal/Operations.lean
theorem sub_eq_sInf {a b : ℝ≥0∞} : a - b = sInf { d | a ≤ d + b }
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem Heap.WF.tail (hwf : (s : Heap α).WF le n) : (s.tail le).WF le 0
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
    (hd : HasDerivWithinAt d d' s x) :
    HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Negating a rotation by -π / 2 is equivalent to rotation by π / 2. -/
@[simp]
theorem neg_rotation_neg_pi_div_two (x : V) :
    -o.rotation (-π / 2 : ℝ) x = o.rotation (π / 2 : ℝ) x
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem hasProd_le_inj {g : κ → α} (e : ι → κ) (he : Injective e)
    (hs : ∀ c, c ∉ Set.range e → 1 ≤ g c) (h : ∀ i, f i ≤ g (e i)) (hf : HasProd f a₁)
    (hg : HasProd g a₂) : a₁ ≤ a₂
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_toEquiv (h : M ≃ₘ^n⟮I, I'⟯ M') : ⇑h.toEquiv = h
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
theorem coeff_invOfUnit [DecidableEq σ] (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (u : Rˣ) :
    coeff R n (invOfUnit φ u) =
      if n = 0 then ↑u⁻¹
      else
        -↑u⁻¹ *
          ∑ x ∈ antidiagonal n,
            if x.2 < n then coeff R x.1 φ * coeff R x.2 (invOfUnit φ u) else 0
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simps]
def StarAlgEquiv.restrictScalars (f : A ≃⋆ₐ[S] B) : A ≃⋆ₐ[R] B
-- Mathlib/Computability/Primrec.lean
theorem head {n : ℕ} : @Primrec' n.succ head
-- Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean
theorem coe_stream_nth_rat_eq :
    ((IntFractPair.stream q n).map (mapFr (↑)) : Option <| IntFractPair K) =
      IntFractPair.stream v n
-- Mathlib/Data/Matrix/RowCol.lean
theorem updateRow_apply [DecidableEq m] {i' : m} :
    updateRow M i b i' j = if i' = i then b j else M i' j
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma norm_natCast_cpow_le_norm_natCast_cpow_iff {n : ℕ} (hn : 1 < n) {w z : ℂ} :
    ‖(n : ℂ) ^ w‖ ≤ ‖(n : ℂ) ^ z‖ ↔ w.re ≤ z.re