ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₂_eq_zero_iff_epi₁ : T.mor₂ = 0 ↔ Epi T.mor₁
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
/-- Easy inclusion: a differentiability point with derivative in `K` belongs to `D f K`. -/
theorem differentiable_set_subset_D :
    { x | DifferentiableAt 𝕜 f x ∧ fderiv 𝕜 f x ∈ K } ⊆ D f K
-- Mathlib/NumberTheory/ClassNumber/FunctionField.lean
/-- The class number of a function field is `1` iff the ring of integers is a PID. -/
theorem classNumber_eq_one_iff :
    classNumber Fq F = 1 ↔ IsPrincipalIdealRing (ringOfIntegers Fq F)
-- Mathlib/Order/Filter/Ker.lean
@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem recDiagAux_zero_right {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m)
    (h : zero_left 0 = zero_right 0 := by first | assumption | trivial) :
    Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma singleObjCyclesSelfIso_inv_naturality :
    (singleObjCyclesSelfIso c j A).inv ≫ cyclesMap ((single C c j).map f) j =
      f ≫ (singleObjCyclesSelfIso c j B).inv
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_of_pair_subset {x y} (hxy : x ≠ y) (h : {x, y} ⊆ s) : s.Nontrivial
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem comap_comap (S : Subsemigroup P) (g : N →ₙ* P) (f : M →ₙ* N) :
    (S.comap g).comap f = S.comap (g.comp f)
-- Mathlib/Data/Complex/Basic.lean
theorem mem_reProdIm {z : ℂ} {s t : Set ℝ} : z ∈ s ×ℂ t ↔ z.re ∈ s ∧ z.im ∈ t
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem pointwise_smul_toAddSubmonoid (a : α) (S : AddSubgroup A) :
    (a • S).toAddSubmonoid = a • S.toAddSubmonoid
-- Mathlib/Algebra/Algebra/Bilinear.lean
@[simp]
theorem mulLeftRight_apply (a b x : A) : mulLeftRight R (a, b) x = a * x * b
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
@[simp]
theorem comp_id (f : Q₁ →qᵢ Q₂) : f.comp (id Q₁) = f
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- The image of a right invariant measure under a left action is right invariant, assuming that
the action preserves multiplication. -/
@[to_additive "The image of a right invariant measure under a left additive action is right
 invariant, assuming that the action preserves addition."]
theorem isMulRightInvariant_map_smul
    {α} [SMul α G] [SMulCommClass α Gᵐᵒᵖ G] [MeasurableSpace α] [MeasurableSMul α G]
    [IsMulRightInvariant μ] (a : α) :
    IsMulRightInvariant (map (a • · : G → G) μ)
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_Iio {a : ℝ} : volume (Iio a) = ∞
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
/-- The ordinal approximants of the least fixed point are stabilizing
  when reaching a fixed point of f -/
theorem lfpApprox_eq_of_mem_fixedPoints {a b : Ordinal} (h_init : x ≤ f x) (h_ab : a ≤ b)
    (h : lfpApprox f x a ∈ fixedPoints f) : lfpApprox f x b = lfpApprox f x a
-- Mathlib/Topology/Compactification/OnePoint.lean
lemma continuous_iff {Y : Type*} [TopologicalSpace Y] (f : OnePoint X → Y) : Continuous f ↔
    Tendsto (fun x : X ↦ f x) (coclosedCompact X) (𝓝 (f ∞)) ∧ Continuous (fun x : X ↦ f x)
-- Mathlib/Algebra/Vertex/HVertexOperator.lean
@[simp]
theorem compHahnSeries_add (u v : U) :
    compHahnSeries A B (u + v) = compHahnSeries A B u + compHahnSeries A B v
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_smul [SMulZeroClass S R] (s : S) (r : R) : (↑(s • r) : ℍ[R]) = s • (r : ℍ[R])
-- Mathlib/Data/Multiset/Basic.lean
theorem rel_eq {s t : Multiset α} : Rel (· = ·) s t ↔ s = t
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp]
theorem coeSucc_eq_succ {a : Fin n} : castSucc a + 1 = a.succ
-- Mathlib/Data/PNat/Prime.lean
@[simp]
theorem gcd_one {n : ℕ+} : gcd n 1 = 1
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem out' : ∀ {it}, ValidFor l r it → it = ⟨⟨l.reverse ++ r⟩, ⟨utf8Len l.reverse⟩⟩
-- Mathlib/Probability/Kernel/Basic.lean
theorem sum_add [Countable ι] (κ η : ι → Kernel α β) :
    (Kernel.sum fun n => κ n + η n) = Kernel.sum κ + Kernel.sum η
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
theorem gcd_mul_lcm (m n : Nat) : gcd m n * lcm m n = m * n
-- Mathlib/Data/Ordmap/Ordset.lean
@[simp]
theorem toList_nil : toList (@nil α) = []
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma p_opcyclesMap : S₁.pOpcycles ≫ opcyclesMap φ = φ.τ₂ ≫ S₂.pOpcycles
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive (attr := aesop safe -100 (rule_sets := [Continuous]), fun_prop)]
theorem Continuous.pow {f : X → M} (h : Continuous f) (n : ℕ) : Continuous fun b => f b ^ n
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive sub.instNeBot]
lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g)
-- Mathlib/Data/Num/Lemmas.lean
theorem ofInt'_toZNum : ∀ n : ℕ, toZNum n = ZNum.ofInt' n
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem ContinuousLinearMap.reApplyInnerSelf_apply (T : E →L[𝕜] E) (x : E) :
    T.reApplyInnerSelf x = re ⟪T x, x⟫
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- The normal closure of `s` is the smallest normal subgroup containing `s`. -/
theorem normalClosure_le_normal {N : Subgroup G} [N.Normal] (h : s ⊆ N) : normalClosure s ≤ N
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem conj_I : conj I = -I
-- Mathlib/CategoryTheory/Localization/StructuredArrow.lean
/-- The bijection `StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L'`
when `L` and `L'` are two localization functors for the same class of morphisms. -/
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L'
-- Mathlib/Combinatorics/Colex.lean
/-- If `s ⊆ t`, then `s ≤ t` in the colex order. Note the converse does not hold, as inclusion does
not form a linear order. -/
lemma toColex_le_toColex_of_subset (h : s ⊆ t) : toColex s ≤ toColex t
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- If a multilinear map in finitely many variables on normed spaces is continuous, then it
satisfies the inequality `‖f m‖ ≤ C * ∏ i, ‖m i‖`, for some `C` which can be chosen to be
positive. -/
theorem exists_bound_of_continuous (hf : Continuous f) :
    ∃ C : ℝ, 0 < C ∧ ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma mem_posFittingCompOf (x : L) (m : M) :
    m ∈ posFittingCompOf R M x ↔ ∀ (k : ℕ), ∃ n, (toEnd R L M x ^ k) n = m
-- Mathlib/Data/List/Cycle.lean
/-- An induction principle for `Cycle`. Use as `induction s`. -/
@[elab_as_elim, induction_eliminator]
theorem induction_on {C : Cycle α → Prop} (s : Cycle α) (H0 : C nil)
    (HI : ∀ (a) (l : List α), C ↑l → C ↑(a :: l)) : C s
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp] lemma induce_singleton_eq_top (v : V) : G.induce {v} = ⊤
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableWithinAt.add_const (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y + c) s x
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem toLinearEquiv_injective :
    Function.Injective (toLinearEquiv : (M₁ ≃SL[σ₁₂] M₂) → M₁ ≃ₛₗ[σ₁₂] M₂)
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
/-- `gramSchmidt` produces a triangular matrix of vectors when given a basis. -/
theorem gramSchmidt_triangular {i j : ι} (hij : i < j) (b : Basis ι 𝕜 E) :
    b.repr (gramSchmidt 𝕜 b i) j = 0
-- Mathlib/Order/Interval/Finset/Basic.lean
/-- `Finset.cons` version of `Finset.Ioc_insert_left`. -/
theorem Icc_eq_cons_Ioc (h : a ≤ b) : Icc a b = (Ioc a b).cons a left_not_mem_Ioc
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma sups_singleton : s ⊻ {b} = s.image (· ⊔ b)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_some {x y : F} (h : (W.baseChange F).toAffine.Nonsingular x y) :
    map W f (some h) = some ((W.baseChange_nonsingular f.injective ..).mpr h)
-- Mathlib/Analysis/MeanInequalities.lean
theorem Lp_add_le_tsum_of_nonneg' (hp : 1 ≤ p) (hf : ∀ i, 0 ≤ f i) (hg : ∀ i, 0 ≤ g i)
    (hf_sum : Summable fun i => f i ^ p) (hg_sum : Summable fun i => g i ^ p) :
    (∑' i, (f i + g i) ^ p) ^ (1 / p) ≤ (∑' i, f i ^ p) ^ (1 / p) + (∑' i, g i ^ p) ^ (1 / p)
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem comp_ite {P : Prop} [Decidable P] {X Y Z : C} (f : X ⟶ Y) (g g' : Y ⟶ Z) :
    (f ≫ if P then g else g') = if P then f ≫ g else f ≫ g'
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isRelPrime_mul_unit_left_right : IsRelPrime y (x * z) ↔ IsRelPrime y z
-- Mathlib/CategoryTheory/Limits/ConcreteCategory.lean
theorem colimit_exists_rep [HasColimit F] (x : ↑(colimit F)) :
    ∃ (j : J) (y : F.obj j), colimit.ι F j y = x
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- If `C` is filtered, then we can give an explicit condition for a functor `F : C ⥤ D` to
    be final. The converse is also true, see `final_iff_of_isFiltered`. -/
theorem Functor.final_of_exists_of_isFiltered [IsFilteredOrEmpty C]
    (h₁ : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ : ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
      ∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t) : Functor.Final F
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem eq_zero_or_eq_sub_one_add_one : ∀ {n}, n = 0 ∨ n = n - 1 + 1
-- .lake/packages/lean4/src/lean/Init/Control/Except.lean
@[simp] theorem map_id : Except.map (ε := ε) (α := α) (β := α) id = id
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffOn.contMDiffAt (h : ContMDiffOn I I' n f s) (hx : s ∈ 𝓝 x) :
    ContMDiffAt I I' n f x
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
theorem map_monotone (f : V ↪ W) : Monotone (SimpleGraph.map f)
-- Mathlib/Probability/Independence/Basic.lean
@[to_additive]
lemma iIndepFun.indepFun_mul_mul (hf_indep : iIndepFun (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    IndepFun (f i * f j) (f k * f l) μ
-- Mathlib/FieldTheory/Normal.lean
theorem Normal.splits (_ : Normal F K) (x : K) : Splits (algebraMap F K) (minpoly F x)
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- `seminormFromConst_seq c f x` is antitone. -/
theorem seminormFromConst_seq_antitone (x : R) : Antitone (seminormFromConst_seq c f x)
-- Mathlib/Algebra/Ring/Ext.lean
@[ext] theorem AddGroupWithOne.ext ⦃inst₁ inst₂ : AddGroupWithOne R⦄
    (h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
    (h_one : (letI := inst₁; One.one : R) = (letI := inst₂; One.one)) :
    inst₁ = inst₂
-- Mathlib/Probability/Independence/Conditional.lean
theorem condIndep_iSup_of_antitone [SemilatticeInf ι] {m : ι → MeasurableSpace Ω}
    (h_indep : ∀ i, CondIndep m' (m i) m₁ hm' μ) (h_le : ∀ i, m i ≤ mΩ) (h_le' : m₁ ≤ mΩ)
    (hm : Antitone m) :
    CondIndep m' (⨆ i, m i) m₁ hm' μ
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem coprime_iff_isRelPrime {m n : ℕ} : m.Coprime n ↔ IsRelPrime m n
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_iff_isIso_leftHomologyMap' (φ : S₁ ⟶ S₂)
    (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) :
    QuasiIso φ ↔ IsIso (leftHomologyMap' φ h₁ h₂)
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
theorem IsSymmetric.add {T S : E →ₗ[𝕜] E} (hT : T.IsSymmetric) (hS : S.IsSymmetric) :
    (T + S).IsSymmetric
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
/-- Typeclass for an extension being an algebraic closure. -/
class IsAlgClosure (R : Type u) (K : Type v) [CommRing R] [Field K] [Algebra R K]
    [NoZeroSMulDivisors R K] : Prop where
  alg_closed : IsAlgClosed K
  algebraic : Algebra.IsAlgebraic R K
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem characteristic_iff_map_le : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.map ϕ.toMonoidHom ≤ H
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem withTopCongr_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) :
    e₁.withTopCongr.trans e₂.withTopCongr = (e₁.trans e₂).withTopCongr
-- Mathlib/Logic/Equiv/List.lean
@[simp, nolint unusedHavesSuffices] -- Porting note: false positive
theorem decode_list_succ (v : ℕ) :
    decode (α := List α) (succ v) =
      (· :: ·) <$> decode (α := α) v.unpair.1 <*> decode (α := List α) v.unpair.2
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
@[simp]
theorem tensorTensorTensorComm_symm_tmul (m : M) (n : N) (p : P) (q : Q) :
    (tensorTensorTensorComm R A M N P Q).symm ((m ⊗ₜ p) ⊗ₜ (n ⊗ₜ q)) = (m ⊗ₜ n) ⊗ₜ (p ⊗ₜ q)
-- Mathlib/Data/Matroid/Closure.lean
lemma subset_closure_of_subset' (M : Matroid α) (hXY : X ⊆ Y) (hX : X ⊆ M.E := by aesop_mat) :
    X ⊆ M.closure Y
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem disjoint_add_right {s t u : Multiset α} :
    Disjoint s (t + u) ↔ Disjoint s t ∧ Disjoint s u
-- Mathlib/CategoryTheory/Monoidal/Limits.lean
@[simp]
theorem limLax_map {F G : J ⥤ C} (α : F ⟶ G) : limLax.map α = lim.map α
-- Mathlib/Data/PNat/Basic.lean
theorem mod_le (m k : ℕ+) : mod m k ≤ m ∧ mod m k ≤ k
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem sym_sub [Sub α] (a b : α) : sym (a - b) = sym a - sym b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_pos_of_pos_of_lt_pi_div_two {x : ℝ} (h0x : 0 < x) (hxp : x < π / 2) : 0 < tan x
-- Mathlib/GroupTheory/Perm/Fin.lean
theorem coe_cycleRange_of_le {n : ℕ} {i j : Fin n.succ} (h : j ≤ i) :
    (cycleRange i j : ℕ) = if j = i then 0 else (j : ℕ) + 1
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem dual_comp (g : SupBotHom β γ) (f : SupBotHom α β) :
    SupBotHom.dual (g.comp f) = (SupBotHom.dual g).comp (SupBotHom.dual f)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c
-- Mathlib/Data/Setoid/Partition.lean
/-- Equivalence classes partition the type. -/
theorem classes_eqv_classes {r : Setoid α} (a) : ∃! b ∈ r.classes, a ∈ b
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
lemma map_comp_zpow [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G)
    (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n
-- Mathlib/Topology/Homotopy/Contractible.lean
theorem nullhomotopic_of_constant (y : Y) : Nullhomotopic (ContinuousMap.const X y)
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean
@[simp]
theorem PreservesCokernel.iso_inv : (PreservesCokernel.iso G f).inv = cokernelComparison f G
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem neg_coeff (x : 𝕎 R) (n : ℕ) : (-x).coeff n = peval (wittNeg p n) ![x.coeff]
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_conj (x : ℂ) : arg (conj x) = if arg x = π then π else -arg x
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- A family `𝓕 : ι → X → α` is equicontinuous on `S` iff `range 𝓕` is equicontinuous on `S`,
i.e the family `(↑) : range F → X → α` is equicontinuous on `S`. -/
theorem equicontinuousOn_iff_range {F : ι → X → α} {S : Set X} :
    EquicontinuousOn F S ↔ EquicontinuousOn ((↑) : range F → X → α) S
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem zero_equiv_neg_iff {x : PGame} : (0 ≈ -x) ↔ (0 ≈ x)
-- Mathlib/Data/Set/Basic.lean
theorem nmem_setOf_iff {a : α} {p : α → Prop} : a ∉ { x | p x } ↔ ¬p a
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
/-- An upper estimate on the complex distance between two points in terms of the hyperbolic distance
and the imaginary part of one of the points. -/
theorem le_dist_coe (z w : ℍ) : w.im * (1 - Real.exp (-dist z w)) ≤ dist (z : ℂ) w
-- Mathlib/LinearAlgebra/Ray.lean
/-- The ray of `someVector`. -/
@[simp]
theorem someVector_ray (x : Module.Ray R M) : rayOfNeZero R _ x.someVector_ne_zero = x
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem dist_fixedPoint_le (x) : dist x (fixedPoint f hf) ≤ dist x (f x) / (1 - K)
-- Mathlib/Algebra/Field/Subfield.lean
protected theorem intCast_mem (n : ℤ) : (n : K) ∈ s
-- Mathlib/Logic/Pairwise.lean
theorem _root_.Reflexive.set_pairwise_iff (hr : Reflexive r) :
    s.Pairwise r ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → r a b
-- Mathlib/Data/Int/Lemmas.lean
theorem natAbs_eq_iff_sq_eq {a b : ℤ} : a.natAbs = b.natAbs ↔ a ^ 2 = b ^ 2
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
theorem Complex.exp_eq_exp_ℂ : Complex.exp = NormedSpace.exp ℂ
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- The order of a formal power series is at least `n` if
the `i`th coefficient is `0` for all `i < n`. -/
theorem le_order (φ : R⟦X⟧) (n : PartENat) (h : ∀ i : ℕ, ↑i < n → coeff R i φ = 0) :
    n ≤ order φ
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
/-- If `P` is separated, then `P⁺` is a sheaf. -/
theorem isSheaf_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y) :
    Presheaf.IsSheaf J (J.plusObj P)
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
lemma optionEquivRight_X_none : optionEquivRight R S₁ (X none) = C Polynomial.X
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
protected theorem smul {α} [Monoid α] [DistribMulAction α R] [SMulCommClass R α R] (a : α)
    {B : BilinForm R M} (hB : B.IsAlt) : (a • B).IsAlt
-- Mathlib/Order/Lattice.lean
@[simp]
theorem mk_sup_mk [Sup α] [Sup β] (a₁ a₂ : α) (b₁ b₂ : β) :
    (a₁, b₁) ⊔ (a₂, b₂) = (a₁ ⊔ a₂, b₁ ⊔ b₂)
-- Mathlib/Data/Nat/Find.lean
lemma find_eq_iff (h : ∃ n : ℕ, p n) : Nat.find h = m ↔ p m ∧ ∀ n < m, ¬ p n
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
    ⨆ n, m n = generateFrom { s | ∃ n, MeasurableSet[m n] s }
-- Mathlib/MeasureTheory/Function/AEMeasurableOrder.lean
/-- If a function `f : α → ℝ≥0∞` is such that the level sets `{f < p}` and `{q < f}` have measurable
supersets which are disjoint up to measure zero when `p` and `q` are finite numbers satisfying
`p < q`, then `f` is almost-everywhere measurable. -/
theorem ENNReal.aemeasurable_of_exist_almost_disjoint_supersets {α : Type*} {m : MeasurableSpace α}
    (μ : Measure α) (f : α → ℝ≥0∞)
    (h : ∀ (p : ℝ≥0) (q : ℝ≥0), p < q →
      ∃ u v, MeasurableSet u ∧ MeasurableSet v ∧
        { x | f x < p } ⊆ u ∧ { x | (q : ℝ≥0∞) < f x } ⊆ v ∧ μ (u ∩ v) = 0) :
    AEMeasurable f μ
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffAt.smoothAt (h : ContMDiffAt I I' ⊤ f x) : SmoothAt I I' f x
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem Red.reduce_left (h : Red L₁ L₂) : Red L₂ (reduce L₁)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- If `K` is complete, any `v` in `E` can be expressed as a sum of elements of `K` and `Kᗮ`. -/
theorem Submodule.exists_add_mem_mem_orthogonal [HasOrthogonalProjection K] (v : E) :
    ∃ y ∈ K, ∃ z ∈ Kᗮ, v = y + z
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem cosh_abs : cosh |x| = cosh x
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- Any continuous ring homomorphism commutes with `NormedSpace.exp`. -/
theorem map_exp {F} [FunLike F 𝔸 𝔹] [RingHomClass F 𝔸 𝔹] (f : F) (hf : Continuous f) (x : 𝔸) :
    f (exp 𝕂 x) = exp 𝕂 (f x)
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem mem_support_nil_iff {u v : V} : u ∈ (nil : G.Walk v v).support ↔ u = v
-- Mathlib/Data/Set/Basic.lean
theorem mem_insert_of_mem {x : α} {s : Set α} (y : α) : x ∈ s → x ∈ insert y s
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem squarefree_iff_no_irreducibles {x : R} (hx₀ : x ≠ 0) :
    Squarefree x ↔ ∀ p, Irreducible p → ¬ (p * p ∣ x)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem deriv_id : deriv id x = 1
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem union_symm_apply_right {α} {s t : Set α} [DecidablePred fun x => x ∈ s] (H : s ∩ t ⊆ ∅)
    (a : t) : (Equiv.Set.union H).symm (Sum.inr a) = ⟨a, by simp⟩
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
@[simp]
theorem zeroth_den_eq_one : g.dens 0 = 1
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- A version of `WithTop.coe_sSup'` with a more convenient but less general statement. -/
@[norm_cast]
theorem coe_sSup {s : Set α} (hb : BddAbove s) : ↑(sSup s) = (⨆ a ∈ s, ↑a : WithTop α)
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousWithinAt_sum {f : ι → α → γ} {a : Finset ι}
    (ha : ∀ i ∈ a, UpperSemicontinuousWithinAt (f i) s x) :
    UpperSemicontinuousWithinAt (fun z => ∑ i ∈ a, f i z) s x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem normalizedFactors_prod {a : α} (ane0 : a ≠ 0) :
    Associated (normalizedFactors a).prod a
-- Mathlib/Data/Rel.lean
theorem inter_dom_subset_preimage_image (s : Set α) : s ∩ r.dom ⊆ r.preimage (r.image s)
-- Mathlib/Analysis/InnerProductSpace/Positive.lean
theorem IsPositive.inner_nonneg_left {T : E →L[𝕜] E} (hT : IsPositive T) (x : E) :
    0 ≤ re ⟪T x, x⟫
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem rightInvSeq_drop (ω : List B) (j : ℕ) :
    ris (ω.drop j) = (ris ω).drop j
-- Mathlib/Probability/Kernel/Basic.lean
lemma IsFiniteKernel.integrable (μ : Measure α) [IsFiniteMeasure μ]
    (κ : Kernel α β) [IsFiniteKernel κ] {s : Set β} (hs : MeasurableSet s) :
    Integrable (fun x => (κ x s).toReal) μ
-- Mathlib/NumberTheory/Modular.lean
/-- If `|z| < 1`, then applying `S` strictly decreases `im`. -/
theorem im_lt_im_S_smul (h : normSq z < 1) : z.im < (S • z).im
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem zeroLocus_vanishingIdeal_le (V : Set (σ → k)) : V ≤ zeroLocus (vanishingIdeal V)
-- Mathlib/RingTheory/Support.lean
lemma Module.mem_support_iff_of_finite [Module.Finite R M] :
    p ∈ Module.support R M ↔ Module.annihilator R M ≤ p.asIdeal
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Two maps from a coequalizer are equal if they are equal when composed with the coequalizer
    map -/
@[ext]
theorem coequalizer.hom_ext {W : C} {k l : coequalizer f g ⟶ W}
    (h : coequalizer.π f g ≫ k = coequalizer.π f g ≫ l) : k = l
-- Mathlib/Topology/Instances/ENNReal.lean
theorem add_iSup {ι : Sort*} {s : ι → ℝ≥0∞} [Nonempty ι] : a + iSup s = ⨆ b, a + s b
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_ne_top : a ≠ ∞ → b ≠ ∞ → a * b ≠ ∞
-- Mathlib/Dynamics/Flow.lean
/-- If `τ` is a `CanonicallyOrderedAddCommMonoid` (e.g., `ℕ` or `ℝ≥0`), then the notions
`IsFwInvariant` and `IsInvariant` are equivalent. -/
theorem isFwInvariant_iff_isInvariant [CanonicallyOrderedAddCommMonoid τ] {ϕ : τ → α → α}
    {s : Set α} :
    IsFwInvariant ϕ s ↔ IsInvariant ϕ s
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem one_lt_card {o} : 1 < card o ↔ 1 < o
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem cancel_right {g₁ g₂ : sInfHom β γ} {f : sInfHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
/-- The clifford algebra over `CliffordAlgebraQuaternion.Q c₁ c₂` is isomorphic as an `R`-algebra
to `ℍ[R,c₁,c₂]`. -/
@[simps!]
protected def equiv : CliffordAlgebra (Q c₁ c₂) ≃ₐ[R] ℍ[R,c₁,c₂]
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem lequivCongrLeft_apply (h : ι ≃ κ) (f : ⨁ i, M i) (k : κ) :
    lequivCongrLeft R h f k = f (h.symm k)
-- Mathlib/Order/Compare.lean
theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y'
-- Mathlib/Order/CompactlyGenerated/Basic.lean
protected theorem Directed.iSup_inf_eq (h : Directed (· ≤ ·) f) :
    (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a
-- Mathlib/RingTheory/TensorProduct/Basic.lean
lemma _root_.Basis.baseChange_linearMap (b : Basis ι R M) (b' : Basis ι' R N) (ij : ι × ι') :
    baseChange A (b'.linearMap b ij) = (basis A b').linearMap (basis A b) ij
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem agree_children {n : ℕ} (x : CofixA F (succ n)) (y : CofixA F (succ n + 1)) {i j}
    (h₀ : HEq i j) (h₁ : Agree x y) : Agree (children' x i) (children' y j)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/SOM.lean
theorem Mon.mul_denote (ctx : Context) (m₁ m₂ : Mon) : (m₁.mul m₂).denote ctx = m₁.denote ctx * m₂.denote ctx
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem not_isFiniteMeasure_iff : ¬IsFiniteMeasure μ ↔ μ Set.univ = ∞
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem add_sub_add_cancel (a b c : Ordinal) : a + b - (a + c) = b - c