ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioo_of_Ioc : AECover (μ.restrict <| Ioo A B) l fun i => Ioc (a i) (b i)
-- Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
/-- The volume measure in a finite-dimensional inner product space gives measure `1` to the
parallelepiped spanned by any orthonormal basis. -/
theorem OrthonormalBasis.volume_parallelepiped (b : OrthonormalBasis ι ℝ F) :
    volume (parallelepiped b) = 1
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
theorem injectiveSeminorm_tprod_le (m : Π (i : ι), E i) :
    injectiveSeminorm (⨂ₜ[𝕜] i, m i) ≤ ∏ i, ‖m i‖
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem quot_zero_mul (x : PGame) : (⟦0 * x⟧ : Game) = ⟦0⟧
-- Mathlib/Algebra/Module/Submodule/LinearMap.lean
theorem subtype_comp_restrict {f : M →ₗ[R] M₁} {p : Submodule R M} {q : Submodule R M₁}
    (hf : ∀ x ∈ p, f x ∈ q) : q.subtype.comp (f.restrict hf) = f.domRestrict p
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma homology_π_ι :
    S.homologyπ ≫ S.homologyι = S.iCycles ≫ S.pOpcycles
-- Mathlib/Data/List/Basic.lean
theorem length_modifyNthTail (f : List α → List α) (H : ∀ l, length (f l) = length l) :
    ∀ n l, length (modifyNthTail f n l) = length l
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem updateColumn_self [DecidableEq n] : updateColumn M j c i j = c i
-- Mathlib/Order/Defs.lean
theorem le_or_lt (a b : α) : a ≤ b ∨ b < a
-- Mathlib/Data/Int/Cast/Basic.lean
@[simp, norm_cast]
theorem cast_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n) : ℤ) : R) = OfNat.ofNat n
-- Mathlib/Topology/Bornology/Absorbs.lean
lemma mono_left (h : Absorbs M s₁ t) (hs : s₁ ⊆ s₂) : Absorbs M s₂ t
-- Mathlib/Data/Complex/Basic.lean
theorem conj_natCast (n : ℕ) : conj (n : ℂ) = n
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma leadingCoeff_ΨSq [NoZeroDivisors R] {n : ℤ} (h : (n : R) ≠ 0) :
    (W.ΨSq n).leadingCoeff = n ^ 2
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma baseChange_φ (n : ℤ) : (W.baseChange B).φ n = ((W.baseChange A).φ n).map (mapRingHom f)
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem pentagon_hom_hom_inv_inv_hom :
    (α_ W (X ⊗ Y) Z).hom ≫ W ◁ (α_ X Y Z).hom ≫ (α_ W X (Y ⊗ Z)).inv =
      (α_ W X Y).inv ▷ Z ≫ (α_ (W ⊗ X) Y Z).hom
-- Mathlib/Topology/LocallyClosed.lean
lemma isClosed_preimage_val_coborder :
    IsClosed (coborder s ↓∩ s)
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.zsmul_sub_eq [AddCommGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
    f (n • c - x) = (n.negOnePow : ℤ) • f (-x)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem map_eq_bot_iff {s : AffineSubspace k P₁} : s.map f = ⊥ ↔ s = ⊥
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem power_ne_zero {a : Cardinal} (b : Cardinal) : a ≠ 0 → a ^ b ≠ 0
-- Mathlib/RingTheory/Localization/Finiteness.lean
/-- If there exists a set `{ r }` of `R` such that `Mᵣ` is `Rᵣ`-finite for each `r`,
then `M` is a finite `R`-module. -/
theorem of_localizationSpan (t : Set R) (ht : Ideal.span t = ⊤)
    (H : ∀ (g : t), Module.Finite (Localization.Away g.val)
      (LocalizedModule (Submonoid.powers g.val) M)) :
    Module.Finite R M
-- Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
/-- If a function is `C^n`, with `1 ≤ n`, then its bundled derivative is continuous. -/
theorem ContMDiff.continuous_tangentMap (hf : ContMDiff I I' n f) (hmn : 1 ≤ n) :
    Continuous (tangentMap I I' f)
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_eq_submodule_map (f : R →+* S) [h : RingHomSurjective f] (I : Ideal R) :
    I.map f = Submodule.map f.toSemilinearMap I
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem smulRight_eq_comp {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [Module R M₁] [Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) :
    f.smulRight z = (LinearMap.id.smulRight z).compAlternatingMap f
-- Mathlib/Tactic/NormNum/BigOperators.lean
protected lemma Finset.sum_empty {β α : Type*} [CommSemiring β] (f : α → β) :
    IsNat (Finset.sum ∅ f) 0
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- If `Fₙ` tends locally uniformly to `f`, and `gₙ` tends to `x`, then `Fₙ gₙ` tends to `f x`. -/
theorem TendstoLocallyUniformly.tendsto_comp (h : TendstoLocallyUniformly F f p)
    (hf : ContinuousAt f x) (hg : Tendsto g p (𝓝 x)) : Tendsto (fun n => F n (g n)) p (𝓝 (f x))
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma map_b₂ : (W.map φ).b₂ = φ W.b₂
-- Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
theorem universallyClosed_eq : @UniversallyClosed = universally (topologically @IsClosedMap)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. -/
theorem ContDiffAt.prod_map' {f : E → F} {g : E' → F'} {p : E × E'} (hf : ContDiffAt 𝕜 n f p.1)
    (hg : ContDiffAt 𝕜 n g p.2) : ContDiffAt 𝕜 n (Prod.map f g) p
-- Mathlib/Order/SuccPred/Basic.lean
theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- The oriented angle between three points equals the unoriented angle if the sign is
positive. -/
theorem oangle_eq_angle_of_sign_eq_one {p₁ p₂ p₃ : P} (h : (∡ p₁ p₂ p₃).sign = 1) :
    ∡ p₁ p₂ p₃ = ∠ p₁ p₂ p₃
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1SCLM_congr_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : T = T') (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT f = setToL1SCLM α E μ hT' f
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Energy.lean
theorem energy_le_one : P.energy G ≤ 1
-- Mathlib/RingTheory/PiTensorProduct.lean
protected lemma mul_assoc (x y z : ⨂[R] i, A i) : mul (mul x y) z = mul x (mul y z)
-- Mathlib/Computability/Partrec.lean
theorem rfindOpt_mono {α} {f : ℕ → Option α} (H : ∀ {a m n}, m ≤ n → a ∈ f m → a ∈ f n) {a} :
    a ∈ rfindOpt f ↔ ∃ n, a ∈ f n
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem intervalIntegral_tendsto_integral_Ioi (a : ℝ) (hfi : IntegrableOn f (Ioi a) μ)
    (hb : Tendsto b l atTop) :
    Tendsto (fun i => ∫ x in a..b i, f x ∂μ) l (𝓝 <| ∫ x in Ioi a, f x ∂μ)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem mul_ediv_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b) / b = a
-- Mathlib/RingTheory/Binomial.lean
@[simp]
theorem multichoose_one (k : ℕ) : multichoose (1 : R) k = 1
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem coe_inj {x y : R} : (x : ℍ[R,c₁,c₂]) = y ↔ x = y
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_neg (p : R[X]) : (-p).leadingCoeff = -p.leadingCoeff
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousAt_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} {x : α × β} :
    ContinuousAt f x ↔ ContinuousAt (f ⟨x.1, ·⟩) x.2
-- Mathlib/Data/Finmap.lean
theorem mem_keys {a : α} {s : Finmap β} : a ∈ s.keys ↔ a ∈ s
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem HasProd.hasProd_iff_compl {s : Set β} (hf : HasProd (f ∘ (↑) : s → α) a₁) :
    HasProd f a₂ ↔ HasProd (f ∘ (↑) : ↑sᶜ → α) (a₂ / a₁)
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
lemma isZero_quotient_obj_iff (C : HomologicalComplex V c) :
    IsZero ((quotient _ _).obj C) ↔ Nonempty (Homotopy (𝟙 C) 0)
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[simp]
lemma leftHomologyMap'_zero (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) :
    leftHomologyMap' 0 h₁ h₂ = 0
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- The reflection in `Kᗮ` of an element of `K` is its negation. -/
theorem reflection_mem_subspace_orthogonal_precomplement_eq_neg [HasOrthogonalProjection K] {v : E}
    (hv : v ∈ K) : reflection Kᗮ v = -v
-- Mathlib/Data/Int/Log.lean
@[simp]
theorem clog_one_right (b : ℕ) : clog b (1 : R) = 0
-- Mathlib/Order/Heyting/Regular.lean
@[simp, norm_cast]
theorem coe_bot : ((⊥ : Regular α) : α) = ⊥
-- Mathlib/Analysis/Convex/Cone/Proper.lean
theorem comap_comap (g : F →L[ℝ] G) (f : E →L[ℝ] F) (S : ProperCone ℝ G) :
    (S.comap g).comap f = S.comap (g.comp f)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem toEquiv_pointReflection (x : P₁) :
    (pointReflection k x).toEquiv = Equiv.pointReflection x
-- Mathlib/Order/Filter/Prod.lean
/-- If a function tends to a product `g ×ˢ h` of filters, then its second component tends to
`h`. See also `Filter.Tendsto.snd_nhds` for the special case of converging to a point in a
product of two topological spaces. -/
theorem Tendsto.snd {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).2) f h
-- Mathlib/Topology/Algebra/Order/Compact.lean
@[simp 900]
theorem cocompact_eq_atBot_atTop [NoMaxOrder α] [NoMinOrder α]
    [OrderClosedTopology α] [CompactIccSpace α] : cocompact α = atBot ⊔ atTop
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem isOrtho_sSup_left {U : Set (Submodule 𝕜 E)} {V : Submodule 𝕜 E} :
    sSup U ⟂ V ↔ ∀ Uᵢ ∈ U, Uᵢ ⟂ V
-- Mathlib/Data/Nat/Log.lean
@[simp]
theorem log_eq_zero_iff {b n : ℕ} : log b n = 0 ↔ n < b ∨ b ≤ 1
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem bne_self_eq_false [BEq α] [LawfulBEq α] (a : α) : (a != a) = false
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.le_bot : Disjoint a b → a ⊓ b ≤ ⊥
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
lemma equalizerCondition_iff_isSheaf (F : Cᵒᵖ ⥤ D) [Preregular C]
    [∀ {Y X : C} (f : Y ⟶ X) [EffectiveEpi f], HasPullback f f] :
    EqualizerCondition F ↔ Presheaf.IsSheaf (regularTopology C) F
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem and_self_left  : ∀(a b : Bool), (a && (a && b)) = (a && b)
-- Mathlib/Data/Sum/Interval.lean
lemma inr_mem_sumLexLift {c₂ : γ₂} :
    inr c₂ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨
        ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ c₂ ∈ f₂ a₂ b₂
-- Mathlib/Order/Monotone/Basic.lean
theorem monotone_fst : Monotone (@Prod.fst α β)
-- Mathlib/Topology/Basic.lean
@[simp]
theorem Finset.closure_biUnion {ι : Type*} (s : Finset ι) (f : ι → Set X) :
    closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp]
theorem map_one : map (fun (i : ι) ↦ (1 : s i →ₗ[R] s i)) = 1
-- Mathlib/CategoryTheory/Types.lean
theorem surjective_of_epi {X Y : Type u} (f : X ⟶ Y) [hf : Epi f] : Function.Surjective f
-- Mathlib/Data/List/Basic.lean
lemma map_filter' {f : α → β} (hf : Injective f) (l : List α)
    [DecidablePred fun b => ∃ a, p a ∧ f a = b] :
    (l.filter p).map f = (l.map f).filter fun b => ∃ a, p a ∧ f a = b
-- Mathlib/Computability/Partrec.lean
theorem sum_casesOn_right {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ →. σ} (hf : Computable f)
    (hg : Computable₂ g) (hh : Partrec₂ h) :
    @Partrec _ σ _ _ fun a => Sum.casesOn (f a) (fun b => Part.some (g a b)) (h a)
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem ext_iff {e₁ e₂ : ENorm 𝕜 V} : e₁ = e₂ ↔ ∀ x, e₁ x = e₂ x
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem odd_length : Odd (ℓ t)
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem neg_apply (f : CentroidHom α) (a : α) : (-f) a = -f a
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem le_edist_of_le_einfsep {d x} (hx : x ∈ s) {y} (hy : y ∈ s) (hxy : x ≠ y)
    (hd : d ≤ s.einfsep) : d ≤ edist x y
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem Continuous.vsub {f g : α → P} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f -ᵥ g)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
/-- `toIcoMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIcoMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ico a (a + p)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph'_le {o₁ o₂ : Ordinal} : aleph' o₁ ≤ aleph' o₂ ↔ o₁ ≤ o₂
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
@[simp] theorem perpBisector_eq_top : perpBisector p₁ p₂ = ⊤ ↔ p₁ = p₂
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem one_sub_mem {t : β} (ht : t ∈ Ioo (0 : β) 1) : 1 - t ∈ Ioo (0 : β) 1
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem congr_arg {f : 𝓕} :
    ∀ {x x' : E}, x = x' → f x = f x'
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
@[simp (high)]
theorem coe_comp {M N K : SemiNormedGrp₁} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : M → K) = g ∘ f
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem MeasurableSet.subtype_image {s : Set α} {t : Set s} (hs : MeasurableSet s) :
    MeasurableSet t → MeasurableSet (((↑) : s → α) '' t)
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
theorem zero_morphism_ext' {P Q : C} (f : P ⟶ Q) : (∀ a, f a = 0) → 0 = f
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_of_subset {s t : Multiset α} {a : α} (h : s ⊆ t) : a ∈ s → a ∈ t
-- Mathlib/Order/OrdContinuous.lean
theorem map_ciSup (hf : LeftOrdContinuous f) {g : ι → α} (hg : BddAbove (range g)) :
    f (⨆ i, g i) = ⨆ i, f (g i)
-- Mathlib/Data/Multiset/Nodup.lean
@[simp]
theorem coe_nodup {l : List α} : @Nodup α l ↔ l.Nodup
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem comp_zero (f : NormedAddGroupHom V₂ V₃) : f.comp (0 : NormedAddGroupHom V₁ V₂) = 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[trans]
theorem IsLittleO.trans_eventuallyEq {f : α → E} {g₁ g₂ : α → F} (h : f =o[l] g₁)
    (hg : g₁ =ᶠ[l] g₂) : f =o[l] g₂
-- Mathlib/Data/List/Indexes.lean
@[simp]
theorem mapIdx_eq_nil {f : ℕ → α → β} {l : List α} : List.mapIdx f l = [] ↔ l = []
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval_C : (C r).smeval x = r • x ^ 0
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) = f 0
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem union_singleton : s ∪ {a} = insert a s
-- Mathlib/GroupTheory/Divisible.lean
/--
An `AddMonoid A` is `α`-divisible iff `n • x = a` has a solution for all `n ≠ 0 ∈ α` and `a ∈ A`.
Here we adopt a constructive approach where we ask an explicit `div : A → α → A` function such that
* `div a 0 = 0` for all `a ∈ A`
* `n • div a n = a` for all `n ≠ 0 ∈ α` and `a ∈ A`.
-/
class DivisibleBy where
  div : A → α → A
  div_zero : ∀ a, div a 0 = 0
  div_cancel : ∀ {n : α} (a : A), n ≠ 0 → n • div a n = a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem flip_smul (c : 𝕜₃) (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : (c • f).flip = c • f.flip
-- Mathlib/Topology/Support.lean
theorem tsupport_smul_subset_right {M α} [TopologicalSpace X] [Zero α] [SMulZeroClass M α]
    (f : X → M) (g : X → α) : (tsupport fun x => f x • g x) ⊆ tsupport g
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
protected theorem mul_pos {f g : CauSeq α abs} : Pos f → Pos g → Pos (f * g)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem inclusion_self (x : H) : inclusion le_rfl x = x
-- Mathlib/Data/Nat/Log.lean
@[simp] lemma clog_zero_left (n : ℕ) : clog 0 n = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Cauchy–Schwarz inequality with norm -/
theorem real_inner_le_norm (x y : F) : ⟪x, y⟫_ℝ ≤ ‖x‖ * ‖y‖
-- Mathlib/AlgebraicTopology/DoldKan/NReflectsIso.lean
theorem compatibility_N₂_N₁_karoubi :
    N₂ ⋙ (karoubiChainComplexEquivalence C ℕ).functor =
      karoubiFunctorCategoryEmbedding SimplexCategoryᵒᵖ C ⋙
        N₁ ⋙ (karoubiChainComplexEquivalence (Karoubi C) ℕ).functor ⋙
            Functor.mapHomologicalComplex (KaroubiKaroubi.equivalence C).inverse _
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
@[simp]
theorem hasseDeriv_one : @hasseDeriv R _ 1 = derivative
-- Mathlib/Algebra/GroupWithZero/Hom.lean
@[simp] lemma id_comp (f : α →*₀ β) : (id β).comp f = f
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem isSubordinate_single [Fintype ι] (hJ : J ≤ I) (h : x ∈ Box.Icc I) :
    IsSubordinate (single I J hJ x h) r ↔ Box.Icc J ⊆ closedBall x (r x)
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma cotangentSpaceBasis_repr_one_tmul (x i) :
    P.cotangentSpaceBasis.repr (1 ⊗ₜ .D _ _ x) i = aeval P.val (pderiv i x)
-- Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean
/-- Given a diagram
```
a'        a --φ--> b
|         |        |
v         v        v
R' --g--> R --f--> S
```
such that `φ` is strongly cartesian, and morphisms `ψ ψ' : a' ⟶ a` such that
`g ≫ ψ = φ' = g ≫ ψ'`. Then we have that `ψ = ψ'`. -/
protected lemma ext (φ : a ⟶ b) [IsStronglyCartesian p f φ] {R' : 𝒮} {a' : 𝒳} (g : R' ⟶ R)
    {ψ ψ' : a' ⟶ a} [IsHomLift p g ψ] [IsHomLift p g ψ'] (h : ψ ≫ φ = ψ' ≫ φ) : ψ = ψ'
-- Mathlib/Data/Complex/Basic.lean
@[simp] lemma div_ofReal_re (z : ℂ) (x : ℝ) : (z / x).re = z.re / x
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem measurePreserving_hausdorffMeasure (e : X ≃ᵢ Y) (d : ℝ) : MeasurePreserving e μH[d] μH[d]
-- Mathlib/Analysis/Seminorm.lean
/-- Balls at the origin are balanced. -/
theorem balanced_ball_zero : Balanced 𝕜 (Metric.ball (0 : E) r)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem add_div_le_sum_sq_div_card (hst : s ⊆ t) (f : ι → 𝕜) (d : 𝕜) (hx : 0 ≤ x)
    (hs : x ≤ |(∑ i ∈ s, f i) / s.card - (∑ i ∈ t, f i) / t.card|)
    (ht : d ≤ ((∑ i ∈ t, f i) / t.card) ^ 2) :
    d + s.card / t.card * x ^ 2 ≤ (∑ i ∈ t, f i ^ 2) / t.card
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp]
theorem stalkToFiberRingHom_germ (U : Opens (ProjectiveSpectrum.top 𝒜)) (x : U)
    (s : (Proj.structureSheaf 𝒜).1.obj (op U)) :
    stalkToFiberRingHom 𝒜 x ((Proj.structureSheaf 𝒜).presheaf.germ x s) = s.1 x
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.basis_union_of_subset (hI : M.Basis I X) (hJ : M.Indep J) (hIJ : I ⊆ J) :
    M.Basis J (J ∪ X)
-- Mathlib/Tactic/Ring/Basic.lean
theorem one_mul (a : R) : (nat_lit 1).rawCast * a = a
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_lt_one_div_of_lt (ha : 0 < a) (h : a < b) : 1 / b < 1 / a
-- Mathlib/Data/Real/GoldenRatio.lean
/-- The inverse of the golden ratio is the opposite of its conjugate. -/
theorem inv_gold : φ⁻¹ = -ψ
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
/-- The inclusion of `R_hat` in `K_hat` as a ring homomorphism. -/
@[simps]
def Coe.ringHom : RingHom (R_hat R K) (K_hat R K)
-- Mathlib/CategoryTheory/NatIso.lean
theorem isIso_map_iff {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) {X Y : C} (f : X ⟶ Y) :
    IsIso (F₁.map f) ↔ IsIso (F₂.map f)
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.conj_eq_normalizer_conj_of_mem_centralizer [Fact p.Prime] [Finite (Sylow p G)]
    (P : Sylow p G) (x g : G) (hx : x ∈ centralizer (P : Set G))
    (hy : g⁻¹ * x * g ∈ centralizer (P : Set G)) :
    ∃ n ∈ (P : Subgroup G).normalizer, g⁻¹ * x * g = n⁻¹ * x * n
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_embedding_eq_arrow_of_le (le : #β ≤ #α) : #(β ↪ α) = #(β → α)
-- Mathlib/Data/Multiset/Basic.lean
theorem count_le_of_le (a : α) {s t} : s ≤ t → count a s ≤ count a t
-- Mathlib/Logic/Basic.lean
@[simp]
lemma exists_apply_eq_apply2' {α β γ} {f : α → β → γ} {a : α} {b : β} : ∃ x y, f a b = f x y
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem leftLim_eq_sSup [TopologicalSpace α] [OrderTopology α] (h : 𝓝[<] x ≠ ⊥) :
    leftLim f x = sSup (f '' Iio x)
-- Mathlib/RingTheory/HahnSeries/PowerSeries.lean
theorem algebraMap_apply' (x : S) :
    algebraMap S (HahnSeries Γ R) x = ofPowerSeries Γ R (algebraMap S (PowerSeries R) x)
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_atBot_isLUB (h_anti : Antitone f) (ha : IsLUB (Set.range f) a) :
    Tendsto f atBot (𝓝 a)
-- Mathlib/Order/Filter/Prod.lean
/-- Characterization of the `Filter.map` of the coproduct of two principal filters `𝓟 {a}` and
`𝓟 {i}`, under the `Prod.map` of two functions, respectively the constant function `fun a => b` and
the identity function.  Together with the previous lemma,
`map_const_principal_coprod_map_id_principal`, this provides an example showing that the inequality
in the lemma `map_prod_map_coprod_le` can be strict. -/
theorem map_prod_map_const_id_principal_coprod_principal {α β ι : Type*} (a : α) (b : β) (i : ι) :
    map (Prod.map (fun _ : α => b) id) ((𝓟 {a}).coprod (𝓟 {i})) =
      𝓟 (({b} : Set β) ×ˢ (univ : Set ι))
-- Mathlib/Control/Traversable/Equiv.lean
theorem traverse_def (f : α → m β) (x : t' α) :
    Equiv.traverse eqv f x = eqv β <$> traverse f ((eqv α).symm x)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
/-- Explicit formula for the norm of the Gaussian function along the vertical
edges. -/
theorem norm_cexp_neg_mul_sq_add_mul_I (b : ℂ) (c T : ℝ) :
    ‖cexp (-b * (T + c * I) ^ 2)‖ = exp (-(b.re * T ^ 2 - 2 * b.im * c * T - b.re * c ^ 2))
-- Mathlib/Topology/ExtremallyDisconnected.lean
private lemma ExtremallyDisconnected.homeoCompactToT2_injective [ExtremallyDisconnected A]
    [T2Space A] [T2Space E] [CompactSpace E] {ρ : E → A} (ρ_cont : Continuous ρ)
    (ρ_surj : ρ.Surjective) (zorn_subset : ∀ E₀ : Set E, E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ) :
    ρ.Injective
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp, norm_cast]
theorem natCast_mul_eq_nsmul (x : ℝ) (n : ℕ) : ↑((n : ℝ) * x) = n • (↑x : Angle)
-- Mathlib/FieldTheory/IsSepClosed.lean
theorem surjective_comp_algebraMap_of_isSeparable {E : Type*}
    [Field E] [Algebra K E] [Algebra L E] [IsScalarTower K L E] [Algebra.IsSeparable L E] :
    Function.Surjective fun φ : E →ₐ[K] M ↦ φ.comp (IsScalarTower.toAlgHom K L E)
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem exists_minimizer : ∃ f ∈ candidatesB X Y, ∀ g ∈ candidatesB X Y, HD f ≤ HD g
-- Mathlib/Order/Filter/Prod.lean
/-- If a function tends to a product `g ×ˢ h` of filters, then its first component tends to
`g`. See also `Filter.Tendsto.fst_nhds` for the special case of converging to a point in a
product of two topological spaces. -/
theorem Tendsto.fst {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).1) f g
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem star_im : star a.im = -a.im
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid.dual_iff {t : Ordnode α} : Valid t ↔ @Valid αᵒᵈ _ (.dual t)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffWithinAt.contDiffAt (h : ContDiffWithinAt 𝕜 n f s x) (hx : s ∈ 𝓝 x) :
    ContDiffAt 𝕜 n f x
-- Mathlib/Topology/UnitInterval.lean
theorem mul_mem {x y : ℝ} (hx : x ∈ I) (hy : y ∈ I) : x * y ∈ I
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- The right inverse of an isometry is an isometry. -/
theorem right_inv {f : α → β} {g : β → α} (h : Isometry f) (hg : RightInverse g f) : Isometry g
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
theorem not_mem_setOfIdeal {I : Ideal C(X, R)} {x : X} :
    x ∉ setOfIdeal I ↔ ∀ ⦃f : C(X, R)⦄, f ∈ I → f x = 0
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem AlgebraicIndependent.mono {t s : Set A} (h : t ⊆ s)
    (hx : AlgebraicIndependent R ((↑) : s → A)) : AlgebraicIndependent R ((↑) : t → A)
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem casesDiagOn_succ_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) (m) :
    Nat.casesDiagOn (m+1) 0 zero_zero zero_succ succ_zero succ_succ = succ_zero m
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is a purely inseparable field extension, `f` is a separable irreducible polynomial
over `F`, then it is also irreducible over `E`. -/
theorem Polynomial.Separable.map_irreducible_of_isPurelyInseparable {f : F[X]} (hsep : f.Separable)
    (hirr : Irreducible f) [IsPurelyInseparable F E] : Irreducible (f.map (algebraMap F E))
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
private lemma sups_aux : a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure s ∧ a ∈ upperClosure t