ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp] theorem nnnorm_equiv_symm (f : ∀ i, β i) : ‖(WithLp.equiv ⊤ _).symm f‖₊ = ‖f‖₊
-- Mathlib/Topology/MetricSpace/Dilation.lean
theorem comp_continuous_iff {γ} [TopologicalSpace γ] {g : γ → α} :
    Continuous ((f : α → β) ∘ g) ↔ Continuous g
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrOn.comp_mapsTo {t : Set δ} {g : δ → α} {b : δ} (hf : IsExtrOn f s a)
    (hg : MapsTo g t s) (ha : g b = a) : IsExtrOn (f ∘ g) t b
-- Mathlib/Topology/Algebra/GroupCompletion.lean
@[norm_cast]
theorem coe_neg (a : α) : ((-a : α) : Completion α) = -a
-- Mathlib/Algebra/Homology/Single.lean
@[simp]
lemma toSingle₀Equiv_symm_apply_f_zero
    {C : CochainComplex V ℕ} {X : V} (f : C.X 0 ⟶ X) :
    ((toSingle₀Equiv C X).symm f).f 0 = f
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_nonempty_iff {f : α →₀ M} : f.support.Nonempty ↔ f ≠ 0
-- Mathlib/Topology/Inseparable.lean
theorem not_specializes_iff_exists_closed : ¬x ⤳ y ↔ ∃ S : Set X, IsClosed S ∧ x ∈ S ∧ y ∉ S
-- Mathlib/Order/Ideal.lean
/-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
-- Mathlib/Data/ULift.lean
@[simp] lemma map_injective : Injective (ULift.map f : ULift.{u'} α → ULift.{v'} β) ↔ Injective f
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem op_smul_finset_smul_eq_smul_smul_finset (a : α) (s : Finset β) (t : Finset γ)
    (h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c) : (op a • s) • t = s • a • t
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive prod_mono_right]
theorem prod_mono_right (K : Subgroup G) : Monotone fun t : Subgroup N => K.prod t
-- Mathlib/Data/Matroid/Map.lean
lemma Base.map {B : Set α} (hB : M.Base B) {f : α → β} (hf) : (M.map f hf).Base (f '' B)
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
/-- An additive `n`-Freiman homomorphism from a set `A` to a set `B` is a bijective map which
preserves sums of `n` elements. -/
structure IsAddFreimanIso [AddCommMonoid α] [AddCommMonoid β] (n : ℕ) (A : Set α) (B : Set β)
    (f : α → β) : Prop where
  bijOn : BijOn f A B
  /-- An additive `n`-Freiman homomorphism preserves sums of `n` elements. -/
  map_sum_eq_map_sum ⦃s t : Multiset α⦄ (hsA : ∀ ⦃x⦄, x ∈ s → x ∈ A) (htA : ∀ ⦃x⦄, x ∈ t → x ∈ A)
    (hs : Multiset.card s = n) (ht : Multiset.card t = n) :
    (s.map f).sum = (t.map f).sum ↔ s.sum = t.sum
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem trop_top [Top R] : trop (⊤ : R) = 0
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.countP_eq (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂) :
    countP p l₁ = countP p l₂
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
theorem PushoutCocone.inl_colimit_cocone {X Y Z : C} (f : Z ⟶ X) (g : Z ⟶ Y)
    [HasColimit (span f g)] : PushoutCocone.inl (colimit.cocone (span f g)) = pushout.inl _ _
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem mul_one (a : Int) : a * 1 = a
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- The difference with `Algebra.adjoin_induction` is that this acts on the subtype. -/
@[elab_as_elim]
theorem adjoin_induction' {p : adjoin R s → Prop} (mem : ∀ (x) (h : x ∈ s), p ⟨x, subset_adjoin h⟩)
    (algebraMap : ∀ r, p (algebraMap R _ r)) (add : ∀ x y, p x → p y → p (x + y))
    (mul : ∀ x y, p x → p y → p (x * y)) (x : adjoin R s) : p x
-- Mathlib/AlgebraicGeometry/Limits.lean
/-- (Implementation Detail) The glue data associated to a disjoint union. -/
@[simps! J V U f t]
noncomputable
def disjointGlueData : Scheme.GlueData
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem isImage_source_target_of_disjoint (e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) : e.IsImage e'.source e'.target
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem extend_apply [MeasurableSpace β] (f₁ : α →ₛ γ) {g : α → β} (hg : MeasurableEmbedding g)
    (f₂ : β →ₛ γ) (x : α) : (f₁.extend g hg f₂) (g x) = f₁ x
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
theorem affineBasisCover_map_range (X : Scheme.{u}) (x : X)
    (r : (X.local_affine x).choose_spec.choose) :
    Set.range (X.affineBasisCover.map ⟨x, r⟩).1.base =
      (X.affineCover.map x).1.base '' (PrimeSpectrum.basicOpen r).1
-- Mathlib/Data/Nat/Defs.lean
lemma pow_mod (a b n : ℕ) : a ^ b % n = (a % n) ^ b % n
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_atBot_iSup (h_anti : Antitone f) : Tendsto f atBot (𝓝 (⨆ i, f i))
-- Mathlib/Data/Real/EReal.lean
theorem coe_nnreal_eq_coe_real (x : ℝ≥0) : ((x : ℝ≥0∞) : EReal) = (x : ℝ)
-- Mathlib/Algebra/Ring/Units.lean
@[simp]
theorem IsUnit.neg_iff [Monoid α] [HasDistribNeg α] (a : α) : IsUnit (-a) ↔ IsUnit a
-- Mathlib/Algebra/Group/Equiv/TypeTags.lean
/-- Reinterpret `G ≃+ Additive H` as `Multiplicative G ≃* H`. -/
@[simps]
def AddEquiv.toMultiplicative'' [AddZeroClass G] [MulOneClass H] :
    G ≃+ Additive H ≃ (Multiplicative G ≃* H)
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive (attr := simp)]
theorem uncurry_mul [∀ a b, Mul (γ a b)] (x y : ∀ a b, γ a b) :
    Sigma.uncurry (x * y) = Sigma.uncurry x * Sigma.uncurry y
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem WithBot.ciSup_empty [IsEmpty ι] [SupSet α] (f : ι → WithBot α) :
    ⨆ i, f i = ⊥
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- Lift a functor `F : C ⥤ D` to `WithTerminal C ⥤ D`. -/
@[simps]
def lift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, F.obj x ⟶ Z)
    (hM : ∀ (x y : C) (f : x ⟶ y), F.map f ≫ M y = M x) : WithTerminal C ⥤ D
-- Mathlib/Combinatorics/Colex.lean
lemma toColex_inj {s t : Finset α} : toColex s = toColex t ↔ s = t
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem sup_apply (x : ℝ) : (f ⊔ g) x = max (f x) (g x)
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftProp_iff {P : (H → H') → Set H → H → Prop} {f : M → M'} :
    LiftProp P f ↔
      Continuous f ∧ ∀ x, P (chartAt H' (f x) ∘ f ∘ (chartAt H x).symm) univ (chartAt H x x)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ1728_j [Invertible (2 : R)] : (ofJ1728 R).j = 1728
-- Mathlib/Data/Matrix/Basis.lean
theorem mulVec_stdBasisMatrix [Fintype m] (i : n) (j : m) (c : α) (x : m → α) :
    mulVec (stdBasisMatrix i j c) x = Function.update (0 : n → α) i (c * x j)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem symm {a b : α} (hab : a ≈ b) : b ≈ a
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
lemma solidClosure_min (hst : s ⊆ t) (ht : IsSolid t) : solidClosure s ⊆ t
-- Mathlib/Data/List/Sort.lean
theorem sorted_ofFn_iff {r : α → α → Prop} : (ofFn f).Sorted r ↔ ((· < ·) ⇒ r) f f
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem one_le_inv : 1 ≤ a⁻¹ ↔ a ≤ 1
-- Mathlib/Data/Finsupp/Order.lean
nonrec theorem disjoint_iff {f g : ι →₀ α} : Disjoint f g ↔ Disjoint f.support g.support
-- Mathlib/Algebra/DirectSum/Basic.lean
theorem mk_injective (s : Finset ι) : Function.Injective (mk β s)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem ofSet_trans {s : Set X} (hs : IsOpen s) : (ofSet s hs).trans e = e.restr s
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem pos_eq_endPos {l r it} (h : ValidFor l r it) : it.2 = it.1.endPos ↔ r = []
-- Mathlib/Order/Bounds/Basic.lean
theorem isGreatest_Iic : IsGreatest (Iic a) a
-- Mathlib/CategoryTheory/Monoidal/Category.lean
/-- The tensor product bifunctor `C ⥤ C ⥤ C` of a monoidal category. -/
@[simps]
def curriedTensor : C ⥤ C ⥤ C
-- Mathlib/Topology/Separation.lean
theorem specializes_iff_eq [T1Space X] {x y : X} : x ⤳ y ↔ x = y
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
/-- The restriction of a presheafed space along an open embedding into the space.
-/
@[simps]
def restrict {U : TopCat} (X : PresheafedSpace C) {f : U ⟶ (X : TopCat)}
    (h : OpenEmbedding f) : PresheafedSpace C
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
protected theorem image_symm_eq_preimage (e : P₁ ≃ᵃL[k] P₂) (s : Set P₂) :
    e.symm '' s = e ⁻¹' s
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap
-- Mathlib/Data/Finset/Lattice.lean
/-- A version of `Finset.sup'_map` with LHS and RHS reversed.
Also, this lemma assumes that `s` is nonempty instead of assuming that its image is nonempty. -/
lemma sup'_comp_eq_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : s.Nonempty) :
    s.sup' hs (g ∘ f) = (s.map f).sup' (map_nonempty.2 hs) g
-- Mathlib/Data/Real/Pi/Wallis.lean
theorem W_eq_integral_sin_pow_div_integral_sin_pow (k : ℕ) : (π / 2)⁻¹ * W k =
    (∫ x : ℝ in (0)..π, sin x ^ (2 * k + 1)) / ∫ x : ℝ in (0)..π, sin x ^ (2 * k)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_mul (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x * y) = logb b x + logb b y
-- Mathlib/Topology/PartitionOfUnity.lean
theorem toPartitionOfUnity_eq_mul_prod (i : ι) (x : X) (t : Finset ι)
    (ht : ∀ j, WellOrderingRel j i → f j x ≠ 0 → j ∈ t) :
    f.toPartitionOfUnity i x = f i x * ∏ j ∈ t.filter fun j => WellOrderingRel j i, (1 - f j x)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem mul_def {f g : k[G]} :
    f * g = f.sum fun a₁ b₁ => g.sum fun a₂ b₂ => single (a₁ + a₂) (b₁ * b₂)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem size_empty : (#[] : Array α).size = 0
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
/-- Two multivariate formal power series are equal
 if and only if all their coefficients are equal. -/
theorem ext_iff {φ ψ : MvPowerSeries σ R} : φ = ψ ↔ ∀ n : σ →₀ ℕ, coeff R n φ = coeff R n ψ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasStrictFDerivAt.cos (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
/-- The maximal ideal of `k⟦X⟧` is generated by `X`. -/
theorem maximalIdeal_eq_span_X : LocalRing.maximalIdeal (k⟦X⟧) = Ideal.span {X}
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The direction equals the `vectorSpan`. -/
theorem direction_eq_vectorSpan (s : AffineSubspace k P) : s.direction = vectorSpan k (s : Set P)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffOn.prod_mk_space {f : M → E'} {g : M → F'} (hf : ContMDiffOn I 𝓘(𝕜, E') n f s)
    (hg : ContMDiffOn I 𝓘(𝕜, F') n g s) : ContMDiffOn I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) s
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma natDegree_preΨ_pos {n : ℤ} (hn : 2 < n.natAbs) (h : (n : R) ≠ 0) :
    0 < (W.preΨ n).natDegree
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_div (hx : x ≠ 0) (hy : y ≠ 0) : logb b (x / y) = logb b x - logb b y
-- Mathlib/CategoryTheory/Yoneda.lean
/-- The Yoneda embedding, as a functor from `C` into presheaves on `C`.

See <https://stacks.math.columbia.edu/tag/001O>.
-/
@[simps]
def yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasStrictFDerivAt.const_mul (ha : HasStrictFDerivAt a a' x) (b : 𝔸) :
    HasStrictFDerivAt (fun y => b * a y) (b • a') x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem ne_zero_iff_zero_lt : n ≠ 0 ↔ 0 < n
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Variant of the mean value inequality on a convex set, using a bound on the difference between
the derivative and a fixed linear map, rather than a bound on the derivative itself. Version with
`HasFDerivWithinAt`. -/
theorem norm_image_sub_le_of_norm_hasFDerivWithin_le'
    (hf : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (bound : ∀ x ∈ s, ‖f' x - φ‖ ≤ C)
    (hs : Convex ℝ s) (xs : x ∈ s) (ys : y ∈ s) : ‖f y - f x - φ (y - x)‖ ≤ C * ‖y - x‖
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_smul (f : MvPowerSeries σ R) (n) (a : R) : coeff _ n (a • f) = a * coeff _ n f
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem embDomain_apply :
    s.embDomain f b = if h : b ∈ Set.range f then s (Classical.choose h) else 0
-- Mathlib/Data/List/Basic.lean
@[simp] theorem nthLe_tail (l : List α) (i) (h : i < l.tail.length)
    (h' : i + 1 < l.length := (by simp only [length_tail] at h; omega)) :
    l.tail.nthLe i h = l.nthLe (i + 1) h'
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem card_support_eq_three (hp : p.IsUnitTrinomial) : p.support.card = 3
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp]
theorem map_atTop (e : α ≃o β) : map (e : α → β) atTop = atTop
-- Mathlib/FieldTheory/IntermediateField.lean
protected theorem intCast_mem (n : ℤ) : (n : L) ∈ S
-- Mathlib/CategoryTheory/Comma/Over.lean
theorem iteratedSliceBackward_forget_forget :
    iteratedSliceBackward f ⋙ forget f ⋙ forget X = forget f.left
-- Mathlib/Data/List/Lemmas.lean
theorem foldl_range_eq_of_range_eq {f : α → β → α} {g : α → γ → α}
    (hfg : (Set.range fun a c => f c a) = Set.range fun b c => g c b) (a : α) :
    Set.range (foldl f a) = Set.range (foldl g a)
-- Mathlib/Data/Multiset/FinsetOps.lean
@[simp]
theorem cons_ndunion (s t : Multiset α) (a : α) : ndunion (a ::ₘ s) t = ndinsert a (ndunion s t)
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp] theorem moduleCat_of_toModuleCat (X : CoalgebraCat.{v} R) :
    ModuleCat.of R X.toModuleCat = X.toModuleCat
-- Mathlib/Probability/Martingale/Basic.lean
theorem martingale_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : Adapted 𝒢 f)
    (hint : ∀ i, Integrable (f i) μ) (hf : ∀ i, f i =ᵐ[μ] μ[f (i + 1)|𝒢 i]) : Martingale f 𝒢 μ
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[simp, fun_prop]
theorem DifferentiableAt.inverse (hf : DifferentiableAt 𝕜 h z) (hz : IsUnit (h z)) :
    DifferentiableAt 𝕜 (fun x => Ring.inverse (h x)) z
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem isNClique_one : G.IsNClique 1 s ↔ ∃ a, s = {a}
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem contains_eq [BEq α] (a : α) (l : AssocList α β) :
    contains a l = l.toList.any (·.1 == a)
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.left_le_of_le_sup_right (h : a ≤ b ⊔ c) (hd : Disjoint a c) : a ≤ b
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- For `f : α →ᵤ β`, `𝓝 f` admits the family `{g | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓑` as a filter
basis, for any basis `𝓑` of `𝓤 β`. -/
protected theorem hasBasis_nhds_of_basis (f) {p : ι → Prop} {s : ι → Set (β × β)}
    (h : HasBasis (𝓤 β) p s) :
    (𝓝 f).HasBasis p fun i => { g | (f, g) ∈ UniformFun.gen α β (s i) }
-- Mathlib/Order/Lattice.lean
theorem le_map_inf [SemilatticeInf α] [SemilatticeSup β] {f : α → β} (h : Antitone f) (x y : α) :
    f x ⊔ f y ≤ f (x ⊓ y)
-- Mathlib/Logic/Equiv/List.lean
theorem raise'_chain : ∀ (l) {m n}, m < n → List.Chain (· < ·) m (raise' l n)
-- Mathlib/CategoryTheory/Monoidal/Functorial.lean
/-- Construct a bundled `LaxMonoidalFunctor` from the object level function
and `Functorial` and `LaxMonoidal` typeclasses.
-/
@[simps]
def of (F : C → D) [I₁ : Functorial.{v₁, v₂} F] [I₂ : LaxMonoidal.{v₁, v₂} F] :
    LaxMonoidalFunctor.{v₁, v₂} C D
-- Mathlib/Combinatorics/Quiver/Cast.lean
theorem cast_eq_of_cons_eq_cons {u v v' w : U} {p : Path u v} {p' : Path u v'} {e : v ⟶ w}
    {e' : v' ⟶ w} (h : p.cons e = p'.cons e') : p.cast rfl (obj_eq_of_cons_eq_cons h) = p'
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem semiconjBy_star_star_star {x y z : R} :
    SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z
-- Mathlib/Order/Fin/Tuple.lean
@[simp] lemma strictAnti_vecCons : StrictAnti (vecCons a f) ↔ f 0 < a ∧ StrictAnti f
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- The supremum of a set of congruence relations is the same as the smallest congruence relation
    containing the supremum of the set's image under the map to the underlying binary relation. -/
@[to_additive "The supremum of a set of additive congruence relations is the same as the smallest
additive congruence relation containing the supremum of the set's image under the map to the
underlying binary relation."]
theorem sSup_def {S : Set (Con M)} :
    sSup S = conGen (sSup ((⇑) '' S))
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[to_additive (attr := simp)]
theorem inv_mk (f : α → γ) (hf) : (mk f hf : α →ₘ[μ] γ)⁻¹ = mk f⁻¹ hf.inv
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tsum_geometric_inv_two : (∑' n : ℕ, (2 : ℝ)⁻¹ ^ n) = 2
-- Mathlib/Data/Multiset/Basic.lean
theorem erase_le_iff_le_cons {s t : Multiset α} {a : α} : s.erase a ≤ t ↔ s ≤ a ::ₘ t
-- Mathlib/Data/List/Iterate.lean
@[simp]
theorem length_iterate (f : α → α) (a : α) (n : ℕ) : length (iterate f a n) = n
-- Mathlib/GroupTheory/HNNExtension.lean
@[simp]
theorem toSubgroupEquiv_one : toSubgroupEquiv φ 1 = φ
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem closure_univ : closure (Set.univ : Set R) = ⊤
-- Mathlib/CategoryTheory/Sites/Coherent/Equivalence.lean
/--
The coherent sheaf condition on an essentially small site can be checked after precomposing with
the equivalence with a small category.
-/
theorem precoherent_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :
    IsSheaf (coherentTopology C) F ↔
      IsSheaf (coherentTopology (SmallModel C)) ((equivSmallModel C).inverse.op ⋙ F)
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
/--
If `g` and `h` commute, then `g` moves `h ^ j • x` iff `g` moves `x`.
-/
@[to_additive "If `g` and `h` commute, then `g` moves `(j • h) +ᵥ x` iff `g` moves `x`."]
theorem smul_zpow_movedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • (fixedBy α g)ᶜ = (fixedBy α g)ᶜ
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[mono]
theorem toNonUnitalSubsemiring_strictMono :
    StrictMono (toNonUnitalSubsemiring : NonUnitalSubring R → NonUnitalSubsemiring R)
-- Mathlib/Data/Sum/Basic.lean
theorem update_inl_apply_inr [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ} :
    update f (inl i) x (inr j) = f (inr j)
-- Mathlib/Algebra/Homology/Embedding/Extend.lean
lemma d_none_eq_zero (i j : Option ι) (hi : i = none) :
    d K i j = 0
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp)]
theorem comp_apply (x : F) : (p.comp f) x = p (f x)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_comm_iff (nH : H.Normal) {a b : G} : a * b ∈ H ↔ b * a ∈ H
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
@[reassoc (attr := simp)]
theorem pullbackAssoc_inv_fst_fst [HasPullback ((pullback.snd _ _ : Z₁ ⟶ X₂) ≫ f₃) f₄]
    [HasPullback f₁ ((pullback.fst _ _ : Z₂ ⟶ X₂) ≫ f₂)] :
    (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst _ _ ≫ pullback.fst _ _ = pullback.fst _ _
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem self_trans_symm (h : X ≃ₜ Y) : h.trans h.symm = Homeomorph.refl X
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem coe_mem_principalUnitGroup_iff {x : A.unitGroup} :
    (x : Kˣ) ∈ A.principalUnitGroup ↔
      A.unitGroupMulEquiv x ∈ (Units.map (LocalRing.residue A).toMonoidHom).ker
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_sub (since := "2024-06-26")]
protected theorem map_sub (x y) : φ (x - y) = φ x - φ y
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpIndL1Fin_smul' [NormedSpace ℝ F] [SMulCommClass ℝ 𝕜 F] (hs : MeasurableSet s)
    (hμs : μ s ≠ ∞) (c : 𝕜) (x : F) :
    condexpIndL1Fin hm hs hμs (c • x) = c • condexpIndL1Fin hm hs hμs x
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- From a natrual transformation of functors `C ⥤ D`, the induced natural transformation
of functors `WithInitial C ⥤ WithInitial D`. -/
@[simps]
def map₂ {D : Type*} [Category D] {F G : C ⥤ D} (η : F ⟶ G) : map F ⟶ map G
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem mul_pos_iff_of_pos_right {a b : Nat} (h : 0 < b) :
    0 < a * b ↔ 0 < a
-- Mathlib/Logic/Equiv/List.lean
@[simp]
theorem list_ofNat_zero : ofNat (List α) 0 = []
-- Mathlib/RingTheory/Algebraic.lean
theorem bijective_of_isScalarTower' [Field R] [Algebra K R]
    [NoZeroSMulDivisors K R]
    [Algebra.IsAlgebraic K R] [Algebra L R] [IsScalarTower K L R] (f : R →ₐ[K] L) :
    Function.Bijective f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem tan_ne_zero_iff {θ : ℂ} : tan θ ≠ 0 ↔ ∀ k : ℤ, (k * π / 2 : ℂ) ≠ θ
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
/-- Construct a functor out of the wide pushout shape given a J-indexed collection of arrows from a
fixed object.
-/
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem mem_factors'_of_dvd {a p : α} (ha0 : a ≠ 0) (hp : Irreducible p) (hd : p ∣ a) :
    Subtype.mk (Associates.mk p) (irreducible_mk.2 hp) ∈ factors' a
-- Mathlib/Algebra/Order/Ring/Abs.lean
/-- If `a` is even, then `n` is odd iff `n % a` is odd. -/
lemma Odd.mod_even_iff (ha : Even a) : Odd (n % a) ↔ Odd n
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumLexDualAntidistrib_inl :
    sumLexDualAntidistrib α β (toDual (inl a)) = inr (toDual a)
-- Mathlib/Data/Set/Lattice.lean
protected theorem image_preimage : GaloisConnection (image f) (preimage f)
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_sub (x y : ℤ[i]) : ((x - y : ℤ[i]) : ℂ) = x - y
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem eq_of_eqOn_dense {s : Set G} (hs : closure s = ⊤) {f g : G →* M} (h : s.EqOn f g) : f = g
-- Mathlib/Data/Finset/Prod.lean
@[simp, norm_cast]
theorem coe_offDiag : (s.offDiag : Set (α × α)) = (s : Set α).offDiag
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma eq_div_of_mul_eq (h : IsUnit c) : a * c = b → a = b / c
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp, norm_cast]
theorem natCast_div (m n : ℕ) : ((m / n : ℕ) : Ordinal) = m / n
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- The cones defined by `coneOfAdj` are limit cones. -/
@[simps]
def isLimitConeOfAdj (F : J ⥤ C) :
    IsLimit (coneOfAdj adj F)
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- The composition of left homology map data. -/
@[simps]
def comp {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃}
    {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData} {h₃ : S₃.LeftHomologyData}
    (ψ : LeftHomologyMapData φ h₁ h₂) (ψ' : LeftHomologyMapData φ' h₂ h₃) :
    LeftHomologyMapData (φ ≫ φ') h₁ h₃
-- Mathlib/Control/Fold.lean
@[simp]
theorem toList_eq_self {xs : List α} : toList xs = xs
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem quot_map_mk (β : Type v) (f : List (α × Bool) → List (β × Bool))
    (H : (Red.Step ⇒ Red.Step) f f) : Quot.map f H (mk L) = mk (f L)
-- Mathlib/Order/Filter/Pointwise.lean
theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).NeBot → g.NeBot
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected nonrec theorem SmoothWithinAt.coordChange
    (hf : SmoothWithinAt IM IB f s x) (hg : SmoothWithinAt IM 𝓘(𝕜, F) g s x)
    (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
    SmoothWithinAt IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) s x
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp, norm_cast]
theorem coe_zsmul (z : ℤ) (x : R) : (↑(z • x) : c.Quotient) = z • (x : c.Quotient)
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma infIrredUpperSet_symm_apply (s : {s : UpperSet α // InfIrred s}) [Fintype s] :
    infIrredUpperSet.symm s = (s.1 : Set α).toFinset.inf id
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem Perm.subtypeCongr.symm : (ep.subtypeCongr en).symm = Perm.subtypeCongr ep.symm en.symm
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
theorem changeForm.associated_neg_proof [Invertible (2 : R)] :
    (QuadraticMap.associated (R := R) (M := M) (-Q)).toQuadraticMap = 0 - Q