ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
/-- A particular case of Sard's Theorem. Let `f : E → F` be a map between finite dimensional real
vector spaces. Suppose that `f` is `C¹` smooth on a convex set `s` of Hausdorff dimension strictly
less than the dimension of `F`. Then the complement of the image `f '' s` is dense in `F`. -/
theorem ContDiffOn.dense_compl_image_of_dimH_lt_finrank [FiniteDimensional ℝ F] {f : E → F}
    {s t : Set E} (h : ContDiffOn ℝ 1 f s) (hc : Convex ℝ s) (ht : t ⊆ s)
    (htF : dimH t < finrank ℝ F) : Dense (f '' t)ᶜ
-- Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean
lemma exact₀ {Z : C} (I : InjectiveResolution Z) :
    (ShortComplex.mk _ _ I.ι_f_zero_comp_complex_d).Exact
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_eq_symm (hy : y ≤ x) (h : x \ y = z) : x \ z = y
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
theorem card_eq_of_mem_parts_chunk (hs : s ∈ (chunk hP G ε hU).parts) :
    s.card = m ∨ s.card = m + 1
-- Mathlib/RingTheory/Artinian.lean
lemma primeSpectrum_finite : {I : Ideal R | I.IsPrime}.Finite
-- Mathlib/RingTheory/WittVector/Compare.lean
theorem zmodEquivTrunc_apply {x : ZMod (p ^ n)} :
    zmodEquivTrunc p n x = ZMod.castHom (by rfl) (TruncatedWittVector p n (ZMod p)) x
-- Mathlib/MeasureTheory/Function/Jacobian.lean
theorem lintegral_image_eq_lintegral_abs_det_fderiv_mul (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) (g : E → ℝ≥0∞) :
    ∫⁻ x in f '' s, g x ∂μ = ∫⁻ x in s, ENNReal.ofReal |(f' x).det| * g (f x) ∂μ
-- Mathlib/Order/Heyting/Boundary.lean
@[simp]
theorem boundary_bot : ∂ (⊥ : α) = ⊥
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem basisOf_apply (i : ι) (j : { j : ι // j ≠ i }) : b.basisOf i j = b ↑j -ᵥ b i
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
    (h_meas_s : MeasurableSet s) : (μ - ν) s = 0
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem dualBasis_repr_apply (B : BilinForm K V) (hB : B.Nondegenerate) (b : Basis ι K V) (x i) :
    (B.dualBasis hB b).repr x i = B x (b i)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- A variant of `Matrix.det_units_conj'`. -/
theorem det_conj' {M : Matrix m m α} (h : IsUnit M) (N : Matrix m m α) :
    det (M⁻¹ * N * M) = det N
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_I_smul_self (x : E) :
    @Inner.inner ℝ E (Inner.rclikeToReal 𝕜 E) x ((I : 𝕜) • x) = 0
-- Mathlib/Algebra/Jordan/Basic.lean
/-- A commutative Jordan multipication -/
class IsCommJordan [CommMagma A] : Prop where
  lmul_comm_rmul_rmul : ∀ a b : A, a * b * (a * a) = a * (b * (a * a))
-- Mathlib/Order/Atoms.lean
theorem IsStronglyAtomic.of_wellFounded_lt (h : WellFounded ((· < ·) : α → α → Prop)) :
    IsStronglyAtomic α
-- Mathlib/Data/Matrix/Basic.lean
theorem smul_one_eq_diagonal [DecidableEq m] (a : α) :
    a • (1 : Matrix m m α) = diagonal fun _ => a
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
theorem integral_eq_sub_of_hasDerivAt_of_tendsto (hab : a < b) {fa fb}
    (hderiv : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x) (hint : IntervalIntegrable f' volume a b)
    (ha : Tendsto f (𝓝[>] a) (𝓝 fa)) (hb : Tendsto f (𝓝[<] b) (𝓝 fb)) :
    ∫ y in a..b, f' y = fb - fa
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
theorem rank_span_set {s : Set M} (hs : LinearIndependent R (fun x => x : s → M)) :
    Module.rank R ↑(span R s) = #s
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_zero [Zero α] [One α] [Add α] [Neg α] : ((0 : ZNum) : α) = 0
-- Mathlib/Topology/Instances/Matrix.lean
theorem Summable.matrix_conjTranspose [StarAddMonoid R] [ContinuousStar R] {f : X → Matrix m n R}
    (hf : Summable f) : Summable fun x => (f x)ᴴ
-- Mathlib/Data/Multiset/Basic.lean
@[simp] lemma lt_singleton : s < {a} ↔ s = 0
-- Mathlib/Algebra/MvPolynomial/PDeriv.lean
theorem pderiv_eq_zero_of_not_mem_vars {i : σ} {f : MvPolynomial σ R} (h : i ∉ f.vars) :
    pderiv i f = 0
-- Mathlib/Data/Nat/Count.lean
theorem count_succ_eq_succ_count_iff {n : ℕ} : count p (n + 1) = count p n + 1 ↔ p n
-- Mathlib/Analysis/Convolution.lean
/-- The convolution `g * f` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`),
given in terms of composition with additional smooth functions. -/
theorem contDiffOn_convolution_left_with_param_comp [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
    (L : E' →L[𝕜] E →L[𝕜] F) {s : Set P} {n : ℕ∞} {v : P → G} (hv : ContDiffOn 𝕜 n v s) {f : G → E}
    {g : P → G → E'} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
    (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
    (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) : ContDiffOn 𝕜 n (fun x => (g x ⋆[L, μ] f) (v x)) s
-- Mathlib/MeasureTheory/PiSystem.lean
theorem has_univ : d.Has univ
-- Mathlib/Analysis/Complex/Basic.lean
@[continuity]
theorem continuous_conj : Continuous (conj : ℂ → ℂ)
-- Mathlib/Data/List/Destutter.lean
theorem destutter_sublist : ∀ l : List α, l.destutter R <+ l
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem map_nil (f : α → β) : map f nil = nil
-- Mathlib/Topology/MetricSpace/Bounded.lean
@[simp]
theorem ediam_univ_of_noncompact [ProperSpace α] [NoncompactSpace α] :
    EMetric.diam (univ : Set α) = ∞
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
@[simp]
theorem rank_finsupp (ι : Type w) :
    Module.rank R (ι →₀ M) = Cardinal.lift.{v} #ι * Cardinal.lift.{w} (Module.rank R M)
-- Mathlib/Algebra/Order/Monovary.lean
lemma MonovaryOn.div_left₀ (hf₁ : ∀ i ∈ s, 0 ≤ f₁ i) (hf₂ : ∀ i ∈ s, 0 < f₂ i)
    (h₁ : MonovaryOn f₁ g s) (h₂ : AntivaryOn f₂ g s) : MonovaryOn (f₁ / f₂) g s
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
theorem tangentBundleCore_coordChange_achart (x x' z : M) :
    (tangentBundleCore I M).coordChange (achart H x) (achart H x') z =
      fderivWithin 𝕜 (extChartAt I x' ∘ (extChartAt I x).symm) (range I) (extChartAt I x z)
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- A simple sufficient condition for bounding `levyProkhorovEDist` between probability measures
from above. The condition involves only one of two natural bounds, the other bound is for free. -/
lemma levyProkhorovEDist_le_of_forall_le
    (μ ν : Measure Ω) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] (δ : ℝ≥0∞)
    (h : ∀ ε B, δ < ε → ε < ∞ → MeasurableSet B → μ B ≤ ν (thickening ε.toReal B) + ε) :
    levyProkhorovEDist μ ν ≤ δ
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_add_le {x y g} (hx : v x ≤ g) (hy : v y ≤ g) : v (x + y) ≤ g
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem LinearMap.rank_le_of_injective (f : M →ₗ[R] M₁) (i : Injective f) :
    Module.rank R M ≤ Module.rank R M₁
-- Mathlib/Data/Set/Prod.lean
theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β i) :
    (fun (g : ∀ i, α i) i => f _ (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i
-- Mathlib/Order/Monotone/Basic.lean
theorem antitoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
    AntitoneOn (fun _ : α ↦ c) s
-- Mathlib/Data/Real/Irrational.lean
theorem of_add_int (m : ℤ) (h : Irrational (x + m)) : Irrational x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem sup_mul_inf (a b : Associates α) : (a ⊔ b) * (a ⊓ b) = a * b
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem associator_inv_naturality_middle (X : C) {Y Y' : C} (f : Y ⟶ Y') (Z : C) :
    X ◁ f ▷ Z ≫ (α_ X Y' Z).inv = (α_ X Y Z).inv ≫ (X ◁ f) ▷ Z
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- Ultrametric property of a p-adic valuation. -/
lemma add_eq_min {q r : ℚ} (hqr : q + r ≠ 0) (hq : q ≠ 0) (hr : r ≠ 0)
    (hval : padicValRat p q ≠ padicValRat p r) :
    padicValRat p (q + r) = min (padicValRat p q) (padicValRat p r)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating twice is equivalent to rotating by the sum of the angles. -/
@[simp]
theorem rotation_rotation (θ₁ θ₂ : Real.Angle) (x : V) :
    o.rotation θ₁ (o.rotation θ₂ x) = o.rotation (θ₁ + θ₂) x
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem inv_pow : ∀ {a : ℝ≥0∞} {n : ℕ}, (a ^ n)⁻¹ = a⁻¹ ^ n
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem card_fintypeIoc : Fintype.card (Set.Ioc a b) = b - a
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
protected lemma posSemidef_add {A : Matrix m m R} {B : Matrix m m R}
    (hA : A.PosSemidef) (hB : B.PosDef) : (A + B).PosDef
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem EuclideanSpace.volume_ball (x : EuclideanSpace ℝ ι) (r : ℝ) :
    volume (Metric.ball x r) = (.ofReal r) ^ card ι *
      .ofReal (Real.sqrt π ^ card ι / Gamma (card ι / 2 + 1))
-- Mathlib/Analysis/Convex/Side.lean
theorem wSameSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.WSameSide x y ↔ x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
theorem mem_col_iff {μ : YoungDiagram} {j : ℕ} {c : ℕ × ℕ} : c ∈ μ.col j ↔ c ∈ μ ∧ c.snd = j
-- Mathlib/Data/Finmap.lean
theorem insert_insert_of_ne {a a'} {b : β a} {b' : β a'} (s : Finmap β) (h : a ≠ a') :
    (s.insert a b).insert a' b' = (s.insert a' b').insert a b
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_iUnion_apply [Countable ι] {s : ι → Set α} (hd : Pairwise (Disjoint on s))
    (hm : ∀ i, MeasurableSet (s i)) {t : Set α} (ht : MeasurableSet t) :
    μ.restrict (⋃ i, s i) t = ∑' i, μ.restrict (s i) t
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem T_one : T R 1 = X
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
theorem ofNat_lt :
    (no_index (OfNat.ofNat m : α)) < (no_index (OfNat.ofNat n)) ↔
      (OfNat.ofNat m : ℕ) < OfNat.ofNat n
-- Mathlib/Computability/TuringMachine.lean
theorem stk_nth_val {K : Type*} {Γ : K → Type*} {L : ListBlank (∀ k, Option (Γ k))} {k S} (n)
    (hL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse) :
    L.nth n k = S.reverse.get? n
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
theorem lift_reverse [h : HasInvolutiveReverse V']
    (φ : Prefunctor V V') {X Y : Symmetrify V} (f : X ⟶ Y) :
    (Symmetrify.lift φ).map (Quiver.reverse f) = Quiver.reverse ((Symmetrify.lift φ).map f)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Iff.trans (h₁ : a ↔ b) (h₂ : b ↔ c) : a ↔ c
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma P3.trans (h₁ : P3 x₁ x₂ y₁ y₂) (h₂ : P3 x₂ x₃ y₁ y₂) : P3 x₁ x₃ y₁ y₂
-- Mathlib/CategoryTheory/Category/KleisliCat.lean
theorem KleisliCat.comp_def {m} [Monad m] (α β γ : KleisliCat m) (xs : α ⟶ β) (ys : β ⟶ γ) (a : α) :
    (xs ≫ ys) a = xs a >>= ys
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem ext {x y : ℤ_[p]} : (x : ℚ_[p]) = y → x = y
-- Mathlib/SetTheory/Game/PGame.lean
theorem moveRight_neg_symm {x : PGame} (i) :
    x.moveRight (toLeftMovesNeg.symm i) = -(-x).moveLeft i
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
@[simp] theorem map_eq (x : Id α) (f : α → β) : f <$> x = f x
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableWithinAt.inv' (hf : DifferentiableWithinAt 𝕜 h S z) (hz : h z ≠ 0) :
    DifferentiableWithinAt 𝕜 (fun x => (h x)⁻¹) S z
-- Mathlib/Data/Set/Lattice.lean
theorem prod_iUnion {s : Set α} {t : ι → Set β} : (s ×ˢ ⋃ i, t i) = ⋃ i, s ×ˢ t i
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_add' : ∀ x y, v (x + y) ≤ v x ∨ v (x + y) ≤ v y
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem preimage_sUnion {f : α → β} {s : Set (Set β)} : f ⁻¹' ⋃₀s = ⋃ t ∈ s, f ⁻¹' t
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[simp, measurability]
protected theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) {i : Bool} : MeasurableSet (cond i s₁ s₂)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.inv {f : E → 𝕜'} {n} (hf : ContDiff 𝕜 n f) (h : ∀ x, f x ≠ 0) :
    ContDiff 𝕜 n fun x => (f x)⁻¹
-- Mathlib/Deprecated/Ring.lean
/-- A map of rings that is a semiring homomorphism is also a ring homomorphism. -/
theorem of_semiring {f : α → β} (H : IsSemiringHom f) : IsRingHom f
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isGreatest_singleton : IsGreatest {a} a
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
@[simp]
theorem id_leftLim (x : ℝ) : leftLim StieltjesFunction.id x = x
-- Mathlib/Algebra/Lie/InvariantForm.lean
lemma mem_orthogonal (N : LieSubmodule R L M) (y : M) :
    y ∈ orthogonal Φ hΦ_inv N ↔ ∀ x ∈ N, Φ x y = 0
-- Mathlib/Data/Ordmap/Ordset.lean
theorem size_eq_realSize : ∀ {t : Ordnode α}, Sized t → size t = realSize t
-- Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean
@[simp] lemma directLimitRight_tmul_of {i : ι} (m : M) (g : G i) :
    directLimitRight f M (m ⊗ₜ of _ _ _ _ _ g) = of _ _ _ _ i (m ⊗ₜ g)
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_succ_floor (a : α) : a < ⌊a⌋₊.succ
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_of_iff_false : (p ↔ False) → ¬p
-- Mathlib/Analysis/ODE/PicardLindelof.lean
protected theorem continuousOn :
    ContinuousOn (uncurry v) (Icc v.tMin v.tMax ×ˢ closedBall v.x₀ v.R)
-- Mathlib/Topology/UniformSpace/Equiv.lean
theorem preimage_image (h : α ≃ᵤ β) (s : Set α) : h ⁻¹' (h '' s) = s
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
@[ext]
lemma hom_ext {A B : CommMon_ C} (f g : A ⟶ B) (h : f.hom = g.hom) : f = g
-- Mathlib/Data/List/Nodup.lean
theorem count_eq_of_nodup [DecidableEq α] {a : α} {l : List α} (d : Nodup l) :
    count a l = if a ∈ l then 1 else 0
-- Mathlib/Data/Analysis/Filter.lean
theorem mem_sets {f : Filter α} (F : f.Realizer) {a : Set α} : a ∈ f ↔ ∃ b, F.F b ⊆ a
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem MonotoneOn.quasilinearOn (hf : MonotoneOn f s) (hs : Convex 𝕜 s) : QuasilinearOn 𝕜 s f
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma le_induce_union_right : G'.induce s' ≤ G'.induce (s ∪ s')
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousAt.comp₂_continuousWithinAt_of_eq {f : β × γ → δ} {g : α → β}
    {h : α → γ} {x : α} {s : Set α} {y : β × γ} (hf : ContinuousAt f y)
    (hg : ContinuousWithinAt g s x) (hh : ContinuousWithinAt h s x) (e : (g x, h x) = y) :
    ContinuousWithinAt (fun x ↦ f (g x, h x)) s x
-- Mathlib/Order/RelClasses.lean
lemma ne_of_ssuperset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → b ≠ a
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma map_zero_one : map F f 0 1 (by simp) = f
-- Mathlib/Data/Set/Functor.lean
@[simp]
theorem pure_def (a : α) : (pure a : Set α) = {a}
-- Mathlib/Topology/Basic.lean
protected theorem IsOpen.mem_nhds_iff (hs : IsOpen s) : s ∈ 𝓝 x ↔ x ∈ s
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
lemma end_apply_apply (ij : ι × ι) (k : ι) : (b.end ij) (b k) = if ij.2 = k then b ij.1 else 0
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[simp]
theorem pullback.congrHom_inv {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂)
    (h₂ : g₁ = g₂) [HasPullback f₁ g₁] [HasPullback f₂ g₂] :
    (pullback.congrHom h₁ h₂).inv =
      pullback.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) (by simp [h₁]) (by simp [h₂])
-- Mathlib/AlgebraicGeometry/Restrict.lean
theorem morphismRestrict_val_base {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
    ⇑(f ∣_ U).val.base = U.1.restrictPreimage f.val.base
-- Mathlib/Data/Finset/Fold.lean
theorem fold_image_idem [DecidableEq α] {g : γ → α} {s : Finset γ} [hi : Std.IdempotentOp op] :
    (image g s).fold op b f = s.fold op b (f ∘ g)
-- Mathlib/Data/ZMod/Basic.lean
@[simp, norm_cast]
theorem cast_intCast (h : m ∣ n) (k : ℤ) : (cast (k : ZMod n) : R) = k
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_C_mul_X_pow_le (n : ℕ) (a : R) : degree (C a * X ^ n) ≤ n
-- Mathlib/Logic/Function/Basic.lean
lemma FactorsThrough.extend_apply {g : α → γ} (hf : g.FactorsThrough f) (e' : β → γ) (a : α) :
    extend f g e' (f a) = g a
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem le_of_not_lt {x y : Int} (h : ¬ (x < y)) : y ≤ x
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem map₂_nil (f : α → β → γ) : Vector.map₂ f nil nil = nil
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem leadingCoeff_C_mul_X_pow (a : R) (n : ℕ) : leadingCoeff (C a * X ^ n) = a
-- Mathlib/Algebra/DirectSum/Module.lean
/-- If a collection of submodules has just two indices, `i` and `j`, then
`DirectSum.IsInternal` is equivalent to `isCompl`. -/
theorem isInternal_submodule_iff_isCompl (A : ι → Submodule R M) {i j : ι} (hij : i ≠ j)
    (h : (Set.univ : Set ι) = {i, j}) : IsInternal A ↔ IsCompl (A i) (A j)
-- Mathlib/Data/Bundle.lean
theorem TotalSpace.mk_injective (b : B) : Injective (mk b : E b → TotalSpace F E)
-- Mathlib/GroupTheory/Frattini.lean
lemma frattini_le_comap_frattini_of_surjective : frattini G ≤ (frattini H).comap φ
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma norm_prime_cpow_le_one_half (p : Nat.Primes) {s : ℂ} (hs : 1 < s.re) :
    ‖(p : ℂ) ^ (-s)‖ ≤ 1 / 2
-- Mathlib/Order/Heyting/Basic.lean
theorem inf_sdiff_left : a \ b ⊓ a = a \ b
-- Mathlib/Data/Nat/Cast/Order/Field.lean
/-- Natural division is always less than division in the field. -/
theorem cast_div_le {m n : ℕ} : ((m / n : ℕ) : α) ≤ m / n
-- Mathlib/Data/List/Sigma.lean
theorem NodupKeys.eq_of_fst_eq {l : List (Sigma β)} (nd : NodupKeys l) {s s' : Sigma β} (h : s ∈ l)
    (h' : s' ∈ l) : s.1 = s'.1 → s = s'
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.totallyBounded_Icc (a b : α) : TotallyBounded (Icc a b)
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem prod_symm (eX : PartialHomeomorph X X') (eY : PartialHomeomorph Y Y') :
    (eX.prod eY).symm = eX.symm.prod eY.symm
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
lemma zpow_zpow_self₀ (a : G₀) (m n : ℤ) : Commute (a ^ m) (a ^ n)
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Coercion to a function as a `RingHom`. -/
@[simps!]
def coeFnRingHom {α : Type*} {β : Type*} [TopologicalSpace α] [TopologicalSpace β] [Semiring β]
    [TopologicalSemiring β] : C(α, β) →+* α → β
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
theorem LinearIndependent.span_eq_top_of_card_eq_finrank' {ι : Type*}
    [Fintype ι] [FiniteDimensional K V] {b : ι → V} (lin_ind : LinearIndependent K b)
    (card_eq : Fintype.card ι = finrank K V) : span K (Set.range b) = ⊤
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
/-- Conclude that `HD`, being Lipschitz, is continuous -/
private theorem HD_continuous : Continuous (HD : Cb X Y → ℝ)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is a finite separable extension of exponential characteristic `q`, if `{ u_i }` is a
family of elements of `E` which is `F`-linearly independent, then `{ u_i ^ (q ^ n) }` is also
`F`-linearly independent for any natural number `n`. A special case of
`LinearIndependent.map_pow_expChar_pow_of_isSeparable`
and is an intermediate result used to prove it. -/
private theorem LinearIndependent.map_pow_expChar_pow_of_fd_isSeparable
    [FiniteDimensional F E] [Algebra.IsSeparable F E]
    (h : LinearIndependent F v) : LinearIndependent F (v · ^ q ^ n)
-- Mathlib/Data/Set/Prod.lean
theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α))
-- Mathlib/Data/Real/Sqrt.lean
theorem le_sqrt_of_sq_le (h : x ^ 2 ≤ y) : x ≤ √y
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem unique_irreducible ⦃p q : R⦄ (hp : Irreducible p) (hq : Irreducible q) :
    Associated p q
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma rel_iff (x y : R) : I.ringCon x y ↔ x - y ∈ I
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem inv_anti_mono (hI : I ≠ 0) (hJ : J ≠ 0) (hIJ : I ≤ J) : J⁻¹ ≤ I⁻¹
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
lemma coeFn_def (μ : FiniteMeasure Ω) : μ = fun s ↦ ((μ : Measure Ω) s).toNNReal
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
@[simp]
theorem monomorphisms.iff : (monomorphisms C) f ↔ Mono f
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b
-- Mathlib/Data/Real/Irrational.lean
theorem irrational_sqrt_natCast_iff {n : ℕ} : Irrational (√n) ↔ ¬IsSquare n
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
theorem ucs_zero : N.ucs 0 = N
-- Mathlib/Topology/LocallyFinite.lean
theorem locallyFinite_sum {f : ι ⊕ ι' → Set X} :
    LocallyFinite f ↔ LocallyFinite (f ∘ Sum.inl) ∧ LocallyFinite (f ∘ Sum.inr)
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp] theorem counit_comp_lsingle (i : ι) : counit ∘ₗ (lsingle i : A →ₗ[R] _) = counit
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem C_injective : Injective (C : R → R[X])
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
/-- If `γ` is an integral curve of a vector field `v`, then `γ t` is tangent to `v (γ t)` when
  expressed in the local chart around the initial point `γ t₀`. -/
lemma IsIntegralCurveOn.hasDerivAt (hγ : IsIntegralCurveOn γ v s) {t : ℝ} (ht : t ∈ s)
    (hsrc : γ t ∈ (extChartAt I (γ t₀)).source) :
    HasDerivAt ((extChartAt I (γ t₀)) ∘ γ)
      (tangentCoordChange I (γ t) (γ t₀) (γ t) (v (γ t))) t
-- Mathlib/Order/WithBot.lean
@[simp]
theorem unbot_coe (x : α) (h : (x : WithBot α) ≠ ⊥ := coe_ne_bot) : (x : WithBot α).unbot h = x
-- Mathlib/Data/Set/Card.lean
theorem encard_eq_three {α : Type u_1} {s : Set α} :
    encard s = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}
-- Mathlib/CategoryTheory/CommSq.lean
theorem horiz_inv {f : W ≅ X} {i : Y ≅ Z} (p : CommSq f.hom g h i.hom) :
    CommSq f.inv h g i.inv
-- Mathlib/NumberTheory/NumberField/Norm.lean
theorem coe_algebraMap_norm [Algebra.IsSeparable K L] (x : 𝓞 L) :
    (algebraMap (𝓞 K) (𝓞 L) (norm K x) : L) = algebraMap K L (Algebra.norm K (x : L))
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
lemma natCast_cpow_natCast_mul (n m : ℕ) (z : ℂ) : (n : ℂ) ^ (m * z) = ((n : ℂ) ^ m) ^ z
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- The intersection of two covering sieves is covering.

See <https://stacks.math.columbia.edu/tag/00Z5> (1), or [MM92] Chapter III,
Section 2, Definition 1 (iv).
-/
theorem intersection_covering (rj : R ∈ J X) (sj : S ∈ J X) : R ⊓ S ∈ J X
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.of_denote_eq_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_eq ctx (cancelAux fuel m₁ m₂ r₁ r₂)) : denote_eq ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)
-- Mathlib/Probability/Distributions/Gamma.lean
lemma gammaPDF_of_nonneg {a r x : ℝ} (hx : 0 ≤ x) :
    gammaPDF a r x = ENNReal.ofReal (r ^ a / (Gamma a) * x ^ (a-1) * exp (-(r * x)))
-- Mathlib/Data/Set/Card.lean
theorem encard_diff_singleton_of_mem (h : a ∈ s) :
    (s \ {a}).encard = s.encard - 1
-- Mathlib/Data/Rat/Lemmas.lean
@[simp]
theorem inv_natCast_num (a : ℕ) : (a : ℚ)⁻¹.num = Int.sign a
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousAt.finset_inf'_apply (hne : s.Nonempty) (hs : ∀ i ∈ s, ContinuousAt (f i) x) :
    ContinuousAt (fun a ↦ s.inf' hne (f · a)) x
-- Mathlib/RingTheory/RingHom/FiniteType.lean
theorem finiteType_holdsForLocalizationAway : HoldsForLocalizationAway @FiniteType
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean
@[simp] lemma tensorAssoc_apply
    (Q₁ : QuadraticForm R M₁) (Q₂ : QuadraticForm R M₂) (Q₃ : QuadraticForm R M₃)
    (x : (M₁ ⊗[R] M₂) ⊗[R] M₃) :
    tensorAssoc Q₁ Q₂ Q₃ x = TensorProduct.assoc R M₁ M₂ M₃ x
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
@[simp]
theorem degree_hermite (n : ℕ) : (hermite n).degree = n
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[simp]
lemma image_subtype_val_Ico {s : Set α} [OrdConnected s] (x y : s) :
    Subtype.val '' Ico x y = Ico x.1 y
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
lemma realContinuousMapZeroOfNNReal_injective :
    Function.Injective (realContinuousMapZeroOfNNReal (X := X) (A := A))
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp, norm_cast]
theorem coe_smul (r : R) (p : AddGroupSeminorm E) : ⇑(r • p) = r • ⇑p
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem pointwise_smul_def {a : M} (S : Subsemiring R) :
    a • S = S.map (MulSemiringAction.toRingHom _ _ a)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Bounded.weak {t : Ordnode α} {o₁ o₂} (h : Bounded t o₁ o₂) : Bounded t ⊥ ⊤