ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem map_ciSup_set (e : α ≃o β) {s : Set γ} {f : γ → α} (hf : BddAbove (f '' s))
    (hne : s.Nonempty) : e (⨆ i : s, f i) = ⨆ i : s, e (f i)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_or_inj_right_iff :
    ∀ {m x y : Bool}, (x && m) = (y && m) ∧ (x || m) = (y || m) ↔ x = y
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- If `Fₙ` tends uniformly to `f`, and `gₙ` tends to `x`, then `Fₙ gₙ` tends to `f x`. -/
theorem TendstoUniformly.tendsto_comp (h : TendstoUniformly F f p) (hf : ContinuousAt f x)
    (hg : Tendsto g p (𝓝 x)) : Tendsto (fun n => F n (g n)) p (𝓝 (f x))
-- Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean
lemma two_mul_card_edgeFinset :
    2 * G.edgeFinset.card = (univ.filter fun (x, y) ↦ G.Adj x y).card
-- Mathlib/Data/Nat/ModEq.lean
theorem gcd_eq (h : a ≡ b [MOD m]) : gcd a m = gcd b m
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_triangle (a b c : α) : a \ c ≤ a \ b ⊔ b \ c
-- Mathlib/Analysis/Seminorm.lean
protected theorem uniformContinuous [UniformSpace E] [UniformAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p
-- Mathlib/Data/Fin/Basic.lean
lemma castPred_succAbove (x : Fin n) (y : Fin (n + 1)) (h : castSucc x < y)
    (h' := Fin.ne_last_of_lt $ (succAbove_lt_iff_castSucc_lt ..).2 h) :
    (y.succAbove x).castPred h' = x
-- Mathlib/RingTheory/HahnSeries/PowerSeries.lean
theorem coeff_toPowerSeries {f : HahnSeries ℕ R} {n : ℕ} :
    PowerSeries.coeff R n (toPowerSeries f) = f.coeff n
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[reassoc]
theorem hexagon_forward_inv (X Y Z : C) :
    (α_ Y Z X).inv ≫ (β_ X (Y ⊗ Z)).inv ≫ (α_ X Y Z).inv =
      Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫ (β_ X Y).inv ▷ Z
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem tendsto_exp_comap_re_atBot_nhdsWithin : Tendsto exp (comap re atBot) (𝓝[≠] 0)
-- Mathlib/Data/Finset/NAry.lean
/-- The other direction does not hold because of the `s`-`s` cross terms on the RHS. -/
theorem image₂_distrib_subset_left {γ : Type*} {u : Finset γ} {f : α → δ → ε} {g : β → γ → δ}
    {f₁ : α → β → β'} {f₂ : α → γ → γ'} {g' : β' → γ' → ε}
    (h_distrib : ∀ a b c, f a (g b c) = g' (f₁ a b) (f₂ a c)) :
    image₂ f s (image₂ g t u) ⊆ image₂ g' (image₂ f₁ s t) (image₂ f₂ s u)
-- Mathlib/Data/Vector/Basic.lean
theorem get_cons_zero (a : α) (v : Vector α n) : get (a ::ᵥ v) 0 = a
-- Mathlib/Tactic/NormNum/Pow.lean
theorem intPow_negOfNat_bit0 {b' c' : ℕ} (h1 : Nat.pow a b' = c')
    (hb : nat_lit 2 * b' = b) (hc : c' * c' = c) :
    Int.pow (Int.negOfNat a) b = Int.ofNat c
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem map_id : map (f₂ := f₁) (g₂ := g₁) (id V₁) (id W₁) rfl rfl = id (f₁.equalizer g₁)
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem tail_cons (a : α) (s : Stream' α) : tail (a::s) = s
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.inter (hs : IsLowerSet s) (ht : IsLowerSet t) : IsLowerSet (s ∩ t)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem subseq_tendsto_of_neBot {f : Filter α} [IsCountablyGenerated f] {u : ℕ → α}
    (hx : NeBot (f ⊓ map u atTop)) : ∃ θ : ℕ → ℕ, StrictMono θ ∧ Tendsto (u ∘ θ) atTop f
-- Mathlib/ModelTheory/Complexity.lean
theorem not_all_isAtomic (φ : L.BoundedFormula α (n + 1)) : ¬φ.all.IsAtomic
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem length_append (as bs : List α) : (as ++ bs).length = as.length + bs.length
-- Mathlib/NumberTheory/Dioph.lean
theorem eq_dioph : Dioph fun v => f v = g v
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp]
theorem op_toSubring (S : Subalgebra R A) : S.op.toSubring = S.toSubring.op
-- Mathlib/Analysis/NormedSpace/RieszLemma.lean
theorem Metric.closedBall_infDist_compl_subset_closure {x : F} {s : Set F} (hx : x ∈ s) :
    closedBall x (infDist x sᶜ) ⊆ closure s
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem HasFDerivWithinAt.congr_mono (h : HasFDerivWithinAt f f' s x) (ht : EqOn f₁ f t)
    (hx : f₁ x = f x) (h₁ : t ⊆ s) : HasFDerivWithinAt f₁ f' t x
-- Mathlib/Data/Finsupp/Defs.lean
protected theorem unique_ext_iff [Unique α] {f g : α →₀ M} : f = g ↔ f default = g default
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
protected theorem add_tsub_cancel_left (ha : AddLECancellable a) : a + b - a = b
-- Mathlib/Data/Set/Function.lean
theorem injOn_of_injective (h : Injective f) {s : Set α} : InjOn f s
-- Mathlib/FieldTheory/Adjoin.lean
theorem algEquivOfEq_toAlgHom {p q : K[X]} (hp : p ≠ 0) (h_eq : p = q) :
    (algEquivOfEq hp h_eq).toAlgHom = liftHom p (root q) (by rw [h_eq, aeval_eq, mk_self])
-- Mathlib/Data/DFinsupp/Lex.lean
theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (α i)] (r) [IsStrictOrder ι r] {x y : Π₀ i, α i}
    (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
-- Mathlib/Computability/Reduce.lean
theorem Equiv.Computable.symm {α β} [Primcodable α] [Primcodable β] {e : α ≃ β} :
    e.Computable → e.symm.Computable
-- .lake/packages/lean4/src/lean/Init/Classical.lean
theorem not_and_iff_or_not_not : ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Mathlib/Data/Ordmap/Ordset.lean
theorem findMax'_all {P : α → Prop} : ∀ (x : α) (t), P x → All P t → P (findMax' x t)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem norm_compLp_le (L : E →L[𝕜] F) (f : Lp E p μ) : ‖L.compLp f‖ ≤ ‖L‖ * ‖f‖
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
nonrec theorem ContinuousWithinAt.rpow (hf : ContinuousWithinAt f s x)
    (hg : ContinuousWithinAt g s x) (h : f x ≠ 0 ∨ 0 < g x) :
    ContinuousWithinAt (fun t => f t ^ g t) s x
-- Mathlib/Topology/Order/LawsonTopology.lean
@[simp] lemma of_Lawson_symm_eq : (@ofLawson α).symm = toLawson
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem coprodMap_apply (f : ∀ i : ι, M i →ₗ[R] N) (x : Π₀ i, M i) :
    coprodMap f x =
      DFinsupp.sum (mapRange (fun i => f i) (fun _ => LinearMap.map_zero _) x) fun _ =>
        id
-- Mathlib/Order/Atoms.lean
/-- A complete upper-modular lattice that is atomistic is strongly atomic.
Not an instance to prevent loops. -/
theorem CompleteLattice.isStronglyAtomic [IsUpperModularLattice α] [IsAtomistic α] :
    IsStronglyAtomic α
-- Mathlib/Topology/Bornology/Basic.lean
/-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
Such spaces are equivalently specified by their bounded sets, see `Bornology.ofBounded`
and `Bornology.ext_iff_isBounded`-/
class Bornology (α : Type*) where
  /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
  should always prefer `Bornology.cobounded` because it makes the `α` argument explicit. -/
  cobounded' : Filter α
  /-- The cobounded filter in a bornology is smaller than the cofinite filter. This is a field of
  the structure, but one should always prefer `Bornology.le_cofinite` because it makes the `α`
  argument explicit. -/
  le_cofinite' : cobounded' ≤ cofinite
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
theorem smul_left (a : R) (x y : M) : B (a • x) y = a * B x y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma nonsingular_iff (P : Fin 3 → R) : W.Nonsingular P ↔ W.Equation P ∧
    (W.a₁ * P y * P z ≠ 3 * P x ^ 2 + 2 * W.a₂ * P x * P z + W.a₄ * P z ^ 2 ∨
      P y * P z ≠ -P y * P z - W.a₁ * P x * P z - W.a₃ * P z ^ 2 ∨
      P y ^ 2 + W.a₁ * P x * P y + 2 * W.a₃ * P y * P z
        ≠ W.a₂ * P x ^ 2 + 2 * W.a₄ * P x * P z + 3 * W.a₆ * P z ^ 2)
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f : R → ℝ` is a nonzero, nonnegative, multiplicatively bounded function, then
  `seminormFromBounded' f` is nonzero. -/
theorem seminormFromBounded_nonzero (f_ne_zero : f ≠ 0) (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y) :
    seminormFromBounded' f ≠ 0
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem coe_multilinearMap_injective :
    Function.Injective ((↑) : M [⋀^ι]→ₗ[R] N → MultilinearMap R (fun _ : ι => M) N)
-- Mathlib/FieldTheory/Fixed.lean
theorem cardinal_mk_algHom (K : Type u) (V : Type v) (W : Type w) [Field K] [Field V] [Algebra K V]
    [FiniteDimensional K V] [Field W] [Algebra K W] :
    Cardinal.mk (V →ₐ[K] W) ≤ finrank W (V →ₗ[K] W)
-- Mathlib/Data/Fin/Basic.lean
theorem cast_le_cast (eq : n = m) {a b : Fin n} : cast eq a ≤ cast eq b ↔ a ≤ b
-- Mathlib/Data/Nat/Factorization/Basic.lean
/-- The only prime factor of prime `p` is `p` itself. -/
theorem Prime.eq_of_factorization_pos {p q : ℕ} (hp : Prime p) (h : p.factorization q ≠ 0) :
    p = q
-- Mathlib/Logic/Denumerable.lean
@[simp]
theorem ofNat_range : Set.range (ofNat s) = Set.univ
-- Mathlib/Order/Partition/Finpartition.lean
/-- Given a finpartition `P` of `a` and finpartitions of each part of `P`, this yields the
finpartition of `a` obtained by juxtaposing all the subpartitions. -/
@[simps]
def bind (P : Finpartition a) (Q : ∀ i ∈ P.parts, Finpartition i) : Finpartition a
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem subtype_comp_codRestrict (f : M →[L] N) (p : L.Substructure N) (h : ∀ b, f b ∈ p) :
    p.subtype.toHom.comp (codRestrict p f h) = f
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem nfp_le_of_principal {op : Ordinal → Ordinal → Ordinal} {a o : Ordinal} (hao : a < o)
    (ho : Principal op o) : nfp (op a) a ≤ o
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp] theorem mk_eq_bot_iff {N : Submodule R M} {h} :
    (⟨N, h⟩ : LieSubmodule R L M) = ⊥ ↔ N = ⊥
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
/-- Re-indexing the components of the tensor product by an equivalence `e` is compatible
with `PiTensorProduct.map`. -/
theorem map_comp_reindex_eq (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) :
    map (fun i ↦ f (e.symm i)) ∘ₗ reindex R s e = reindex R t e ∘ₗ map f
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem principal_empty : 𝓟 (∅ : Set α) = ⊥
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem id_toLinearMap : (CoalgHom.id R A : A →ₗ[R] A) = LinearMap.id
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp]
lemma zero_hom : (0 : Ext X Y n).hom = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
private lemma add_eq_zero (P Q : W.Point) : P + Q = 0 ↔ P = -Q
-- Mathlib/RingTheory/Presentation.lean
lemma finitePresentation_of_isFinite [P.IsFinite] :
    FinitePresentation R S
-- Mathlib/Algebra/Group/Basic.lean
lemma eq_of_inv_mul_eq_one (h : a⁻¹ * b = 1) : a = b
-- Mathlib/NumberTheory/NumberField/House.lean
theorem basis_repr_abs_le_const_mul_house (α : 𝓞 K) (i : K →+* ℂ) :
    Complex.abs (((integralBasis K).reindex (equivReindex K).symm).repr α i) ≤
      (c K) * house (algebraMap (𝓞 K) K α)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The difference of two `C^n` functions on a domain is `C^n`. -/
theorem ContDiffOn.sub {s : Set E} {f g : E → F} (hf : ContDiffOn 𝕜 n f s)
    (hg : ContDiffOn 𝕜 n g s) : ContDiffOn 𝕜 n (fun x => f x - g x) s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_le_add_iff_left (a : Int) : a + b ≤ a + c ↔ b ≤ c
-- Mathlib/Data/Nat/Defs.lean
protected lemma zero_eq_mul : 0 = m * n ↔ m = 0 ∨ n = 0
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
@[simp]
theorem isSubordinate_toPartitionOfUnity :
    f.toPartitionOfUnity.IsSubordinate U ↔ f.IsSubordinate U
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem eq_rnDeriv₀ [SigmaFinite ν] {s : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) (hs : s ⟂ₘ ν) (hadd : μ = s + ν.withDensity f) :
    f =ᵐ[ν] μ.rnDeriv ν
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem valid_zero : Valid s 0
-- Mathlib/Data/Real/Archimedean.lean
theorem iInf_Ioi_eq_iInf_rat_gt {f : ℝ → ℝ} (x : ℝ) (hf : BddBelow (f '' Ioi x))
    (hf_mono : Monotone f) : ⨅ r : Ioi x, f r = ⨅ q : { q' : ℚ // x < q' }, f q
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
/-- The `StarSubalgebra.inclusion` of a star subalgebra is an `Embedding`. -/
theorem embedding_inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) : Embedding (inclusion h)
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem div_sat (c : Constraint) (t : Int) (k : Nat) (n : k ≠ 0) (h : (k : Int) ∣ t) (w : c.sat t) :
    (c.div k).sat (t / k)
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem coe_id : ⇑(EsakiaHom.id α) = id
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp]
theorem coe_smul : ⇑(r • X) = r • ⇑X
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem im_imJ : a.im.imJ = a.imJ
-- Mathlib/Algebra/Group/AddChar.lean
/-- An additive character maps negatives to inverses (when defined) -/
lemma map_neg_eq_inv (ψ : AddChar A M) (a : A) : ψ (-a) = (ψ a)⁻¹
-- Mathlib/CategoryTheory/Monoidal/Category.lean
theorem whiskerLeft_iff {X Y : C} (f g : X ⟶ Y) : 𝟙_ C ◁ f = 𝟙_ C ◁ g ↔ f = g
-- Mathlib/Data/Nat/Factorial/DoubleFactorial.lean
theorem doubleFactorial_eq_prod_even : ∀ n : ℕ, (2 * n)‼ = ∏ i ∈ Finset.range n, 2 * (i + 1)
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[norm_cast]
theorem coe_projIcc (a b : α) (h : a ≤ b) (x : α) : (projIcc a b h x : α) = max a (min b x)
-- Mathlib/Analysis/Convex/Side.lean
theorem wOppSide_lineMap_left {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : t ≤ 0) : s.WOppSide (lineMap x y t) y
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDeriv_succ_apply_right {n : ℕ} (m : Fin (n + 1) → E) :
    (iteratedFDeriv 𝕜 (n + 1) f x : (Fin (n + 1) → E) → F) m =
      iteratedFDeriv 𝕜 n (fun y => fderiv 𝕜 f y) x (init m) (m (last n))
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem lineDeriv_neg : lineDeriv 𝕜 f x (-v) = - lineDeriv 𝕜 f x v
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem top_add_top : (⊤ : EReal) + ⊤ = ⊤
-- Mathlib/NumberTheory/Dioph.lean
theorem proj_dioph_of_nat {n : ℕ} (m : ℕ) [IsLT m n] : DiophFn fun v : Vector3 ℕ n => v &m
-- Mathlib/Computability/Primrec.lean
theorem nat_omega_rec' (f : β → σ) {m : β → ℕ} {l : β → List β} {g : β → List σ → Option σ}
    (hm : Primrec m) (hl : Primrec l) (hg : Primrec₂ g)
    (Ord : ∀ b, ∀ b' ∈ l b, m b' < m b)
    (H : ∀ b, g b ((l b).map f) = some (f b)) : Primrec f
-- Mathlib/Topology/Basic.lean
theorem frontier_inter_subset (s t : Set X) :
    frontier (s ∩ t) ⊆ frontier s ∩ closure t ∪ closure s ∩ frontier t
-- Mathlib/Data/Finset/NAry.lean
theorem card_image₂_le (f : α → β → γ) (s : Finset α) (t : Finset β) :
    (image₂ f s t).card ≤ s.card * t.card
-- Mathlib/AlgebraicGeometry/Limits.lean
theorem isAffineOpen_bot (X : Scheme) : IsAffineOpen (⊥ : X.Opens)
-- Mathlib/GroupTheory/Sylow.lean
theorem subtype_injective {P Q : Sylow p G} {hP : ↑P ≤ N} {hQ : ↑Q ≤ N}
    (h : P.subtype hP = Q.subtype hQ) : P = Q
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_finset_sup [ConditionallyCompleteLinearOrder β] [OrderBot β] {f : Filter α}
    {F : ι → α → β} {s : Finset ι}
    (h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
    (h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
    limsup (fun a ↦ sup s (fun i ↦ F i a)) f = sup s (fun i ↦ limsup (F i) f)
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
/-- An alias of `MeasureTheory.MeasurePreserving.comp` with a convenient defeq and argument order
for `MeasurableEquiv` -/
protected theorem trans {e : α ≃ᵐ β} {e' : β ≃ᵐ γ}
    {μa : Measure α} {μb : Measure β} {μc : Measure γ}
    (h : MeasurePreserving e μa μb) (h' : MeasurePreserving e' μb μc) :
    MeasurePreserving (e.trans e') μa μc
-- Mathlib/CategoryTheory/EssentiallySmall.lean
theorem locallySmall_of_faithful {C : Type u} [Category.{v} C] {D : Type u'} [Category.{v'} D]
    (F : C ⥤ D) [F.Faithful] [LocallySmall.{w} D] : LocallySmall.{w} C
-- Mathlib/Data/List/Basic.lean
theorem exists_mem_cons_of {p : α → Prop} {a : α} (l : List α) (h : p a) : ∃ x ∈ a :: l, p x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem mk_finsupp_lift_of_infinite' (α : Type u) (β : Type v) [Nonempty α] [Zero β] [Infinite β] :
    #(α →₀ β) = max (lift.{v} #α) (lift.{u} #β)
-- Mathlib/NumberTheory/EulerProduct/Basic.lean
/-- The *Euler Product* for a multiplicative arithmetic function `f` with values in a
complete normed commutative ring `R`: if `‖f ·‖` is summable, then
`∏' p : Nat.Primes, ∑' e, f (p ^ e) = ∑' n, f n`.
This version is stated in the form of convergence of finite partial products. -/
nonrec theorem IsMultiplicative.eulerProduct {f : ArithmeticFunction R} (hf : f.IsMultiplicative)
    (hsum : Summable (‖f ·‖)) :
    Tendsto (fun n : ℕ ↦ ∏ p ∈ primesBelow n, ∑' e, f (p ^ e)) atTop (𝓝 (∑' n, f n))
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp]
theorem fastGrowing_one : fastGrowing 1 = fun n => 2 * n
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_min_of_nonpos (ha : a ≤ 0) (b₁ b₂ : β) : a • min b₁ b₂ = max (a • b₁) (a • b₂)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_eq_sub (a b : α) : toIocMod hp a b = toIocMod hp 0 (b - a) + a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma equiv_zero_of_Z_eq_zero {P : Fin 3 → F} (h : W.Nonsingular P) (hPz : P z = 0) :
    P ≈ ![0, 1, 0]
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem conj (w : W) : cs.IsReflection (w * t * w⁻¹)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuousOn_iInf_rng {u : κ → UniformSpace α'} {F : ι → X → α'}
    {S : Set X} :
    EquicontinuousOn (uα := ⨅ k, u k) F S ↔ ∀ k, EquicontinuousOn (uα := u k) F S
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem associated_toQuadraticMap (B : BilinMap R M R) (x y : M) :
    associatedHom S B.toQuadraticMap x y = ⅟ (2 : R) • (B x y + B y x)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem dvd_add_right {a b c : Int} (H : a ∣ b) : a ∣ b + c ↔ a ∣ c
-- .lake/packages/lean4/src/lean/Init/WF.lean
theorem induction {C : α → Prop} (a : α) (h : ∀ x, (∀ y, r y x → C y) → C x) : C a
-- Mathlib/Analysis/Seminorm.lean
theorem ball_mono {p : Seminorm 𝕜 E} {r₁ r₂ : ℝ} (h : r₁ ≤ r₂) : p.ball x r₁ ⊆ p.ball x r₂
-- Mathlib/Topology/Basic.lean
theorem DenseRange.closure_range (h : DenseRange f) : closure (range f) = univ
-- Mathlib/Algebra/Ring/Equiv.lean
theorem ofBijective_apply [NonUnitalRingHomClass F R S] (f : F) (hf : Function.Bijective f)
    (x : R) : ofBijective f hf x = f x
-- Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
/-- If a function is differentiable inside a convex set with nonempty interior, and has a second
derivative at a point of this convex set, then this second derivative is symmetric. -/
theorem Convex.second_derivative_within_at_symmetric {s : Set E} (s_conv : Convex ℝ s)
    (hne : (interior s).Nonempty) {f : E → F} {f' : E → E →L[ℝ] F} {f'' : E →L[ℝ] E →L[ℝ] F}
    (hf : ∀ x ∈ interior s, HasFDerivAt f (f' x) x) {x : E} (xs : x ∈ s)
    (hx : HasFDerivWithinAt f' f'' (interior s) x) (v w : E) : f'' v w = f'' w v
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
/-- If a function is continuous on an open set `s`, then it is strongly measurable at the filter
`𝓝 x` for all `x ∈ s` if either the source space or the target space is second-countable. -/
theorem ContinuousOn.stronglyMeasurableAtFilter [TopologicalSpace α] [OpensMeasurableSpace α]
    [TopologicalSpace β] [PseudoMetrizableSpace β] [SecondCountableTopologyEither α β] {f : α → β}
    {s : Set α} {μ : Measure α} (hs : IsOpen s) (hf : ContinuousOn f s) :
    ∀ x ∈ s, StronglyMeasurableAtFilter f (𝓝 x) μ
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem Real.nndist_eq' (x y : ℝ) : nndist x y = Real.nnabs (y - x)
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
theorem nonMemberSubfamily_union (a : α) (𝒜 ℬ : Finset (Finset α)) :
    (𝒜 ∪ ℬ).nonMemberSubfamily a = 𝒜.nonMemberSubfamily a ∪ ℬ.nonMemberSubfamily a
-- Mathlib/GroupTheory/Commutator.lean
/-- The commutator of direct product is contained in the direct product of the commutators.

See `commutator_pi_pi_of_finite` for equality given `Fintype η`.
-/
theorem commutator_pi_pi_le {η : Type*} {Gs : η → Type*} [∀ i, Group (Gs i)]
    (H K : ∀ i, Subgroup (Gs i)) :
    ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ ≤ Subgroup.pi Set.univ fun i => ⁅H i, K i⁆
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The constant term of `cyclotomic n R` is `1` if `2 ≤ n`. -/
theorem cyclotomic_coeff_zero (R : Type*) [CommRing R] {n : ℕ} (hn : 1 < n) :
    (cyclotomic n R).coeff 0 = 1
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem memℒp_one_iff_integrable {f : α → β} : Memℒp f 1 μ ↔ Integrable f μ
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_pair : ({x, y} : Set α).infsep = dist x y
-- Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean
theorem deriv_sqrt_mul_log (x : ℝ) :
    deriv (fun x => √x * log x) x = (2 + log x) / (2 * √x)
-- Mathlib/Topology/Algebra/GroupWithZero.lean
nonrec theorem ContinuousAt.div_const {a : α} (hf : ContinuousAt f a) (y : G₀) :
    ContinuousAt (fun x => f x / y) a
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem le_zeroLocus_iff_le_vanishingIdeal {V : Set (σ → k)} {I : Ideal (MvPolynomial σ k)} :
    V ≤ zeroLocus I ↔ I ≤ vanishingIdeal V
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem BilinForm.mul_toMatrix' (B : BilinForm R₂ (n → R₂)) (M : Matrix n n R₂) :
    M * BilinForm.toMatrix' B = BilinForm.toMatrix' (B.compLeft (Matrix.toLin' Mᵀ))
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem nontrivial_iff : Nontrivial (Submodule R M) ↔ Nontrivial M
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_le {s : Multiset α} {a : α} : s.sup ≤ a ↔ ∀ b ∈ s, b ≤ a
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floorRing_floor_eq : @FloorRing.floor = @Int.floor
-- Mathlib/Data/Finset/Sups.lean
lemma Nonempty.of_diffs_right : (s \\ t).Nonempty → t.Nonempty
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem div_le_iff {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x / y ≤ z ↔ x ≤ z * y
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem congr' {s : Set H} {x : H} {f g : H → H'} (h : f =ᶠ[𝓝 x] g) (hP : P g s x) : P f s x
-- Mathlib/Probability/ProbabilityMassFunction/Integrals.lean
theorem bernoulli_expectation {p : ℝ≥0∞} (h : p ≤ 1) :
    ∫ b, cond b 1 0 ∂((bernoulli p h).toMeasure) = p.toReal
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
@[simp]
lemma shiftFunctor_obj_d' (K : CochainComplex C ℤ) (n i j : ℤ) :
    ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K).d i j =
      n.negOnePow • K.d _ _
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem zero_memℓp : Memℓp (0 : ∀ i, E i) p
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
lemma IsMatching.coeSubgraph {G' : Subgraph G} {M : Subgraph G'.coe} (hM : M.IsMatching) :
    M.coeSubgraph.IsMatching
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
lemma uniformEquicontinuous_restrict_iff (F : ι → β → α) {S : Set β} :
    UniformEquicontinuous (S.restrict ∘ F) ↔ UniformEquicontinuousOn F S
-- Mathlib/Data/Set/Lattice.lean
theorem prod_sUnion {s : Set α} {C : Set (Set β)} : s ×ˢ ⋃₀C = ⋃₀((fun t => s ×ˢ t) '' C)
-- Mathlib/Data/Real/Irrational.lean
theorem of_sub_nat (m : ℕ) (h : Irrational (x - m)) : Irrational x
-- Mathlib/Data/Complex/Exponential.lean
/-- The definition of `cosh` in terms of `exp`. -/
theorem cosh_eq (x : ℝ) : cosh x = (exp x + exp (-x)) / 2
-- Mathlib/Data/Set/Card.lean
theorem ncard_ne_zero_of_mem {a : α} (h : a ∈ s) (hs : s.Finite := by toFinite_tac) : s.ncard ≠ 0
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval₂Hom_zero_apply (f : R →+* S₂) (p : MvPolynomial σ R) :
    eval₂Hom f (0 : σ → S₂) p = f (constantCoeff p)
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
/-- Upper bound for the summand `|c * z + d| ^ (-k)`, as a product of a function of `z` and a
function of `c, d`. -/
lemma summand_bound {k : ℝ} (hk : 0 ≤ k) (x : Fin 2 → ℤ) :
    Complex.abs (x 0 * z + x 1) ^ (-k) ≤ (r z) ^ (-k) * ‖x‖ ^ (-k)
-- Mathlib/Topology/Semicontinuous.lean
theorem UpperSemicontinuous.upperSemicontinuousAt (h : UpperSemicontinuous f) (x : α) :
    UpperSemicontinuousAt f x
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
/-- The localization functor to the constructed localized category for a morphism property
that has left calculus of fractions. -/
@[simps obj]
def Q : C ⥤ Localization W