ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/EqToHom.lean
@[simp]
theorem eqToIso.inv {X Y : C} (p : X = Y) : (eqToIso p).inv = eqToHom p.symm
-- Mathlib/Analysis/Normed/Operator/Compact.lean
@[simp]
theorem ContinuousLinearMap.coe_mkOfIsCompactOperator {f : M₁ →ₛₗ[σ₁₂] M₂}
    (hf : IsCompactOperator f) : (ContinuousLinearMap.mkOfIsCompactOperator hf : M₁ → M₂) = f
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive (attr := simp)]
theorem coe_inv_interval : (↑(s⁻¹) : Interval α) = (↑s)⁻¹
-- Mathlib/CategoryTheory/Sites/Closed.lean
/--
The topology given by the closure operator `J.close` on a Grothendieck topology is the same as `J`.
-/
theorem topologyOfClosureOperator_self :
    (topologyOfClosureOperator J₁.closureOperator fun X Y => J₁.pullback_close) = J₁
-- Mathlib/Data/Int/Lemmas.lean
theorem natAbs_le_iff_sq_le {a b : ℤ} : a.natAbs ≤ b.natAbs ↔ a ^ 2 ≤ b ^ 2
-- Mathlib/Order/FixedPoints.lean
theorem isFixedPt_gfp : IsFixedPt f (gfp f)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Formula for orthogonal projection onto a single vector. -/
theorem orthogonalProjection_singleton {v : E} (w : E) :
    (orthogonalProjection (𝕜 ∙ v) w : E) = (⟪v, w⟫ / ((‖v‖ ^ 2 : ℝ) : 𝕜)) • v
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
/-- At an invertible element `x` of a normed algebra `R`, the Fréchet derivative of the inversion
operation is the linear map `fun t ↦ - x⁻¹ * t * x⁻¹`.

TODO: prove that `Ring.inverse` is analytic and use it to prove a `HasStrictFDerivAt` lemma.
TODO (low prio): prove a version without assumption `[CompleteSpace R]` but within the set of
units. -/
@[fun_prop]
theorem hasFDerivAt_ring_inverse (x : Rˣ) :
    HasFDerivAt Ring.inverse (-mulLeftRight 𝕜 R ↑x⁻¹ ↑x⁻¹) x
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem ae_le_pi {β : ι → Type*} [∀ i, Preorder (β i)] {f f' : ∀ i, α i → β i}
    (h : ∀ i, f i ≤ᵐ[μ i] f' i) :
    (fun (x : ∀ i, α i) i => f i (x i)) ≤ᵐ[Measure.pi μ] fun x i => f' i (x i)
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp 1100]
theorem dNext_zero_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) : dNext 0 f = 0
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem deriv_fderiv : smulRight (1 : 𝕜 →L[𝕜] 𝕜) (deriv f x) = fderiv 𝕜 f x
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_differentiableWithinAt_iff {f : G → E} {s : Set G} {x : G} :
    DifferentiableWithinAt 𝕜 (iso ∘ f) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Algebra/Regular/Basic.lean
/-- The element `0` is right-regular if and only if `R` is trivial. -/
theorem isRightRegular_zero_iff_subsingleton : IsRightRegular (0 : R) ↔ Subsingleton R
-- Mathlib/Algebra/MvPolynomial/Rename.lean
theorem rename_prod_mk_eval₂ (j : τ) (g : σ → MvPolynomial σ R) :
    rename (Prod.mk j) (p.eval₂ C g) = p.eval₂ C fun x => rename (Prod.mk j) (g x)
-- Mathlib/Order/Filter/Basic.lean
lemma _root_.Finset.eventuallyLE_iInter {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋂ i ∈ s, f i) ≤ᶠ[l] (⋂ i ∈ s, g i)
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_one : ((1 : ℤ_[p]) : ℚ_[p]) = 1
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem Bool.inf_eq_band : (· ⊓ ·) = and
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
lemma restrictScalarsId'App_inv_apply (M : ModuleCat R) (x : M) :
    (restrictScalarsId'App f hf M).inv x = x
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- The `p`-adic valuation of `n!` is equal to the `p`-adic valuation of the factorial of the
largest multiple of `p` below `n`, i.e. `(p * ⌊n / p⌋)!`. -/
@[simp] theorem padicValNat_mul_div_factorial (n : ℕ) [hp : Fact p.Prime] :
    padicValNat p (p * (n / p))! = padicValNat p n !
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_iff {s : Set E} : Bornology.IsVonNBounded 𝕜 s ↔ Bornology.IsBounded s
-- Mathlib/Data/Finset/Lattice.lean
theorem isGreatest_max' : IsGreatest (↑s) (s.max' H)
-- Mathlib/Combinatorics/SetFamily/Shadow.lean
/-- The shadow of a family of `r`-sets is a family of `r - 1`-sets. -/
protected theorem _root_.Set.Sized.shadow (h𝒜 : (𝒜 : Set (Finset α)).Sized r) :
    (∂ 𝒜 : Set (Finset α)).Sized (r - 1)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma QuasiIso.exact_iff {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    [S₁.HasHomology] [S₂.HasHomology] [QuasiIso φ] : S₁.Exact ↔ S₂.Exact
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_pow_sub_sub (x₀ : E') {m : ℕ} (h : 1 < m) :
    (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => x - x₀
-- Mathlib/Topology/Order/OrderClosed.lean
theorem continuous_min : Continuous fun p : α × α => min p.1 p.2
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem constantCoeff_wittStructureRat (Φ : MvPolynomial idx ℚ) (h : constantCoeff Φ = 0) (n : ℕ) :
    constantCoeff (wittStructureRat p Φ n) = 0
-- Mathlib/Algebra/Order/Hom/Ring.lean
theorem toFun_eq_coe (f : α →+*o β) : f.toFun = f
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_of_mem {x} (h : x ∈ s) : s.Nonempty
-- Mathlib/CategoryTheory/Equivalence.lean
@[reassoc (attr := simp)]
theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
    e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X)
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/-- The Gelfand transform is an isometry when the algebra is a C⋆-algebra over `ℂ`. -/
theorem gelfandTransform_isometry : Isometry (gelfandTransform ℂ A)
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
/-- The inclusion functor from sheaves to presheaves. -/
@[simps]
def sheafToPresheaf : Sheaf J A ⥤ Cᵒᵖ ⥤ A
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- `f : α →+* β` has a trivial codomain iff `f 1 = 0`. -/
theorem codomain_trivial_iff_map_one_eq_zero : (0 : β) = 1 ↔ f 1 = 0
-- Mathlib/SetTheory/Game/Impartial.lean
theorem impartialAux_def {G : PGame} :
    G.ImpartialAux ↔
      (G ≈ -G) ∧ (∀ i, ImpartialAux (G.moveLeft i)) ∧ ∀ j, ImpartialAux (G.moveRight j)
-- Mathlib/Topology/Basic.lean
theorem TopologicalSpace.ext_iff_isClosed {t₁ t₂ : TopologicalSpace X} :
    t₁ = t₂ ↔ ∀ s, IsClosed[t₁] s ↔ IsClosed[t₂] s
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem topologicalSpace_mono [TopologicalSpace F] [TopologicalAddGroup F] (h : 𝔖₂ ⊆ 𝔖₁) :
    instTopologicalSpace σ F 𝔖₁ ≤ instTopologicalSpace σ F 𝔖₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem mul_le_mul_right {n m : Nat} (k : Nat) (h : n ≤ m) : n * k ≤ m * k
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem compPMap_apply (g : F →ₗ[R] G) (f : E →ₗ.[R] F) (x) : g.compPMap f x = g (f x)
-- Mathlib/Logic/Equiv/Defs.lean
@[simp]
lemma ofBijective_symm_apply_apply (f : α → β) (hf : Bijective f) (x : α) :
    (ofBijective f hf).symm (f x) = x
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_modify [Monad m] (f : σ → σ) (s : σ) : (modify f : StateT σ m PUnit).run s = pure (⟨⟩, f s)
-- Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
theorem wEquiv.refl {α : TypeVec n} (x : q.P.W α) : WEquiv x x
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_multiset_sum (s : Multiset ℂ) : exp s.sum = (s.map exp).prod
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
theorem Intersecting.not_compl_mem {s : Set α} (hs : s.Intersecting) {a : α} (ha : a ∈ s) :
    aᶜ ∉ s
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem _root_.OrderIso.isBoundedUnder_le_comp [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ}
    {u : γ → α} : (IsBoundedUnder (· ≤ ·) l fun x => e (u x)) ↔ IsBoundedUnder (· ≤ ·) l u
-- Mathlib/GroupTheory/PushoutI.lean
theorem prod_smul_empty (w : NormalWord d) : w.prod • empty = w
-- Mathlib/Analysis/InnerProductSpace/Dual.lean
theorem ext_inner_left_basis {ι : Type*} {x y : E} (b : Basis ι 𝕜 E)
    (h : ∀ i : ι, ⟪b i, x⟫ = ⟪b i, y⟫) : x = y
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem tendsto_left_nhds_uniformity {a : α} : Tendsto (fun a' => (a, a')) (𝓝 a) (𝓤 α)
-- Mathlib/ModelTheory/LanguageMap.lean
@[simp]
theorem funMap_sumInr [(L'.sum L).Structure M] [(LHom.sumInr : L →ᴸ L'.sum L).IsExpansionOn M] {n}
    {f : L.Functions n} {x : Fin n → M} : @funMap (L'.sum L) M _ n (Sum.inr f) x = funMap f x
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem subtypeEquiv_apply {p : α → Prop} {q : β → Prop}
    (e : α ≃ β) (h : ∀ a : α, p a ↔ q (e a)) (x : { x // p x }) :
    e.subtypeEquiv h x = ⟨e x, (h _).1 x.2⟩
-- Mathlib/CategoryTheory/Functor/Currying.lean
lemma uncurry_obj_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : uncurry.obj F₁ = uncurry.obj F₂) :
    F₁ = F₂
-- Mathlib/Data/Ordmap/Ordset.lean
theorem dual_rotateR (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (rotateR l x r) = rotateL (dual r) x (dual l)
-- Mathlib/Data/Seq/Seq.lean
theorem get?_zip (s : Seq α) (t : Seq β) (n : ℕ) :
    get? (zip s t) n = Option.map₂ Prod.mk (get? s n) (get? t n)
-- Mathlib/Algebra/Associated/Basic.lean
@[trans]
protected theorem trans [Monoid α] : ∀ {x y z : α}, x ~ᵤ y → y ~ᵤ z → x ~ᵤ z
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp, fun_prop]
protected theorem DifferentiableAt.prod_map (hf : DifferentiableAt 𝕜 f p.1)
    (hf₂ : DifferentiableAt 𝕜 f₂ p.2) : DifferentiableAt 𝕜 (fun p : E × G => (f p.1, f₂ p.2)) p
-- Mathlib/RingTheory/Etale/Basic.lean
theorem of_unramified_and_smooth [h₁ : FormallyUnramified R A]
    [h₂ : FormallySmooth R A] : FormallyEtale R A
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfMinpoly_symm (pb : PowerBasis A S) (pb' : PowerBasis A S')
    (h : minpoly A pb.gen = minpoly A pb'.gen) :
    (pb.equivOfMinpoly pb' h).symm = pb'.equivOfMinpoly pb h.symm
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_lt_mul_of_lt_of_lt {a b c d : Nat} (hac : a < c) (hbd : b < d) :
    a * b < c * d
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
protected theorem Injective [Mul α] [PartialOrder α] {a : α} (ha : MulLECancellable a) :
    Injective (a * ·)
-- Mathlib/RingTheory/LocalProperties.lean
theorem localization_away_map_finite (r : R) [IsLocalization.Away r R']
    [IsLocalization.Away (f r) S'] (hf : f.Finite) : (IsLocalization.Away.map R' S' f r).Finite
-- Mathlib/Data/Set/Card.lean
theorem exists_subset_encard_eq {k : ℕ∞} (hk : k ≤ s.encard) : ∃ t, t ⊆ s ∧ t.encard = k
-- Mathlib/Data/Finset/Sigma.lean
@[simp]
theorem disjiUnion_map_sigma_mk :
    s.disjiUnion (fun i => (t i).map (Embedding.sigmaMk i)) pairwiseDisjoint_map_sigmaMk =
      s.sigma t
-- Mathlib/Data/Set/Function.lean
lemma MapsTo.comp_left (g : β → γ) (hf : MapsTo f s t) : MapsTo (g ∘ f) s (g '' t)
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem StronglyMeasurable.integral_kernel_prod_right' ⦃f : α × β → E⦄ (hf : StronglyMeasurable f) :
    StronglyMeasurable fun x => ∫ y, f (x, y) ∂κ x
-- Mathlib/FieldTheory/SplittingField/IsSplittingField.lean
theorem mul (f g : F[X]) (hf : f ≠ 0) (hg : g ≠ 0) [IsSplittingField F K f]
    [IsSplittingField K L (g.map <| algebraMap F K)] : IsSplittingField F L (f * g)
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
@[simp]
theorem coe_neg : ⇑(-f) = -f
-- Mathlib/MeasureTheory/Function/LpSpace.lean
/-- `MeasureTheory.Lp.compMeasurePreserving` as a linear map. -/
@[simps]
def compMeasurePreservingₗ (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗ[𝕜] Lp E p μ
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[reassoc (attr := simp), elementwise]
lemma appLE_appIso_inv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] {U : Y.Opens}
    {V : X.Opens} (e : V ≤ f ⁻¹ᵁ U) :
    f.appLE U V e ≫ (f.appIso V).inv =
        Y.presheaf.map (homOfLE <| (f.image_le_image_of_le e).trans
          (f.image_preimage_eq_opensRange_inter U ▸ inf_le_right)).op
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem ext (A₁ A₂ : IndexSet Δ) (h₁ : A₁.1 = A₂.1) (h₂ : A₁.e ≫ eqToHom (by rw [h₁]) = A₂.e) :
    A₁ = A₂
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem dropWhile_eq (p : Char → Bool) (s : String) : s.dropWhile p = ⟨s.1.dropWhile p⟩
-- Mathlib/Algebra/Associated/Basic.lean
theorem DvdNotUnit.not_unit [CommMonoidWithZero α] {p q : α} (hp : DvdNotUnit p q) : ¬IsUnit q
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tendsto_sin_pi_div_two : Tendsto sin (𝓝[<] (π / 2)) (𝓝 1)
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem Quotient.equiv_symm {R M N : Type*} [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (P : Submodule R M) (Q : Submodule R N) (f : M ≃ₗ[R] N)
    (hf : P.map f = Q) :
    (Quotient.equiv P Q f hf).symm =
      Quotient.equiv Q P f.symm ((Submodule.map_symm_eq_iff f).mpr hf)
-- Mathlib/FieldTheory/Normal.lean
@[simp]
theorem AlgEquiv.restrictNormal_commutes [Normal F E] (x : E) :
    algebraMap E K₂ (χ.restrictNormal E x) = χ (algebraMap E K₁ x)
-- Mathlib/Topology/Algebra/InfiniteSum/Defs.lean
@[to_additive]
theorem HasProd.multipliable (h : HasProd f a) : Multipliable f
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
theorem exists_succ_nth_stream_of_fr_zero {ifp_succ_n : IntFractPair K}
    (stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n)
    (succ_nth_fr_eq_zero : ifp_succ_n.fr = 0) :
    ∃ ifp_n : IntFractPair K, IntFractPair.stream v n = some ifp_n ∧ ifp_n.fr⁻¹ = ⌊ifp_n.fr⁻¹⌋
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem decode_encode [DecidableEq α] (s : Sym (Option α) n.succ) : decode (encode s) = s
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem all_cons : (a::l).all f = (f a && l.all f)
-- Mathlib/NumberTheory/LSeries/HurwitzZeta.lean
/-- Reformulation of `hasSum_expZeta_of_one_lt_re` using `LSeriesHasSum`. -/
lemma LSeriesHasSum_exp (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    LSeriesHasSum (cexp <| 2 * π * I * a * ·) s (expZeta a s)
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem restr_univ {e : PartialHomeomorph X Y} : e.restr univ = e
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
/-- Maximal intersecting families are upper sets. Finset version. -/
theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
    (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α)
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem interior_reProdIm (s t : Set ℝ) : interior (s ×ℂ t) = interior s ×ℂ interior t
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem sum_append : Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂
-- Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean
theorem measurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) : Measurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem coe_center : ↑(center R) = Set.center R
-- Mathlib/Order/GaloisConnection.lean
theorem u_sSup_l_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    (s : Set α) : u (sSup (l '' s)) = sSup s
-- Mathlib/ModelTheory/Substructures.lean
theorem closure_unionᵢ {ι} (s : ι → Set M) : closure L (⋃ i, s i) = ⨆ i, closure L (s i)
-- Mathlib/Order/SupClosed.lean
@[simp] lemma latticeClosure_empty : latticeClosure (∅ : Set α) = ∅
-- Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean
lemma map_prod_map {α' : Type*} [MeasurableSpace α'] {β' : Type*} [MeasurableSpace β']
    {f : α → α'} {g : β → β'} (f_mble : Measurable f) (g_mble : Measurable g) :
    (μ.map f_mble.aemeasurable).prod (ν.map g_mble.aemeasurable)
      = (μ.prod ν).map (f_mble.prod_map g_mble).aemeasurable
-- Mathlib/Computability/RegularExpressions.lean
/-- The language of the map is the map of the language. -/
@[simp]
theorem matches'_map (f : α → β) :
    ∀ P : RegularExpression α, (P.map f).matches' = Language.map f P.matches'
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem funUnique_symm_apply {α β : Type*} [Unique α] [Preorder β] :
    ((funUnique α β).symm : β → α → β) = Function.const α
-- Mathlib/Algebra/Module/LocalizedModule.lean
/--
If `(M', f : M ⟶ M')` satisfies universal property of localized module, then `M'` is isomorphic to
`LocalizedModule S M` as an `R`-module.
-/
@[simps!]
noncomputable def iso : LocalizedModule S M ≃ₗ[R] M'
-- Mathlib/MeasureTheory/PiSystem.lean
theorem le_def {α} {a b : DynkinSystem α} : a ≤ b ↔ a.Has ≤ b.Has
-- Mathlib/Data/ZMod/Basic.lean
theorem neg_eq_self_mod_two (a : ZMod 2) : -a = a
-- Mathlib/RingTheory/WittVector/Frobenius.lean
theorem coeff_frobeniusFun (x : 𝕎 R) (n : ℕ) :
    coeff (frobeniusFun x) n = MvPolynomial.aeval x.coeff (frobeniusPoly p n)
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp] theorem toBialgebraCatIso_refl : toBialgebraCatIso (BialgEquiv.refl R X) = .refl _
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem inv_whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) [IsIso f] :
    inv (f ▷ Z) = inv f ▷ Z
-- Mathlib/Logic/Function/Defs.lean
protected theorem RightInverse.id {g : β → α} {f : α → β} (h : RightInverse g f) : f ∘ g = id
-- Mathlib/LinearAlgebra/Pi.lean
/-- Linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def piFinTwo (M : Fin 2 → Type v)
    [(i : Fin 2) → AddCommMonoid (M i)] [(i : Fin 2) → Module R (M i)] :
    ((i : Fin 2) → M i) ≃ₗ[R] M 0 × M 1
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_re_zero_left (x : E) : re ⟪0, x⟫ = 0
-- Mathlib/Data/Set/Image.lean
theorem range_iff_surjective : range f = univ ↔ Surjective f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem two_pos : 0 < 2
-- Mathlib/Algebra/Order/AbsoluteValue.lean
/-- `AbsoluteValue.abs` is `abs` as a bundled `AbsoluteValue`. -/
@[simps]
protected def abs : AbsoluteValue S S
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem ofLe_eq_comap_incl : ofLe h = K.comap K'.incl
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem nextOr_self_cons_cons (xs : List α) (x y d : α) : nextOr (x :: y :: xs) x d = y
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
protected theorem map_add [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x + y)) = f (update m i x) + f (update m i y)
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- Limit cones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t
-- Mathlib/Algebra/Lie/TraceForm.lean
@[simp] lemma traceForm_eq_zero_of_isTrivial [IsTrivial L M] :
    traceForm R L M = 0
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem forall_mem_zpowers {x : G} {p : G → Prop} : (∀ g ∈ zpowers x, p g) ↔ ∀ m : ℤ, p (x ^ m)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem set_of_valid (cs cs' : List Char) (c' : Char) :
    set ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩ c' = ⟨cs ++ cs'.modifyHead fun _ => c'⟩
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem append_append_left_iff : ∀ L, Red (L ++ L₁) (L ++ L₂) ↔ Red L₁ L₂
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem exists_root {f : Polynomial (AlgebraicClosureAux k)}
    (hfm : f.Monic) (hfi : Irreducible f) : ∃ x : AlgebraicClosureAux k, f.eval x = 0
-- Mathlib/GroupTheory/SemidirectProduct.lean
theorem inl_aut_inv (g : G) (n : N) : (inl ((φ g)⁻¹ n) : N ⋊[φ] G) = inr g⁻¹ * inl n * inr g
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem norm_eq_card_dsupport (f : lp E 0) : ‖f‖ = (lp.memℓp f).finite_dsupport.toFinset.card
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma map_b₄ : (W.map φ).b₄ = φ W.b₄
-- Mathlib/Order/Category/CompleteLat.lean
/-- The equivalence between `CompleteLat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : CompleteLat ≌ CompleteLat
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem coe_neg : ⇑(-f) = -f
-- Mathlib/AlgebraicGeometry/Spec.lean
theorem algebraMap_pushforward_stalk :
    algebraMap R ((Spec.topMap f _* (structureSheaf S).1).stalk p) =
      f ≫ StructureSheaf.toPushforwardStalk f p
-- Mathlib/Data/Nat/ModEq.lean
lemma cancel_right_div_gcd' (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : a * c ≡ b * d [MOD m]) :
    a ≡ b [MOD m / gcd m c]
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
theorem isTotallySeparated_empty : IsTotallySeparated (∅ : Set α)
-- Mathlib/Logic/Basic.lean
@[deprecated exists_eq_left (since := "2024-04-06")]
theorem bex_eq_left {a : α} : (∃ (x : _) (_ : x = a), p x) ↔ p a
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem exists_gt (f : CauSeq α abs) : ∃ a : α, f < const a
-- Mathlib/Algebra/Polynomial/Bivariate.lean
lemma eval_C_X_comp_eval₂_map_C_X :
    (evalRingHom (C X : R[X][Y])).comp (eval₂RingHom (mapRingHom <| algebraMap R R[X][Y]) (C Y)) =
      .id _
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isRadical_vanishingIdeal (s : Set (PrimeSpectrum R)) : (vanishingIdeal s).IsRadical
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem mem_star_iff (S : Subalgebra R A) (x : A) : x ∈ star S ↔ star x ∈ S
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- For every `n ∈ ℕ` and every ideal `I`, `val_v(I^n) = n*val_v(I)`. -/
theorem count_pow (n : ℕ) (I : FractionalIdeal R⁰ K) :
    count K v (I ^ n) = n * count K v I
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
theorem coproductIso_mk_comp_inv {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    (↾fun x : F j => (⟨j, x⟩ : Σj, F j)) ≫ (coproductIso F).inv = Sigma.ι F j
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_diff_right : Ioc a b \ {b} = Ioo a b
-- Mathlib/Topology/Order/PartialSups.lean
protected lemma ContinuousAt.partialSups (hf : ∀ k ≤ n, ContinuousAt (f k) x) :
    ContinuousAt (partialSups f n) x
-- Mathlib/Data/Fin/Basic.lean
protected theorem mul_zero' [NeZero n] (k : Fin n) : k * 0 = 0
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
theorem of_nat (m : ℕ) : padicNorm p m ≤ 1
-- Mathlib/Data/Set/Image.lean
theorem _root_.Disjoint.of_image (h : Disjoint (f '' s) (f '' t)) : Disjoint s t
-- Mathlib/Order/Filter/Basic.lean
/-- If two filters are disjoint, then a function cannot tend to both of them along a non-trivial
filter. -/
theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter β} (hf : Tendsto f a b₁)
    [NeBot a] (hb : Disjoint b₁ b₂) : ¬Tendsto f a b₂
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem div_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
    I / J = ⟨I / J, fractional_div_of_nonzero h⟩
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem smul_imJ [SMul S R] (s : S) : (s • a).imJ = s • a.imJ
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
/-- `AffineMap.linear` on endomorphisms is a `MonoidHom`. -/
@[simps]
def linearHom : (P1 →ᵃ[k] P1) →* V1 →ₗ[k] V1
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem add_closure_setOf_eq_single :
    AddSubmonoid.closure { f : α →₀ M | ∃ a b, f = single a b } = ⊤
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem toFinset_image2 (f : α → β → γ) (s : Set α) (t : Set β) [Fintype s] [Fintype t]
    [Fintype (image2 f s t)] : (image2 f s t).toFinset = Finset.image₂ f s.toFinset t.toFinset
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mem_sInf {S : Set (Sublattice α)} : a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L
-- Mathlib/Topology/Algebra/Ring/Basic.lean
theorem Subsemiring.isClosed_topologicalClosure (s : Subsemiring α) :
    IsClosed (s.topologicalClosure : Set α)
-- Mathlib/Data/List/NodupEquivFin.lean
theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone l.get
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- If `K` is of characteristic `0` and there is a primitive `n`-th root of unity in `K`,
then `cyclotomic n K` comes from a unique polynomial with integer coefficients. -/
theorem unique_int_coeff_of_cycl {K : Type*} [CommRing K] [IsDomain K] [CharZero K] {ζ : K}
    {n : ℕ+} (h : IsPrimitiveRoot ζ n) :
    ∃! P : ℤ[X], map (Int.castRingHom K) P = cyclotomic' n K
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem rat_sup_continuous_lemma {ε : α} {a₁ a₂ b₁ b₂ : α} :
    abs (a₁ - b₁) < ε → abs (a₂ - b₂) < ε → abs (a₁ ⊔ a₂ - b₁ ⊔ b₂) < ε
-- Mathlib/Probability/Moments.lean
@[simp]
theorem moment_zero (hp : p ≠ 0) : moment 0 p μ = 0