ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_eq_of_degree_eq_some {p : R[X]} {n : ℕ} (h : degree p = n) : natDegree p = n
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem norm_pow_mul_le_seminorm (f : 𝓢(E, F)) (k : ℕ) (x₀ : E) :
    ‖x₀‖ ^ k * ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 k 0) f
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The inner product between a vector and a `π / 2` rotation of that vector is zero. -/
@[simp]
theorem inner_rotation_pi_div_two_right (x : V) : ⟪x, o.rotation (π / 2 : ℝ) x⟫ = 0
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem preimage_coe_affineSpan_singleton (x : P) :
    ((↑) : affineSpan k ({x} : Set P) → P) ⁻¹' {x} = univ
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem eq_C_of_natDegree_le_zero (h : natDegree p ≤ 0) : p = C (coeff p 0)
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem ofVector_cons (a : α) (v : Vector α n) : ↑(Vector.cons a v) = a ::ₛ (↑v : Sym α n)
-- Mathlib/ModelTheory/DirectLimit.lean
theorem iSup_range_of_eq_top : ⨆ i, (of L ι G f i).toHom.range = ⊤
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurableSet_prod_of_nonempty {s : Set α} {t : Set β} (h : (s ×ˢ t).Nonempty) :
    MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t
-- Mathlib/Topology/Basic.lean
theorem mem_closure_iff_nhds_basis {p : ι → Prop} {s : ι → Set X} (h : (𝓝 x).HasBasis p s) :
    x ∈ closure t ↔ ∀ i, p i → ∃ y ∈ t, y ∈ s i
-- Mathlib/RingTheory/Localization/Basic.lean
theorem ne_zero_of_mk'_ne_zero {x : R} {y : M} (hxy : IsLocalization.mk' S x y ≠ 0) : x ≠ 0
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_neg (f : CentroidHom α) : ⇑(-f) = -f
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
/-- The chain rule.

Note that the function `h₂` is a function on an algebra. If you are looking for the chain rule
with `h₂` taking values in a vector space, use `HasDerivAt.scomp_of_eq`. -/
theorem HasDerivAt.comp_of_eq
    (hh₂ : HasDerivAt h₂ h₂' y) (hh : HasDerivAt h h' x) (hy : y = h x) :
    HasDerivAt (h₂ ∘ h) (h₂' * h') x
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncate_comp_wittVector_truncate {m : ℕ} (hm : n ≤ m) :
    (@truncate p _ n R _ m hm).comp (WittVector.truncate m) = WittVector.truncate n
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[simp, norm_cast]
theorem aemeasurable_coe_nnreal_real_iff {f : α → ℝ≥0} {μ : Measure α} :
    AEMeasurable (fun x => f x : α → ℝ) μ ↔ AEMeasurable f μ
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem pred_coe_bot : pred ↑(⊥ : α) = (⊥ : WithBot α)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem eq_C_of_degree_le_zero (h : degree p ≤ 0) : p = C (coeff p 0)
-- Mathlib/Order/SuccPred/Basic.lean
theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
@[simp]
theorem AdditiveFunctor.forget_obj (F : C ⥤+ D) : (AdditiveFunctor.forget C D).obj F = F.1
-- Mathlib/LinearAlgebra/Matrix/Orthogonal.lean
/-- `Aᵀ` has orthogonal columns iff `A` has orthogonal rows. -/
@[simp]
theorem transpose_hasOrthogonalCols_iff_hasOrthogonalRows [Fintype n] :
    Aᵀ.HasOrthogonalCols ↔ A.HasOrthogonalRows
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
lemma EdgeDisjointTriangles.map (f : α ↪ β) (hG : G.EdgeDisjointTriangles) :
    (G.map f).EdgeDisjointTriangles
-- Mathlib/Algebra/Category/ModuleCat/Biproducts.lean
/-- We verify that the biproduct in `ModuleCat R` is isomorphic to
the cartesian product of the underlying types:
-/
@[simps! hom_apply]
noncomputable def biprodIsoProd (M N : ModuleCat.{v} R) :
    (M ⊞ N : ModuleCat.{v} R) ≅ ModuleCat.of R (M × N)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem support_sum_monomial_coeff (p : MvPolynomial σ R) :
    (∑ v ∈ p.support, monomial v (coeff v p)) = p
-- Mathlib/ModelTheory/Satisfiability.lean
theorem mem_or_not_mem (φ : L.Sentence) : φ ∈ L.completeTheory M ∨ φ.not ∈ L.completeTheory M
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.lt_right_of_left_lt' (hf : ConcaveOn 𝕜 s f) {x y : E} {a b : 𝕜} (hx : x ∈ s)
    (hy : y ∈ s) (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) (hfx : f (a • x + b • y) < f x) :
    f y < f (a • x + b • y)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem count_le_count_of_le {a b p : Associates α} (hb : b ≠ 0) (hp : Irreducible p) (h : a ≤ b) :
    p.count a.factors ≤ p.count b.factors
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem liftAddHom_symm_apply_apply [AddCommMonoid M] [AddCommMonoid N] (F : (α →₀ M) →+ N) (x : α)
    (y : M) : (liftAddHom (α := α) (M := M) (N := N)).symm F x y = F (single x y)
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp]
theorem add_halves (a : R) : a / 2 + a / 2 = a
-- Mathlib/Order/SupIndep.lean
theorem CompleteLattice.Independent.supIndep' [CompleteLattice α] {f : ι → α} (s : Finset ι)
    (h : CompleteLattice.Independent f) : s.SupIndep f
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
protected theorem reverseAux_eq_reverse_append {u v w : V} (p : G.Walk u v) (q : G.Walk u w) :
    p.reverseAux q = p.reverse.append q
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem sym_add [Add α] (a b : α) : sym (a + b) = sym a + sym b
-- Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean
theorem isWeaklyEisensteinAt : IsWeaklyEisensteinAt f 𝓟
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
theorem surjective_of_epi_of_preservesPushout {X Y : C} (f : X ⟶ Y) [Epi f]
    [PreservesColimitsOfShape WalkingSpan (forget C)] : Function.Surjective f
-- Mathlib/Algebra/Group/Nat.lean
lemma not_even_iff : ¬ Even n ↔ n % 2 = 1
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
theorem cast_add_one_pos (n : ℕ) : 0 < (n : α) + 1
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem Measurable.sumMap {_ : MeasurableSpace γ} {_ : MeasurableSpace δ} {f : α → β} {g : γ → δ}
    (hf : Measurable f) (hg : Measurable g) : Measurable (Sum.map f g)
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- If `C` has colimits then any reflective subcategory has colimits. -/
theorem hasColimits_of_reflective (R : D ⥤ C) [Reflective R] [HasColimitsOfSize.{v, u} C] :
    HasColimitsOfSize.{v, u} D
-- Mathlib/RingTheory/RingHom/FinitePresentation.lean
/--
If `S` is an `R`-algebra with a surjection from a finitely-presented `R`-algebra `A`, such that
localized at a spanning set `{ r }` of elements of `A`, `Sᵣ` is finitely-presented, then
`S` is finitely presented.
This is almost `finitePresentation_ofLocalizationSpanTarget`. The difference is,
that here the set `t` generates the unit ideal of `A`, while in the general version,
it only generates a quotient of `A`.
-/
lemma finitePresentation_ofLocalizationSpanTarget_aux
    {R S A : Type*} [CommRing R] [CommRing S] [CommRing A] [Algebra R S] [Algebra R A]
    [Algebra.FinitePresentation R A] (f : A →ₐ[R] S) (hf : Function.Surjective f)
    (t : Finset A) (ht : Ideal.span (t : Set A) = ⊤)
    (H : ∀ g : t, Algebra.FinitePresentation R (Localization.Away (f g))) :
    Algebra.FinitePresentation R S
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem map_comap_eq_self
    {f : A →ₐ[R] B} {S : Subalgebra R B} (h : S ≤ f.range) : (S.comap f).map f = S
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp, norm_cast]
theorem coe_pow (x : s) (n : ℕ) : ↑(x ^ n) = (x : R) ^ n
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem not_mem_support_iff : n ∉ p.support ↔ p.coeff n = 0
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_one : ⌊(1 : α)⌋₊ = 1
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem integrable_of_isFiniteMeasure [IsFiniteMeasure μ] (f : α →ₛ E) : Integrable f μ
-- Mathlib/Topology/Inseparable.lean
theorem mem_closed_iff (h : x ~ᵢ y) (hs : IsClosed s) : x ∈ s ↔ y ∈ s
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem cardinal_le_rank {ι : Type v} {v : ι → M}
    (hv : LinearIndependent R v) : #ι ≤ Module.rank R M
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_sup {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : a < sup.{_, v} f ↔ ∃ i, a < f i
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem mem_toNonUnitalSubring {S : NonUnitalSubalgebra R A} {x} :
    x ∈ S.toNonUnitalSubring ↔ x ∈ S
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mem_inv_smul_finset_iff : b ∈ a⁻¹ • s ↔ a • b ∈ s
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
/-- A single function that is `Memℒp f p μ` is tight with respect to `μ`. -/
theorem Memℒp.exists_eLpNorm_indicator_compl_lt {β : Type*} [NormedAddCommGroup β] (hp_top : p ≠ ∞)
    {f : α → β} (hf : Memℒp f p μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ s : Set α, MeasurableSet s ∧ μ s < ∞ ∧ eLpNorm (sᶜ.indicator f) p μ < ε
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
lemma naturality (i : op U' ⟶ op U) :
    Y.presheaf.map i ≫ f.app U = f.app U' ≫ X.presheaf.map ((Opens.map f.1.base).map i.unop).op
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bodd_neg (n : ℤ) : bodd (-n) = bodd n
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem getLeft_inl (h : (inl x : α ⊕ β).isLeft) : (inl x).getLeft h = x
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem not_isDiag_of_mem_edgeFinset : e ∈ G.edgeFinset → ¬e.IsDiag
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ico_inter_Ico_consecutive (a b c : α) : Ico a b ∩ Ico b c = ∅
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The first part of the third cosimplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} : X.δ (Fin.castSucc i) ≫ X.σ i = 𝟙 _
-- Mathlib/Algebra/DirectSum/Basic.lean
lemma toAddMonoid_injective : Injective (toAddMonoid : (∀ i, β i →+ γ) → (⨁ i, β i) →+ γ)
-- Mathlib/Algebra/Group/Subsemigroup/Membership.lean
@[to_additive]
theorem mem_iSup_of_directed {S : ι → Subsemigroup M} (hS : Directed (· ≤ ·) S) {x : M} :
    (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDerivWithin_succ_apply_left {n : ℕ} (m : Fin (n + 1) → E) :
    (iteratedFDerivWithin 𝕜 (n + 1) f s x : (Fin (n + 1) → E) → F) m =
      (fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 n f s) s x : E → E[×n]→L[𝕜] F) (m 0) (tail m)
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem mkUnits_eq {u : ℚ_[p]} (h : ‖u‖ = 1) : ((mkUnits h : ℤ_[p]) : ℚ_[p]) = u
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_nonneg {m : MeasurableSpace α} (T : Set α → G' →L[ℝ] G'')
    (hT_nonneg : ∀ s x, 0 ≤ x → 0 ≤ T s x) (f : α →ₛ G') (hf : 0 ≤ f) :
    0 ≤ setToSimpleFunc T f
-- Mathlib/RingTheory/JacobsonIdeal.lean
@[simp]
theorem jacobson_eq_top_iff : jacobson I = ⊤ ↔ I = ⊤
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- If `f` is integrable on a box `I` along `l`, then for any fixed subset `s` of `I` that can be
represented as a finite union of boxes, the integral sums of `f` over tagged prepartitions that
cover exactly `s` form a Cauchy “sequence” along `l`. -/
theorem cauchy_map_integralSum_toFilteriUnion (h : Integrable I l f vol) (π₀ : Prepartition I) :
    Cauchy ((l.toFilteriUnion I π₀).map (integralSum f vol))
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem val_two {n : Nat} : (2 : Fin (n + 3)).val = 2
-- Mathlib/RingTheory/Ideal/Norm.lean
theorem prime_of_irreducible_absNorm_span {a : S} (ha : a ≠ 0)
    (hI : Irreducible (Ideal.absNorm (Ideal.span ({a} : Set S)))) : Prime a
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem pow_sup_pow_eq_top {m n : ℕ} (h : I ⊔ J = ⊤) : I ^ m ⊔ J ^ n = ⊤
-- Mathlib/LinearAlgebra/Ray.lean
theorem exists_pos_right_iff_sameRay (hx : x ≠ 0) (hy : y ≠ 0) :
    (∃ r : R, 0 < r ∧ x = r • y) ↔ SameRay R x y
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem AlgebraicIndependent.image {ι} {s : Set ι} {f : ι → A}
    (hs : AlgebraicIndependent R fun x : s => f x) :
    AlgebraicIndependent R fun x : f '' s => (x : A)
-- Mathlib/Order/Filter/Basic.lean
theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f
-- Mathlib/Topology/Bornology/Constructions.lean
theorem boundedSpace_induced_iff {α β : Type*} [Bornology β] {f : α → β} :
    @BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f)
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bitwise_bit (f : Bool → Bool → Bool) (a m b n) :
    bitwise f (bit a m) (bit b n) = bit (f a b) (bitwise f m n)
-- Mathlib/Topology/FiberBundle/Trivialization.lean
protected theorem continuousOn : ContinuousOn e' e'.source
-- Mathlib/LinearAlgebra/Dual.lean
theorem toDual_injective : Injective b.toDual
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem ofBoolRing_toBoolRing (a : α) : ofBoolRing (toBoolRing a) = a
-- Mathlib/Order/Closure.lean
theorem mem_iff (s : Set β) (x : β) : x ∈ l s ↔ ∀ S : α, s ⊆ S → x ∈ S
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
/-- Given a dense set `t`, then the range of `deriv f` is contained in the closure of the submodule
spanned by the image of `t`. -/
theorem range_deriv_subset_closure_span_image
    (f : 𝕜 → F) {t : Set 𝕜} (h : Dense t) :
    range (deriv f) ⊆ closure (Submodule.span 𝕜 (f '' t))
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- Allows for more efficient code for `padicValNat` -/
@[csimp]
theorem padicValNat_eq_maxPowDiv : @padicValNat = @maxPowDiv
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp]
theorem unop_bot : (⊥ : Subalgebra R Aᵐᵒᵖ).unop = ⊥
-- Mathlib/Order/LiminfLimsup.lean
theorem sdiff_liminf (a : α) : a \ liminf u f = limsup (fun b => a \ u b) f
-- Mathlib/Logic/Relator.lean
lemma LeftTotal.rel_exists (h : LeftTotal R) :
    ((R ⇒ (· → ·)) ⇒ (· → ·)) (fun p => ∃i, p i) (fun q => ∃i, q i)
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
private lemma aux (h : ∀ t ∈ 𝒜, a ∉ t) (ht : 𝒜.Shatters t) : a ∉ t
-- Mathlib/Combinatorics/SimpleGraph/Hasse.lean
theorem pathGraph_two_eq_top : pathGraph 2 = ⊤
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem dOne_comp_dZero : dOne A ∘ₗ dZero A = 0
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem balancedCore_subset (s : Set E) : balancedCore 𝕜 s ⊆ s
-- Mathlib/NumberTheory/EulerProduct/Basic.lean
/-- The *Euler Product* for a multiplicative arithmetic function `f` with values in a
complete normed commutative ring `R`: if `‖f ·‖` is summable, then
`∏' p : Nat.Primes, ∑' e, f (p ^ e) = ∑' n, f n`.
This version is stated in terms of `HasProd`. -/
nonrec theorem IsMultiplicative.eulerProduct_hasProd {f : ArithmeticFunction R}
    (hf : f.IsMultiplicative) (hsum : Summable (‖f ·‖)) :
    HasProd (fun p : Primes ↦ ∑' e, f (p ^ e)) (∑' n, f n)
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem mem_vsub_const_affineSegment {x y z : P} (p : P) :
    z -ᵥ p ∈ affineSegment R (x -ᵥ p) (y -ᵥ p) ↔ z ∈ affineSegment R x y
-- Mathlib/Probability/Process/Stopping.lean
/-- The stopped process of an adapted process with continuous paths is adapted. -/
theorem Adapted.stoppedProcess [MetrizableSpace ι] (hu : Adapted f u)
    (hu_cont : ∀ ω, Continuous fun i => u i ω) (hτ : IsStoppingTime f τ) :
    Adapted f (stoppedProcess u τ)
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
theorem tot : affineSpan k (range b) = ⊤
-- Mathlib/Analysis/Convex/Topology.lean
theorem Convex.combo_self_interior_mem_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E} (hx : x ∈ s)
    (hy : y ∈ interior s) {a b : 𝕜} (ha : 0 ≤ a) (hb : 0 < b) (hab : a + b = 1) :
    a • x + b • y ∈ interior s
-- Mathlib/CategoryTheory/Sites/Sheafification.lean
@[simp]
theorem sheafifyMap_id (P : Cᵒᵖ ⥤ D) : sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem padicValNat_prime_prime_pow {q : ℕ} [hp : Fact p.Prime] [hq : Fact q.Prime]
    (n : ℕ) (neq : p ≠ q) : padicValNat p (q ^ n) = 0
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
theorem Mon_tensor_mul_one (M N : Mon_ C) :
    (M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
      (ρ_ (M.X ⊗ N.X)).hom
-- Mathlib/Data/Finset/Basic.lean
theorem eq_singleton_or_nontrivial (ha : a ∈ s) : s = {a} ∨ s.Nontrivial
-- Mathlib/Probability/Density.lean
protected theorem congr {X Y : Ω → E} (hXY : X =ᵐ[ℙ] Y) : pdf X ℙ μ = pdf Y ℙ μ
-- Mathlib/CategoryTheory/DifferentialObject.lean
@[ext]
theorem ext {A B : DifferentialObject S C} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat) : f = g
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.of_append_right : Nodup (l₁ ++ l₂) → Nodup l₂
-- Mathlib/Order/Cover.lean
theorem CovBy.image (f : α ↪o β) (hab : a ⋖ b) (h : (range f).OrdConnected) : f a ⋖ f b
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma sq_eq_sq_iff_abs_eq_abs (a b : α) : a ^ 2 = b ^ 2 ↔ |a| = |b|
-- Mathlib/Data/Finset/Lattice.lean
theorem iInf_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → β) :
    ⨅ y ∈ s.biUnion t, f y = ⨅ (x ∈ s) (y ∈ t x), f y
-- Mathlib/Data/Complex/Exponential.lean
theorem ofReal_cosh_ofReal_re (x : ℝ) : ((cosh x).re : ℂ) = cosh x
-- Mathlib/NumberTheory/FLT/Three.lean
/-- Given `(S : Solution)`, we have that `λ ∣ (S.a + η ^ 2 * S.b)`. -/
lemma lambda_dvd_a_add_eta_sq_mul_b : λ ∣ (S.a + η ^ 2 * S.b)
-- Mathlib/Order/Fin/Basic.lean
lemma monotone_castPred_comp (hf : ∀ a, f a ≠ last n) (hf₂ : Monotone f) :
    Monotone (fun a => castPred (f a) (hf a))
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- The natural isomorphism `F(A ⨯ -) ≅ FA ⨯ F-`, provided each `prodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def prodComparisonNatIso [HasBinaryProducts C] [HasBinaryProducts D] (A : C)
    [∀ B, IsIso (prodComparison F A B)] :
    prod.functor.obj A ⋙ F ≅ F ⋙ prod.functor.obj (F.obj A)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
/-- Taking the involute of the product a list of $n$ vectors lifted via `ι` is equivalent to
premultiplying by ${-1}^n$. -/
theorem involute_prod_map_ι :
    ∀ l : List M, involute (l.map <| ι Q).prod = (-1 : R) ^ l.length • (l.map <| ι Q).prod
-- Mathlib/NumberTheory/Dioph.lean
theorem sumsq_nonneg (x : α → ℕ) : ∀ l, 0 ≤ sumsq l x
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem EuclideanSpace.edist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : edist x y = (∑ i, edist (x i) (y i) ^ 2) ^ (1 / 2 : ℝ)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The scalar multiplication of two `C^n` functions at a point is `C^n` at this point. -/
theorem ContDiffAt.smul {f : E → 𝕜} {g : E → F} (hf : ContDiffAt 𝕜 n f x)
    (hg : ContDiffAt 𝕜 n g x) : ContDiffAt 𝕜 n (fun x => f x • g x) x
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected theorem FiberBundle.extChartAt (x : TotalSpace F E) :
    extChartAt (IB.prod 𝓘(𝕜, F)) x =
      (trivializationAt F E x.proj).toPartialEquiv ≫
        (extChartAt IB x.proj).prod (PartialEquiv.refl F)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma baseChange_ψ₂ : (W.baseChange B).ψ₂ = (W.baseChange A).ψ₂.map (mapRingHom f)
-- Mathlib/Data/Matroid/Closure.lean
lemma isClosed_iff_flat {F : Iic M.E} : M.subtypeClosure.IsClosed F ↔ M.Flat F
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem partNum_none_iff_s_none : g.partNums.get? n = none ↔ g.s.get? n = none
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b)
-- Mathlib/Probability/Moments.lean
theorem aestronglyMeasurable_exp_mul_sum {X : ι → Ω → ℝ} {s : Finset ι}
    (h_int : ∀ i ∈ s, AEStronglyMeasurable (fun ω => exp (t * X i ω)) μ) :
    AEStronglyMeasurable (fun ω => exp (t * (∑ i ∈ s, X i) ω)) μ
-- Mathlib/ModelTheory/Substructures.lean
theorem map_comap_le {S : L.Substructure N} {f : M →[L] N} : (S.comap f).map f ≤ S
-- Mathlib/Order/GameAdd.lean
theorem _root_.Prod.GameAdd.to_sym2 {a₁ a₂ b₁ b₂ : α} (h : Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂)) :
    Sym2.GameAdd rα s(a₁, b₁) s(a₂, b₂)
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem interedges_biUnion (s : Finset ι) (t : Finset κ) (f : ι → Finset α) (g : κ → Finset β) :
    interedges r (s.biUnion f) (t.biUnion g) =
      (s ×ˢ t).biUnion fun ab ↦ interedges r (f ab.1) (g ab.2)
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem inv_hom_id (f : X ⟶ Y) [I : IsIso f] : inv f ≫ f = 𝟙 Y
-- Mathlib/Analysis/Convex/Segment.lean
theorem Icc_subset_segment : Icc x y ⊆ [x -[𝕜] y]
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem not_imp_of_and_not : a ∧ ¬b → ¬(a → b)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem of_mono_eq_zero {X Y : C} (f : X ⟶ Y) [Mono f] (h : f = 0) : IsZero X
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem map_toOuterMeasure (hf : AEMeasurable f μ) :
    (μ.map f).toOuterMeasure = (OuterMeasure.map f μ.toOuterMeasure).trim
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_sum (p : T[X]) (g : ℕ → T → R[X]) (x : S) :
    (p.sum g).eval₂ f x = p.sum fun n a => (g n a).eval₂ f x
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arctan`. -/
theorem angle_eq_arctan_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
    (h0 : p₃ ≠ p₂) : ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.eventually_mul_div_cancel (h : IsBigOWith c l u v) : u / v * v =ᶠ[l] u
-- Mathlib/Data/Option/Basic.lean
theorem pbind_map (f : α → β) (x : Option α) (g : ∀ b : β, b ∈ x.map f → Option γ) :
    pbind (Option.map f x) g = x.pbind fun a h ↦ g (f a) (mem_map_of_mem _ h)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem inv_closure : ∀ s : Set G, (closure s)⁻¹ = closure s⁻¹
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma supIrredLowerSet_apply (a : α) : supIrredLowerSet a = ⟨Iic a, supIrred_Iic _⟩
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[ext]
theorem ext {h h' : α ≃ᵤ β} (H : ∀ x, h x = h' x) : h = h'
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem map_toSubring : (p.toSubring T hp).map (Subring.subtype T) = p
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_le_mul_of_nonpos_of_nonneg [ExistsAddOfLE α] [MulPosMono α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hac : a ≤ c) (hdb : d ≤ b) (hc : c ≤ 0) (hb : 0 ≤ b) : a * b ≤ c * d
-- Mathlib/Data/Fin/Basic.lean
theorem le_pred_castSucc_iff {a b : Fin (n + 1)} (ha : castSucc a ≠ 0) :
    b ≤ (castSucc a).pred ha ↔ b < a
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- An affine combination is unaffected by changing the weights to the
corresponding indicator function and adding points to the set. -/
theorem affineCombination_indicator_subset (w : ι → k) (p : ι → P) {s₁ s₂ : Finset ι}
    (h : s₁ ⊆ s₂) :
    s₁.affineCombination k p w = s₂.affineCombination k p (Set.indicator (↑s₁) w)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
Proof by cases on an `Or`. If `a ∨ b`, and both `a` and `b` imply
proposition `c`, then `c` is true.
-/
theorem Or.elim {c : Prop} (h : Or a b) (left : a → c) (right : b → c) : c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean
/-- The power series expansion of `Real.cosh`. -/
lemma hasSum_cosh (r : ℝ) : HasSum (fun n  ↦ r ^ (2 * n) / ↑(2 * n)!) (cosh r)
-- Mathlib/SetTheory/Surreal/Multiplication.lean
theorem Equiv.mul_congr (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ * y₁ ≈ x₂ * y₂
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem toOuterMeasure_caratheodory : p.toOuterMeasure.caratheodory = ⊤
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem inv_hom_id_tensor' {V W X Y Z : C} (f : V ⟶ W) [IsIso f] (g : X ⟶ Y) (h : Y ⟶ Z) :
    (inv f ⊗ g) ≫ (f ⊗ h) = (𝟙 W ⊗ g) ≫ (𝟙 W ⊗ h)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_mul_X : eval₂ f x (p * X) = eval₂ f x p * x
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_not_intro {p : Prop} (h : p) : ¬ ¬ p
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arctan`, version subtracting vectors. -/
theorem oangle_sub_left_eq_arctan_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle (x - y) x = Real.arctan (‖y‖ / ‖x‖)