ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_comp_const_mul (r : R) (f : R → R) (a : A)
    (hf : ContinuousOn f ((r * ·) '' (spectrum R a)) := by cfc_cont_tac)  (ha : p a := by cfc_tac) :
    cfc (f <| r * ·) a = cfc f (r • a)
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem isPrimary_of_isMaximal_radical [CommRing R] {I : Ideal R} (hi : IsMaximal (radical I)) :
    IsPrimary I
-- Mathlib/Data/Set/MemPartition.lean
lemma finite_memPartition (f : ℕ → Set α) (n : ℕ) : Set.Finite (memPartition f n)
-- Mathlib/Computability/ContextFreeGrammar.lean
/-- Add extra prefix to context-free deriving. -/
lemma Derives.append_left {v w : List (Symbol T g.NT)}
    (hvw : g.Derives v w) (p : List (Symbol T g.NT)) :
    g.Derives (p ++ v) (p ++ w)
-- Mathlib/Computability/Reduce.lean
theorem OneOneEquiv.le_congr_right {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv q r) : p ≤₁ q ↔ p ≤₁ r
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_refl :
    LinearIsometryEquiv.piLpCongrRight p (fun i => .refl 𝕜 (α i)) = .refl _ _
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem coeff_inv_aux (n : ℕ) (a : R) (φ : R⟦X⟧) :
    coeff R n (inv.aux a φ) =
      if n = 0 then a
      else
        -a *
          ∑ x ∈ antidiagonal n,
            if x.2 < n then coeff R x.1 φ * coeff R x.2 (inv.aux a φ) else 0
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.disjoint_span_image (hv : LinearIndependent R v) {s t : Set ι}
    (hs : Disjoint s t) : Disjoint (Submodule.span R <| v '' s) (Submodule.span R <| v '' t)
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem empty_infs : ∅ ⊼ t = ∅
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_conj (y : 𝔸) (x : 𝔸) (hy : y ≠ 0) : exp 𝕂 (y * x * y⁻¹) = y * exp 𝕂 x * y⁻¹
-- Mathlib/RingTheory/PiTensorProduct.lean
lemma algebraMap_apply (r : R') (i : ι) [DecidableEq ι] :
    algebraMap R' (⨂[R] i, A i) r = tprod R (Pi.mulSingle i (algebraMap R' (A i) r))
-- Mathlib/Order/Filter/Basic.lean
theorem nonempty_of_neBot (f : Filter α) [NeBot f] : Nonempty α
-- Mathlib/Data/Nat/Choose/Sum.lean
/-- The sum of `(n+1).choose i * f i (n+1-i)` can be split into two sums at rank `n`,
respectively of `n.choose i * f i (n+1-i)` and `n.choose i * f (i+1) (n-i)`. -/
theorem sum_choose_succ_mul (f : ℕ → ℕ → R) (n : ℕ) :
    (∑ i ∈ range (n + 2), ((n + 1).choose i : R) * f i (n + 1 - i)) =
      (∑ i ∈ range (n + 1), (n.choose i : R) * f i (n + 1 - i)) +
        ∑ i ∈ range (n + 1), (n.choose i : R) * f (i + 1) (n - i)
-- Mathlib/Combinatorics/Additive/Corner/Roth.lean
private lemma farFromTriangleFree_graph [DecidableEq G] (hε : ε * card G ^ 2 ≤ A.card) :
    (graph <| triangleIndices A).FarFromTriangleFree (ε / 9)
-- Mathlib/Order/Filter/CardinalInter.lean
/-- Every CardinalInterFilter with c > aleph0 is a CountableInterFilter -/
theorem CardinalInterFilter.toCountableInterFilter (l : Filter α) [CardinalInterFilter l c]
    (hc : aleph0 < c) : CountableInterFilter l
-- Mathlib/Topology/Category/UniformSpace.lean
@[simp]
theorem coe_of (X : Type u) [UniformSpace X] : (of X : Type u) = X
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- `F(S) / F` is a separable extension if and only if all elements of `S` are
separable elements. -/
theorem IntermediateField.isSeparable_adjoin_iff_isSeparable {S : Set E} :
    Algebra.IsSeparable F (adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If a function is `C^n` with `1 ≤ n`, then the derivative of `f` is also a strict derivative. -/
theorem ContDiff.hasStrictFDerivAt {f : E' → F'} {x : E'} (hf : ContDiff 𝕂 n f) (hn : 1 ≤ n) :
    HasStrictFDerivAt f (fderiv 𝕂 f x) x
-- Mathlib/Data/Option/Basic.lean
theorem getD_default_eq_iget [Inhabited α] (o : Option α) :
    o.getD default = o.iget
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma zpow_sub₀ (ha : a ≠ 0) (m n : ℤ) : a ^ (m - n) = a ^ m / a ^ n
-- Mathlib/Tactic/NormNum/NatSqrt.lean
theorem isNat_sqrt : {x nx z : ℕ} → IsNat x nx → Nat.sqrt nx = z → IsNat (Nat.sqrt x) z
-- Mathlib/Topology/Gluing.lean
theorem preimage_image_eq_image' (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = (D.t i j ≫ D.f _ _) '' (D.f _ _ ⁻¹' U)
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
protected theorem hasMFDerivWithinAt : HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x (f : E →L[𝕜] E')
-- Mathlib/Probability/Moments.lean
theorem iIndepFun.integrable_exp_mul_sum [IsProbabilityMeasure μ] {X : ι → Ω → ℝ}
    (h_indep : iIndepFun (fun i => inferInstance) X μ) (h_meas : ∀ i, Measurable (X i))
    {s : Finset ι} (h_int : ∀ i ∈ s, Integrable (fun ω => exp (t * X i ω)) μ) :
    Integrable (fun ω => exp (t * (∑ i ∈ s, X i) ω)) μ
-- Mathlib/CategoryTheory/Preadditive/Projective.lean
theorem of_iso {P Q : C} (i : P ≅ Q) (hP : Projective P) : Projective Q
-- Mathlib/RingTheory/Jacobson.lean
theorem isJacobson_of_isIntegral' (f : R →+* S) (hf : f.IsIntegral) (hR : IsJacobson R) :
    IsJacobson S
-- Mathlib/Logic/Equiv/Fin.lean
@[simp] theorem finSuccEquivLast_symm_none : finSuccEquivLast.symm none = Fin.last n
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.smul (h₁ : IsBigOWith c l k₁ k₂) (h₂ : IsBigOWith c' l f' g') :
    IsBigOWith (c * c') l (fun x => k₁ x • f' x) fun x => k₂ x • g' x
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem sqFrom_id (C₁ : HomologicalComplex V c) (i : ι) : sqFrom (𝟙 C₁) i = 𝟙 _
-- Mathlib/Computability/NFA.lean
@[simp]
theorem evalFrom_nil (S : Set σ) : M.evalFrom S [] = S
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem Unit_of_divided_by_X_pow_order_nonzero {f : k⟦X⟧} (hf : f ≠ 0) :
    ↑(Unit_of_divided_by_X_pow_order f) = divided_by_X_pow_order hf
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_lt_div_iff : 1 < a / b ↔ 0 < b ∧ b < a ∨ b < 0 ∧ a < b
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- Markov's inequality for counting measure with hypothesis using `tsum` in `ℝ≥0`. -/
theorem _root_.NNReal.count_const_le_le_of_tsum_le [MeasurableSingletonClass α] {a : α → ℝ≥0}
    (a_mble : Measurable a) (a_summable : Summable a) {c : ℝ≥0} (tsum_le_c : ∑' i, a i ≤ c)
    {ε : ℝ≥0} (ε_ne_zero : ε ≠ 0) : Measure.count { i : α | ε ≤ a i } ≤ c / ε
-- Mathlib/Probability/Martingale/Basic.lean
theorem submartingale_of_condexp_sub_nonneg_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ}
    (hadp : Adapted 𝒢 f) (hint : ∀ i, Integrable (f i) μ)
    (hf : ∀ i, 0 ≤ᵐ[μ] μ[f (i + 1) - f i|𝒢 i]) : Submartingale f 𝒢 μ
-- Mathlib/RingTheory/WittVector/Basic.lean
private theorem ghostFun_zero : ghostFun (0 : 𝕎 R) = 0
-- Mathlib/Order/MinMax.lean
@[gcongr] theorem max_le_max_right (c) (h : a ≤ b) : max a c ≤ max b c
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_cons (a : α) (s : Multiset α) : (a ::ₘ s).sup = a ⊔ s.sup
-- Mathlib/Data/Finset/Image.lean
/-- A version of `Finset.map_disjUnion` for writing in the other direction. -/
theorem map_disjUnion' {f : α ↪ β} (s₁ s₂ : Finset α) (h') (h := (disjoint_map _).mp h') :
    (s₁.disjUnion s₂ h).map f = (s₁.map f).disjUnion (s₂.map f) h'
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- In a space with second countable topology and a sigma-finite measure, a measurable function
is `FinStronglyMeasurable`. -/
@[aesop 90% apply (rule_sets := [Measurable])]
theorem finStronglyMeasurable_of_measurable {_m0 : MeasurableSpace α} (μ : Measure α)
    [SigmaFinite μ] (hf : Measurable f) : FinStronglyMeasurable f μ
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem kerLiftAlg_mk (f : A →ₐ[R₁] B) (a : A) :
    kerLiftAlg f (Quotient.mk (RingHom.ker f) a) = f a
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem norm_eq_zero {d : ℤ} (h_nonsquare : ∀ n : ℤ, d ≠ n * n) (a : ℤ√d) : norm a = 0 ↔ a = 0
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem submatrix_one_equiv [Zero α] [One α] [DecidableEq m] [DecidableEq l] (e : l ≃ m) :
    (1 : Matrix m m α).submatrix e e = 1
-- Mathlib/Data/Stream/Init.lean
theorem get_succ_iterate (n : ℕ) (f : α → α) (a : α) :
    get (iterate f a) (succ n) = get (iterate f (f a)) n
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem ediam_range : EMetric.diam (range f) = EMetric.diam (univ : Set E)
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
/-- The quadratic character is nontrivial as a multiplicative character
when the domain has odd characteristic. -/
theorem quadraticChar_ne_one (hF : ringChar F ≠ 2) : quadraticChar F ≠ 1
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem vars_C_mul (a : A) (ha : a ≠ 0) (φ : MvPolynomial σ A) :
    (C a * φ : MvPolynomial σ A).vars = φ.vars
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma isNilRegular_def :
    IsNilRegular φ x ↔ (Polynomial.coeff (φ x).charpoly (nilRank φ) ≠ 0)
-- Mathlib/Order/Hom/CompleteLattice.lean
theorem copy_eq (f : sSupHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Data/Real/ConjExponents.lean
lemma sub_one_mul_conj : (p - 1) * q = p
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma Y_sub_negPolynomial : Y - W.negPolynomial = W.polynomialY
-- Mathlib/Data/Ordmap/Ordset.lean
theorem dual_balanceR (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (balanceR l x r) = balanceL (dual r) x (dual l)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_apply_superset (h : s ⊆ t) : μ.restrict s t = μ s
-- Mathlib/Order/Closure.lean
lemma closure_min (hxy : x ≤ y) (hy : c.IsClosed y) : c x ≤ y
-- Mathlib/Topology/Compactness/Compact.lean
lemma IsCompact.elim_nhds_subcover_nhdsSet (hs : IsCompact s) {U : X → Set X}
    (hU : ∀ x ∈ s, U x ∈ 𝓝 x) : ∃ t : Finset X, (∀ x ∈ t, x ∈ s) ∧ (⋃ x ∈ t, U x) ∈ 𝓝ˢ s
-- Mathlib/CategoryTheory/NatIso.lean
@[simp]
theorem cancel_natIso_hom_right_assoc {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y)
    (f' : W ⟶ X') (g' : X' ⟶ F.obj Y) :
    f ≫ g ≫ α.hom.app Y = f' ≫ g' ≫ α.hom.app Y ↔ f ≫ g = f' ≫ g'
-- Mathlib/Dynamics/FixedPoints/Topology.lean
/-- If the iterates `f^[n] x` converge to `y` and `f` is continuous at `y`,
then `y` is a fixed point for `f`. -/
theorem isFixedPt_of_tendsto_iterate {x y : α} (hy : Tendsto (fun n => f^[n] x) atTop (𝓝 y))
    (hf : ContinuousAt f y) : IsFixedPt f y
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
/-- Existence of local integral curves for a $C^1$ vector field on a smooth manifold without
boundary. -/
lemma exists_isIntegralCurveAt_of_contMDiffAt_boundaryless [BoundarylessManifold I M]
    (hv : ContMDiffAt I I.tangent 1 (fun x ↦ (⟨x, v x⟩ : TangentBundle I M)) x₀) :
    ∃ γ : ℝ → M, γ t₀ = x₀ ∧ IsIntegralCurveAt γ v t₀
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_pow [Nontrivial R] (abv : R → S) [IsAbsoluteValue abv] (a : R) (n : ℕ) :
    abv (a ^ n) = abv a ^ n
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
@[reassoc]
theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    X.δ j.succ ≫ X.δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) =
      X.δ i ≫ X.δ j
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- If a bounded group homomorphism map is constructed from a group homomorphism via the constructor
`NormedAddGroupHom.ofLipschitz`, then its norm is bounded by the bound given to the constructor. -/
theorem ofLipschitz_norm_le (f : V₁ →+ V₂) {K : ℝ≥0} (h : LipschitzWith K f) :
    ‖ofLipschitz f h‖ ≤ K
-- Mathlib/Data/Nat/PSub.lean
theorem psub_eq_none {m n : ℕ} : psub m n = none ↔ m < n
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem add_mem ⦃x⦄ (hx : x ∈ S) ⦃y⦄ (hy : y ∈ S) : x + y ∈ S
-- Mathlib/Data/Set/Card.lean
theorem two_lt_ncard (hs : s.Finite := by toFinite_tac) :
    2 < s.ncard ↔ ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a ≠ b ∧ a ≠ c ∧ b ≠ c
-- Mathlib/CategoryTheory/Adjunction/Whiskering.lean
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G
-- Mathlib/Analysis/BoundedVariation.lean
/-- A real function into a finite dimensional real vector space which is Lipschitz on a set
is differentiable almost everywhere in this set. For the general Rademacher theorem assuming
that the source space is finite dimensional, see `LipschitzOnWith.ae_differentiableWithinAt_of_mem`.
-/
theorem LipschitzOnWith.ae_differentiableWithinAt_of_mem_real {C : ℝ≥0} {f : ℝ → V} {s : Set ℝ}
    (h : LipschitzOnWith C f s) : ∀ᵐ x, x ∈ s → DifferentiableWithinAt ℝ f s x
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma MeasurableEmbedding.prod_mk_right {β γ : Type*} [MeasurableSingletonClass α]
    {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
    {f : γ → β} (hf : MeasurableEmbedding f) (x : α) :
    MeasurableEmbedding (fun y ↦ (f y, x))
-- Mathlib/Data/Set/Basic.lean
theorem inter_insert_of_not_mem (h : a ∉ s) : s ∩ insert a t = s ∩ t
-- Mathlib/Data/Fintype/Basic.lean
@[simp] -- Porting note: new attribute
theorem toFinset_singleton (a : α) [Fintype ({a} : Set α)] : ({a} : Set α).toFinset = {a}
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone : Cone F
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem add_left_aux2' (x y z : E) :
    ‖x + y + z‖ * ‖x + y + z‖ - ‖x + y - z‖ * ‖x + y - z‖ =
    ‖x + z‖ * ‖x + z‖ - ‖x - z‖ * ‖x - z‖ +
    (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2
-- Mathlib/FieldTheory/Fixed.lean
theorem linearIndependent_toLinearMap (R : Type u) (A : Type v) (B : Type w) [CommSemiring R]
    [Ring A] [Algebra R A] [CommRing B] [IsDomain B] [Algebra R B] :
    LinearIndependent B (AlgHom.toLinearMap : (A →ₐ[R] B) → A →ₗ[R] B)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem two_inv_lt_one : (2⁻¹ : α) < 1
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumAssoc_apply_inl_inl (a) : sumAssoc α β γ (inl (inl a)) = inl a
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma BoundaryGE.false_of_isTruncLE {j : ι} (hj : e.BoundaryGE j) [e.IsTruncLE] : False
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem map_le_smul_top (I : Ideal R) (f : R →ₗ[R] M) :
    Submodule.map f I ≤ I • (⊤ : Submodule R M)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem map_dvd (f : R →+* S) {x y : R[X]} : x ∣ y → x.map f ∣ y.map f
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lift_compr₂ (g : P →ₗ[R] Q) : lift (f.compr₂ g) = g.comp (lift f)
-- Mathlib/Algebra/Quaternion.lean
theorem eq_re_of_eq_coe {a : ℍ[R,c₁,c₂]} {x : R} (h : a = x) : a = a.re
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_id_of {X : Type u} [Ring X] :
    @DFunLike.coe no_index (RingCat.of X ⟶ RingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_from_prod_countable [Countable β] [MeasurableSingletonClass β]
    {_ : MeasurableSpace γ} {f : α × β → γ} (hf : ∀ y, Measurable fun x => f (x, y)) :
    Measurable f
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp] theorem dist_ofAdd (a b : X) : dist (ofAdd a) (ofAdd b) = dist a b
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean
theorem quasiSeparated_stableUnderBaseChange :
    MorphismProperty.StableUnderBaseChange @QuasiSeparated
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem isLimit_iff_omega_dvd {a : Ordinal} : IsLimit a ↔ a ≠ 0 ∧ ω ∣ a
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem rename_esymm (n : ℕ) (e : σ ≃ τ) : rename e (esymm σ R n) = esymm τ R n
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem powerlt_zero {a : Cardinal} : a ^< 0 = 0
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem exists_real_pos_lt_infEdist_of_not_mem_closure {x : α} {E : Set α} (h : x ∉ closure E) :
    ∃ ε : ℝ, 0 < ε ∧ ENNReal.ofReal ε < infEdist x E
-- Mathlib/Topology/Algebra/Order/Field.lean
/-- The function `r ↦ r⁻¹` tends to `0` on the right as `r → +∞`. -/
theorem tendsto_inv_atTop_zero' : Tendsto (fun r : 𝕜 => r⁻¹) atTop (𝓝[>] (0 : 𝕜))
-- Mathlib/LinearAlgebra/Dimension/Free.lean
theorem Module.finite_of_finrank_pos (h : 0 < finrank R M) :
    Module.Finite R M
-- Mathlib/RingTheory/MvPolynomial/Basic.lean
theorem mem_restrictTotalDegree (p : MvPolynomial σ R) :
    p ∈ restrictTotalDegree σ R m ↔ p.totalDegree ≤ m
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
theorem Basis.prod_addHaar (v : Basis ι ℝ E) (w : Basis ι' ℝ F) :
    (v.prod w).addHaar = v.addHaar.prod w.addHaar
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A ring homomorphism from a `Ring R` to a `SeminormedRing S` which induces the norm structure
`SeminormedRing.induced` makes `R` satisfy `‖(1 : R)‖ = 1` whenever `‖(1 : S)‖ = 1`. -/
theorem NormOneClass.induced {F : Type*} (R S : Type*) [Ring R] [SeminormedRing S]
    [NormOneClass S] [FunLike F R S] [RingHomClass F R S] (f : F) :
    @NormOneClass R (SeminormedRing.induced R S f).toNorm _
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem zpow_add_one_of_ne_neg_one {A : M} : ∀ n : ℤ, n ≠ -1 → A ^ (n + 1) = A ^ n * A
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsCycle.rotate {u v : V} {c : G.Walk v v} (hc : c.IsCycle) (h : u ∈ c.support) :
    (c.rotate h).IsCycle
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem mul_self_inj_of_nonneg (a0 : 0 ≤ a) (b0 : 0 ≤ b) : a * a = b * b ↔ a = b
-- Mathlib/Algebra/Ring/Parity.lean
lemma div_two_mul_two_add_one_of_odd (h : Odd n) : n / 2 * 2 + 1 = n
-- Mathlib/Analysis/Calculus/Conformal/InnerProduct.lean
/-- A real differentiable map `f` is conformal at point `x` if and only if its
    differential `f'` at that point scales every inner product by a positive scalar. -/
theorem conformalAt_iff {f : E → F} {x : E} {f' : E →L[ℝ] F} (h : HasFDerivAt f f' x) :
    ConformalAt f x ↔ ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪f' u, f' v⟫ = c * ⟪u, v⟫
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma nonempty_countableGeneratingSet [MeasurableSpace α] [CountablyGenerated α] :
    Set.Nonempty (countableGeneratingSet α)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem mkPiAlgebraFin_apply (m : Fin n → A) :
    ContinuousMultilinearMap.mkPiAlgebraFin R n A m = (List.ofFn m).prod
-- Mathlib/Topology/UniformSpace/Compact.lean
/-- On a compact uniform space, the topology determines the uniform structure, entourages are
exactly the neighborhoods of the diagonal. -/
theorem compactSpace_uniformity [CompactSpace α] : 𝓤 α = ⨆ x, 𝓝 (x, x)
-- Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean
theorem Asymptotics.IsLittleO.sum_range {α : Type*} [NormedAddCommGroup α] {f : ℕ → α} {g : ℕ → ℝ}
    (h : f =o[atTop] g) (hg : 0 ≤ g) (h'g : Tendsto (fun n => ∑ i ∈ range n, g i) atTop atTop) :
    (fun n => ∑ i ∈ range n, f i) =o[atTop] fun n => ∑ i ∈ range n, g i
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem IsPRadical.pow_mem [IsPRadical i p] (x : L) :
    ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succ_le_succ_iff {a b : Fin n} : a.succ ≤ b.succ ↔ a ≤ b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
lemma nonneg_iff_isSelfAdjoint_and_quasispectrumRestricts {a : A} :
    0 ≤ a ↔ IsSelfAdjoint a ∧ QuasispectrumRestricts a ContinuousMap.realToNNReal
-- Mathlib/Data/Set/Basic.lean
theorem exists_mem_of_nonempty (α) : ∀ [Nonempty α], ∃ x : α, x ∈ (univ : Set α)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
@[simp]
theorem IntegrableAtFilter.inf_ae_iff {l : Filter α} :
    IntegrableAtFilter f (l ⊓ ae μ) μ ↔ IntegrableAtFilter f l μ
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma divInt_neg (n d : ℤ) : n /. -d = -n /. d
-- .lake/packages/lean4/src/lean/Init/Data/Int/Basic.lean
@[simp] theorem default_eq_zero : default = (0 : Int)
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem basicOpen_mul_le_right (f g : R) : basicOpen (f * g) ≤ basicOpen g
-- Mathlib/RingTheory/FreeCommRing.lean
theorem isSupported_upwards (hs : IsSupported x s) (hst : s ⊆ t) : IsSupported x t
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
theorem fderiv_smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
    fderiv 𝕜 (fun y => c y • f) x = (fderiv 𝕜 c x).smulRight f
-- Mathlib/Probability/Kernel/Composition.lean
theorem prod_apply' (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsSFiniteKernel η]
    (a : α) {s : Set (β × γ)} (hs : MeasurableSet s) :
    (κ ×ₖ η) a s = ∫⁻ b : β, (η a) {c : γ | (b, c) ∈ s} ∂κ a
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
nonrec theorem symm : e.symm.MDifferentiable I' I
-- Mathlib/Data/List/Dedup.lean
@[simp]
theorem dedup_nil : dedup [] = ([] : List α)
-- Mathlib/Algebra/Star/Basic.lean
/-- In a commutative ring, make `simp` prefer leaving the order unchanged. -/
@[simp]
theorem star_mul' [CommSemigroup R] [StarMul R] (x y : R) : star (x * y) = star x * star y
-- Mathlib/Probability/Kernel/CondDistrib.lean
/-- **Regular conditional probability distribution**: kernel associated with the conditional
expectation of `Y` given `X`.
For almost all `a`, `condDistrib Y X μ` evaluated at `X a` and a measurable set `s` is equal to
the conditional expectation `μ⟦Y ⁻¹' s | mβ.comap X⟧ a`. It also satisfies the equality
`μ[(fun a => f (X a, Y a)) | mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂(condDistrib Y X μ (X a))`
for all integrable functions `f`. -/
noncomputable irreducible_def condDistrib {_ : MeasurableSpace α} [MeasurableSpace β] (Y : α → Ω)
    (X : α → β) (μ : Measure α) [IsFiniteMeasure μ] : Kernel β Ω
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[to_additive (attr := simp)]
lemma dist_unop (x y : αᵐᵒᵖ) : dist (unop x) (unop y) = dist x y
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem HasCompactSupport.fderiv_apply (hf : HasCompactSupport f) (v : E) :
    HasCompactSupport (fderiv 𝕜 f · v)
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumCompl_apply_inl (p : α → Prop) [DecidablePred p] (x : { a // p a }) :
    sumCompl p (Sum.inl x) = x
-- Mathlib/Order/LiminfLimsup.lean
lemma liminf_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    liminf (u ∘ v) f = liminf u (map v f)
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem foldr_le_nfpFamily (f : ι → Ordinal → Ordinal)
    (a l) : List.foldr f a l ≤ nfpFamily.{u, v} f a
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem multispan_obj_right (b) : I.multispan.obj (WalkingMultispan.right b) = I.right b
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem comap_comp (f : R →+* S) (g : S →+* S') : comap (g.comp f) = (comap f).comp (comap g)
-- Mathlib/Data/PFun.lean
theorem dom_eq (f : α →. β) : Dom f = { x | ∃ y, y ∈ f x }
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAnti.mapsTo_Ico (h : StrictAnti f) : MapsTo f (Ico a b) (Ioc (f b) (f a))
-- Mathlib/Data/Sym/Sym2.lean
@[aesop norm (rule_sets := [Sym2])]
theorem mem_iff' {a b c : α} : Sym2.Mem a s(b, c) ↔ a = b ∨ a = c
-- Mathlib/Data/Nat/Choose/Multinomial.lean
theorem multinomial_univ_three (a b c : ℕ) :
    multinomial Finset.univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem get_cons_succ {as : List α} {h : i + 1 < (a :: as).length} :
  (a :: as).get ⟨i+1, h⟩ = as.get ⟨i, Nat.lt_of_succ_lt_succ h⟩
-- Mathlib/CategoryTheory/Shift/CommShift.lean
@[reassoc]
lemma shift_app (a : A) (X : C) :
    (τ.app X)⟦a⟧' = (F₁.commShiftIso a).inv.app X ≫
      τ.app (X⟦a⟧) ≫ (F₂.commShiftIso a).hom.app X
-- Mathlib/Analysis/Convex/Cone/Basic.lean
/-- The positive cone of an ordered module is always pointed. -/
theorem pointed_positive : Pointed (positive 𝕜 E)
-- Mathlib/SetTheory/Game/PGame.lean
theorem relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
    (i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i
-- Mathlib/Topology/Bornology/Constructions.lean
theorem boundedSpace_subtype_iff {p : α → Prop} :
    BoundedSpace (Subtype p) ↔ IsBounded { x | p x }