ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Concept.lean
@[simp]
theorem sSup_snd (S : Set (Concept α β r)) : (sSup S).snd = ⋂ c ∈ S, (c : Concept _ _ _).snd
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem isSheaf_of_isSheaf_comp (s : A ⥤ B) [ReflectsLimitsOfSize.{v₁, max v₁ u₁} s]
    (h : IsSheaf J (P ⋙ s)) : IsSheaf J P
-- Mathlib/Data/Nat/EvenOddRec.lean
@[simp]
theorem evenOddRec_even {P : ℕ → Sort*} (h0 : P 0) (h_even : ∀ i, P i → P (2 * i))
    (h_odd : ∀ i, P i → P (2 * i + 1)) (H : h_even 0 h0 = h0) (n : ℕ) :
    (2 * n).evenOddRec h0 h_even h_odd = h_even n (evenOddRec h0 h_even h_odd n)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem coe_comap (s : Subring S) (f : R →+* S) : (s.comap f : Set R) = f ⁻¹' s
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem smul_units_def (f : A₁ ≃ₐ[R] A₁) (x : A₁ˣ) :
    f • x = Units.map f x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_one : (1 : MvPolynomial σ R).eval₂ f g = 1
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem dotProduct_add : u ⬝ᵥ (v + w) = u ⬝ᵥ v + u ⬝ᵥ w
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
lemma mulSupport_one_add [AddLeftCancelMonoid R] (f : ι → R) :
    mulSupport (fun x ↦ 1 + f x) = support f
-- Mathlib/Probability/Distributions/Gaussian.lean
/-- The map of a Gaussian distribution by addition of a constant is a Gaussian. -/
lemma gaussianReal_map_const_add (y : ℝ) :
    (gaussianReal μ v).map (y + ·) = gaussianReal (μ + y) v
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem continuousOn_exp {s : Set ℂ} : ContinuousOn exp s
-- Mathlib/Algebra/Category/GrpWithZero.lean
lemma coe_id {X : GrpWithZero} : (𝟙 X : X → X) = id
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.finset_sup_apply
    (hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x) :
    ContinuousWithinAt (fun a ↦ s.sup (f · a)) t x
-- Mathlib/MeasureTheory/Integral/Marginal.lean
theorem lmarginal_eq_of_subset {f g : (∀ i, π i) → ℝ≥0∞} (hst : s ⊆ t)
    (hf : Measurable f) (hg : Measurable g) (hfg : ∫⋯∫⁻_s, f ∂μ = ∫⋯∫⁻_s, g ∂μ) :
    ∫⋯∫⁻_t, f ∂μ = ∫⋯∫⁻_t, g ∂μ
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem cons_val_succ' {i : ℕ} (h : i.succ < m.succ) (x : α) (u : Fin m → α) :
    vecCons x u ⟨i.succ, h⟩ = u ⟨i, Nat.lt_of_succ_lt_succ h⟩
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
protected theorem stronglyMeasurable (f : Lp.simpleFunc E p μ) :
    StronglyMeasurable (toSimpleFunc f)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- Multiplicativity of a continuous multilinear map along all coordinates at the same time,
writing `f (fun i ↦ c i • m i)` as `(∏ i, c i) • f m`. -/
theorem map_smul_univ [Fintype ι] (c : ι → R) (m : ∀ i, M₁ i) :
    (f fun i => c i • m i) = (∏ i, c i) • f m
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConvexOn.convexOn {s : Set E} {f : E → β} (hf : StrictConvexOn 𝕜 s f) :
    ConvexOn 𝕜 s f
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- A function whose codomain's cardinality is infinite but strictly smaller than its domain's
has an infinite fiber.
-/
theorem exists_infinite_fiber {β α : Type u} (f : β → α) (w : #α < #β) (w' : Infinite α) :
    ∃ a : α, Infinite (f ⁻¹' {a})
-- Mathlib/CategoryTheory/Filtered/Basic.lean
theorem coeq₃_condition₃ {j₁ j₂ : C} (f g h : j₁ ⟶ j₂) : f ≫ coeq₃Hom f g h = h ≫ coeq₃Hom f g h
-- Mathlib/Analysis/LocallyConvex/Polar.lean
@[simp]
theorem zero_mem_polar (s : Set E) : (0 : F) ∈ B.polar s
-- Mathlib/Topology/Category/TopCat/OpenNhds.lean
@[simp]
theorem inclusionMapIso_inv (x : X) : (inclusionMapIso f x).inv = 𝟙 _
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_localTrivAt_target (p : B × F) (b : B) :
    p ∈ (Z.localTrivAt b).target ↔ p.1 ∈ (Z.localTrivAt b).baseSet
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem toRingEquiv_eq_coe : e.toRingEquiv = e
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem inv_zero' : (0 : FractionalIdeal R₁⁰ K)⁻¹ = 0
-- Mathlib/GroupTheory/Perm/Option.lean
/-- The set of all permutations of `Option α` can be constructed by augmenting the set of
permutations of `α` by each element of `Option α` in turn. -/
theorem Finset.univ_perm_option {α : Type*} [DecidableEq α] [Fintype α] :
    @Finset.univ (Perm <| Option α) _ =
      (Finset.univ : Finset <| Option α × Perm α).map Equiv.Perm.decomposeOption.symm.toEmbedding
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp]
theorem FGModuleCatEvaluation_apply (f : FGModuleCatDual K V) (x : V) :
    (FGModuleCatEvaluation K V) (f ⊗ₜ x) = f.toFun x
-- Mathlib/Data/Complex/Basic.lean
theorem normSq_one : normSq 1 = 1
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain.addMonoidHom_comp (f : β → γ) (g : α → β) :
    (mapDomain.addMonoidHom (f ∘ g) : (α →₀ M) →+ γ →₀ M) =
      (mapDomain.addMonoidHom f).comp (mapDomain.addMonoidHom g)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem one_power {a : Cardinal} : (1 : Cardinal) ^ a = 1
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma one_mem_range_sumCoeffsExp : 1 ∈ Set.range (fun (p : ℝ) => ∑ i, a i * (b i) ^ p)
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma opcyclesMap'_sub :
    opcyclesMap' (φ - φ') h₁ h₂ = opcyclesMap' φ h₁ h₂ -
      opcyclesMap' φ' h₁ h₂
-- Mathlib/Data/Nat/Bits.lean
@[simp]
lemma bodd_add (m n : ℕ) : bodd (m + n) = bxor (bodd m) (bodd n)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[simp]
theorem _root_.aestronglyMeasurable_iUnion_iff [PseudoMetrizableSpace β] {s : ι → Set α} :
    AEStronglyMeasurable f (μ.restrict (⋃ i, s i)) ↔
      ∀ i, AEStronglyMeasurable f (μ.restrict (s i))
-- .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean
theorem eraseIdx_eq_take_drop_succ :
    ∀ (l : List α) (i : Nat), l.eraseIdx i = l.take i ++ l.drop (i + 1)
-- Mathlib/Data/List/Basic.lean
theorem foldl_eq_of_comm' : ∀ a b l, foldl f a (b :: l) = f (foldl f a l) b
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
lemma mul_log_nonneg {x : ℝ} (hx : 1 ≤ x) : 0 ≤ x * log x
-- Mathlib/Analysis/Convex/Basic.lean
theorem ite_eq_mem_stdSimplex (i : ι) : (if i = · then (1 : 𝕜) else 0) ∈ stdSimplex 𝕜 ι
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- `fderiv 𝕜 f` is smooth at `x₀`. -/
theorem ContDiffAt.fderiv_right (hf : ContDiffAt 𝕜 n f x₀) (hmn : (m + 1 : ℕ∞) ≤ n) :
    ContDiffAt 𝕜 m (fderiv 𝕜 f) x₀
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
@[measurability, fun_prop]
theorem measurable_derivWithin_Ici [MeasurableSpace F] [BorelSpace F] :
    Measurable fun x => derivWithin f (Ici x) x
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem empty_eq : (∅ : List α) = []
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
lemma restrict (h : μ ⟂ₘ ν) (s : Set α) : μ.restrict s ⟂ₘ ν
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem center_eq_top (A : Type*) [NonUnitalCommSemiring A] [Module R A] [IsScalarTower R A A]
    [SMulCommClass R A A] : center R A = ⊤
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
@[simp, norm_cast]
theorem cast_le : (m : α) ≤ n ↔ m ≤ n
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem mem_map {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} {y : B} :
    y ∈ map f S ↔ ∃ x ∈ S, f x = y
-- Mathlib/FieldTheory/KummerExtension.lean
lemma root_X_pow_sub_C_ne_zero' {n : ℕ} {a : K} (hn : 0 < n) (ha : a ≠ 0) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0
-- Mathlib/Topology/Order/Monotone.lean
/-- If an antitone function is continuous at the indexed supremum of a bounded function on
a nonempty `Sort`, then it sends this supremum to the infimum of the composition. -/
theorem Antitone.map_ciSup_of_continuousAt {f : α → β} {g : γ → α} (Cf : ContinuousAt f (⨆ i, g i))
    (Af : Antitone f) (H : BddAbove (range g)) : f (⨆ i, g i) = ⨅ i, f (g i)
-- Mathlib/Data/List/MinMax.lean
@[simp, deprecated maximum_eq_bot "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem maximum_eq_none {l : List α} : l.maximum = none ↔ l = []
-- Mathlib/Data/Fintype/Powerset.lean
@[simp] lemma univ_filter_card_eq (k : ℕ) :
    (univ : Finset (Finset α)).filter (fun s ↦ s.card = k) = univ.powersetCard k
-- Mathlib/Algebra/Lie/Submodule.lean
@[mono]
theorem map_mono (h : N ≤ N₂) : N.map f ≤ N₂.map f
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_vaddConst (p : P) : ⇑(vaddConst 𝕜 p) = fun v => v +ᵥ p
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem isEmpty_prod {α β : Type*} : IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_X_add_C [Semiring S] (r : S) : (X + C r).leadingCoeff = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem foldl_append {β : Type _} (f : β → α → β) (b) (l l' : List α) :
    (l ++ l').foldl f b = l'.foldl f (l.foldl f b)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csInf_univ [ConditionallyCompleteLinearOrder α] [OrderBot α] : sInf (univ : Set α) = ⊥
-- Mathlib/Topology/PartialHomeomorph.lean
theorem replaceEquiv_eq_self (e' : PartialEquiv X Y)
    (h : e.toPartialEquiv = e') : e.replaceEquiv e' h = e
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp] theorem polarBilin_prod (Q₁ : QuadraticMap R M₁ P) (Q₂ : QuadraticMap R M₂ P) :
    (Q₁.prod Q₂).polarBilin =
      Q₁.polarBilin.compl₁₂ (.fst R M₁ M₂) (.fst R M₁ M₂) +
      Q₂.polarBilin.compl₁₂ (.snd R M₁ M₂) (.snd R M₁ M₂)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem tan_int_mul_pi_div_two (n : ℤ) : tan (n * π / 2) = 0
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_compl (x : α) : xᶜᶜ = x
-- Mathlib/Data/Sigma/Basic.lean
theorem fst_surjective_iff : Surjective (fst : (Σ a, β a) → α) ↔ ∀ a, Nonempty (β a)
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem lapply_comp_lsingle_of_ne (a a' : α) (h : a ≠ a') :
    lapply a ∘ₗ lsingle a' = (0 : M →ₗ[R] M)
-- Mathlib/Algebra/GeomSum.lean
theorem Odd.geom_sum_pos [LinearOrderedRing α] (h : Odd n) : 0 < ∑ i ∈ range n, x ^ i
-- Mathlib/Order/SupClosed.lean
@[simp] lemma supClosed_univ : SupClosed (univ : Set α)
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upcrossings_lt_top_iff :
    upcrossings a b f ω < ∞ ↔ ∃ k, ∀ N, upcrossingsBefore a b f N ω ≤ k
-- Mathlib/RingTheory/Ideal/Cotangent.lean
lemma CotangentSpace.map_eq_top_iff [IsNoetherianRing R] {M : Submodule R (maximalIdeal R)} :
    M.map (maximalIdeal R).toCotangent = ⊤ ↔ M = ⊤
-- Mathlib/CategoryTheory/EffectiveEpi/Enough.lean
/--
An effective presentation of an object `X` with respect to a functor `F` is the data of an effective
epimorphism of the form `F.obj p ⟶ X`.
-/
structure EffectivePresentation (X : D) where
  /-- The object of `C` giving the source of the effective epi -/
  p : C
  /-- The morphism `F.obj p ⟶ X` -/
  f : F.obj p ⟶ X
  /-- `f` is an effective epi -/
  effectiveEpi : EffectiveEpi f
-- Mathlib/Data/List/Infix.lean
@[simp]
theorem length_tails (l : List α) : length (tails l) = length l + 1
-- Mathlib/Data/ZMod/Basic.lean
lemma ringEquivCongr_symm {a b : ℕ} (hab : a = b) :
    (ringEquivCongr hab).symm = ringEquivCongr hab.symm
-- Mathlib/LinearAlgebra/Matrix/Diagonal.lean
theorem proj_diagonal (i : n) (w : n → R) : (proj i).comp (toLin' (diagonal w)) = w i • proj i
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In a preadditive category, we can construct a biproduct for `f : J → C` from
any bicone `b` for `f` satisfying `total : ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.X`.

(That is, such a bicone is a limit cone and a colimit cocone.)
-/
theorem hasBiproduct_of_total {f : J → C} (b : Bicone f)
    (total : ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt) : HasBiproduct f
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
theorem eval₂_one_cyclotomic_prime_pow {R S : Type*} [CommRing R] [Semiring S] (f : R →+* S)
    {p : ℕ} (k : ℕ) [Fact p.Prime] : eval₂ f 1 (cyclotomic (p ^ (k + 1)) R) = p
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp] theorem counit_comp_inr : counit ∘ₗ inr R A B = counit
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem IsGLB.mul_right {s : Set α} (ha : 0 ≤ a) (hs : IsGLB s b) :
    IsGLB ((fun b => b * a) '' s) (b * a)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability]
theorem measurable_coe_nnreal_ennreal : Measurable ((↑) : ℝ≥0 → ℝ≥0∞)
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem singleton_join (a) : join ({a} : Multiset (Multiset α)) = a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_Z_eq_zero_left {P Q : Fin 3 → R} (hP : W'.Equation P) (hPz : P z = 0) (hQz : Q z ≠ 0) :
    W'.add P Q = (P x * Q z) • Q
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma hasRightExtension_iff_of_iso₂ : HasRightKanExtension L F ↔ HasRightKanExtension L F'
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
protected theorem dvd_add {a b c : Nat} (h₁ : a ∣ b) (h₂ : a ∣ c) : a ∣ b + c
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem frobenius_def : frobenius R p x = x ^ p
-- Mathlib/Data/Real/Hyperreal.lean
theorem InfinitePos.not_infinitesimal {x : ℝ*} (h : InfinitePos x) : ¬Infinitesimal x
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
lemma exists_finset_linearIndependent_of_le_rank {n : ℕ} (hn : n ≤ Module.rank R M) :
    ∃ s : Finset M, s.card = n ∧ LinearIndependent R ((↑) : s → M)
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_mul_leadingCoeff_self_inv (p : K[X]) :
    natDegree (p * C (leadingCoeff p)⁻¹) = natDegree p
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp] -- Porting note: was not a `dsimp` lemma
theorem comap_id (S : ConvexCone 𝕜 E) : S.comap LinearMap.id = S
-- Mathlib/Algebra/Order/Floor.lean
theorem sub_half_lt_round (x : α) : x - 1 / 2 < round x
-- Mathlib/Data/List/AList.lean
@[simp]
theorem lookup_insert_ne {a a'} {b' : β a'} {s : AList β} (h : a ≠ a') :
    lookup a (insert a' b' s) = lookup a s
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
theorem id_def (M : Mat_ C) :
    (𝟙 M : Hom M M) = fun i j => if h : i = j then eqToHom (congr_arg M.X h) else 0
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
lemma Differentiable.sub_iff_right (hg : Differentiable 𝕜 f) :
    Differentiable 𝕜 (fun y => f y - g y) ↔ Differentiable 𝕜 g
-- .lake/packages/batteries/Batteries/Data/HashMap/Basic.lean
/-- A hash is lawful if elements which compare equal under `==` have equal hash. -/
class LawfulHashable (α : Type _) [BEq α] [Hashable α] : Prop where
  /-- Two elements which compare equal under the `BEq` instance have equal hash. -/
  hash_eq {a b : α} : a == b → hash a = hash b
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem add_eq_bot_iff {x y : EReal} : x + y = ⊥ ↔ x = ⊥ ∨ y = ⊥
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem findIdx_nil {α : Type _} (p : α → Bool) : [].findIdx p = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem add_left_cancel (a) {b c : Ordinal} : a + b = a + c ↔ b = c
-- Mathlib/Data/Finset/Basic.lean
theorem isEmpty_coe_sort {s : Finset α} : IsEmpty (s : Type _) ↔ s = ∅
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem cramer_submatrix_equiv (A : Matrix m m α) (e : n ≃ m) (b : n → α) :
    cramer (A.submatrix e e) b = cramer A (b ∘ e.symm) ∘ e
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem nonneg_and_nonneg_or_nonpos_and_nonpos_of_mul_nonneg
    [MulPosStrictMono α] [PosMulStrictMono α]
    (hab : 0 ≤ a * b) : 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0
-- Mathlib/Order/RelIso/Basic.lean
/-- `Sum.inr` as a relation embedding into `Sum.LiftRel r s`. -/
@[simps]
def sumLiftRelInr (r : α → α → Prop) (s : β → β → Prop) : s ↪r Sum.LiftRel r s
-- Mathlib/Algebra/Lie/OfAssociative.lean
lemma LieAlgebra.ad_pow_lie (x y z : L) (n : ℕ) :
    ((ad R L x) ^ n) ⁅y, z⁆ =
      ∑ ij ∈ antidiagonal n, n.choose ij.1 • ⁅((ad R L x) ^ ij.1) y, ((ad R L x) ^ ij.2) z⁆
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_mul_int_iff : Irrational (x * m) ↔ m ≠ 0 ∧ Irrational x
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_eq_iff_eq_add_of_le (h : b ≤ a) : a - b = c ↔ a = c + b
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
@[simp]
theorem ratio_zpow (e : X ≃ᵈ X) (n : ℤ) : ratio (e ^ n) = ratio e ^ n
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt g₁ g₁' s' (h x))
    (hh : HasDerivAt h h' x) (hs : ∀ x, h x ∈ s') : HasDerivAt (g₁ ∘ h) (h' • g₁') x
-- Mathlib/Computability/Partrec.lean
theorem vector_tail {n} : Computable (@Vector.tail α n)
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp]
theorem rel_mk {s : Con R} {h a b} : RingCon.mk s h a b ↔ s a b
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_eq_bot {a b : α} : a ∆ b = ⊥ ↔ a = b
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- A preadditive category with finite products has finite biproducts. -/
theorem HasFiniteBiproducts.of_hasFiniteProducts [HasFiniteProducts C] : HasFiniteBiproducts C
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
theorem Module.free_of_finite_type_torsion_free [_root_.Finite ι] {s : ι → M}
    (hs : span R (range s) = ⊤) [NoZeroSMulDivisors R M] : Module.Free R M
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem map_subtype_embedding_Ico (hp : ∀ ⦃a b x⦄, a ≤ x → x ≤ b → p a → p b → p x):
    (Ico a b).map (Embedding.subtype p) = (Ico a b : Finset α)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem Integrable.lintegral_lt_top {f : α → ℝ} (hf : Integrable f μ) :
    (∫⁻ x, ENNReal.ofReal (f x) ∂μ) < ∞
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_inter (s t : Multiset α) : toFinset (s ∩ t) = toFinset s ∩ toFinset t
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
/-- Bisimulation principle using `LiftR'` to match and relate children of two trees. -/
theorem Cofix.bisim₂ {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop)
    (h : ∀ x y, r x y → LiftR' (RelLast' α r) (Cofix.dest x) (Cofix.dest y)) :
    ∀ x y, r x y → x = y
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma tendsto_setIntegral_densityProcess (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (a : α) {s : Set β} (hs : MeasurableSet s) (A : Set γ) :
    Tendsto (fun i ↦ ∫ x in A, densityProcess κ ν i a x s ∂(ν a)) atTop
      (𝓝 (∫ x in A, density κ ν a x s ∂(ν a)))
-- Mathlib/Algebra/DirectSum/Ring.lean
theorem list_prod_ofFn_of_eq_dProd (n : ℕ) (fι : Fin n → ι) (fA : ∀ a, A (fι a)) :
    (List.ofFn fun a => of A (fι a) (fA a)).prod = of A _ ((List.finRange n).dProd fι fA)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem card_Iio_eq_card_Iic_sub_one (a : α) : (Iio a).card = (Iic a).card - 1
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem diam_insert : diam (insert x s) = max (⨆ y ∈ s, edist x y) (diam s)
-- Mathlib/Data/Set/Sigma.lean
theorem sigma_preimage_right {g : ∀ i, β i → α i} :
    (s.sigma fun i ↦ g i ⁻¹' t i) = (fun p : Σ i, β i ↦ Sigma.mk p.1 (g _ p.2)) ⁻¹' s.sigma t
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma shiftIso_inv_app (n a a' : ℤ) (ha' : n + a = a') (K : CochainComplex C ℤ) :
    (shiftIso C n a a' ha').inv.app K =
      ShortComplex.homologyMap ((shiftShortComplexFunctorIso C n a a' ha').inv.app K)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem _root_.Set.algebraMap_mem_centralizer {s : Set A} (r : R) :
    algebraMap R A r ∈ s.centralizer
-- Mathlib/CategoryTheory/Equivalence.lean
@[simp]
theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
    (⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unitInv = unit_iso.inv
-- Mathlib/Data/List/Basic.lean
theorem span.loop_eq_take_drop :
    ∀ l₁ l₂ : List α, span.loop p l₁ l₂ = (l₂.reverse ++ takeWhile p l₁, dropWhile p l₁)
-- Mathlib/Data/Nat/Choose/Bounds.lean
theorem pow_le_choose (r n : ℕ) : ((n + 1 - r : ℕ) ^ r : α) / r ! ≤ n.choose r
-- Mathlib/Algebra/Order/Group/Int.lean
@[to_additive (attr := simp) abs_zsmul_eq_zero]
lemma zpow_abs_eq_one (a : G) (n : ℤ) : a ^ |n| = 1 ↔ a ^ n = 1
-- Mathlib/Topology/Constructions.lean
/-- Suppose `π i` is a family of topological spaces indexed by `i : ι`, and `X` is a type
endowed with a family of maps `f i : X → π i` for every `i : ι`, hence inducing a
map `g : X → Π i, π i`. This lemma shows that infimum of the topologies on `X` induced by
the `f i` as `i : ι` varies is simply the topology on `X` induced by `g : X → Π i, π i`
where `Π i, π i` is endowed with the usual product topology. -/
theorem inducing_iInf_to_pi {X : Type*} (f : ∀ i, X → π i) :
    @Inducing X (∀ i, π i) (⨅ i, induced (f i) inferInstance) _ fun x i => f i x
-- Mathlib/Logic/Function/Conjugate.lean
protected theorem eq (h : Semiconj₂ f ga gb) (x y : α) : f (ga x y) = gb (f x) (f y)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem getElem_eq_data_getElem (a : Array α) (h : i < a.size) : a[i] = a.data[i]
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem coeFn_inf (f g : α →ₘ[μ] β) : ⇑(f ⊓ g) =ᵐ[μ] fun x => f x ⊓ g x
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
theorem SimpContFract.of_isContFract :
    (SimpContFract.of v).IsContFract
-- Mathlib/FieldTheory/SeparableDegree.lean
@[simp]
theorem natSepDegree_X : (X : F[X]).natSepDegree = 1
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_iff_forall_lt : IsLowerSet s ↔ ∀ ⦃a b : α⦄, b < a → a ∈ s → b ∈ s
-- Mathlib/Data/Setoid/Partition.lean
theorem eq (i) : s i = { x | hs.index x = i }
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- val_v(1) = 0. -/
theorem count_one : count K v (1 : FractionalIdeal R⁰ K) = 0
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
theorem coe_fn_injective : Injective fun (μ : OuterMeasure α) (s : Set α) => μ s
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_iSup (s : Finset β) (f : β → L.BoundedFormula α n)
    (v : α → M) (v' : Fin n → M) :
    (iSup s f).Realize v v' ↔ ∃ b ∈ s, (f b).Realize v v'
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem prodMap_id : (id : M →ₗ[R] M).prodMap (id : M₂ →ₗ[R] M₂) = id
-- Mathlib/RingTheory/MatrixAlgebra.lean
@[simp]
theorem toFunAlgHom_apply (a : A) (m : Matrix n n R) :
    toFunAlgHom R A n (a ⊗ₜ m) = a • m.map (algebraMap R A)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[local simp] theorem emod_self {a : Int} : a % a = 0
-- Mathlib/Topology/PartialHomeomorph.lean
/-- A partial homeomorphism is continuous at any point of its source -/
protected theorem continuousAt {x : X} (h : x ∈ e.source) : ContinuousAt e x
-- Mathlib/Algebra/Ring/Ext.lean
@[ext] theorem ext ⦃inst₁ inst₂ : NonAssocRing R⦄
    (h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
    (h_mul : local_hMul[R, inst₁] = local_hMul[R, inst₂]) :
    inst₁ = inst₂
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isUnramified_iff_stabilizer_eq_bot [IsGalois k K] : IsUnramified k w ↔ Stab w = ⊥
-- Mathlib/SetTheory/Game/PGame.lean
theorem sub_congr {w x y z : PGame} (h₁ : w ≈ x) (h₂ : y ≈ z) : w - y ≈ x - z
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_eval_comp {R : Type*} [CommSemiring R] (n : ℕ) (p : R[X]) [Algebra R S]
    (x : S) : ((ascPochhammer S n).comp (p.map (algebraMap R S))).eval x =
    (ascPochhammer S n).eval (p.eval₂ (algebraMap R S) x)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- Weaker version of the monotone convergence theorem-/
theorem lintegral_iSup_ae {f : ℕ → α → ℝ≥0∞} (hf : ∀ n, Measurable (f n))
    (h_mono : ∀ n, ∀ᵐ a ∂μ, f n a ≤ f n.succ a) : ∫⁻ a, ⨆ n, f n a ∂μ = ⨆ n, ∫⁻ a, f n a ∂μ
-- Mathlib/LinearAlgebra/BilinearForm/TensorProduct.lean
@[simp]
theorem tensorDistribEquiv_apply (B : BilinForm R M₁ ⊗ BilinForm R M₂) :
    tensorDistribEquiv R (M₁ := M₁) (M₂ := M₂) B = tensorDistrib R R B
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem tendsto_normalize_testAgainstNN_of_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} (μs_lim : Tendsto μs F (𝓝 μ)) (nonzero : μ ≠ 0) (f : Ω →ᵇ ℝ≥0) :
    Tendsto (fun i => (μs i).normalize.toFiniteMeasure.testAgainstNN f) F
      (𝓝 (μ.normalize.toFiniteMeasure.testAgainstNN f))
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.eq_of_basis (hI : M.Indep I) (hJ : M.Basis J I) : J = I
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
@[simp]
theorem power_basis_int'_dim [hcycl : IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p) :
    hζ.integralPowerBasis'.dim = φ p
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- `val_v(I⁻ⁿ) = -val_v(Iⁿ)` for every `n ∈ ℤ`. -/
theorem count_neg_zpow (n : ℤ) (I : FractionalIdeal R⁰ K) :
    count K v (I ^ (-n)) = - count K v (I ^ n)