ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Module/CharacterModule.lean
theorem dual_rTensor_conj_homEquiv (f : A →ₗ[R] A') :
    homEquiv.symm.toLinearMap ∘ₗ dual (f.rTensor B) ∘ₗ homEquiv.toLinearMap = f.lcomp R _
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem symm_comp_self (e : M₁ ≃SL[σ₁₂] M₂) : (e.symm : M₂ → M₁) ∘ (e : M₁ → M₂) = id
-- Mathlib/Logic/Nontrivial/Basic.lean
theorem nontrivial_iff_lt [LinearOrder α] : Nontrivial α ↔ ∃ x y : α, x < y
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_eq_of_eq_add_rev (h : a = b + c) : a - b = c
-- Mathlib/CategoryTheory/Endomorphism.lean
@[ext]
lemma ext {X : C} {φ₁ φ₂ : Aut X} (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem eta (f : R[X]) : Polynomial.ofFinsupp f.toFinsupp = f
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
@[ext]
lemma ext {P Q : AffineTargetMorphismProperty}
    (H : ∀ ⦃X Y : Scheme⦄ (f : X ⟶ Y) [IsAffine Y], P f ↔ Q f) : P = Q
-- Mathlib/Data/Nat/Defs.lean
lemma div_lt_div_of_lt_of_dvd {a b d : ℕ} (hdb : d ∣ b) (h : a < b) : a / d < b / d
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_trim {μ : Measure α} (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    ∫⁻ a, f a ∂μ.trim hm = ∫⁻ a, f a ∂μ
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem OrthogonalFamily.eq_ite [DecidableEq ι] {i j : ι} (v : G i) (w : G j) :
    ⟪V i v, V j w⟫ = ite (i = j) ⟪V i v, V j w⟫ 0
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap_comp_rTensor {M' : Submodule R S} (hM : M' ≤ M) :
    mulMap M N ∘ₗ (inclusion hM).rTensor N = mulMap M' N
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- The sum of a finite power series is continuous. -/
protected theorem FormalMultilinearSeries.continuousOn_of_finite
    (p : FormalMultilinearSeries 𝕜 E F) {n : ℕ} (hn : ∀ m, n ≤ m → p m = 0) :
    Continuous p.sum
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem toZ_iterate_pred_ge (n : ℕ) : -(n : ℤ) ≤ toZ i0 (pred^[n] i0)
-- Mathlib/LinearAlgebra/InvariantBasisNumber.lean
theorem card_le_of_surjective' [RankCondition R] {α β : Type*} [Fintype α] [Fintype β]
    (f : (α →₀ R) →ₗ[R] β →₀ R) (i : Surjective f) : Fintype.card β ≤ Fintype.card α
-- Mathlib/Analysis/Convex/Side.lean
theorem not_wOppSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).WOppSide x y
-- Mathlib/Algebra/Order/Group/Indicator.lean
lemma indicator_le_indicator_nonneg (s : Set α) (f : α → M) :
    s.indicator f ≤ {a | 0 ≤ f a}.indicator f
-- Mathlib/GroupTheory/Perm/Support.lean
theorem pow_apply_eq_self_of_apply_eq_self {x : α} (hfx : f x = x) : ∀ n : ℕ, (f ^ n) x = x
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableOn.mdifferentiableAt (h : MDifferentiableOn I I' f s) (hx : s ∈ 𝓝 x) :
    MDifferentiableAt I I' f x
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem memℒp_norm_iff {f : α → E} (hf : AEStronglyMeasurable f μ) :
    Memℒp (fun x => ‖f x‖) p μ ↔ Memℒp f p μ
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- The supremum of a singleton is the element of the singleton-/
@[simp]
theorem csSup_singleton (a : α) : sSup {a} = a
-- Mathlib/SetTheory/Cardinal/Basic.lean
lemma not_isLimit_natCast : (n : ℕ) → ¬ IsLimit (n : Cardinal.{u})
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The weighted sum is unaffected by changing the weights to the
corresponding indicator function and adding points to the set. -/
theorem weightedVSub_indicator_subset (w : ι → k) (p : ι → P) {s₁ s₂ : Finset ι} (h : s₁ ⊆ s₂) :
    s₁.weightedVSub p w = s₂.weightedVSub p (Set.indicator (↑s₁) w)
-- Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean
theorem div_eq_filter_card {a b c : ℕ} (hb0 : 0 < b) (hc : a / b ≤ c) :
    a / b = ((Ico 1 c.succ).filter fun x => x * b ≤ a).card
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem pow_card (a : K) : a ^ q = a
-- Mathlib/Tactic/CC/Lemmas.lean
theorem iff_eq_true_of_eq {a b : Prop} (h : a = b) : (a ↔ b) = True
-- Mathlib/Data/Set/BoolIndicator.lean
theorem preimage_boolIndicator_eq_union (t : Set Bool) :
    s.boolIndicator ⁻¹' t = (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅
-- Mathlib/Order/WellFoundedSet.lean
nonrec theorem IsPWO.mono (ht : t.IsPWO) : s ⊆ t → s.IsPWO
-- Mathlib/Order/Interval/Set/Basic.lean
/-- If `a ≤ b`, then `(b, +∞) ⊆ (a, +∞)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Ioi_subset_Ioi_iff`. -/
@[gcongr]
theorem Ioi_subset_Ioi (h : a ≤ b) : Ioi b ⊆ Ioi a
-- Mathlib/Dynamics/BirkhoffSum/Average.lean
@[simp]
theorem birkhoffAverage_one' (f : α → α) (g : α → M) : birkhoffAverage R f g 1 = g
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_le_atBot : (atBot : Filter α).IsBounded (· ≤ ·)
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
/-- Relation between `Λ s` and the Mellin transform of `f - f₀`, where the latter is defined. -/
theorem hasMellin {s : ℂ} (hs : P.k < s.re) : HasMellin (P.f · - P.f₀) s (P.Λ s)
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem lsmul_apply (r : R) (m : M) : lsmul R M r m = r • m
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem integrableOn_Ico_iff_integrableOn_Ioo :
    IntegrableOn f (Ico a b) μ ↔ IntegrableOn f (Ioo a b) μ
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
@[deprecated (since := "2024-07-15")]
theorem id_eq {P : Karoubi C} : 𝟙 P = ⟨P.p, by repeat' rw [P.idem]⟩
-- Mathlib/Algebra/GroupWithZero/Basic.lean
theorem mul_left_surjective₀ {a : G₀} (h : a ≠ 0) : Surjective fun g => a * g
-- Mathlib/Data/Multiset/Powerset.lean
theorem powersetCard_coe (n) (l : List α) :
    @powersetCard α n l = ((sublistsLen n l).map (↑) : List (Multiset α))
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[simp]
theorem generateFrom_insert_univ (S : Set (Set α)) :
    generateFrom (insert Set.univ S) = generateFrom S
-- Mathlib/RingTheory/LocalProperties.lean
theorem RingHom.LocalizationPreserves.away (H : RingHom.LocalizationPreserves @P) (r : R)
    [IsLocalization.Away r R'] [IsLocalization.Away (f r) S'] (hf : P f) :
    P (IsLocalization.Away.map R' S' f r)
-- Mathlib/Data/Set/Card.lean
theorem le_ncard_of_inj_on_range {n : ℕ} (f : ℕ → α) (hf : ∀ i < n, f i ∈ s)
    (f_inj : ∀ i < n, ∀ j < n, f i = f j → i = j) (hs : s.Finite := by toFinite_tac) :
    n ≤ s.ncard
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp, norm_cast] lemma cast_mul (m n : ℕ) : ((m * n : ℕ) : α) = m * n
-- Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean
/-- If `C` has a terminal object and binary products, then it has a product for objects indexed by
`Fin n`.
This is a helper lemma for `hasFiniteProductsOfHasBinaryAndTerminal`, which is more general
than this.
-/
private theorem hasProduct_fin : ∀ (n : ℕ) (f : Fin n → C), HasProduct f
-- Mathlib/CategoryTheory/Limits/FunctorCategory.lean
@[ext]
theorem colimit_obj_ext {H : J ⥤ K ⥤ C} [HasColimitsOfShape J C] {k : K} {W : C}
    {f g : (colimit H).obj k ⟶ W} (w : ∀ j, (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g) :
    f = g
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem mul_le_edist (hf : AntilipschitzWith K f) (x y : α) :
    (K : ℝ≥0∞)⁻¹ * edist x y ≤ edist (f x) (f y)
-- Mathlib/Logic/Function/Iterate.lean
lemma iterate_cancel (hf : Injective f) (ha : f^[m] a = f^[n] a) : f^[m - n] a = a
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem AdjoinMonic.isIntegral (z : AdjoinMonic k) : IsIntegral k z
-- Mathlib/Data/List/NatAntidiagonal.lean
/-- The length of the antidiagonal of `n` is `n + 1`. -/
@[simp]
theorem length_antidiagonal (n : ℕ) : (antidiagonal n).length = n + 1
-- Mathlib/Probability/Martingale/Centering.lean
theorem martingalePart_add_ae_eq [SigmaFiniteFiltration μ ℱ] {f g : ℕ → Ω → E}
    (hf : Martingale f ℱ μ) (hg : Adapted ℱ fun n => g (n + 1)) (hg0 : g 0 = 0)
    (hgint : ∀ n, Integrable (g n) μ) (n : ℕ) : martingalePart (f + g) ℱ μ n =ᵐ[μ] f n
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
theorem comp_val {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).val = f.val ≫ g.val
-- Mathlib/Combinatorics/SimpleGraph/Ends/Properties.lean
/-- A locally finite preconnected infinite graph has at least one end. -/
lemma nonempty_ends_of_infinite [LocallyFinite G] [Fact G.Preconnected] [Infinite V] :
    G.end.Nonempty
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factors_unique {f g : Multiset α} (hf : ∀ x ∈ f, Irreducible x)
    (hg : ∀ x ∈ g, Irreducible x) (h : f.prod ~ᵤ g.prod) : Multiset.Rel Associated f g
-- Mathlib/Data/Set/Basic.lean
theorem mem_dite_univ_left (p : Prop) [Decidable p] (t : ¬p → Set α) (x : α) :
    (x ∈ if h : p then univ else t h) ↔ ∀ h : ¬p, x ∈ t h
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem ofRealCLM_coe : (@ofRealCLM K _ : ℝ →ₗ[ℝ] K) = ofRealAm.toLinearMap
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
lemma FamilyOfElements.restrict_map
    (p : FamilyOfElements P R) (φ : P ⟶ Q) {R' : Presieve X} (h : R' ≤ R) :
    (p.restrict h).map φ = (p.map φ).restrict h
-- Mathlib/Order/Antichain.lean
theorem eq (hs : IsStrongAntichain r s) {a b c : α} (ha : a ∈ s) (hb : b ∈ s) (hac : r a c)
    (hbc : r b c) : a = b
-- Mathlib/MeasureTheory/Function/UnifTight.lean
/-- A finite sequence of Lp functions is uniformly tight. -/
theorem unifTight_finite [Finite ι] (hp_top : p ≠ ∞) {f : ι → α → β}
    (hf : ∀ i, Memℒp (f i) p μ) : UnifTight f p μ
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_codRestrict {τ₂₁ : R₂ →+* R} (p : Submodule R M) (f : M₂ →ₛₗ[τ₂₁] M) (hf) :
    ker (codRestrict p f hf) = ker f
-- Mathlib/Data/Finset/PImage.lean
@[simp]
theorem mem_toFinset {o : Part α} [Decidable o.Dom] {x : α} : x ∈ o.toFinset ↔ x ∈ o
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_pos_iff_support {f : α → ℝ≥0∞} (hf : Measurable f) :
    (0 < ∫⁻ a, f a ∂μ) ↔ 0 < μ (Function.support f)
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_mul (m n : ℕ∞) : ofENat (m * n) = m * n
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_inj {V₁ V₂ : Submodule R M} :
    restrictScalars S V₁ = restrictScalars S V₂ ↔ V₁ = V₂
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem piComm_symm {φ : α → β → Sort*} : (piComm φ).symm = (piComm <| swap φ)
-- Mathlib/Data/Finset/Grade.lean
lemma isCoatom_compl_singleton (a : α) : IsCoatom ({a}ᶜ : Finset α)
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem pullback_obj_left (f : X ⟶ Y) (g : MonoOver Y) :
    ((pullback f).obj g : C) = Limits.pullback g.arrow f
-- Mathlib/Data/Nat/ModEq.lean
theorem add_mod_add_ite (a b c : ℕ) :
    ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c
-- Mathlib/Order/Filter/EventuallyConst.lean
lemma apply {ι : Type*} {p : ι → Type*} {g : α → ∀ x, p x}
    (h : EventuallyConst g l) (i : ι) : EventuallyConst (g · i) l
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
theorem hlast' (i : Fin N.succ) (h : 1 ≤ τ) : a.r (last N) ≤ τ * a.r i
-- Mathlib/Data/Sym/Basic.lean
@[simp, norm_cast]
theorem coe_append (s : Sym α n) (s' : Sym α n') : (s.append s' : Multiset α) = s + s'
-- Mathlib/Data/Set/Basic.lean
theorem union_diff_cancel {s t : Set α} (h : s ⊆ t) : s ∪ t \ s = t
-- Mathlib/Data/Real/EReal.lean
lemma bot_mul_coe_of_pos {x : ℝ} (h : 0 < x) : (⊥ : EReal) * x = ⊥
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem balanced_iInter {f : ι → Set E} (h : ∀ i, Balanced 𝕜 (f i)) : Balanced 𝕜 (⋂ i, f i)
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
/-- If there are distinct ordinals with equal value then
  every value succeding the smaller ordinal are fixed points -/
lemma lfpApprox_mem_fixedPoints_of_eq {a b c : Ordinal}
    (h_init : x ≤ f x) (h_ab : a < b) (h_ac : a ≤ c) (h_fab : lfpApprox f x a = lfpApprox f x b) :
    lfpApprox f x c ∈ fixedPoints f
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
    (h : g.IsCycleOn s) : (g.extendDomain f).IsCycleOn ((↑) ∘ f '' s)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[aesop safe apply (rule_sets := [SetLike])]
theorem intCast_mem (n : ℤ) : (n : R) ∈ s
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem centralizer_univ {R} [Semiring R] : centralizer Set.univ = center R
-- Mathlib/Data/Finset/Card.lean
theorem _root_.Multiset.toFinset_card_eq_one_iff [DecidableEq α] (s : Multiset α) :
    s.toFinset.card = 1 ↔ Multiset.card s ≠ 0 ∧ ∃ a : α, s = Multiset.card s • {a}
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
lemma commutator_apply (a : L) : ⁅D1, D2⁆ a = D1 (D2 a) - D2 (D1 a)
-- Mathlib/Logic/Equiv/Basic.lean
theorem subtypeEquivCodomain_symm_apply_ne
    (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X) (h : x' ≠ x) :
    ((subtypeEquivCodomain f).symm y : X → Y) x' = f ⟨x', h⟩
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma intCast_mul_right (h : Commute a b) (m : ℤ) : Commute a (m * b)
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
lemma set_smul_mono_left {s t : Set S} (le : s ≤ t) :
    s • N ≤ t • N
-- Mathlib/Algebra/Order/BigOperators/Group/List.lean
@[to_additive] lemma prod_eq_one_iff : l.prod = 1 ↔ ∀ x ∈ l, x = (1 : M)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem mk_bounded_subset {α : Type*} (h : ∀ x < #α, (2^x) < #α) {r : α → α → Prop}
    [IsWellOrder α r] (hr : (#α).ord = type r) : #{ s : Set α // Bounded r s } = #α
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
@[reassoc (attr := simp)]
theorem right_comp_retraction (f g : A ⟶ B) [IsCoreflexivePair f g] :
    g ≫ commonRetraction f g = 𝟙 A
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem dist_eq : dist f g = sInf { C | 0 ≤ C ∧ ∀ x : α, dist (f x) (g x) ≤ C }
-- Mathlib/Algebra/DirectSum/Ring.lean
@[simp]
theorem of_zero_pow (a : A 0) : ∀ n : ℕ, of A 0 (a ^ n) = of A 0 a ^ n
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem mem_blur' (q : Semiquot α) {s : Set α} (h : q.s ⊆ s) {a : α} : a ∈ blur' q h ↔ a ∈ s
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem consRecOn_empty {motive : Word M → Sort*} (h_empty : motive empty)
    (h_cons : ∀ (i) (m : M i) (w) h1 h2, motive w → motive (cons m w h1 h2)) :
    consRecOn empty h_empty h_cons = h_empty
-- Mathlib/Algebra/Order/Hom/Ring.lean
theorem trans_toRingEquiv (f : α ≃+*o β) (g : β ≃+*o γ) :
    (OrderRingIso.trans f g).toRingEquiv = RingEquiv.trans f.toRingEquiv g.toRingEquiv
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/--
The closure of a singleton `{a}` in the lower topology is the left-closed right-infinite interval
[a, ∞).
-/
@[simp]
theorem closure_singleton (a : α) : closure {a} = Ici a
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem div_tendsto_atTop_of_degree_gt (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0)
    (hnng : 0 ≤ P.leadingCoeff / Q.leadingCoeff) :
    Tendsto (fun x => eval x P / eval x Q) atTop atTop
-- Mathlib/Order/Chain.lean
@[ext]
theorem ext : (s : Set α) = t → s = t
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem UniformEmbedding.comp {g : β → γ} (hg : UniformEmbedding g) {f : α → β}
    (hf : UniformEmbedding f) : UniformEmbedding (g ∘ f)
-- Mathlib/ModelTheory/Fraisse.lean
theorem age.jointEmbedding : JointEmbedding (L.age M)
-- Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean
/-- For the `I`-adic topology, the neighborhoods of zero has basis given by the powers of `I`. -/
theorem hasBasis_nhds_zero_adic (I : Ideal R) :
    HasBasis (@nhds R I.adicTopology (0 : R)) (fun _n : ℕ => True) fun n =>
      ((I ^ n : Ideal R) : Set R)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.principal_inf (hl : l.HasBasis p s) (s' : Set α) :
    (𝓟 s' ⊓ l).HasBasis p fun i => s' ∩ s i
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Sized.balance' {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (balance' l x r)
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem norm_map (u : unitary (H →L[𝕜] H)) (x : H) : ‖(u : H →L[𝕜] H) x‖ = ‖x‖
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- The difference of two completed even Hurwitz zeta functions is differentiable at `s = 1`. -/
lemma differentiableAt_one_completedHurwitzZetaEven_sub_completedHurwitzZetaEven
    (a b : UnitAddCircle) :
    DifferentiableAt ℂ (fun s ↦ completedHurwitzZetaEven a s - completedHurwitzZetaEven b s) 1
-- Mathlib/Analysis/Complex/Angle.lean
lemma angle_one_right (hx : x ≠ 0) : angle x 1 = |x.arg|
-- Mathlib/Order/Bounds/Basic.lean
theorem BddAbove.bddAbove_image2_of_bddBelow :
    BddAbove s → BddBelow t → BddAbove (Set.image2 f s t)
-- Mathlib/CategoryTheory/Sites/CoverLifting.lean
lemma Functor.cover_lift [G.IsCocontinuous J K] {U : C} {S : Sieve (G.obj U)}
    (hS : S ∈ K (G.obj U)) : S.functorPullback G ∈ J U
-- Mathlib/Algebra/Algebra/Opposite.lean
@[simp]
theorem toLinearMap_toOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.toOpposite hf).toLinearMap = (opLinearEquiv R : B ≃ₗ[R] Bᵐᵒᵖ) ∘ₗ f.toLinearMap
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem isometryEquiv_comap_mkMetric (m : ℝ≥0∞ → ℝ≥0∞) (f : X ≃ᵢ Y) :
    comap f (mkMetric m) = mkMetric m
-- Mathlib/Data/Sym/Basic.lean
theorem replicate_succ {a : α} {n : ℕ} : replicate n.succ a = a ::ₛ replicate n a
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_div {a b c : Ordinal} (c0 : c ≠ 0) : a ≤ b / c ↔ c * a ≤ b
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem range_re : range re = univ
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem HasGradientAt.unique {gradf gradg : F}
    (hf : HasGradientAt f gradf x) (hg : HasGradientAt f gradg x) :
    gradf = gradg
-- Mathlib/Topology/MetricSpace/Dilation.lean
theorem ratio_ne_zero [DilationClass F α β] (f : F) : ratio f ≠ 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The oriented angle between two vectors equals the unoriented angle if the sign is positive. -/
theorem oangle_eq_angle_of_sign_eq_one {x y : V} (h : (o.oangle x y).sign = 1) :
    o.oangle x y = InnerProductGeometry.angle x y
-- Mathlib/ModelTheory/Substructures.lean
theorem comap_iInf_map_of_injective (S : ι → L.Substructure M) :
    (⨅ i, (S i).map f).comap f = iInf S
-- Mathlib/Analysis/Convex/Gauge.lean
theorem Convex.lipschitzWith_gauge {r : ℝ≥0} (hc : Convex ℝ s) (hr : 0 < r)
    (hs : Metric.ball (0 : E) r ⊆ s) : LipschitzWith r⁻¹ (gauge s)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem pop_data (arr : Array α) : arr.pop.data = arr.data.dropLast
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem normSq_pos {z : K} : 0 < normSq z ↔ z ≠ 0
-- Mathlib/Topology/Instances/ENNReal.lean
theorem iSup_add_iSup {ι : Sort*} {f g : ι → ℝ≥0∞} (h : ∀ i j, ∃ k, f i + g j ≤ f k + g k) :
    iSup f + iSup g = ⨆ a, f a + g a
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
theorem mem_unitaryGroup_iff : A ∈ Matrix.unitaryGroup n α ↔ A * star A = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_iff_get {a} {l : List α} : a ∈ l ↔ ∃ n, get l n = a
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem norm_def' (a : 𝓜(𝕜, A)) : ‖a‖ = ‖toProdMulOppositeHom a‖
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem fromBlocks_one : fromBlocks (1 : Matrix l l α) 0 0 (1 : Matrix m m α) = 1
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem ball_disjoint_closedBall (h : δ + ε ≤ dist x y) : Disjoint (ball x δ) (closedBall y ε)
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem familyOfElements_compatible : hx.familyOfElements.Compatible
-- Mathlib/Topology/Algebra/Field.lean
theorem Subfield.isClosed_topologicalClosure (s : Subfield α) :
    IsClosed (s.topologicalClosure : Set α)
-- Mathlib/RingTheory/Multiplicity.lean
protected theorem pow' {p a : α} (hp : Prime p) (ha : Finite p a) :
    ∀ {k : ℕ}, get (multiplicity p (a ^ k)) (finite_pow hp ha) = k * get (multiplicity p a) ha
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma measurableSet_countablePartitionSet (n : ℕ) (a : α) :
    MeasurableSet (countablePartitionSet n a)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem map_srange (g : S →ₙ+* T) (f : R →ₙ+* S) : map g (srange f) = srange (g.comp f)
-- Mathlib/Data/PNat/Interval.lean
theorem map_subtype_embedding_Ico : (Ico a b).map (Embedding.subtype _) = Ico ↑a ↑b
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_mk_iff' (p : Submodule R M) (h) {x : M} :
    x ∈ (⟨p, h⟩ : LieSubmodule R L M) ↔ x ∈ p
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem And.imp_left (h : a → b) : a ∧ c → b ∧ c
-- Mathlib/Data/Finsupp/Basic.lean
theorem equivMapDomain_eq_mapDomain {M} [AddCommMonoid M] (f : α ≃ β) (l : α →₀ M) :
    equivMapDomain f l = mapDomain f l
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
lemma δ_zero_cochain_comp {n₂ : ℤ} (z₁ : Cochain F G 0) (z₂ : Cochain G K n₂)
    (m₂ : ℤ) (h₂ : n₂ + 1 = m₂) :
    δ n₂ m₂ (z₁.comp z₂ (zero_add n₂)) =
      z₁.comp (δ n₂ m₂ z₂) (zero_add m₂) +
      n₂.negOnePow • ((δ 0 1 z₁).comp z₂ (by rw [add_comm, h₂]))
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_sSup {S : Set (Opens α)} : (↑(sSup S) : Set α) = ⋃ i ∈ S, ↑i
-- Mathlib/Order/Atoms.lean
/-- A complemented modular coatomic lattice is strongly coatomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyCoatomic [IsCoatomic α] : IsStronglyCoatomic α
-- Mathlib/Order/Filter/Basic.lean
@[mono]
theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁.seq g₁ ≤ f₂.seq g₂
-- Mathlib/Algebra/Order/Monovary.lean
lemma Monovary.mul_right₀ (hg₁ : 0 ≤ g₁) (hg₂ : 0 ≤ g₂) (h₁ : Monovary f g₁) (h₂ : Monovary f g₂) :
    Monovary f (g₁ * g₂)
-- Mathlib/Order/Filter/Basic.lean
theorem Tendsto.mono_right {f : α → β} {x : Filter α} {y z : Filter β} (hy : Tendsto f x y)
    (hz : y ≤ z) : Tendsto f x z
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem zero_ediv : ∀ b : Int, 0 / b = 0
-- Mathlib/RingTheory/SimpleModule.lean
theorem sSup_simples_le (N : Submodule R M) :
    sSup { m : Submodule R M | IsSimpleModule R m ∧ m ≤ N } = N
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma interior_iInter (f : ι → Set α) : interior (⋂ i, f i) = ⋂ i, interior (f i)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.div (htu : t ~[l] u) (hvw : v ~[l] w) :
    (fun x ↦ t x / v x) ~[l] fun x ↦ u x / w x
-- Mathlib/CategoryTheory/Monoidal/FunctorCategory.lean
@[simp]
theorem tensorUnit_map {X Y} {f : X ⟶ Y} : (𝟙_ (C ⥤ D)).map f = 𝟙 (𝟙_ D)
-- Mathlib/LinearAlgebra/StdBasis.lean
theorem stdBasis_apply (i : ι) (b : φ i) : stdBasis R φ i b = update (0 : (a : ι) → φ a) i b
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem taylor_zero' : taylor (0 : R) = LinearMap.id
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_zero {_m0 : MeasurableSpace α} (s : Set α) : (0 : Measure α).restrict s = 0
-- Mathlib/Algebra/ModEq.lean
theorem sub_modEq_iff_modEq_add : a - b ≡ c [PMOD p] ↔ a ≡ c + b [PMOD p]
-- Mathlib/Data/Real/EReal.lean
lemma neg_sub {x y : EReal} (h1 : x ≠ ⊥ ∨ y ≠ ⊥) (h2 : x ≠ ⊤ ∨ y ≠ ⊤) :
    - (x - y) = - x + y
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
protected theorem TendstoLocallyUniformly.tendstoLocallyUniformlyOn
    (h : TendstoLocallyUniformly F f p) : TendstoLocallyUniformlyOn F f p s
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem zero_apply (m : ∀ i, M₁ i) : (0 : ContinuousMultilinearMap R M₁ M₂) m = 0
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
theorem _root_.isRoot_of_unity_iff (h : 0 < n) (R : Type*) [CommRing R] [IsDomain R] {ζ : R} :
    ζ ^ n = 1 ↔ ∃ i ∈ n.divisors, (cyclotomic i R).IsRoot ζ
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- If `F.cocones` is corepresented by `X`, any cocone is the extension of the colimit cocone by the
corresponding morphism. -/
theorem cocone_fac (s : Cocone F) : (colimitCocone h).extend (homOfCocone h s) = s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean
/-- Note this also holds for `z = 0`, but we do not need this case for `sin_pi_mul_eq`. -/
theorem integral_cos_mul_cos_pow_even (n : ℕ) (hz : z ≠ 0) :
    (((1 : ℂ) - z ^ 2 / ((n : ℂ) + 1) ^ 2) *
        ∫ x in (0 : ℝ)..π / 2, Complex.cos (2 * z * x) * (cos x : ℂ) ^ (2 * n + 2)) =
      (2 * n + 1 : ℂ) / (2 * n + 2) *
        ∫ x in (0 : ℝ)..π / 2, Complex.cos (2 * z * x) * (cos x : ℂ) ^ (2 * n)