ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem ofLeftInverse_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f) (x : G) :
    ↑(ofLeftInverse h x) = f x
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem nhdsWithin_Ioi_basis' {a : α} (h : ∃ b, a < b) : (𝓝[>] a).HasBasis (a < ·) (Ioo a)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem WithBot.sSup_empty [SupSet α] : sSup (∅ : Set (WithBot α)) = ⊥
-- Mathlib/LinearAlgebra/Dual.lean
lemma range_eq_top_of_ne_zero :
    LinearMap.range f = ⊤
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive (attr := simp)]
theorem div_ball : s / ball x δ = x⁻¹ • thickening δ s
-- Mathlib/Data/Seq/Computation.lean
theorem Equiv.equivalence : Equivalence (@Equiv α)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- A compact subset has finite measure for a measure which is finite on compacts. -/
theorem _root_.IsCompact.measure_ne_top [TopologicalSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] ⦃K : Set α⦄ (hK : IsCompact K) : μ K ≠ ∞
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factors_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y} : P.Factors (0 : X ⟶ Y)
-- Mathlib/RingTheory/Nilpotent/Basic.lean
theorem IsNilpotent.isUnit_add_one [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (r + 1)
-- .lake/packages/lean4/src/lean/Init/Data/List/BasicAux.lean
theorem getElem_append_right (as bs : List α) (h : ¬ i < as.length) {h' h''} : (as ++ bs)[i]'h' = bs[i - as.length]'h''
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to infinity along a nontrivial filter `l`, then
`fun x ↦ r * f x` tends to infinity if and only if `0 < r. `-/
theorem tendsto_const_mul_atTop_iff_pos [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atTop ↔ 0 < r
-- Mathlib/Data/Rat/Cast/Order.lean
@[mono]
theorem cast_mono : Monotone ((↑) : ℚ≥0 → K)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffOn.smoothOn (h : ContMDiffOn I I' ⊤ f s) : SmoothOn I I' f s
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem measure_closedBall_div_le_integral [IsAddHaarMeasure μ] (K : ℝ) (h : f.rOut ≤ K * f.rIn) :
    (μ (closedBall c f.rOut)).toReal / K ^ finrank ℝ E ≤ ∫ x, f x ∂μ
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem AntitoneOn.Ioo (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
    MonotoneOn (fun x => Ioo (f x) (g x)) s
-- Mathlib/RingTheory/Derivation/Basic.lean
theorem toFun_eq_coe : D.toFun = ⇑D
-- Mathlib/Order/WithBot.lean
theorem strictMono_iff {f : WithBot α → β} :
    StrictMono f ↔ StrictMono (fun a => f a : α → β) ∧ ∀ x : α, f ⊥ < f x
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem succ_mono : CategoryTheory.Mono (ModuleCat.ofHom (πs C o))
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem radical_eq_top : radical I = ⊤ ↔ I = ⊤
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem mk_finsupp_lift_of_infinite (α : Type u) (β : Type v) [Infinite α] [Zero β] [Nontrivial β] :
    #(α →₀ β) = max (lift.{v} #α) (lift.{u} #β)
-- Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean
@[simp]
theorem directSumRight_symm_lof_tmul (x : M₁') (i : ι₂) (y : M₂ i) :
    (directSumRight R M₁' M₂).symm (DirectSum.lof R _ _ i (x ⊗ₜ[R] y)) =
      x ⊗ₜ[R] DirectSum.lof R _ _ i y
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem iterate_derivative_X_pow_eq_smul (n : ℕ) (k : ℕ) :
    derivative^[k] (X ^ n : R[X]) = (Nat.descFactorial n k : R) • X ^ (n - k)
-- Mathlib/Algebra/Group/AddChar.lean
@[simp, norm_cast] lemma pow_apply (ψ : AddChar A M) (n : ℕ) (a : A) : (ψ ^ n) a = (ψ a) ^ n
-- Mathlib/Algebra/Algebra/Defs.lean
@[norm_cast]
theorem coe_mul (a b : R) : (↑(a * b : R) : A) = ↑a * ↑b
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem toZ_of_lt (hi : i < i0) : toZ i0 i = -Nat.find (exists_pred_iterate_of_le hi.le)
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem Subsemiring.one_mem_toNonUnitalSubsemiring (S : Subsemiring R) :
    (1 : R) ∈ S.toNonUnitalSubsemiring
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_singleton (a : α) : card ({a} : Finset α) = 1
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma map_zero_zero : map F f 0 0 (by simp) = 𝟙 X
-- Mathlib/NumberTheory/KummerDedekind.lean
@[simp]
theorem quotAdjoinEquivQuotMap_apply_mk (hx : (conductor R x).comap (algebraMap R S) ⊔ I = ⊤)
    (h_alg : Function.Injective (algebraMap R<x> S)) (a : R<x>) :
    quotAdjoinEquivQuotMap hx h_alg (Ideal.Quotient.mk (I.map (algebraMap R R<x>)) a) =
      Ideal.Quotient.mk (I.map (algebraMap R S)) ↑a
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_subset [Fintype s] {t : Finset α} : s.toFinset ⊆ t ↔ s ⊆ t
-- Mathlib/Data/Fin/Basic.lean
theorem rev_lt_iff {i j : Fin n} : rev i < j ↔ rev j < i
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem prod_inf_prod : prod p q₁ ⊓ prod p' q₁' = prod (p ⊓ p') (q₁ ⊓ q₁')
-- Mathlib/CategoryTheory/MorphismProperty/Composition.lean
lemma of_precomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hfg : W (f ≫ g)) :
    W g
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
protected theorem pow_mem {M : Type*} [Monoid M] (S : Submonoid M) {x : M} (hx : x ∈ S) (n : ℕ) :
    x ^ n ∈ S
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem inv_def (e : E ≃ₗᵢ[R] E) : (e⁻¹ : E ≃ₗᵢ[R] E) = e.symm
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.trans_le (hfg : f =O[l] g') (hgk : ∀ x, ‖g' x‖ ≤ ‖k x‖) : f =O[l] k
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)},
    Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem derivWithin_clm_apply (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hu : DifferentiableWithinAt 𝕜 u s x) :
    derivWithin (fun y => (c y) (u y)) s x = derivWithin c s x (u x) + c x (derivWithin u s x)
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma diffs_subset_iff : s \\ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a \ b ∈ u
-- Mathlib/Data/Nat/Squarefree.lean
theorem minSqFac_has_prop (n : ℕ) : MinSqFacProp n (minSqFac n)
-- Mathlib/Data/Seq/Computation.lean
theorem Results.length {s : Computation α} {a n} [_T : Terminates s] : Results s a n → length s = n
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Finset.measurable_range_sup' {f : ℕ → δ → α} {n : ℕ} (hf : ∀ k ≤ n, Measurable (f k)) :
    Measurable ((range (n + 1)).sup' nonempty_range_succ f)
-- Mathlib/LinearAlgebra/Ray.lean
/-- If a vector `v₁` is on the same ray as a nonzero vector `v₂`, then it is equal to `c • v₂` for
some nonnegative `c`. -/
theorem exists_nonneg_right (h : SameRay R x y) (hy : y ≠ 0) : ∃ r : R, 0 ≤ r ∧ x = r • y
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
theorem measurable_of_measurable_nnreal_prod [MeasurableSpace β] [MeasurableSpace γ]
    {f : ℝ≥0∞ × β → γ} (H₁ : Measurable fun p : ℝ≥0 × β => f (p.1, p.2))
    (H₂ : Measurable fun x => f (∞, x)) : Measurable f
-- Mathlib/RingTheory/LocalRing/RingHom/Basic.lean
/-- If `f : R →+* S` is a local ring hom, then `R` is a local ring if `S` is. -/
theorem RingHom.domain_localRing {R S : Type*} [CommSemiring R] [CommSemiring S] [H : LocalRing S]
    (f : R →+* S) [IsLocalRingHom f] : LocalRing R
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mem_smul {x : β} : x ∈ s • t ↔ ∃ y ∈ s, ∃ z ∈ t, y • z = x
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- If there are no configurations of satellites with `N+1` points, one never uses more than `N`
distinct families in the Besicovitch inductive construction. -/
theorem color_lt {i : Ordinal.{u}} (hi : i < p.lastStep) {N : ℕ}
    (hN : IsEmpty (SatelliteConfig α N p.τ)) : p.color i < N
-- Mathlib/Data/List/Basic.lean
theorem filter_eq_foldr (p : α → Bool) (l : List α) :
    filter p l = foldr (fun a out => bif p a then a :: out else out) [] l
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem comp_id : f.comp id = f
-- Mathlib/Logic/Basic.lean
theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q
-- Mathlib/Data/Nat/Cast/Commute.lean
theorem cast_comm (n : ℕ) (x : α) : (n : α) * x = x * n
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Every functor indexing a (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelPair` -/
@[simps!]
def diagramIsoParallelPair (F : WalkingParallelPair ⥤ C) :
    F ≅ parallelPair (F.map left) (F.map right)
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem add_moveRight_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma _root_.MeasurableEquiv.gaussianReal_map_symm_apply (hv : v ≠ 0) (f : ℝ ≃ᵐ ℝ) {f' : ℝ → ℝ}
    (h_deriv : ∀ x, HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s) :
    (gaussianReal μ v).map f.symm s
      = ENNReal.ofReal (∫ x in s, |f' x| * gaussianPDFReal μ v (f x))
-- Mathlib/Data/NNReal/Basic.lean
theorem iSup_mul_le {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ i, g i * h ≤ a) : iSup g * h ≤ a
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem linMulLin_apply (f g : M →ₗ[R] A) (x) : linMulLin f g x = f x * g x
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
/-- A number satisfying the Liouville condition with exponent `p > 1` is an irrational number. -/
protected theorem irrational (h : LiouvilleWith p x) (hp : 1 < p) : Irrational x
-- Mathlib/Order/SuccPred/Limit.lean
theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSpace_le_of_le_const (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, τ ω ≤ i) :
    hτ.measurableSpace ≤ f i
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Submonoid M} (i : ι) :
    ∀ {x : M}, x ∈ S i → x ∈ iSup S
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
@[simp]
theorem support_zsmul (k : ℤ) (h : k ≠ 0) (a : FreeAbelianGroup X) :
    support (k • a) = support a
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- If `S` a module-finite free `R`-algebra, then the `R`-rank of a nonzero `R`-free
ideal `I` of `S` is the same as the rank of `S`. -/
theorem Ideal.rank_eq {R S : Type*} [CommRing R] [StrongRankCondition R] [Ring S] [IsDomain S]
    [Algebra R S] {n m : Type*} [Fintype n] [Fintype m] (b : Basis n R S) {I : Ideal S}
    (hI : I ≠ ⊥) (c : Basis m R I) : Fintype.card m = Fintype.card n
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasStrictDerivAt.sinh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x
-- Mathlib/Data/NNReal/Basic.lean
theorem iSup_empty [IsEmpty ι] (f : ι → ℝ≥0) : ⨆ i, f i = 0
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem sign_neg_one : sign (-1) = -1
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
/-- A point in the antidiagonal is determined by its first co-ordinate (subtype version of
`Finset.antidiagonal_congr`). This lemma is used by the `ext` tactic. -/
@[ext] theorem antidiagonal_subtype_ext {p q : antidiagonal n} (h : p.val.1 = q.val.1) : p = q
-- Mathlib/Data/Set/Image.lean
@[simp, mfld_simps]
theorem preimage_inter {s t : Set β} : f ⁻¹' (s ∩ t) = f ⁻¹' s ∩ f ⁻¹' t
-- Mathlib/FieldTheory/RatFunc/Defs.lean
/-- Induction principle for `RatFunc K`: if `f p q : P (RatFunc.mk p q)` for all `p q`,
then `P` holds on all elements of `RatFunc K`.

See also `induction_on`, which is a recursion principle defined in terms of `algebraMap`.
-/
@[elab_as_elim]
protected theorem induction_on' {P : RatFunc K → Prop} :
    ∀ (x : RatFunc K) (_pq : ∀ (p q : K[X]) (_ : q ≠ 0), P (RatFunc.mk p q)), P x
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- For any function `f : α → ℝ≥0∞`, there exists a measurable function `g ≤ f` with the same
integral. -/
theorem exists_measurable_le_lintegral_eq (f : α → ℝ≥0∞) :
    ∃ g : α → ℝ≥0∞, Measurable g ∧ g ≤ f ∧ ∫⁻ a, f a ∂μ = ∫⁻ a, g a ∂μ
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
@[simp] lemma support_inv' (f : ι → G₀) : support f⁻¹ = support f
-- Mathlib/CategoryTheory/MorphismProperty/Factorization.lean
/-- Given two classes of morphisms `W₁` and `W₂` on a category `C`, this is
the data of the factorization of a morphism `f : X ⟶ Y` as `i ≫ p` with
`W₁ i` and `W₂ p`. -/
structure MapFactorizationData {X Y : C} (f : X ⟶ Y) where
  /-- the intermediate object in the factorization -/
  Z : C
  /-- the first morphism in the factorization -/
  i : X ⟶ Z
  /-- the second morphism in the factorization -/
  p : Z ⟶ Y
  fac : i ≫ p = f := by aesop_cat
  hi : W₁ i
  hp : W₂ p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_succ_iff_lt_or_eq : m < succ n ↔ m < n ∨ m = n
-- Mathlib/Data/Set/Lattice.lean
theorem univ_pi_eq_iInter (t : ∀ i, Set (π i)) : pi univ t = ⋂ i, eval i ⁻¹' t i
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ico_eq_empty_iff : Ico a b = ∅ ↔ ¬a < b
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Uniform convergence on a singleton is equivalent to regular convergence -/
theorem tendstoUniformlyOn_singleton_iff_tendsto :
    TendstoUniformlyOn F f p {x} ↔ Tendsto (fun n : ι => F n x) p (𝓝 (f x))
-- Mathlib/Algebra/Group/Invertible/Basic.lean
theorem Commute.invOf_right [Monoid α] {a b : α} [Invertible b] (h : Commute a b) :
    Commute a (⅟ b)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem any (f) : ∀ {s}, ValidFor l m r s → s.any f = m.any f
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
/-- Coercion of a `MonoidHom` into a function is itself a `MonoidHom`.

See also `MonoidHom.eval`. -/
@[to_additive (attr := simps) "Coercion of an `AddMonoidHom` into a function is itself
an `AddMonoidHom`.

See also `AddMonoidHom.eval`."]
def MonoidHom.coeFn (α β : Type*) [MulOneClass α] [CommMonoid β] : (α →* β) →* α → β
-- Mathlib/CategoryTheory/Limits/EpiMono.lean
lemma mono_iff_isPullback : Mono f ↔ IsPullback (𝟙 X) (𝟙 X) f f
-- Mathlib/Probability/Cdf.lean
/-- The cdf is monotone. -/
lemma monotone_cdf : Monotone (cdf μ)
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_smul' (f : V →ₗ[K] V₂) (a : K) : ker (a • f) = ⨅ _ : a ≠ 0, ker f
-- Mathlib/Order/RelSeries.lean
/--
For any type `α`, each term of `α` gives a relation series with the right most index to be 0.
-/
@[simps!] def singleton (a : α) : RelSeries r
-- Mathlib/Order/SuccPred/Basic.lean
theorem Ioi_pred_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = Ici a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
lemma opNorm_mul_apply (x : 𝕜') : ‖mul 𝕜 𝕜' x‖ = ‖x‖
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
@[csimp] private theorem fastJacobiSym.eq : jacobiSym = fastJacobiSym
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem normed_le_div_measure_closedBall_rIn (x : E) :
    f.normed μ x ≤ 1 / (μ (closedBall c f.rIn)).toReal
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem support_takeUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).support ⊆ p.support
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem bmod_neg (x : Int) (m : Nat) (p : x % m ≥ (m + 1) / 2) : bmod x m = (x % m) - m
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem hasDerivAt_exp (x : ℝ) : HasDerivAt exp (exp x) x
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_le_one (x : Icc (0 : α) 1) : (x : α) ≤ 1
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem continuousAt_mul_const {a b : ℝ≥0∞} (h : a ≠ ∞ ∨ b ≠ 0) :
    ContinuousAt (fun x => x * a) b
-- Mathlib/Order/InitialSeg.lean
@[simp]
theorem leAdd_apply (r : α → α → Prop) (s : β → β → Prop) (a) : leAdd r s a = Sum.inl a
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
/-- A simple graph is an irreflexive symmetric relation `Adj` on a vertex type `V`.
The relation describes which pairs of vertices are adjacent.
There is exactly one edge for every pair of adjacent vertices;
see `SimpleGraph.edgeSet` for the corresponding edge set.
-/
@[ext, aesop safe constructors (rule_sets := [SimpleGraph])]
structure SimpleGraph (V : Type u) where
  /-- The adjacency relation of a simple graph. -/
  Adj : V → V → Prop
  symm : Symmetric Adj := by aesop_graph
  loopless : Irreflexive Adj := by aesop_graph
-- Mathlib/RingTheory/Localization/Basic.lean
theorem isLocalization_iff_of_ringEquiv (h : S ≃+* P) :
    IsLocalization M S ↔
      haveI := (h.toRingHom.comp <| algebraMap R S).toAlgebra; IsLocalization M P
-- Mathlib/FieldTheory/Finite/Polynomial.lean
/-- `MvPolynomial.eval` as a `K`-linear map. -/
@[simps]
def evalₗ [CommSemiring K] : MvPolynomial σ K →ₗ[K] (σ → K) → K
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[ext]
lemma hom_ext₀ {F G : ComposableArrows C 0} {φ φ' : F ⟶ G}
    (h : app' φ 0 = app' φ' 0) :
    φ = φ'
-- Mathlib/Order/Disjoint.lean
lemma Disjoint.ne_iff (hab : Disjoint a b) : a ≠ b ↔ a ≠ ⊥ ∨ b ≠ ⊥
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem neg_im : (-a).im = -a.im
-- Mathlib/FieldTheory/PrimitiveElement.lean
/-- **Primitive element theorem** assuming E is finite. -/
theorem exists_primitive_element_of_finite_top [Finite E] : ∃ α : E, F⟮α⟯ = ⊤
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem curry_apply (f : α × β →₀ M) (x : α) (y : β) : f.curry x y = f (x, y)
-- Mathlib/Data/Finset/Basic.lean
theorem disjoint_toFinset {m1 m2 : Multiset α} :
    _root_.Disjoint m1.toFinset m2.toFinset ↔ m1.Disjoint m2
-- Mathlib/Data/PFun.lean
@[simp]
theorem prodMap_id_id : (PFun.id α).prodMap (PFun.id β) = PFun.id _
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
theorem smooth_transDiffeomorph_left {f : M → M'} :
    Smooth (I.transDiffeomorph e) I' f ↔ Smooth I I' f
-- Mathlib/CategoryTheory/Localization/SmallShiftedHom.lean
lemma hasSmallLocalizedShiftedHom_iff
    (L : C ⥤ D) [L.IsLocalization W] [L.CommShift M] (X Y : C) :
    HasSmallLocalizedShiftedHom.{w} W M X Y ↔
      ∀ (a b : M), Small.{w} ((L.obj X)⟦a⟧ ⟶ (L.obj Y)⟦b⟧)
-- Mathlib/Probability/Independence/Kernel.lean
theorem indep_of_indep_of_le_left {m₁ m₂ m₃ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : Indep m₁ m₂ κ μ) (h31 : m₃ ≤ m₁) :
    Indep m₃ m₂ κ μ
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- Definition of `≤` for congruence relations. -/
theorem le_def {c d : RingCon R} : c ≤ d ↔ ∀ {x y}, c x y → d x y
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mem_inv {x : α} : x ∈ s⁻¹ ↔ ∃ y ∈ s, y⁻¹ = x
-- Mathlib/Data/Matrix/Kronecker.lean
theorem trace_kroneckerTMul [Fintype m] [Fintype n] (A : Matrix m m α) (B : Matrix n n β) :
    trace (A ⊗ₖₜ[R] B) = trace A ⊗ₜ[R] trace B
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem smul_iSup {R : Type*} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    {ι : Sort*} (f : ι → OuterMeasure α) (c : R) :
    (c • ⨆ i, f i) = ⨆ i, c • f i
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem tendsto_list_prod {f : ι → α → M} {x : Filter α} {a : ι → M} :
    ∀ l : List ι,
      (∀ i ∈ l, Tendsto (f i) x (𝓝 (a i))) →
        Tendsto (fun b => (l.map fun c => f c b).prod) x (𝓝 (l.map a).prod)
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem Module.finite_of_rank_eq_one [Module.Free R M] (h : Module.rank R M = 1) :
    Module.Finite R M
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem linfty_opNorm_diagonal [DecidableEq m] (v : m → α) : ‖diagonal v‖ = ‖v‖
-- Mathlib/Data/Multiset/Nodup.lean
protected theorem Nodup.pairwise : (∀ a ∈ s, ∀ b ∈ s, a ≠ b → r a b) → Nodup s → Pairwise r s
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem or_left_comm  : a ∨ (b ∨ c) ↔ b ∨ (a ∨ c)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp)]
theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1
-- Mathlib/Data/Int/CardIntervalMod.lean
/-- There are `⌊(b - v) / r⌋ - ⌊(a - v) / r⌋` numbers congruent to `v` mod `r` in `(a, b]`,
if `a ≤ b`. `Nat` version of `Int.Ioc_filter_modEq_card`. -/
theorem Ioc_filter_modEq_card (v : ℕ) : ((Ioc a b).filter (· ≡ v [MOD r])).card =
    max (⌊(b - v) / (r : ℚ)⌋ - ⌊(a - v) / (r : ℚ)⌋) 0
-- Mathlib/Algebra/Module/Defs.lean
/-- Only a ring of characteristic zero can can have a non-trivial module without additive or
scalar torsion. -/
theorem CharZero.of_noZeroSMulDivisors [Nontrivial M] [NoZeroSMulDivisors ℤ M] : CharZero R
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem singleton_div_singleton (a b : α) : ({a} : Finset α) / {b} = {a / b}
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
@[simp] lemma of_symm_smul (f : R[X]) (m : AEval R M a) :
    (of R M a).symm (f • m) = aeval a f • (of R M a).symm m
-- Mathlib/Data/Multiset/Nodup.lean
theorem nodup_map_iff_of_injective {f : α → β} (d : Function.Injective f) :
    Nodup (map f s) ↔ Nodup s
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySum_isBounded : Bornology.IsBounded (convexBodySum K B)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
/-- A vector in `K` is orthogonal to one in `Kᗮ`. -/
theorem inner_right_of_mem_orthogonal {u v : E} (hu : u ∈ K) (hv : v ∈ Kᗮ) : ⟪u, v⟫ = 0
-- Mathlib/Algebra/BigOperators/WithTop.lean
@[simp, norm_cast] lemma coe_sum (s : Finset ι) (f : ι → α) :
    ∑ i ∈ s, f i = ∑ i ∈ s, (f i : WithBot α)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem coprodAssoc_apply_inr (x : P) : coprodAssoc M N P (inr x) = inr (inr x)
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
theorem map_P {D : Type*} [Category D] [Preadditive D] (G : C ⥤ D) [G.Additive]
    (X : SimplicialObject C) (q n : ℕ) :
    G.map ((P q : K[X] ⟶ _).f n) = (P q : K[((whiskering C D).obj G).obj X] ⟶ _).f n
-- Mathlib/Data/Set/Finite.lean
theorem empty_card : Fintype.card (∅ : Set α) = 0
-- Mathlib/Data/Nat/Fib/Basic.lean
lemma fib_add_one : ∀ {n}, n ≠ 0 → fib (n + 1) = fib (n - 1) + fib n
-- Mathlib/SetTheory/Game/State.lean
theorem turnBound_ne_zero_of_left_move {s t : S} (m : t ∈ l s) : turnBound s ≠ 0
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
theorem colLen_eq_card (μ : YoungDiagram) {j : ℕ} : μ.colLen j = (μ.col j).card
-- Mathlib/Combinatorics/SetFamily/Shadow.lean
/-- `t` is in the shadow of `𝒜` iff there is a `s ∈ 𝒜` from which we can remove one element to
get `t`. -/
lemma mem_shadow_iff : t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, ∃ a ∈ s, erase s a = t
-- Mathlib/RingTheory/Localization/AtPrime.lean
@[simp]
theorem localRingHom_id : localRingHom I I (RingHom.id R) (Ideal.comap_id I).symm = RingHom.id _
-- Mathlib/Data/DFinsupp/Basic.lean
/-- While we didn't need decidable instances to define it, we do to reduce it to a sum -/
theorem sumAddHom_apply [∀ i, AddZeroClass (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [AddCommMonoid γ] (φ : ∀ i, β i →+ γ) (f : Π₀ i, β i) : sumAddHom φ f = f.sum fun x => φ x
-- Mathlib/NumberTheory/Bertrand.lean
/-- Proves that **Bertrand's postulate** holds for all sufficiently large `n`.
-/
theorem exists_prime_lt_and_le_two_mul_eventually (n : ℕ) (n_large : 512 ≤ n) :
    ∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n
-- Mathlib/Analysis/Convolution.lean
theorem convolution_def [Sub G] : (f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem uniqueMDiffOn_preimage (h : M ≃ₘ^n⟮I, J⟯ N) (hn : 1 ≤ n) {s : Set N} :
    UniqueMDiffOn I (h ⁻¹' s) ↔ UniqueMDiffOn J s
-- Mathlib/Algebra/DirectSum/LinearMap.lean
/-- The trace of an endomorphism of a direct sum is the sum of the traces on each component.

See also `LinearMap.trace_restrict_eq_sum_trace_restrict`. -/
lemma trace_eq_sum_trace_restrict [Fintype ι]
    {f : M →ₗ[R] M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    trace R M f = ∑ i, trace R (N i) (f.restrict (hf i))
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- An alternative constructor to `QuadraticMap.mk`, for rings where `polar` can be used. -/
@[simps]
def ofPolar (toFun : M → N) (toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x)
    (polar_add_left : ∀ x x' y : M, polar toFun (x + x') y = polar toFun x y + polar toFun x' y)
    (polar_smul_left : ∀ (a : R) (x y : M), polar toFun (a • x) y = a • polar toFun x y) :
    QuadraticMap R M N
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem out_mul (a b : Associates α) : (a * b).out = a.out * b.out