ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Int/CardIntervalMod.lean
lemma Ioc_filter_modEq_eq (v : ℤ) : (Ioc a b).filter (· ≡ v [ZMOD r]) =
    ((Ioc (a - v) (b - v)).filter (r ∣ ·)).map ⟨(· + v), add_left_injective v⟩
-- Mathlib/Data/TwoPointing.lean
@[simp]
theorem nonempty_two_pointing_iff : Nonempty (TwoPointing α) ↔ Nontrivial α
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma map₁_fst {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (p : YonedaCollection F X) : (YonedaCollection.map₁ η p).fst = p.fst
-- Mathlib/LinearAlgebra/Dual.lean
@[mono]
theorem dualCoannihilator_anti {U V : Submodule R (Module.Dual R M)} (hUV : U ≤ V) :
    V.dualCoannihilator ≤ U.dualCoannihilator
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_iUnion (s : ι → Set α) (t : α → Set β) :
    ⋂ x ∈ ⋃ i, s i, t x = ⋂ (i) (x ∈ s i), t x
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_on_submodule_iff_disjoint_ker_lsmul_submodule :
    IsSMulRegular N r ↔ Disjoint (LinearMap.ker (LinearMap.lsmul R M r)) N
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[ext high]
theorem ext_to_ring (f g : A →ₐc[R] R) : f = g
-- Mathlib/Algebra/Lie/Weights/Basic.lean
theorem coe_weightSpace_of_top (χ : L → R) :
    (weightSpace M (χ ∘ (⊤ : LieSubalgebra R L).incl) : Submodule R M) = weightSpace M χ
-- Mathlib/Topology/Sheaves/Stalks.lean
@[reassoc (attr := simp)]
lemma pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk
    (f : X ⟶ Y) (F : Y.Presheaf C) (V : (Opens Y)ᵒᵖ) (x : (Opens.map f).obj V.unop) :
    ((pushforwardPullbackAdjunction C f).unit.app F).app V ≫ germToPullbackStalk C f F _ x =
      F.germ ⟨f x, x.2⟩
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
/-- An alternative way to provide the argument to `CliffordAlgebra.lift` when `2` is invertible.

To show a function squares to the quadratic form, it suffices to show that
`f x * f y + f y * f x = algebraMap _ _ (polar Q x y)` -/
theorem forall_mul_self_eq_iff {A : Type*} [Ring A] [Algebra R A] (h2 : IsUnit (2 : A))
    (f : M →ₗ[R] A) :
    (∀ x, f x * f x = algebraMap _ _ (Q x)) ↔
      (LinearMap.mul R A).compl₂ f ∘ₗ f + (LinearMap.mul R A).flip.compl₂ f ∘ₗ f =
        Q.polarBilin.compr₂ (Algebra.linearMap R A)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Hereditarily.mem (h : x.Hereditarily p) (hy : y ∈ x) : y.Hereditarily p
-- Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean
/-- If `C` has finite coproducts, a functor `Discrete α ⥤ C` lifts to a functor
    `Finset (Discrete α) ⥤ C` by taking coproducts. -/
@[simps!]
def liftToFinset [HasFiniteCoproducts C] (F : Discrete α ⥤ C) : Finset (Discrete α) ⥤ C
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
/-- A bundled version of `AddMonoidAlgebra.divOf`. -/
@[simps]
noncomputable def divOfHom : Multiplicative G →* AddMonoid.End k[G]
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_zsmul_add' (a b : α) (m : ℤ) :
    toIcoMod hp (m • p + a) b = m • p + toIcoMod hp a b
-- Mathlib/Data/Countable/Defs.lean
@[simp]
lemma not_countable [Uncountable α] : ¬Countable α
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem opRingEquiv_symm_single [AddCommMonoid G] (r : kᵐᵒᵖ) (x : Gᵐᵒᵖ) :
    AddMonoidAlgebra.opRingEquiv.symm (single x r) = op (single x r.unop)
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem sign_subtypePerm (f : Perm α) {p : α → Prop} [DecidablePred p] (h₁ : ∀ x, p x ↔ p (f x))
    (h₂ : ∀ x, f x ≠ x → p x) : sign (subtypePerm f h₁) = sign f
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.neg_eq [NormOneClass 𝕜] (h : Balanced 𝕜 s) : -s = s
-- Mathlib/Data/Nat/PSub.lean
theorem sub_eq_psub (m : ℕ) : ∀ n, m - n = (psub m n).getD 0
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem SmoothOn.comp_smooth {t : Set M'} {g : M' → M''} (hg : SmoothOn I' I'' g t)
    (hf : Smooth I I' f) (ht : ∀ x, f x ∈ t) : Smooth I I'' (g ∘ f)
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
/-- The product of an element of `S` and an element of the additive closure of a multiplicative
submonoid `S` is contained in the additive closure of `S`. -/
theorem mul_left_mem_add_closure (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure (S : Set R)) :
    a * b ∈ AddSubmonoid.closure (S : Set R)
-- Mathlib/Data/Matroid/Closure.lean
@[simp] lemma closure_union_closure_empty_eq (M : Matroid α) (X : Set α) :
    M.closure X ∪ M.closure ∅ = M.closure X
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_left_comm (s t u : Set E) :
    convexJoin 𝕜 s (convexJoin 𝕜 t u) = convexJoin 𝕜 t (convexJoin 𝕜 s u)
-- Mathlib/Topology/Order/Monotone.lean
/-- If a monotone function is continuous at the infimum of a nonempty bounded below set `s`,
then it sends this infimum to the infimum of the image of `s`. -/
theorem Monotone.map_csInf_of_continuousAt {f : α → β} {s : Set α} (Cf : ContinuousAt f (sInf s))
    (Mf : Monotone f) (ne : s.Nonempty) (H : BddBelow s) : f (sInf s) = sInf (f '' s)
-- Mathlib/Topology/Connected/Clopen.lean
/-- If every map to `Bool` (a discrete two-element space), that is
continuous on a set `s`, is constant on s, then s is preconnected -/
theorem isPreconnected_of_forall_constant {s : Set α}
    (hs : ∀ f : α → Bool, ContinuousOn f s → ∀ x ∈ s, ∀ y ∈ s, f x = f y) : IsPreconnected s
-- Mathlib/Data/Set/Prod.lean
/-- A product set is included in a product set if and only factors are included, or a factor of the
first set is empty. -/
theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem exists_pos_tsum_mul_lt_of_countable {ε : ℝ≥0∞} (hε : ε ≠ 0) {ι} [Countable ι] (w : ι → ℝ≥0∞)
    (hw : ∀ i, w i ≠ ∞) : ∃ δ : ι → ℝ≥0, (∀ i, 0 < δ i) ∧ (∑' i, (w i * δ i : ℝ≥0∞)) < ε
-- Mathlib/FieldTheory/Adjoin.lean
theorem fg_of_noetherian (S : IntermediateField F E) [IsNoetherian F E] : S.FG
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ upperBounds s)
    (Hat : a ∈ t) : f a ∈ upperBounds (f '' s)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- If `s` is a compact set and `μ` is finite at `𝓝 x` for every `x ∈ s`, then `s` admits an open
superset of finite measure. -/
theorem exists_open_superset_measure_lt_top' (h : IsCompact s)
    (hμ : ∀ x ∈ s, μ.FiniteAtFilter (𝓝 x)) : ∃ U ⊇ s, IsOpen U ∧ μ U < ∞
-- Mathlib/Probability/Independence/Basic.lean
@[symm]
theorem Indep.symm (h : Indep m₁ m₂ μ) : Indep m₂ m₁ μ
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma integral_llr_tilted_right [IsProbabilityMeasure μ] [SigmaFinite ν]
    (hμν : μ ≪ ν) (hfμ : Integrable f μ) (hfν : Integrable (fun x ↦ exp (f x)) ν)
    (h_int : Integrable (llr μ ν) μ) :
    ∫ x, llr μ (ν.tilted f) x ∂μ = ∫ x, llr μ ν x ∂μ - ∫ x, f x ∂μ + log (∫ x, exp (f x) ∂ν)
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem length_modify [BEq α] {a : α} : (modify a f l).length = l.length
-- Mathlib/Algebra/Star/CentroidHom.lean
theorem star_centerToCentroidCenter (z : NonUnitalStarSubsemiring.center α) :
    star (centerToCentroidCenter z) =
      (centerToCentroidCenter (star z : NonUnitalStarSubsemiring.center α))
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- Subtracting two `affineCombination`s. -/
theorem affineCombination_vsub (w₁ w₂ : ι → k) (p : ι → P) :
    s.affineCombination k p w₁ -ᵥ s.affineCombination k p w₂ = s.weightedVSub p (w₁ - w₂)
-- Mathlib/Data/List/Perm.lean
theorem permutations_perm_permutations' (ts : List α) : ts.permutations ~ ts.permutations'
-- Mathlib/Topology/Basic.lean
theorem isOpen_iUnion {f : ι → Set X} (h : ∀ i, IsOpen (f i)) : IsOpen (⋃ i, f i)
-- Mathlib/Data/Nat/Defs.lean
lemma leRecOn_succ' {C : ℕ → Sort*} {n} {h : n ≤ n + 1} {next : ∀ {k}, C k → C (k + 1)} (x : C n) :
    (leRecOn h next x : C (n + 1)) = next x
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem filter_smul {_ : Monoid R} [AddMonoid M] [DistribMulAction R M] {b : R} {v : α →₀ M} :
    (b • v).filter p = b • v.filter p
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem lineMap_linear (p₀ p₁ : P1) :
    (lineMap p₀ p₁ : k →ᵃ[k] P1).linear = LinearMap.id.smulRight (p₁ -ᵥ p₀)
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem aedisjoint_compl_right : AEDisjoint μ s sᶜ
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem concat_eq_append {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    p.concat h = p.append (cons h nil)
-- Mathlib/Data/Sym/Sym2.lean
theorem congr_left {a b c : α} : s(b, a) = s(c, a) ↔ b = c
-- Mathlib/Logic/Equiv/Set.lean
@[simp high]
protected theorem subset_symm_image {α β} (e : α ≃ β) (s : Set α) (t : Set β) :
    s ⊆ e.symm '' t ↔ e '' s ⊆ t
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem normalize?_eq_some (w : normalize? (s, x) = some (s', x')) :
    normalizeConstraint s x = s' ∧ normalizeCoeffs s x = x'
-- Mathlib/Probability/Kernel/WithDensity.lean
/-- If a kernel `κ` is finite and a function `f : α → β → ℝ≥0∞` is bounded, then `withDensity κ f`
is finite. -/
theorem isFiniteKernel_withDensity_of_bounded (κ : Kernel α β) [IsFiniteKernel κ] {B : ℝ≥0∞}
    (hB_top : B ≠ ∞) (hf_B : ∀ a b, f a b ≤ B) : IsFiniteKernel (withDensity κ f)
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive add]
theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (Kf + Kg) fun x => f x * g x
-- Mathlib/Analysis/Calculus/Deriv/Prod.lean
theorem deriv_pi (h : ∀ i, DifferentiableAt 𝕜 (fun x => φ x i) x) :
    deriv φ x = fun i => deriv (fun x => φ x i) x
-- Mathlib/Algebra/Regular/Basic.lean
/-- In a non-trivial ring, the element `0` is not left-regular -- with typeclasses. -/
theorem not_isLeftRegular_zero [nR : Nontrivial R] : ¬IsLeftRegular (0 : R)
-- Mathlib/Algebra/MvPolynomial/Rename.lean
@[simp]
theorem constantCoeff_rename {τ : Type*} (f : σ → τ) (φ : MvPolynomial σ R) :
    constantCoeff (rename f φ) = constantCoeff φ
-- Mathlib/CategoryTheory/Subobject/Limits.lean
theorem equalizerSubobject_factors_iff {W : C} (h : W ⟶ X) :
    (equalizerSubobject f g).Factors h ↔ h ≫ f = h ≫ g
-- Mathlib/Dynamics/BirkhoffSum/Basic.lean
theorem birkhoffSum_one (f : α → α) (g : α → M) (x : α) : birkhoffSum f g 1 x = g x
-- Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean
/-- Shows that for any `q : ℚ` with `0 < q < 1`, the numerator of the fractional part of
`IntFractPair.of q⁻¹` is smaller than the numerator of `q`.
-/
theorem of_inv_fr_num_lt_num_of_pos (q_pos : 0 < q) : (IntFractPair.of q⁻¹).fr.num < q.num
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- In a `p`-th cyclotomic extension of `ℚ`, we have that `ζ - 1` divides `p` in `𝓞 K`. -/
lemma toInteger_sub_one_dvd_prime' [hcycl : IsCyclotomicExtension {p} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑p) : ((hζ.toInteger - 1)) ∣ p
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[reassoc (attr := simp)]
lemma hom_inv_id_hom (e : F ≅ G) (n : A) : e.hom.hom n ≫ e.inv.hom n = 𝟙 _
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A map is proper if and only if it is closed and its fibers are compact. -/
theorem isProperMap_iff_isClosedMap_and_compact_fibers :
    IsProperMap f ↔ Continuous f ∧ IsClosedMap f ∧ ∀ y, IsCompact (f ⁻¹' {y})
-- Mathlib/Algebra/Algebra/Bilinear.lean
@[simp]
theorem mulRight_eq_zero_iff (a : A) : mulRight R a = 0 ↔ a = 0
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem image_fst_graph [DecidableEq α] (f : α →₀ M) : f.graph.image Prod.fst = f.support
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- An isometric automorphism of an oriented real inner product space of dimension 2 (usual notation
`J`). This automorphism squares to -1. We will define rotations in such a way that this
automorphism is equal to rotation by 90 degrees. -/
irreducible_def rightAngleRotation : E ≃ₗᵢ[ℝ] E
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem darts_nil {u : V} : (nil : G.Walk u u).darts = []
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
    x * y >>= f = (x >>= f) * (y >>= f)
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem div_ball_one : s / ball 1 δ = thickening δ s
-- Mathlib/ModelTheory/FinitelyGenerated.lean
theorem CG.sup {N₁ N₂ : L.Substructure M} (hN₁ : N₁.CG) (hN₂ : N₂.CG) : (N₁ ⊔ N₂).CG
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[to_additive]
theorem pow_smul_mem_closure_smul {N : Type*} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
    (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s)
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
/-- Construct `I`-adic cauchy sequence from sequence satisfying the successive cauchy condition. -/
@[simps]
def AdicCauchySequence.mk (f : ℕ → M)
    (h : ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)]) : AdicCauchySequence I M
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem IsReduced.nodup_leftInvSeq {ω : List B} (rω : cs.IsReduced ω) : List.Nodup (lis ω)
-- Mathlib/RingTheory/Localization/NumDen.lean
lemma associated_den_num_inv (x : K) (hx : x ≠ 0) : Associated (den A x : A) (num A x⁻¹)
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
theorem hasSum_iteratedFDeriv [CharZero 𝕜] {y : E} (hy : y ∈ EMetric.ball 0 r) :
    HasSum (fun n ↦ (n ! : 𝕜)⁻¹ • iteratedFDeriv 𝕜 n f x fun _ ↦ y) (f (x + y))
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is separable, then the perfect closure of `F` in `E` is equal to `F`. Note that
  the converse is not necessarily true (see https://math.stackexchange.com/a/3009197)
  even when `E / F` is algebraic. -/
theorem perfectClosure.eq_bot_of_isSeparable [Algebra.IsSeparable F E] : perfectClosure F E = ⊥
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem constantCoeff_coe : PowerSeries.constantCoeff R φ = φ.coeff 0
-- Mathlib/Algebra/AlgebraicCard.lean
theorem cardinal_mk_lift_le_mul :
    Cardinal.lift.{u} #{ x : A // IsAlgebraic R x } ≤ Cardinal.lift.{v} #R[X] * ℵ₀
-- Mathlib/Analysis/Convex/Segment.lean
theorem mem_segment_sub_add [Invertible (2 : 𝕜)] (x y : E) : x ∈ [x - y -[𝕜] x + y]
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem apply_apply' (v : E) (f : E →SL[σ₁₂] F) : apply' F σ₁₂ v f = f v
-- Mathlib/Topology/Order/Basic.lean
/-- The set of points which are isolated on the right is countable when the space is
second-countable. -/
theorem countable_setOf_covBy_right [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, x ⋖ y }
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem Minpoly.toAdjoin.surjective : Function.Surjective (Minpoly.toAdjoin R x)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem LipschitzWith.integrable_comp_iff_of_antilipschitz {K K'} {f : α → β} {g : β → γ}
    (hg : LipschitzWith K g) (hg' : AntilipschitzWith K' g) (g0 : g 0 = 0) :
    Integrable (g ∘ f) μ ↔ Integrable f μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[local simp] protected theorem neg_mul (a b : Int) : -a * b = -(a * b)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.congr' {f : α → β} {g : α → γ} (hf : HasFiniteIntegral f μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) : HasFiniteIntegral g μ
-- Mathlib/NumberTheory/FLT/Basic.lean
lemma fermatLastTheoremWith_nat_int_rat_tfae (n : ℕ) :
    TFAE [FermatLastTheoremWith ℕ n, FermatLastTheoremWith ℤ n, FermatLastTheoremWith ℚ n]
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp]
theorem matPolyEquiv_symm_apply_coeff (p : (Matrix n n R)[X]) (i j : n) (k : ℕ) :
    coeff (matPolyEquiv.symm p i j) k = coeff p k i j
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp, norm_cast]
theorem coe_nsmul (n : ℕ) (x : R) : (↑(n • x) : c.Quotient) = n • (x : c.Quotient)
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
/-- A module `M` is precomplete with respect to an ideal `I` if every Cauchy sequence converges. -/
class IsPrecomplete : Prop where
  prec' : ∀ f : ℕ → M, (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
    ∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)]
-- Mathlib/LinearAlgebra/Pi.lean
theorem iSup_map_single [DecidableEq ι] [Finite ι] :
    ⨆ i, map (LinearMap.single i : φ i →ₗ[R] (i : ι) → φ i) (p i) = pi Set.univ p
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem map_sup : (I ⊔ I₂).map f = I.map f ⊔ I₂.map f
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem nndist_inv_inv₀ {z w : α} (hz : z ≠ 0) (hw : w ≠ 0) :
    nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊)
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[aesop safe apply]
theorem conjugate' {x : R} (hx : IsSelfAdjoint x) (z : R) : IsSelfAdjoint (star z * x * z)
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem locallyConvexSpace_induced {t : TopologicalSpace F} [LocallyConvexSpace 𝕜 F]
    (f : E →ₗ[𝕜] F) : @LocallyConvexSpace 𝕜 E _ _ _ (t.induced f)
-- Mathlib/Algebra/Associated/Basic.lean
theorem Irreducible.ne_zero [MonoidWithZero α] : ∀ {p : α}, Irreducible p → p ≠ 0
-- Mathlib/Data/Nat/Factorial/Basic.lean
lemma factorial_le_pow : ∀ n, n ! ≤ n ^ n
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem contMDiffOn_iff_contDiffOn {f : E → E'} {s : Set E} :
    ContMDiffOn 𝓘(𝕜, E) 𝓘(𝕜, E') n f s ↔ ContDiffOn 𝕜 n f s
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem hyperfilter_le_cofinite : ↑(hyperfilter α) ≤ @cofinite α
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem id_whiskerLeft_symm {X X' : C} (f : X ⟶ X') :
    f = (λ_ X).inv ≫ 𝟙_ C ◁ f ≫ (λ_ X').hom
-- Mathlib/RingTheory/SimpleModule.lean
theorem RingHom.isSemisimpleRing_of_surjective (f : R →+* S) (hf : Function.Surjective f)
    [IsSemisimpleRing R] : IsSemisimpleRing S
-- Mathlib/Data/Holor.lean
theorem cprankMax_sum [Ring α] {β} {n : ℕ} (s : Finset β) (f : β → Holor α ds) :
    (∀ x ∈ s, CPRankMax n (f x)) → CPRankMax (s.card * n) (∑ x ∈ s, f x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
@[simp]
theorem deriv_arctan : deriv arctan = fun (x : ℝ) => 1 / (1 + x ^ 2)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem borel_eq_generateFrom_isClosed [TopologicalSpace α] :
    borel α = .generateFrom { s | IsClosed s }
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma isCoprime_helper {r s t w : 𝓞 K} (hr : ¬ λ ∣ r) (hs : ¬ λ ∣ s)
    (Hp : ∀ {p}, Prime p → p ∣ t → p ∣ w → Associated p λ) (H₁ : ∀ {q}, q ∣ r → q ∣ t)
    (H₂ : ∀ {q}, q ∣ s → q ∣ w) : IsCoprime r s
-- Mathlib/MeasureTheory/PiSystem.lean
theorem IsPiSystem.insert_empty {α} {S : Set (Set α)} (h_pi : IsPiSystem S) :
    IsPiSystem (insert ∅ S)
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tendsto_nat_floor_mul_div_atTop {a : R} (ha : 0 ≤ a) :
    Tendsto (fun x ↦ (⌊a * x⌋₊ : R) / x) atTop (𝓝 a)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem sign_eq_zero_iff_zero (a : Int) : sign a = 0 ↔ a = 0
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma cons' {r : R} {rs : List R} (h1 : IsSMulRegular M r)
    (h2 : IsRegular (QuotSMulTop r M) (rs.map (Ideal.Quotient.mk (Ideal.span {r})))) :
    IsRegular M (r :: rs)
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_fst' : ⇑(fst R A B) = Prod.fst
-- Mathlib/RingTheory/PrimeSpectrum.lean
@[simp]
theorem mem_zeroLocus (x : PrimeSpectrum R) (s : Set R) : x ∈ zeroLocus s ↔ s ⊆ x.asIdeal
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma unop_tensorHom {X₁ Y₁ X₂ Y₂ : Cᵒᵖ} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).unop = f.unop ⊗ g.unop
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem darts_bypass_subset {u v : V} (p : G.Walk u v) : p.bypass.darts ⊆ p.darts
-- Mathlib/Order/Filter/Bases.lean
@[instance]
theorem isCountablyGenerated_top : IsCountablyGenerated (⊤ : Filter α)
-- Mathlib/LinearAlgebra/TensorProduct/Vanishing.lean
/-- If the map $M' \otimes N \to M \otimes N$ is injective for every finitely generated submodule
$M' \subseteq M$, then it is in fact injective for every submodule $M' \subseteq M$. -/
theorem rTensor_injective_of_forall_FG_rTensor_injective
    (hMN : ∀ (M' : Submodule R M) (_ : M'.FG), Injective (rTensor N M'.subtype))
    (M' : Submodule R M) : Injective (rTensor N M'.subtype)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
/-- Two linear maps (M ⊗ N) ⊗ (P ⊗ Q) → S which agree on all elements of the
form (m ⊗ₜ n) ⊗ₜ (p ⊗ₜ q) are equal. -/
theorem ext_fourfold' {φ ψ : (M ⊗[R] N) ⊗[R] P ⊗[R] Q →ₗ[R] S}
    (H : ∀ w x y z, φ (w ⊗ₜ x ⊗ₜ (y ⊗ₜ z)) = ψ (w ⊗ₜ x ⊗ₜ (y ⊗ₜ z))) : φ = ψ
-- Mathlib/CategoryTheory/Limits/EpiMono.lean
lemma mono_iff_isIso_fst (hc : IsLimit c) : Mono f ↔ IsIso c.fst
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem num_algebraMap (p : K[X]) : num (algebraMap _ _ p) = p
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Existence of minimizers
Let `u` be a point in a real inner product space, and let `K` be a nonempty complete convex subset.
Then there exists a (unique) `v` in `K` that minimizes the distance `‖u - v‖` to `u`.
 -/
theorem exists_norm_eq_iInf_of_complete_convex {K : Set F} (ne : K.Nonempty) (h₁ : IsComplete K)
    (h₂ : Convex ℝ K) : ∀ u : F, ∃ v ∈ K, ‖u - v‖ = ⨅ w : K, ‖u - w‖
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
theorem rep_nonzero (v : ℙ K V) : v.rep ≠ 0
-- Mathlib/Topology/List.lean
theorem continuous_eraseIdx {n : ℕ} : Continuous fun l : List α => eraseIdx l n
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
nonrec theorem integral_ofReal {a b : ℝ} {μ : Measure ℝ} {f : ℝ → ℝ} :
    (∫ x in a..b, (f x : ℂ) ∂μ) = ↑(∫ x in a..b, f x ∂μ)
-- Mathlib/Data/Nat/Pairing.lean
theorem unpair_add_le (n : ℕ) : (unpair n).1 + (unpair n).2 ≤ n
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
lemma HasRightDerivedFunctor.hasLeftKanExtension [HasRightDerivedFunctor F W] :
    HasLeftKanExtension L F
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_imp : (φ.imp ψ).Realize v ↔ φ.Realize v → ψ.Realize v
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem trailingCoeff_nonzero_iff_nonzero : trailingCoeff p ≠ 0 ↔ p ≠ 0
-- Mathlib/SetTheory/Ordinal/Basic.lean
protected theorem not_lt_zero (o : Ordinal) : ¬o < 0
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem mono_comp {X Y Z : C} (f : X ⟶ Y) [Mono f] (g : Y ⟶ Z) [Mono g] : Mono (f ≫ g)
-- Mathlib/Data/Finset/Prod.lean
theorem filter_product (p : α → Prop) (q : β → Prop) [DecidablePred p] [DecidablePred q] :
    ((s ×ˢ t).filter fun x : α × β => p x.1 ∧ q x.2) = s.filter p ×ˢ t.filter q
-- Mathlib/Data/Set/Function.lean
lemma BijOn.prodMap (h₁ : BijOn f₁ s₁ t₁) (h₂ : BijOn f₂ s₂ t₂) :
    BijOn (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)
-- Mathlib/RingTheory/Coprime/Ideal.lean
/-- A finite family of ideals is pairwise coprime (that is, any two of them generate the whole ring)
iff when taking all the possible intersections of all but one of these ideals, the resulting family
of ideals still generate the whole ring.

For example with three ideals : `I ⊔ J = I ⊔ K = J ⊔ K = ⊤ ↔ (I ⊓ J) ⊔ (I ⊓ K) ⊔ (J ⊓ K) = ⊤`.

When ideals are all of the form `I i = R ∙ s i`, this is equivalent to the
`exists_sum_eq_one_iff_pairwise_coprime` lemma. -/
theorem iSup_iInf_eq_top_iff_pairwise {t : Finset ι} (h : t.Nonempty) (I : ι → Ideal R) :
    (⨆ i ∈ t, ⨅ (j) (_ : j ∈ t) (_ : j ≠ i), I j) = ⊤ ↔
      (t : Set ι).Pairwise fun i j => I i ⊔ I j = ⊤
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem interior_Ici' {a : α} (ha : (Iio a).Nonempty) : interior (Ici a) = Ioi a
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem normed_sub (x : E) : f.normed μ (c - x) = f.normed μ (c + x)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_self_right : (a ∧ b) ∧ b ↔ a ∧ b
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
/-- **Disintegration** of finite kernels.
The composition-product of `fst κ` and `condKernel κ` is equal to `κ`. -/
@[deprecated Kernel.disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernel : fst κ ⊗ₖ condKernel κ = κ
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem OrthogonalFamily.norm_sum (l : ∀ i, G i) (s : Finset ι) :
    ‖∑ i ∈ s, V i (l i)‖ ^ 2 = ∑ i ∈ s, ‖l i‖ ^ 2
-- Mathlib/Topology/Bornology/Hom.lean
@[simp]
theorem cancel_right {g₁ g₂ : LocallyBoundedMap β γ} {f : LocallyBoundedMap α β}
    (hf : Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.trans {l₁ l₂ l₃ : List α} (s₁₂ : l₁ <+~ l₂) (s₂₃ : l₂ <+~ l₃) : l₁ <+~ l₃