ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Category/Ring/Colimits.lean
@[simp]
theorem quot_mul (x y) :
    (by exact Quot.mk Setoid.r (mul x y) : ColimitType F) =
      (by exact Quot.mk _ x) * (by exact Quot.mk _ y)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Not.intro {a : Prop} (h : a → False) : ¬a
-- Mathlib/Topology/Order/Basic.lean
theorem order_separated [OrderTopology α] {a₁ a₂ : α} (h : a₁ < a₂) :
    ∃ u v : Set α, IsOpen u ∧ IsOpen v ∧ a₁ ∈ u ∧ a₂ ∈ v ∧ ∀ b₁ ∈ u, ∀ b₂ ∈ v, b₁ < b₂
-- Mathlib/Logic/IsEmpty.lean
theorem isEmpty_fun : IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
theorem op_iSup (S : ι → Subalgebra R A) : (iSup S).op = ⨆ i, (S i).op
-- Mathlib/Data/Multiset/Interval.lean
theorem card_Icc :
    (Finset.Icc s t).card = ∏ i ∈ s.toFinset ∪ t.toFinset, (t.count i + 1 - s.count i)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem lift_includeLeft_includeRight :
    lift includeLeft includeRight (fun a b => (Commute.one_right _).tmul (Commute.one_left _)) =
      .id S (A ⊗[R] B)
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma finite_weightSpaceOf_ne_bot [NoZeroSMulDivisors R M] [IsNoetherian R M] (x : L) :
    {χ : R | weightSpaceOf M χ x ≠ ⊥}.Finite
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem tan_two_mul {x : ℝ} : tan (2 * x) = 2 * tan x / (1 - tan x ^ 2)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem sub_apply (Q Q' : QuadraticMap R M N) (x : M) : (Q - Q') x = Q x - Q' x
-- Mathlib/Data/List/Perm.lean
theorem nodup_permutations (s : List α) (hs : Nodup s) : Nodup s.permutations
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
lemma Triangle.eqToHom_hom₂ {A B : Triangle C} (h : A = B) :
    (eqToHom h).hom₂ = eqToHom (by subst h; rfl)
-- Mathlib/Algebra/Module/Basic.lean
lemma indicator_smul_const (s : Set α) (r : α → R) (m : M) :
    indicator s (r · • m) = (indicator s r · • m)
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
@[fun_prop]
protected theorem DifferentiableAt.iterate {f : E → E} (hf : DifferentiableAt 𝕜 f x) (hx : f x = x)
    (n : ℕ) : DifferentiableAt 𝕜 f^[n] x
-- Mathlib/Algebra/Group/Units.lean
@[simp]
theorem divp_one (a : α) : a /ₚ 1 = a
-- Mathlib/MeasureTheory/Group/MeasurableEquiv.lean
theorem _root_.measurableEmbedding_mulRight₀ {g : G₀} (hg : g ≠ 0) :
    MeasurableEmbedding fun x => x * g
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.tmul (x : A) {y : B} (h : IsIntegral R y) : IsIntegral A (x ⊗ₜ[R] y)
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
lemma isIntegralCurveOn_comp_add {dt : ℝ} :
    IsIntegralCurveOn γ v s ↔ IsIntegralCurveOn (γ ∘ (· + dt)) v { t | t + dt ∈ s }
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
theorem mul_left_mem_nonZeroDivisors_eq_zero_iff {r x : M₁} (hr : r ∈ M₁⁰) : r * x = 0 ↔ x = 0
-- Mathlib/Data/Nat/Count.lean
@[simp] theorem count_false (n : ℕ) : count (fun _ ↦ False) n = 0
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
@[elab_as_elim]
theorem right_induction {P : CliffordAlgebra Q → Prop} (algebraMap : ∀ r : R, P (algebraMap _ _ r))
    (add : ∀ x y, P x → P y → P (x + y)) (mul_ι : ∀ m x, P x → P (x * ι Q m)) : ∀ x, P x
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem coe_lcm (i j : ℤ) : ↑(Int.lcm i j) = GCDMonoid.lcm i j
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem map_zero [Nonempty ι] : f 0 = 0
-- Mathlib/Algebra/Order/Ring/Pow.lean
/-- **Bernoulli's inequality** reformulated to estimate `a^n`. -/
lemma one_add_mul_sub_le_pow (H : -1 ≤ a) (n : ℕ) : 1 + n * (a - 1) ≤ a ^ n
-- Mathlib/Order/WellFounded.lean
protected theorem isIrrefl (h : WellFounded r) : IsIrrefl α r
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma leftHomologyIso_inv_naturality :
    S₁.leftHomologyIso.inv ≫ leftHomologyMap φ =
      homologyMap φ ≫ S₂.leftHomologyIso.inv
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Measurable.inf' (hf : Measurable f) (hg : Measurable g) : Measurable (f ⊓ g)
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
theorem infDist_smul₀ {c : 𝕜} (hc : c ≠ 0) (s : Set E) (x : E) :
    Metric.infDist (c • x) (c • s) = ‖c‖ * Metric.infDist x s
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_biUnion {ι : Type*} {I : Set ι} (hI : I.Finite) {s : ι → Set E} :
    IsVonNBounded 𝕜 (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, IsVonNBounded 𝕜 (s i)
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem sum_pow_char_pow {ι : Type*} (s : Finset ι) (f : ι → R) :
    (∑ i ∈ s, f i) ^ p ^ n = ∑ i ∈ s, f i ^ p ^ n
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive addIndex_empty]
theorem index_empty {V : Set G} : index ∅ V = 0
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem head_val' (B : Fin m.succ → n' → α) (j : n') : (vecHead fun i => B i j) = vecHead B j
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
theorem aemeasurable_const_smul_iff₀ {c : G₀} (hc : c ≠ 0) :
    AEMeasurable (fun x => c • f x) μ ↔ AEMeasurable f μ
-- Mathlib/Analysis/Convex/Basic.lean
theorem AntitoneOn.convex_le (hf : AntitoneOn f s) (hs : Convex 𝕜 s) (r : β) :
    Convex 𝕜 ({ x ∈ s | f x ≤ r })
-- Mathlib/SetTheory/Lists.lean
theorem subset_def {l₁ l₂ : Lists' α true} : l₁ ⊆ l₂ ↔ ∀ a ∈ l₁.toList, a ∈ l₂
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem single_multiset_sum [AddCommMonoid M] (s : Multiset M) (a : α) :
    single a s.sum = (s.map (single a)).sum
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem trans_refl (e : P₁ ≃ᵃ[k] P₂) : e.trans (refl k P₂) = e
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm of `1` is `1`. -/
-- @[simp] -- Porting note (#10618): simp can prove this
protected theorem one : padicNorm p 1 = 1
-- Mathlib/Order/Antisymmetrization.lean
@[simp]
theorem ofAntisymmetrization_le_ofAntisymmetrization_iff {a b : Antisymmetrization α (· ≤ ·)} :
    ofAntisymmetrization (· ≤ ·) a ≤ ofAntisymmetrization (· ≤ ·) b ↔ a ≤ b
-- Mathlib/CategoryTheory/Abelian/RightDerived.lean
@[simp]
theorem NatTrans.rightDerived_id (F : C ⥤ D) [F.Additive] (n : ℕ) :
    NatTrans.rightDerived (𝟙 F) n = 𝟙 (F.rightDerived n)
-- Mathlib/SetTheory/Game/PGame.lean
@[symm]
protected theorem Equiv.symm {x y : PGame} : (x ≈ y) → (y ≈ x)
-- Mathlib/Data/Sum/Order.lean
/-- `Equiv.sumComm` promoted to an order isomorphism. -/
@[simps! apply]
def sumComm (α β : Type*) [LE α] [LE β] : α ⊕ β ≃o β ⊕ α
-- Mathlib/Analysis/Complex/Basic.lean
theorem nndist_of_im_eq {z w : ℂ} (h : z.im = w.im) : nndist z w = nndist z.re w.re
-- Mathlib/Topology/ContinuousOn.lean
theorem Embedding.continuousOn_iff {f : α → β} {g : β → γ} (hg : Embedding g) {s : Set α} :
    ContinuousOn f s ↔ ContinuousOn (g ∘ f) s
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem map_comp_ofLE (cond : LEComap f A B) (h : A' ≤ A) :
    map f cond ∘ ofLE h = map f (cond.mono h le_rfl)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem aleph0_le_lift {c : Cardinal.{u}} : ℵ₀ ≤ lift.{v} c ↔ ℵ₀ ≤ c
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.algebraMap_intNorm (x : B) :
    algebraMap A K (Algebra.intNorm A B x) = Algebra.norm K (algebraMap B L x)
-- Mathlib/FieldTheory/PrimitiveElement.lean
theorem primitive_element_iff_algHom_eq_of_eval (α : E)
    (φ : E →ₐ[F] A) : F⟮α⟯ = ⊤ ↔ ∀ ψ : E →ₐ[F] A, φ α = ψ α → φ = ψ
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableWithinAt.mul_const (ha : DifferentiableWithinAt 𝕜 a s x) (b : 𝔸) :
    DifferentiableWithinAt 𝕜 (fun y => a y * b) s x
-- Mathlib/Order/BooleanAlgebra.lean
theorem sup_eq_sdiff_sup_sdiff_sup_inf : x ⊔ y = x \ y ⊔ y \ x ⊔ x ⊓ y
-- Mathlib/Order/Interval/Set/OrderIso.lean
@[simp]
theorem preimage_Ioo (e : α ≃o β) (a b : β) : e ⁻¹' Ioo a b = Ioo (e.symm a) (e.symm b)
-- Mathlib/Analysis/ODE/Gronwall.lean
/-- There exists only one solution of an ODE \(\dot x=v(t, x)\) with
a given initial value provided that the RHS is Lipschitz continuous in `x`. -/
theorem ODE_solution_unique
    (hv : ∀ t, LipschitzWith K (v t))
    (hf : ContinuousOn f (Icc a b))
    (hf' : ∀ t ∈ Ico a b, HasDerivWithinAt f (v t (f t)) (Ici t) t)
    (hg : ContinuousOn g (Icc a b))
    (hg' : ∀ t ∈ Ico a b, HasDerivWithinAt g (v t (g t)) (Ici t) t)
    (ha : f a = g a) :
    EqOn f g (Icc a b)
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
@[simp]
lemma mk_comp_mkInv [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W Y X]
    [HasSmallLocalizedHom.{w} W Y Y] (f : Y ⟶ X) (hf : W f) :
    (mk W f).comp (mkInv f hf) = mk W (𝟙 Y)
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc (attr := simp)]
theorem Cofork.IsColimit.π_desc {s t : Cofork f g} (hs : IsColimit s) : s.π ≫ hs.desc t = t.π
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_ker_iff {c d : C} (f : c ⟶ d) :
    f ∈ (ker φ).arrows c d ↔ ∃ h : φ.obj c = φ.obj d, φ.map f = eqToHom h
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma map₁_snd {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (p : YonedaCollection F X) : (YonedaCollection.map₁ η p).snd =
      G.map (eqToHom (by rw [YonedaCollection.map₁_fst])) (η.app _ p.snd)
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem hom_f_injective {C₁ C₂ : HomologicalComplex V c} :
    Function.Injective fun f : Hom C₁ C₂ => f.f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem not_mem_nil (a : α) : ¬ a ∈ #[]
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Iic_eq : Iic a = (Iic (a : α)).subtype p
-- Mathlib/CategoryTheory/Sites/Plus.lean
/-- A helper definition used to define the morphisms for `plus`. -/
@[simps]
def diagramPullback {X Y : C} (f : X ⟶ Y) : J.diagram P Y ⟶ (J.pullback f).op ⋙ J.diagram P X
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem mapsTo_iUnion {s : ι → Set α} {t : Set β} {f : α → β} :
    MapsTo f (⋃ i, s i) t ↔ ∀ i, MapsTo f (s i) t
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem lintegral_coeFn (f : α →ₘ[μ] ℝ≥0∞) : ∫⁻ a, f a ∂μ = f.lintegral
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem sub_apply (f g : CuspForm Γ k) (z : ℍ) : (f - g) z = f z - g z
-- Mathlib/RingTheory/LocalRing/RingHom/Basic.lean
/--
The image of the maximal ideal of the source is contained within the maximal ideal of the target.
-/
theorem map_nonunit (f : R →+* S) [IsLocalRingHom f] (a : R) (h : a ∈ maximalIdeal R) :
    f a ∈ maximalIdeal S
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem opNorm_neg : ‖-f‖ = ‖f‖
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma polyCharpoly_coeff_eq_zero_of_basis (b : Basis ι R L) (b' : Basis ι' R L) (k : ℕ)
    (H : (polyCharpoly φ b).coeff k = 0) :
    (polyCharpoly φ b').coeff k = 0
-- Mathlib/Algebra/Lie/Normalizer.lean
theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_sub_eq_sub (a b c : α) : toIocMod hp a (b - c) = toIocMod hp (a + c) b - c
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_rightUnitor_hom_fst (X : C₁ × C₂) :
    ((ρ_ X).hom : X ⊗ 𝟙_ _ ⟶ X).1 = (ρ_ X.1).hom
-- Mathlib/Algebra/AddTorsor.lean
/-- Adding a group element to a point, then subtracting another point,
produces the same result as subtracting the points then adding the
group element. -/
theorem vadd_vsub_assoc (g : G) (p₁ p₂ : P) : g +ᵥ p₁ -ᵥ p₂ = g + (p₁ -ᵥ p₂)
-- Mathlib/ModelTheory/DirectLimit.lean
@[simp]
theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
    (natLERec f' m n h : G' m → G' n) = Nat.leRecOn h (@fun k => f' k)
-- Mathlib/Algebra/Polynomial/Roots.lean
lemma mem_roots_iff_aeval_eq_zero {x : R} (w : p ≠ 0) : x ∈ roots p ↔ aeval x p = 0
-- Mathlib/Algebra/Lie/Abelian.lean
@[norm_cast, simp]
theorem coe_maxTrivHom_apply (f : M →ₗ⁅R,L⁆ N) (m : maxTrivSubmodule R L M) :
    (maxTrivHom f m : N) = f m
-- Mathlib/Algebra/Module/LocalizedModule.lean
private theorem zero_add' (x : LocalizedModule S M) : 0 + x = x
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
lemma r_eq_some {i : ι} {i' : ι'} (hi : e.f i = i') :
    e.r i' = some i
-- Mathlib/Data/List/Sigma.lean
theorem mem_dlookup_iff {a : α} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys) :
    b ∈ dlookup a l ↔ Sigma.mk a b ∈ l
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem coe_coe [AddGroupWithOne R] {f : ArithmeticFunction ℕ} :
    ((f : ArithmeticFunction ℤ) : ArithmeticFunction R) = (f : ArithmeticFunction R)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.restrict (s : Set α) {f : α → E} (hf : Memℒp f p μ) : Memℒp f p (μ.restrict s)
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem add_comm {X Y : C} (a b : X ⟶ Y) : a + b = b + a
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem comp_id (f : TopHom α β) : f.comp (TopHom.id α) = f
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
theorem filter_snd_eq_antidiagonal (n m : A) [DecidablePred (· = m)] [Decidable (m ≤ n)] :
    filter (fun x : A × A ↦ x.snd = m) (antidiagonal n) = if m ≤ n then {(n - m, m)} else ∅
-- Mathlib/Computability/Primrec.lean
theorem PrimrecRel.comp₂ {R : γ → δ → Prop} [∀ a b, Decidable (R a b)] {f : α → β → γ}
    {g : α → β → δ} :
    PrimrecRel R → Primrec₂ f → Primrec₂ g → PrimrecRel fun a b => R (f a b) (g a b)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma nat_card_stabilizer_eq_one_or_two :
    Nat.card (Stab w) = 1 ∨ Nat.card (Stab w) = 2
-- Mathlib/Probability/Process/Stopping.lean
theorem isStoppingTime_const [Preorder ι] (f : Filtration ι m) (i : ι) :
    IsStoppingTime f fun _ => i
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
theorem unit_mateEquiv (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (c : C) :
    G.map (adj₁.unit.app c) ≫ (mateEquiv adj₁ adj₂ α).app _ =
      adj₂.unit.app _ ≫ R₂.map (α.app _)
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem minFac_eq (n : ℕ) : minFac n = if 2 ∣ n then 2 else minFacAux n 3
-- Mathlib/RingTheory/Localization/Module.lean
@[simp] lemma LinearMap.restrictScalars_extendScalarsOfIsLocalization (f : M →ₗ[R] N) :
    (f.extendScalarsOfIsLocalization S A).restrictScalars R = f
-- Mathlib/Data/ENNReal/Inv.lean
theorem div_eq_top : a / b = ∞ ↔ a ≠ 0 ∧ b = 0 ∨ a = ∞ ∧ b ≠ ∞
-- Mathlib/Data/Matrix/Rank.lean
theorem ker_mulVecLin_transpose_mul_self (A : Matrix m n R) :
    LinearMap.ker (Aᵀ * A).mulVecLin = LinearMap.ker (mulVecLin A)
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma f_int_ofNat (k : ℕ) {a : ℝ} (ha : 0 ≤ a) (t : ℝ) (n : ℕ) :
    f_int k a t (Int.ofNat n) = f_nat k a t n
-- Mathlib/Algebra/Field/Basic.lean
theorem div_sub_same {a b : K} (h : b ≠ 0) : (a - b) / b = a / b - 1
-- Mathlib/Topology/PartialHomeomorph.lean
theorem restr_toPartialEquiv' (s : Set X) (hs : IsOpen s) :
    (e.restr s).toPartialEquiv = e.toPartialEquiv.restr s
-- Mathlib/Analysis/Complex/Asymptotics.lean
@[simp, norm_cast]
theorem isTheta_ofReal_right {f : α → E} {g : α → ℝ} : f =Θ[l] (g · : α → ℂ) ↔ f =Θ[l] g
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem toLp_inj {f g : α →ᵇ E} [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    toLp (E := E) p μ 𝕜 f = toLp (E := E) p μ 𝕜 g ↔ f = g
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
lemma appLE_map' (e : V ≤ f ⁻¹ᵁ U) (i : V = V') :
    f.appLE U V' (i ▸ e) ≫ X.presheaf.map (eqToHom i).op = f.appLE U V e
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem shiftLeft_negSucc (m n : ℕ) : -[m+1] <<< (n : ℤ) = -[Nat.shiftLeft' true m n+1]
-- Mathlib/LinearAlgebra/Dimension/DivisionRing.lean
theorem linearIndependent_of_top_le_span_of_card_eq_finrank {ι : Type*} [Fintype ι] {b : ι → V}
    (spans : ⊤ ≤ span K (Set.range b)) (card_eq : Fintype.card ι = finrank K V) :
    LinearIndependent K b
-- Mathlib/Data/Nat/Lattice.lean
@[simp]
theorem sInf_eq_zero {s : Set ℕ} : sInf s = 0 ↔ 0 ∈ s ∨ s = ∅
-- Mathlib/CategoryTheory/Functor/Flat.lean
theorem uniq {K : J ⥤ C} {c : Cone K} (hc : IsLimit c) (s : Cone (K ⋙ F))
    (f₁ f₂ : s.pt ⟶ F.obj c.pt) (h₁ : ∀ j : J, f₁ ≫ (F.mapCone c).π.app j = s.π.app j)
    (h₂ : ∀ j : J, f₂ ≫ (F.mapCone c).π.app j = s.π.app j) : f₁ = f₂
-- Mathlib/Order/Atoms.lean
theorem IsAtom.disjoint_of_ne [SemilatticeInf α] [OrderBot α] {a b : α} (ha : IsAtom a)
    (hb : IsAtom b) (hab : a ≠ b) : Disjoint a b
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiable.comp (hg : MDifferentiable I' I'' g) (hf : MDifferentiable I I' f) :
    MDifferentiable I I'' (g ∘ f)
-- Mathlib/Computability/TMToPartrec.lean
theorem tr_eval (c v) : eval (TM2.step tr) (init c v) = halt <$> Code.eval c v
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
lemma dotProduct_le_dotProduct_of_nonneg_left {u v w : n → R} (huv : u ≤ v) (hw : 0 ≤ w) :
    dotProduct w u ≤ dotProduct w v
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem rescale_X (a : A) : rescale a X = C A a * X
-- Mathlib/Data/Ordering/Lemmas.lean
@[simp]
theorem ite_eq_lt_distrib (c : Prop) [Decidable c] (a b : Ordering) :
    ((if c then a else b) = Ordering.lt) = if c then a = Ordering.lt else b = Ordering.lt
-- Mathlib/Data/Rat/Defs.lean
protected theorem add_divInt (a b c : ℤ) : (a + b) /. c = a /. c + b /. c
-- Mathlib/Data/Complex/Order.lean
theorem pos_iff {z : ℂ} : 0 < z ↔ 0 < z.re ∧ 0 = z.im
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
theorem SeparatesPoints.mono {m m' : MeasurableSpace α} [hsep : @SeparatesPoints _ m] (h : m ≤ m') :
    @SeparatesPoints _ m'
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_ciInf_iff' [Nonempty ι] {f : ι → α} {a : α} : a ≤ iInf f ↔ ∀ i, a ≤ f i
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
lemma codRestrict_apply (P : LieSubmodule R L N) (f : M →ₗ⁅R,L⁆ N) (h : ∀ m, f m ∈ P) (m : M) :
    (f.codRestrict P h m : N) = f m
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
/-- If `e : A ≃ₐ[R] B` is an isomorphism of `R`-algebras, then so is `map e`. -/
@[simps apply]
def mapAlgEquiv (e : A₁ ≃ₐ[R] A₂) : MvPolynomial σ A₁ ≃ₐ[R] MvPolynomial σ A₂
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem Fintype.card_lex (α : Type*) [Fintype α] : Fintype.card (Lex α) = Fintype.card α
-- Mathlib/Data/ENNReal/Operations.lean
protected theorem eq_sub_of_add_eq (hc : c ≠ ∞) : a + c = b → a = b - c
-- Mathlib/RingTheory/Polynomial/Quotient.lean
theorem quotient_map_C_eq_zero {I : Ideal R} {i : R} (hi : i ∈ I) :
    (Ideal.Quotient.mk (Ideal.map (C : R →+* MvPolynomial σ R) I :
      Ideal (MvPolynomial σ R))).comp C i = 0
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem Filter.Tendsto.zpow₀ {f : α → G₀} {l : Filter α} {a : G₀} (hf : Tendsto f l (𝓝 a)) (m : ℤ)
    (h : a ≠ 0 ∨ 0 ≤ m) : Tendsto (fun x => f x ^ m) l (𝓝 (a ^ m))
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem colimit.pre_id (F : J ⥤ C) :
    colimit.pre F (𝟭 _) = colim.map (Functor.leftUnitor F).hom
-- Mathlib/Analysis/Convex/Hull.lean
@[simp]
theorem convexHull_univ : convexHull 𝕜 (univ : Set E) = univ
-- Mathlib/Topology/UniformSpace/Basic.lean
protected theorem UniformSpace.Core.comp_mem_uniformity_sets {c : Core α} {s : Set (α × α)}
    (hs : s ∈ c.uniformity) : ∃ t ∈ c.uniformity, t ○ t ⊆ s
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem map_eq_zero_of_eq (v : ι → M) {i j : ι} (h : v i = v j) (hij : i ≠ j) : f v = 0
-- Mathlib/Topology/Filter.lean
protected theorem tendsto_pure_self (l : Filter X) :
    Tendsto (pure : X → Filter X) l (𝓝 l)
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem IsSubgroup.div_mem {s : Set G} (hs : IsSubgroup s) {x y : G} (hx : x ∈ s) (hy : y ∈ s) :
    x / y ∈ s
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
lemma shiftFunctorAdd'_hom_app_f' (K : CochainComplex C ℤ) (a b ab : ℤ) (h : a + b = ab) (n : ℤ) :
    ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b ab h).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [← h, add_assoc, add_comm a])).hom
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_sUnion {S : Set (Set E)} (hS : S.Finite) :
    IsVonNBounded 𝕜 (⋃₀ S) ↔ ∀ s ∈ S, IsVonNBounded 𝕜 s
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem restrict (hf : P f) (U : Y.Opens) : P (f ∣_ U)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem star_re (z : ℤ√d) : (star z).re = z.re
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If two functions coincide on a set `s`, then their iterated differentials within this set
coincide. See also `Filter.EventuallyEq.iteratedFDerivWithin_eq` and
`Filter.EventuallyEq.iteratedFDerivWithin`. -/
theorem iteratedFDerivWithin_congr (hs : EqOn f₁ f s) (hx : x ∈ s) (n : ℕ) :
    iteratedFDerivWithin 𝕜 n f₁ s x = iteratedFDerivWithin 𝕜 n f s x
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem coe_toSubring {R : Type u} {A : Type v} [CommRing R] [Ring A] [Algebra R A]
    (S : Subalgebra R A) : (↑S.toSubring : Set A) = S
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem eventuallyEq_bind {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
    g₁ =ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ =ᶠ[m x] g₂
-- Mathlib/MeasureTheory/Function/SimpleFuncDense.lean
@[simp]
theorem approxOn_zero {f : β → α} (hf : Measurable f) {s : Set α} {y₀ : α} (h₀ : y₀ ∈ s)
    [SeparableSpace s] (x : β) : approxOn f hf s y₀ h₀ 0 x = y₀
-- Mathlib/NumberTheory/NumberField/FractionalIdeal.lean
/-- The absolute value of the determinant of the base change from `integralBasis` to
`basisOfFractionalIdeal I` is equal to the norm of `I`. -/
theorem det_basisOfFractionalIdeal_eq_absNorm  (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ)
    (e : (Free.ChooseBasisIndex ℤ (𝓞 K)) ≃ (Free.ChooseBasisIndex ℤ I)) :
    |(integralBasis K).det ((basisOfFractionalIdeal K I).reindex e.symm)| =
      FractionalIdeal.absNorm I.1
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem span_zero : span R (0 : Set M) = ⊥
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
@[simp]
lemma comp' {A₁ A₂ A₃ : CommMon_ C} (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃) :
    ((f ≫ g : A₁ ⟶ A₃) : A₁.toMon_ ⟶ A₃.toMon_) = @CategoryStruct.comp (Mon_ C) _ _ _ _ f g
-- Mathlib/Algebra/Algebra/Operations.lean
@[simp]
theorem bot_mul : ⊥ * M = ⊥
-- Mathlib/Order/SupIndep.lean
theorem Independent.mono {s t : ι → α} (hs : Independent s) (hst : t ≤ s) : Independent t
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem Monic.prime_of_degree_eq_one (hp1 : degree p = 1) (hm : Monic p) : Prime p
-- Mathlib/Data/Nat/Size.lean
theorem size_eq_bits_len (n : ℕ) : n.bits.length = n.size
-- Mathlib/Analysis/Convex/Side.lean
theorem WSameSide.trans {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.WSameSide y z) (hy : y ∉ s) : s.WSameSide x z
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
lemma image_inclusion (s : SubMulAction M α) :
    Set.range s.inclusion = s.carrier
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma comap_id (N : Matroid β) : N.comap id = N
-- Mathlib/LinearAlgebra/Prod.lean
theorem inr_eq_prod : inr R M M₂ = prod 0 LinearMap.id
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mul_def (α β : Type u) : #α * #β = #(α × β)
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem dist_apply_le_dist (f₁ f₂ : FunSpace v) (t : Icc v.tMin v.tMax) :
    dist (f₁ t) (f₂ t) ≤ dist f₁ f₂
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Subset.congr_right : ∀ {x y z : PSet}, Equiv x y → (z ⊆ x ↔ z ⊆ y)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Technical lemma to rewrite suitably the preimage of an intersection under an extended chart, to
bring it into a convenient form to apply derivative lemmas. -/
theorem extend_preimage_inter_eq :
    (f.extend I).symm ⁻¹' (s ∩ t) ∩ range I =
      (f.extend I).symm ⁻¹' s ∩ range I ∩ (f.extend I).symm ⁻¹' t
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_union_le_aleph0 {α} {P Q : Set α} :
    #(P ∪ Q : Set α) ≤ ℵ₀ ↔ #P ≤ ℵ₀ ∧ #Q ≤ ℵ₀
-- Mathlib/Order/Basic.lean
theorem strongLT_of_strongLT_of_le (hab : a ≺ b) (hbc : b ≤ c) : a ≺ c
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem comapFunIsLocallyFraction (f : R →+* S) (U : Opens (PrimeSpectrum.Top R))
    (V : Opens (PrimeSpectrum.Top S)) (hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1)
    (s : ∀ x : U, Localizations R x) (hs : (isLocallyFraction R).toPrelocalPredicate.pred s) :
    (isLocallyFraction S).toPrelocalPredicate.pred (comapFun f U V hUV s)
-- Mathlib/Analysis/Convex/Gauge.lean
theorem mem_openSegment_of_gauge_lt_one (absorbs : Absorbent ℝ s) (hgauge : gauge s x < 1) :
    ∃ y ∈ s, x ∈ openSegment ℝ 0 y