ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem reflect_sub (f g : R[X]) (N : ℕ) : reflect N (f - g) = reflect N f - reflect N g
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive (attr := simp)]
lemma one_smul (b : α) : (1 : M) • b = b
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- The infimum of a singleton is the element of the singleton-/
@[simp]
theorem csInf_singleton (a : α) : sInf {a} = a
-- Mathlib/Data/Finset/Basic.lean
theorem val_le_iff_val_subset {a : Finset α} {b : Multiset α} : a.val ≤ b ↔ a.val ⊆ b
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp] lemma piTensorHomMap₂_tprod_tprod_tprod
    (f : ∀ i, s i →ₗ[R] t i →ₗ[R] t' i) (a : ∀ i, s i) (b : ∀ i, t i) :
    piTensorHomMap₂ (tprod R f) (tprod R a) (tprod R b) = tprod R (fun i ↦ f i (a i) (b i))
-- Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean
@[reassoc (attr := simp)]
lemma tensorHom_app_snd {F₁ F₁' F₂ F₂' : J ⥤ C} (f : F₁ ⟶ F₁') (g : F₂ ⟶ F₂') (j : J) :
    (f ⊗ g).app j ≫ snd _ _ = snd _ _ ≫ g.app j
-- Mathlib/Data/Setoid/Partition.lean
/-- This lemma is analogous to `Quotient.out_eq'`. -/
@[simp]
theorem proj_out (x : hs.Quotient) : hs.proj (hs.out x) = x
-- Mathlib/InformationTheory/Hamming.lean
theorem hammingDist_smul_le_hammingDist [∀ i, SMul α (β i)] {k : α} {x y : ∀ i, β i} :
    hammingDist (k • x) (k • y) ≤ hammingDist x y
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
@[simp]
theorem inv_inv_inv (A : Matrix n n α) : A⁻¹⁻¹⁻¹ = A⁻¹
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
/-- Given `α : L ⋙ F' ⟶ F`, the property `F'.IsRightKanExtension α` asserts that
`(F', α)` is a terminal object in the category `RightExtension L F`, i.e. that `(F', α)`
is a right Kan extension of `F` along `L`. -/
class IsRightKanExtension : Prop where
  nonempty_isUniversal : Nonempty (RightExtension.mk F' α).IsUniversal
-- Mathlib/Data/Fintype/Basic.lean
theorem toFinset_ssubset_univ [Fintype α] {s : Set α} [Fintype s] :
    s.toFinset ⊂ Finset.univ ↔ s ⊂ univ
-- Mathlib/Topology/Constructions.lean
theorem nhds_ofDual (x : X) : 𝓝 (ofDual x) = map ofDual (𝓝 x)
-- Mathlib/Data/Finsupp/Basic.lean
theorem zero_not_mem_frange {f : α →₀ M} : (0 : M) ∉ f.frange
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofBaseOfFinite_base {E : Set α} (hE : E.Finite) Base exists_base
    base_exchange subset_ground : (Matroid.ofBaseOfFinite
      hE Base exists_base base_exchange subset_ground).Base = Base
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem snd_comp_toProd : (MonoidHom.snd M N).comp toProd = snd
-- Mathlib/Analysis/Complex/Conformal.lean
/-- A real continuous linear map on the complex plane is conformal if and only if the map or its
    conjugate is complex linear, and the map is nonvanishing. -/
theorem isConformalMap_iff_is_complex_or_conj_linear :
    IsConformalMap g ↔
      ((∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
          ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCLE) ∧
        g ≠ 0
-- Mathlib/Analysis/Quaternion.lean
theorem normSq_eq_norm_mul_self (a : ℍ) : normSq a = ‖a‖ * ‖a‖
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem tendsto_iff_tendstoUniformly {ι : Type*} {F : ι → α →ᵇ β} {f : α →ᵇ β} {l : Filter ι} :
    Tendsto F l (𝓝 f) ↔ TendstoUniformly (fun i => F i) f l
-- Mathlib/FieldTheory/KummerExtension.lean
lemma isGalois_of_isSplittingField_X_pow_sub_C : IsGalois K L
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem Ici_sSup (S : Set α) : Ici (sSup S) = ⨆ a ∈ S, Ici a
-- Mathlib/Order/SupIndep.lean
@[simp, nolint simpNF]
theorem supIndep_attach : (s.attach.SupIndep fun a => f a) ↔ s.SupIndep f
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_self_lt_top_iff {a : ℝ≥0∞} : a * a < ⊤ ↔ a < ⊤
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem coeff_mul_monomial_zero (p : R[X]) (d : ℕ) (r : R) :
    coeff (p * monomial 0 r) d = coeff p d * r
-- Mathlib/Probability/Martingale/Basic.lean
theorem ae_le_condexp [LE E] (hf : Submartingale f ℱ μ) {i j : ι} (hij : i ≤ j) :
    f i ≤ᵐ[μ] μ[f j|ℱ i]
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem as_ideal_lt_as_ideal (x y : ProjectiveSpectrum 𝒜) :
    x.asHomogeneousIdeal < y.asHomogeneousIdeal ↔ x < y
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem Finset.card_add_card_compl [DecidableEq α] [Fintype α] (s : Finset α) :
    s.card + sᶜ.card = Fintype.card α
-- Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean
theorem comp_add (f : X ⟶ Y) (g h : Y ⟶ Z) : f ≫ (g + h) = f ≫ g + f ≫ h
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
/-- The disjoint union of antidiagonals `Σ (n : A), antidiagonal n` is equivalent to the product
    `A × A`. This is such an equivalence, obtained by mapping `(n, (k, l))` to `(k, l)`. -/
@[simps]
def sigmaAntidiagonalEquivProd [AddMonoid A] [HasAntidiagonal A] :
    (Σ n : A, antidiagonal n) ≃ A × A
-- Mathlib/Order/Filter/Cofinite.lean
/-- If `f` tends to a countably generated filter `l` along `Filter.cofinite`,
then for all but countably many elements, `f x ∈ l.ker`. -/
theorem Tendsto.countable_compl_preimage_ker {f : α → β}
    {l : Filter β} [l.IsCountablyGenerated] (h : Tendsto f cofinite l) :
    Set.Countable (f ⁻¹' l.ker)ᶜ
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_atBot_of_monotone [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f)
    (h : ∀ b, ∃ a, f a ≤ b) : Tendsto f atBot atBot
-- Mathlib/Data/Subtype.lean
@[simp]
protected theorem «forall» {q : { a // p a } → Prop} : (∀ x, q x) ↔ ∀ a b, q ⟨a, b⟩
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem Differentiable.norm_sq (hf : Differentiable ℝ f) : Differentiable ℝ fun y => ‖f y‖ ^ 2
-- Mathlib/CategoryTheory/Preadditive/Projective.lean
lemma Limits.IsZero.projective {X : C} (h : IsZero X) : Projective X
-- Mathlib/Data/Nat/Digits.lean
theorem digits_add (b : ℕ) (h : 1 < b) (x y : ℕ) (hxb : x < b) (hxy : x ≠ 0 ∨ y ≠ 0) :
    digits b (x + b * y) = x :: digits b y
-- Mathlib/SetTheory/Cardinal/PartENat.lean
theorem toPartENat_surjective : Surjective toPartENat
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.isHomogeneous_iff_forall_subset :
    I.IsHomogeneous 𝒜 ↔ ∀ i, (I : Set A) ⊆ GradedRing.proj 𝒜 i ⁻¹' I
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem sup_eq_closure (H H' : Subgroup G) : H ⊔ H' = closure ((H : Set G) ∪ (H' : Set G))
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem target_inter_preimage_symm_source_eq (e f : Pretrivialization F proj) :
    f.target ∩ f.toPartialEquiv.symm ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem concat_append {u v w x : V} (p : G.Walk u v) (h : G.Adj v w) (q : G.Walk w x) :
    (p.concat h).append q = p.append (cons h q)
-- Mathlib/Order/BoundedOrder.lean
lemma inf_top_eq (a : α) : a ⊓ ⊤ = a
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive finsum_nonneg]
theorem one_le_finprod' {M : Type*} [OrderedCommMonoid M] {f : α → M} (hf : ∀ i, 1 ≤ f i) :
    1 ≤ ∏ᶠ i, f i
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
theorem map_id : (Option.map id : Option α → Option α) = id
-- Mathlib/Data/Finmap.lean
@[simp]
theorem keys_ext {s₁ s₂ : AList β} : keys ⟦s₁⟧ = keys ⟦s₂⟧ ↔ s₁.keys ~ s₂.keys
-- Mathlib/Topology/Baire/Lemmas.lean
/-- Baire theorem: the intersection of two dense Gδ sets is dense. -/
theorem Dense.inter_of_Gδ {s t : Set X} (hs : IsGδ s) (ht : IsGδ t) (hsc : Dense s)
    (htc : Dense t) : Dense (s ∩ t)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The cosine of the angle between two vectors. -/
theorem cos_angle (x y : V) : Real.cos (angle x y) = ⟪x, y⟫ / (‖x‖ * ‖y‖)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem map_smul_left (r : R) (f : M →ₗ[R] P) (g : N →ₗ[R] Q) : map (r • f) g = r • map f g
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_pow : monomial s a ^ e = monomial (e • s) (a ^ e)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
lemma induce_union_connected {H : G.Subgraph} {s t : Set V}
    (sconn : (H.induce s).Connected) (tconn : (H.induce t).Connected)
    (sintert : (s ⊓ t).Nonempty) :
    (H.induce (s ∪ t)).Connected
-- Mathlib/Topology/Category/Profinite/Basic.lean
theorem FintypeCat.discreteTopology (A : FintypeCat) : DiscreteTopology A
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem calc_norm_le_one {n : ℕ} {z : ℤ_[p]} (hz : ih n z) :
    ‖(↑(F.eval z) : ℚ_[p]) / ↑(F.derivative.eval z)‖ ≤ 1
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
theorem GradedRing.proj_recompose (a : ⨁ i, 𝒜 i) (i : ι) :
    GradedRing.proj 𝒜 i ((decompose 𝒜).symm a) = (decompose 𝒜).symm (DirectSum.of _ i (a i))
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.mono_g' (hS : S.Exact) (h : RightHomologyData S) : Mono h.g'
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_X_pow_sub_C {n : ℕ} (hn : 0 < n) {r : R} :
    (X ^ n - C r).leadingCoeff = 1
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem forall_subset_range_iff {f : α → β} {p : Set β → Prop} :
    (∀ s, s ⊆ range f → p s) ↔ ∀ s, p (f '' s)
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ≤ g b) : s.inf f ≤ s.inf g
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem fst_linear : (fst : P1 × P2 →ᵃ[k] P1).linear = LinearMap.fst k V1 V2
-- Mathlib/Init/Logic.lean
theorem AsTrue.get {c : Prop} [h₁ : Decidable c] (_ : AsTrue c) : c
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem comp_onTerm {L'' : Language} (φ : L' →ᴸ L'') (ψ : L →ᴸ L') :
    ((φ.comp ψ).onTerm : L.Term α → L''.Term α) = φ.onTerm ∘ ψ.onTerm
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem HomogeneousIdeal.mem_irrelevant_iff (a : A) :
    a ∈ HomogeneousIdeal.irrelevant 𝒜 ↔ proj 𝒜 0 a = 0
-- Mathlib/RingTheory/ReesAlgebra.lean
theorem mem_reesAlgebra_iff (f : R[X]) : f ∈ reesAlgebra I ↔ ∀ i, f.coeff i ∈ I ^ i
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arcsin_le_pi_div_two (x : ℝ) : arcsin x ≤ π / 2
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
protected theorem coe_mul (x y : S) : (↑(x * y) : A) = ↑x * ↑y
-- Mathlib/Data/List/Sigma.lean
theorem mem_keys_kinsert {a a'} {b' : β a'} {l : List (Sigma β)} :
    a ∈ (kinsert a' b' l).keys ↔ a = a' ∨ a ∈ l.keys
-- Mathlib/Data/Set/Basic.lean
theorem setOf_app_iff {p : α → Prop} {x : α} : { x | p x } x ↔ p x
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
lemma rotate_distinguished_triangle (T : Triangle (HomotopyCategory C (ComplexShape.up ℤ))) :
    T ∈ distinguishedTriangles C ↔ T.rotate ∈ distinguishedTriangles C
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
@[simp]
theorem constantCoeff_xInTermsOfW [hp : Fact p.Prime] [Invertible (p : R)] (n : ℕ) :
    constantCoeff (xInTermsOfW p R n) = 0
-- Mathlib/Data/Nat/Defs.lean
/-- Induction principle starting at a non-zero number.
To use in an induction proof, the syntax is `induction n, hn using Nat.le_induction` (or the same
for `induction'`).

This is an alias of `Nat.leRec`, specialized to `Prop`. -/
@[elab_as_elim]
lemma le_induction {m : ℕ} {P : ∀ n, m ≤ n → Prop} (base : P m m.le_refl)
    (succ : ∀ n hmn, P n hmn → P (n + 1) (le_succ_of_le hmn)) : ∀ n hmn, P n hmn
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem multipliable_iff_nat_tprod_vanishing {f : ℕ → G} : Multipliable f ↔
    ∀ e ∈ 𝓝 1, ∃ N : ℕ, ∀ t ⊆ {n | N ≤ n}, (∏' n : t, f n) ∈ e
-- .lake/packages/lean4/src/lean/Init/Classical.lean
/-- The Double Negation Theorem: `¬¬P` is equivalent to `P`.
The left-to-right direction, double negation elimination (DNE),
is classically true but not constructively. -/
@[simp] theorem not_not : ¬¬a ↔ a
-- Mathlib/Order/Filter/Basic.lean
theorem forall_in_swap {β : Type*} {p : Set α → β → Prop} :
    (∀ a ∈ f, ∀ (b), p a b) ↔ ∀ (b), ∀ a ∈ f, p a b
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- If `j` is initial in the index category, then the map `limit.π F j` is an isomorphism.
-/
theorem isIso_π_of_isInitial {j : J} (I : IsInitial j) (F : J ⥤ C) [HasLimit F] :
    IsIso (limit.π F j)
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma mulOption_lt_iff_P1 {i j k l} :
    (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ ↔
    P1 (x.moveLeft i) x (x.moveLeft j) y (y.moveLeft k) (-(-y).moveLeft l)
-- Mathlib/Probability/Moments.lean
theorem mgf_pos' (hμ : μ ≠ 0) (h_int_X : Integrable (fun ω => exp (t * X ω)) μ) :
    0 < mgf X μ t
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem integerLattice.inter_ball_finite [NumberField K] (r : ℝ) :
    ((integerLattice K : Set ((K →+* ℂ) → ℂ)) ∩ Metric.closedBall 0 r).Finite
-- Mathlib/NumberTheory/ZetaValues.lean
/-- The Fourier coefficients of `B₀(x) = 1`. -/
theorem bernoulli_zero_fourier_coeff {n : ℤ} (hn : n ≠ 0) : bernoulliFourierCoeff 0 n = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma smul_equiv (P : Fin 3 → R) {u : R} (hu : IsUnit u) : u • P ≈ P
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_mk' (f : A →ₙₐ[R] B) (h) :
    ((⟨f, h⟩ : A →⋆ₙₐ[R] B) : A → B) = f
-- Mathlib/CategoryTheory/Monoidal/Free/Basic.lean
@[simp]
theorem mk_whiskerLeft (X : F C) {Y₁ Y₂ : F C} (f : Y₁ ⟶ᵐ Y₂) :
    ⟦f.whiskerLeft X⟧ = MonoidalCategory.whiskerLeft (C := F C) (X := X) (f := ⟦f⟧)
-- Mathlib/Data/BitVec.lean
theorem toNat_injective {n : Nat} : Function.Injective (BitVec.toNat : BitVec n → _)
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
lemma coroot_root_eq_pairing : P.toLin.flip (P.coroot i) (P.root j) = P.pairing j i
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem ofNat_mul_subNatNat (m n k : Nat) :
    m * subNatNat n k = subNatNat (m * n) (m * k)
-- Mathlib/Topology/Algebra/MulAction.lean
@[to_additive (attr := fun_prop)]
theorem ContinuousOn.smul (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x • g x) s
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- If `f : G → H` is a homomorphism between two additive magmas, then `Finsupp.mapDomain f` is a
non-unital algebra homomorphism between their additive magma algebras. -/
@[simps apply]
def mapDomainNonUnitalAlgHom (k A : Type*) [CommSemiring k] [Semiring A] [Algebra k A]
    {G H F : Type*} [Add G] [Add H] [FunLike F G H] [AddHomClass F G H] (f : F) :
    A[G] →ₙₐ[k] A[H]
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- If the composition of two continuous functions `f : X → Y` and `g : Y → Z` is proper
and `Y` is T2, then `f` is proper. -/
lemma isProperMap_of_comp_of_t2 [T2Space Y] (hf : Continuous f) (hg : Continuous g)
    (hgf : IsProperMap (g ∘ f)) : IsProperMap f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem toListRev_eq (arr : Array α) : arr.toListRev = arr.data.reverse
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem eLpNorm'_lt_top_of_eLpNorm'_lt_top_of_exponent_le {p q : ℝ} [IsFiniteMeasure μ]
    (hf : AEStronglyMeasurable f μ) (hfq_lt_top : eLpNorm' f q μ < ∞) (hp_nonneg : 0 ≤ p)
    (hpq : p ≤ q) : eLpNorm' f p μ < ∞
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem pointReflection_apply (x y : P₁) : pointReflection k x y = x -ᵥ y +ᵥ x
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp, norm_cast]
lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithBot α)
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem get_zero_iterate (f : α → α) (a : α) : get (iterate f a) 0 = a
-- Mathlib/Data/List/Forall2.lean
theorem Forall₂.length_eq : ∀ {l₁ l₂}, Forall₂ R l₁ l₂ → length l₁ = length l₂
-- Mathlib/Topology/PartialHomeomorph.lean
theorem target_inter_inv_preimage_preimage (s : Set Y) :
    e.target ∩ e.symm ⁻¹' (e ⁻¹' s) = e.target ∩ s
-- Mathlib/RingTheory/MvPolynomial/Localization.lean
private lemma auxInv_auxHom : (auxInv S r).comp (auxHom (S := S) r).toRingHom = RingHom.id _
-- Mathlib/Topology/ContinuousOn.lean
@[fun_prop]
theorem continuousOn_apply {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    (i : ι) (s) : ContinuousOn (fun p : ∀ i, π i => p i) s
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem lt_tsub_of_add_lt_right : a + c < b → a < b - c
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem flip (p : BicartesianSq f g h i) : BicartesianSq g f i h
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulIndicator_le {s : Set α} {f g : α → M} (hfg : ∀ a ∈ s, f a ≤ g a) :
    mulIndicator s f ≤ g
-- Mathlib/Data/Real/ENatENNReal.lean
@[simp, norm_cast]
theorem toENNReal_lt : (m : ℝ≥0∞) < n ↔ m < n
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_const (α) [i : Nonempty α] : (∃ _ : α, b) ↔ b
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem hom_refl (C : G.ComponentCompl L) : C.hom (subset_refl L) = C
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem upperClosure_singleton (a : α) : upperClosure ({a} : Set α) = UpperSet.Ici a
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem map_smul [Module R₁ M₂] (f : M₁ →L[R₁] M₂) (c : R₁) (x : M₁) :
    f (c • x) = c • f x
-- Mathlib/Order/Bounds/Basic.lean
theorem image2_upperBounds_lowerBounds_subset_upperBounds_image2 :
    image2 f (upperBounds s) (lowerBounds t) ⊆ upperBounds (image2 f s t)
-- Mathlib/RingTheory/Localization/Basic.lean
@[simp]
theorem mk'_zero (s : M) : IsLocalization.mk' S 0 s = 0
-- Mathlib/LinearAlgebra/Span.lean
theorem sup_toAddSubmonoid : (p ⊔ p').toAddSubmonoid = p.toAddSubmonoid ⊔ p'.toAddSubmonoid
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem nextCoeffUp_of_constantCoeff_eq_zero (p : R[X]) (hp : coeff p 0 = 0) :
    nextCoeffUp p = p.coeff (p.natTrailingDegree + 1)
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem Filter.Tendsto.inseparable_iff_uniformity {l : Filter β} [NeBot l] {f g : β → α} {a b : α}
    (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) :
    Inseparable a b ↔ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem mem_insert (x y : ZFSet) : x ∈ insert x y
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_le_mul_of_nonneg [PosMulMono α] [MulPosMono α]
    (h₁ : a ≤ b) (h₂ : c ≤ d) (a0 : 0 ≤ a) (d0 : 0 ≤ d) : a * c ≤ b * d
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem contains (c) : ∀ {s}, ValidFor l m r s → (s.contains c ↔ c ∈ m)
-- Mathlib/RingTheory/PowerSeries/Basic.lean
/-- Two formal power series are equal if all their coefficients are equal. -/
@[ext]
theorem ext {φ ψ : R⟦X⟧} (h : ∀ n, coeff R n φ = coeff R n ψ) : φ = ψ
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- A submonoid of a monoid `M` is a subset containing 1 and closed under multiplication. -/
structure Submonoid (M : Type*) [MulOneClass M] extends Subsemigroup M where
  /-- A submonoid contains `1`. -/
  one_mem' : (1 : M) ∈ carrier
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Manifold.lean
theorem mdifferentiable_jacobiTheta : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (jacobiTheta ∘ (↑) : ℍ → ℂ)
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem destruct_nil : destruct (nil : Seq α) = none
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem coeFn_add (Q Q' : QuadraticMap R M N) : ⇑(Q + Q') = Q + Q'
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp]
theorem map_comp_obj' (f : X ⟶ Y) (g : Y ⟶ Z) (U) (p) :
    (map (f ≫ g)).obj ⟨U, p⟩ = (map f).obj ((map g).obj ⟨U, p⟩)
-- Mathlib/RingTheory/Ideal/Maps.lean
lemma coe_ker : RingHom.ker f = RingHom.ker (f : A →+* B)
-- Mathlib/RingTheory/ChainOfDivisors.lean
theorem multiplicity_prime_le_multiplicity_image_by_factor_orderIso {m p : Associates M}
    {n : Associates N} (hp : p ∈ normalizedFactors m) (d : Set.Iic m ≃o Set.Iic n) :
    multiplicity p m ≤ multiplicity (↑(d ⟨p, dvd_of_mem_normalizedFactors hp⟩)) n
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem sum_blocksFun : ∑ i, c.blocksFun i = n
-- Mathlib/Topology/Order/Basic.lean
theorem induced_topology_eq_preorder [Preorder α] [Preorder β] [TopologicalSpace β]
    [OrderTopology β] {f : α → β} (hf : ∀ {x y}, f x < f y ↔ x < y)
    (H₁ : ∀ {a b x}, b < f a → ¬(b < f x) → ∃ y, y < a ∧ b ≤ f y)
    (H₂ : ∀ {a b x}, f a < b → ¬(f x < b) → ∃ y, a < y ∧ f y ≤ b) :
    induced f ‹TopologicalSpace β› = Preorder.topology α
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem contDiff_arsinh {n : ℕ∞} : ContDiff ℝ n arsinh
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma shiftShortComplexFunctorIso_add'_hom_app
    (n m mn : ℤ) (hmn : m + n = mn) (a a' a'' : ℤ) (ha' : n + a = a') (ha'' : m + a' = a'')
    (K : CochainComplex C ℤ) :
    (shiftShortComplexFunctorIso C mn a a'' (by rw [← ha'', ← ha', ← add_assoc, hmn])).hom.app K =
      (shortComplexFunctor C (ComplexShape.up ℤ) a).map
        ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) m n mn hmn).hom.app K) ≫
        (shiftShortComplexFunctorIso C n a a' ha').hom.app (K⟦m⟧) ≫
        (shiftShortComplexFunctorIso C m a' a'' ha'' ).hom.app K
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- To prove an inequality between the lifts to a common universe of two different supremums,
it suffices to show that the lift of each cardinal from the smaller supremum
if bounded by the lift of some cardinal from the larger supremum.
-/
theorem lift_iSup_le_lift_iSup {ι : Type v} {ι' : Type v'} {f : ι → Cardinal.{w}}
    {f' : ι' → Cardinal.{w'}} (hf : BddAbove (range f)) (hf' : BddAbove (range f')) {g : ι → ι'}
    (h : ∀ i, lift.{w'} (f i) ≤ lift.{w} (f' (g i))) : lift.{w'} (iSup f) ≤ lift.{w} (iSup f')
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- If a family of sets `𝒜` is contained in an algebra of sets `ℬ`, then so is the algebra of sets
generated by `𝒜`. -/
theorem generateSetAlgebra_subset {ℬ : Set (Set α)} (h : 𝒜 ⊆ ℬ)
    (hℬ : IsSetAlgebra ℬ) : generateSetAlgebra 𝒜 ⊆ ℬ
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
lemma WEqualsLocallyBijective.transport : J.WEqualsLocallyBijective A
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
/-- `DilationEquiv.toEquiv` as a monoid homomorphism. -/
@[simps]
def toPerm : (X ≃ᵈ X) →* Equiv.Perm X
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
/-- This is the `iff` version of `Matrix.IsDiag.fromBlocks`. -/
theorem isDiag_fromBlocks_iff [Zero α] {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
    {D : Matrix n n α} : (A.fromBlocks B C D).IsDiag ↔ A.IsDiag ∧ B = 0 ∧ C = 0 ∧ D.IsDiag
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem rel_prod {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (· * ·) (· * ·)) :
    (Forall₂ R ⇒ R) prod prod
-- Mathlib/Data/Complex/Module.lean
lemma span_selfAdjoint : span ℂ (selfAdjoint A : Set A) = ⊤
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
theorem toLin'_symm_apply (A : SpecialLinearGroup n R) (v : n → R) :
    A.toLin'.symm v = Matrix.toLin' (↑ₘA⁻¹) v
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem comap_iInf {ι β} (f : α → β) (m : ι → OuterMeasure β) :
    comap f (⨅ i, m i) = ⨅ i, comap f (m i)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_zero_left : IsCoprime 0 x ↔ IsUnit x
-- Mathlib/Data/List/Basic.lean
theorem exists_mem_cons_iff (p : α → Prop) (a : α) (l : List α) :
    (∃ x ∈ a :: l, p x) ↔ p a ∨ ∃ x ∈ l, p x
-- Mathlib/Data/Matroid/Closure.lean
lemma Indep.mem_closure_iff (hI : M.Indep I) :
    x ∈ M.closure I ↔ M.Dep (insert x I) ∨ x ∈ I
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem spanningCoe_top : (⊤ : Subgraph G).spanningCoe = G
-- Mathlib/CategoryTheory/Galois/GaloisObjects.lean
@[simp]
lemma comp_autMap {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A) :
    f ≫ (autMap f σ).hom = σ.hom ≫ f
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simp, reassoc]
lemma comp_hom₂ {X Y Z : Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).hom₂ = f.hom₂ ≫ g.hom₂
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pairwise_replicate {α : Type _} {r : α → α → Prop} {x : α} (hx : r x x) :
    ∀ n : Nat, Pairwise r (List.replicate n x)
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem eq_neg_one_of_two_right [NoZeroDivisors R] {ζ : R} (h : IsPrimitiveRoot ζ 2) : ζ = -1
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem lcm_cons (a : α) (s : Multiset α) : (a ::ₘ s).lcm = GCDMonoid.lcm a s.lcm