ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_iff_isIso_liftCycles (φ : S₁ ⟶ S₂)
    (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) :
    QuasiIso φ ↔ IsIso (S₂.liftCycles φ.τ₂ (by rw [φ.comm₂₃, hg₁, zero_comp]))
-- Mathlib/Data/Nat/Digits.lean
theorem digits.injective (b : ℕ) : Function.Injective b.digits
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem BilinForm.toMatrix'_apply (B : BilinForm R₂ (n → R₂)) (i j : n) :
    BilinForm.toMatrix' B i j = B (stdBasis R₂ (fun _ => R₂) i 1) (stdBasis R₂ (fun _ => R₂) j 1)
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tsum_geometric_two' (a : ℝ) : ∑' n : ℕ, a / 2 / 2 ^ n = a
-- Mathlib/LinearAlgebra/Span.lean
/-- The span of a finite subset is compact in the lattice of submodules. -/
theorem finite_span_isCompactElement (S : Set M) (h : S.Finite) :
    CompleteLattice.IsCompactElement (span R S : Submodule R M)
-- Mathlib/Order/Bounds/Basic.lean
/-- If `s` has a least upper bound, then it is bounded above. -/
theorem IsLUB.bddAbove (h : IsLUB s a) : BddAbove s
-- Mathlib/MeasureTheory/Measure/DiracProba.lean
lemma not_tendsto_diracProba_of_not_tendsto [CompletelyRegularSpace X] {x : X} (L : Filter X)
    (h : ¬ Tendsto id L (𝓝 x)) :
    ¬ Tendsto diracProba L (𝓝 (diracProba x))
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem natCast_re (n : ℕ) : (n : ℍ[R,c₁,c₂]).re = n
-- Mathlib/Data/Nat/Bits.lean
@[simp]
lemma div2_succ (n : ℕ) : div2 (succ n) = cond (bodd n) (succ (div2 n)) (div2 n)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem integrableOn_condexpL2_of_measure_ne_top (hm : m ≤ m0) (hμs : μ s ≠ ∞) (f : α →₂[μ] E) :
    IntegrableOn (E := E) (condexpL2 E 𝕜 hm f) s μ
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma Y_eq_of_X_eq {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁) (h₂ : W.Equation x₂ y₂)
    (hx : x₁ = x₂) : y₁ = y₂ ∨ y₁ = W.negY x₂ y₂
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The fundamental property of the adjoint. -/
theorem adjoint_inner_right (A : E →ₗ[𝕜] F) (x : E) (y : F) : ⟪x, adjoint A y⟫ = ⟪A x, y⟫
-- Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
theorem norm_iteratedFDeriv_clm_apply {f : E → F →L[𝕜] G} {g : E → F} {N : ℕ∞} {n : ℕ}
    (hf : ContDiff 𝕜 N f) (hg : ContDiff 𝕜 N g) (x : E) (hn : ↑n ≤ N) :
    ‖iteratedFDeriv 𝕜 n (fun y : E => (f y) (g y)) x‖ ≤ ∑ i ∈ Finset.range (n + 1),
      ↑(n.choose i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
-- Mathlib/RingTheory/MatrixAlgebra.lean
@[simp]
theorem toFunBilinear_apply (a : A) (m : Matrix n n R) :
    toFunBilinear R A n a m = a • m.map (algebraMap R A)
-- Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean
/-- Every terminating continued fraction corresponds to a rational number. -/
theorem exists_rat_eq_of_terminates (terminates : (of v).Terminates) : ∃ q : ℚ, v = ↑q
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem apply_apply (v : E) (f : E →L[𝕜] Fₗ) : apply 𝕜 Fₗ v f = f v
-- Mathlib/RingTheory/LocalRing/Basic.lean
theorem isUnit_or_isUnit_of_isUnit_add {a b : R} (h : IsUnit (a + b)) : IsUnit a ∨ IsUnit b
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diagonal_zero [Zero α] : (diagonal fun _ => 0 : Matrix n n α) = 0
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasFDerivAt.inner (hf : HasFDerivAt f f' x) (hg : HasFDerivAt g g' x) :
    HasFDerivAt (fun t => ⟪f t, g t⟫) ((fderivInnerCLM 𝕜 (f x, g x)).comp <| f'.prod g') x
-- Mathlib/Computability/Primrec.lean
theorem sum_inl : Primrec (@Sum.inl α β)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_sub_eq_sub_one (h : m - n = l + 1) : n < m
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- If `F.cones` is represented by `X`, the cone corresponding to a morphism `f : Y ⟶ X` is
the limit cone extended by `f`. -/
theorem coneOfHom_fac {Y : C} (f : Y ⟶ X) : coneOfHom h f = (limitCone h).extend f
-- Mathlib/Algebra/GroupWithZero/Commute.lean
theorem mul_inverse_rev {M₀} [CommMonoidWithZero M₀] (a b : M₀) :
    Ring.inverse (a * b) = inverse b * inverse a
-- Mathlib/Data/Nat/Cast/Commute.lean
@[simp]
lemma natCast_mul_left (h : SemiconjBy a x y) (n : ℕ) : SemiconjBy (n * a) x y
-- Mathlib/Topology/Bornology/Hom.lean
@[simp]
theorem coe_comp (f : LocallyBoundedMap β γ) (g : LocallyBoundedMap α β) : ⇑(f.comp g) = f ∘ g
-- Mathlib/Order/Hom/Lattice.lean
@[simp] theorem comp_id (f : InfTopHom α β) : f.comp (InfTopHom.id α) = f
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {l₁ l₂ : List α} :
    Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem count_mul_of_coprime' [DecidableEq (Associates α)] {a b : Associates α} {p : Associates α}
    (hp : Irreducible p) (hab : ∀ d, d ∣ a → d ∣ b → ¬Prime d) :
    count p (a * b).factors = count p a.factors ∨ count p (a * b).factors = count p b.factors
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp, reassoc]
theorem colimitIsoColimitCurryCompColim_ι_hom {j} {k} :
    colimit.ι _ (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom =
      (colimit.ι (_) k ≫ colimit.ι (curry.obj G ⋙ colim) j : _ ⟶ colimit (_ ⋙ colim))
-- Mathlib/Algebra/Field/Defs.lean
/-- `OfScientific.ofScientific` is the simp-normal form. -/
@[simp]
theorem Rat.ofScientific_eq_ofScientific (m : ℕ) (s : Bool) (e : ℕ) :
    Rat.ofScientific (OfNat.ofNat m) s (OfNat.ofNat e) = OfScientific.ofScientific m s e
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem filter_length_eq_length {l} : (filter p l).length = l.length ↔ ∀ a ∈ l, p a
-- Mathlib/Topology/Instances/Rat.lean
theorem embedding_coe_real : Embedding ((↑) : ℚ → ℝ)
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_pos : 0 < ⌊a⌋ ↔ 1 ≤ a
-- Mathlib/Algebra/Algebra/Operations.lean
theorem one_eq_span_one_set : (1 : Submodule R A) = span R 1
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem card_rootsOfUnity' {n : ℕ+} (h : IsPrimitiveRoot ζ n) :
    Fintype.card (rootsOfUnity n R) = n
-- Mathlib/Algebra/Group/Defs.lean
/-- A commutative additive magma is a type with an addition which commutes. -/
@[ext]
class AddCommMagma (G : Type u) extends Add G where
  /-- Addition is commutative in an commutative additive magma. -/
  protected add_comm : ∀ a b : G, a + b = b + a
-- Mathlib/Analysis/Analytic/Polynomial.lean
theorem AnalyticOn.eval_linearMap' (f : σ → E →ₗ[𝕜] B) (p : MvPolynomial σ B) :
    AnalyticOn 𝕜 (fun x ↦ eval (f · x) p) Set.univ
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem Filter.EventuallyEq.lineDifferentiableWithinAt_iff
    (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : f₀ x = f₁ x) :
    LineDifferentiableWithinAt 𝕜 f₀ s x v ↔ LineDifferentiableWithinAt 𝕜 f₁ s x v
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [T0Space α]
    {f g : CauchyFilter α} :
    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ Inseparable f g
-- Mathlib/Topology/LocallyConstant/Basic.lean
protected theorem comp {f : X → Y} (hf : IsLocallyConstant f) (g : Y → Z) :
    IsLocallyConstant (g ∘ f)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_add_comm {n m k : Nat} (h : k ≤ n) : n + m - k = n - k + m
-- Mathlib/Algebra/MvPolynomial/Cardinal.lean
theorem cardinal_lift_mk_le_max {σ : Type u} {R : Type v} [CommSemiring R] : #(MvPolynomial σ R) ≤
    max (max (Cardinal.lift.{u} #R) <| Cardinal.lift.{v} #σ) ℵ₀
-- Mathlib/Order/Lattice.lean
theorem inf_le_of_right_le (h : b ≤ c) : a ⊓ b ≤ c
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_eq_bot : sInf s = ⊥ ↔ ∀ b > ⊥, ∃ a ∈ s, a < b
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_injOn_pos_of_base_lt_one : Set.InjOn (logb b) (Set.Ioi 0)
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bit_negSucc (b) (n : ℕ) : bit b -[n+1] = -[Nat.bit (not b) n+1]
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
    stdBasisMatrix i j c * stdBasisMatrix k l d = 0
-- Mathlib/Topology/Order/Monotone.lean
/-- If a monotone function is continuous at the indexed supremum of a bounded function on
a nonempty `Sort`, then it sends this supremum to the supremum of the composition. -/
theorem Monotone.map_ciSup_of_continuousAt {f : α → β} {g : γ → α} (Cf : ContinuousAt f (⨆ i, g i))
    (Mf : Monotone f) (H : BddAbove (range g)) : f (⨆ i, g i) = ⨆ i, f (g i)
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem wellFoundedOn_bUnion [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
theorem Sphere.ne_iff {s₁ s₂ : Sphere P} :
    s₁ ≠ s₂ ↔ s₁.center ≠ s₂.center ∨ s₁.radius ≠ s₂.radius
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem associator_inv_naturality_left {X X' : C} (f : X ⟶ X') (Y Z : C) :
    f ▷ (Y ⊗ Z) ≫ (α_ X' Y Z).inv = (α_ X Y Z).inv ≫ f ▷ Y ▷ Z
-- Mathlib/Logic/Equiv/Functor.lean
@[simp]
theorem mapEquiv_symm_apply (h : α ≃ β) (y : f β) :
    (mapEquiv f h : f α ≃ f β).symm y = map h.symm y
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem card_roots_le_map [IsDomain A] [IsDomain B] {p : A[X]} {f : A →+* B} (h : p.map f ≠ 0) :
    Multiset.card p.roots ≤ Multiset.card (p.map f).roots
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp, norm_cast]
theorem coe_subset_coe : (I : Set (ι → ℝ)) ⊆ J ↔ I ≤ J
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
@[simp]
theorem natDegree_hermite {n : ℕ} : (hermite n).natDegree = n
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
lemma degreeOf_le_iff {n : σ} {f : MvPolynomial σ R} {d : ℕ} :
    degreeOf n f ≤ d ↔ ∀ m ∈ support f, m n ≤ d
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_eq_empty_iff [DenselyOrdered α] : Ioo a b = ∅ ↔ ¬a < b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem mod_div_self (m n : Nat) : m % n / n = 0
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
protected lemma min_le_iff : min (a : WithZero α) b ≤ c ↔ min a b ≤ c
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem weightedSumSquares_apply [Monoid S] [DistribMulAction S R] [SMulCommClass S R R]
    (w : ι → S) (v : ι → R) :
    weightedSumSquares R w v = ∑ i : ι, w i • (v i * v i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_one_mul  (n m : Nat) : (n - 1) * m = n * m - m
-- Mathlib/Tactic/NormNum/LegendreSymbol.lean
theorem isInt_jacobiSymNat : {a na : ℕ} → {b nb : ℕ} → {r : ℤ} →
    IsNat a na → IsNat b nb → jacobiSymNat na nb = r → IsInt (jacobiSymNat a b) r
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Hereditarily.empty : Hereditarily p x → p ∅
-- Mathlib/Logic/Basic.lean
lemma iff_eq_eq {a b : Prop} : (a ↔ b) = (a = b)
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
protected theorem partial_sups [Preorder ι] [LocallyFiniteOrderBot ι] {p : SeminormFamily 𝕜 E ι}
    [TopologicalSpace E] (hp : WithSeminorms p) : WithSeminorms (fun i ↦ (Finset.Iic i).sup p)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In a preadditive category, if the product of `X` and `Y` exists, then the
    binary biproduct of `X` and `Y` exists. -/
theorem HasBinaryBiproduct.of_hasBinaryProduct (X Y : C) [HasBinaryProduct X Y] :
    HasBinaryBiproduct X Y
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem coe_map (s : Sym α n) (f : α → β) : ↑(s.map f) = Multiset.map f s
-- Mathlib/Data/Set/Sups.lean
@[simp] lemma sups_eq_self : s ⊻ s = s ↔ SupClosed s
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem msb_shiftLeftZeroExtend (x : BitVec w) (i : Nat) :
    (shiftLeftZeroExtend x i).msb = x.msb
-- Mathlib/Topology/Order/LawsonTopology.lean
theorem isClosed_preimage_ofLawson {S : Set α} :
    IsClosed (ofLawson ⁻¹' S) ↔ IsClosed[lawson α] S
-- Mathlib/GroupTheory/GroupAction/Basic.lean
/-- To prove inclusion of a *subgroup* in a stabilizer, it is enough to prove inclusions.-/
theorem le_stabilizer_iff_smul_le (s : Set α) (H : Subgroup G) :
    H ≤ stabilizer G s ↔ ∀ g ∈ H, g • s ⊆ s
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
@[gcongr]
theorem _root_.GCongr.natCast_le_natCast {a b : ℕ} (h : a ≤ b) : (a : α) ≤ b
-- Mathlib/Topology/Order/Monotone.lean
/-- If a monotone function is continuous at the supremum of a nonempty bounded above set `s`,
then it sends this supremum to the supremum of the image of `s`. -/
theorem Monotone.map_csSup_of_continuousAt {f : α → β} {s : Set α} (Cf : ContinuousAt f (sSup s))
    (Mf : Monotone f) (ne : s.Nonempty) (H : BddAbove s) : f (sSup s) = sSup (f '' s)
-- Mathlib/NumberTheory/NumberField/Basic.lean
/-- The canonical map from `𝓞 K` to `K` is injective.

This is a convenient abbreviation for `NoZeroSMulDivisors.algebraMap_injective`.
-/
lemma coe_injective : Function.Injective (algebraMap (𝓞 K) K)
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem eq_of_forall_symmetric {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
    (h : ∀ {V}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V) : x = y
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_add {K₁ K₂ : ConvexCone 𝕜 E} {a : E} :
    a ∈ K₁ + K₂ ↔ ∃ x ∈ K₁, ∃ y ∈ K₂, x + y = a
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem AlgebraicIndependent.aeval_comp_mvPolynomialOptionEquivPolynomialAdjoin
    (hx : AlgebraicIndependent R x) (a : A) :
    RingHom.comp
        (↑(Polynomial.aeval a : Polynomial (adjoin R (Set.range x)) →ₐ[_] A) :
          Polynomial (adjoin R (Set.range x)) →+* A)
        hx.mvPolynomialOptionEquivPolynomialAdjoin.toRingHom =
      ↑(MvPolynomial.aeval fun o : Option ι => o.elim a x : MvPolynomial (Option ι) R →ₐ[R] A)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem id_comp (f : sInfHom α β) : (sInfHom.id β).comp f = f
-- Mathlib/Order/CompleteLattice.lean
theorem Equiv.iSup_comp {g : ι' → α} (e : ι ≃ ι') : ⨆ x, g (e x) = ⨆ y, g y
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[ext]
theorem ext (a b : SimplexCategory) : a.len = b.len → a = b
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem of_d (j : α) : (of X d sq).d j (j + 1) = d j
-- Mathlib/RingTheory/AdicCompletion/Exactness.lean
/-- Adic completion preserves surjectivity -/
theorem map_surjective : Function.Surjective (map I f)
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp, norm_cast]
theorem coe_to_distribMulActionHom (f : A →ₛₙₐ[φ] B) : ⇑(f : A →ₑ+[φ] B) = f
-- Mathlib/Topology/PartialHomeomorph.lean
/-- Two partial homeomorphisms are equal when they have equal `toFun`, `invFun` and `source`.
It is not sufficient to have equal `toFun` and `source`, as this only determines `invFun` on
the target. This would only be true for a weaker notion of equality, arguably the right one,
called `EqOnSource`. -/
@[ext]
protected theorem ext (e' : PartialHomeomorph X Y) (h : ∀ x, e x = e' x)
    (hinv : ∀ x, e.symm x = e'.symm x) (hs : e.source = e'.source) : e = e'
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. The maximum of an integrable function is greater than its mean. -/
theorem exists_setAverage_le (hμ : μ s ≠ 0) (hμ₁ : μ s ≠ ∞) (hf : IntegrableOn f s μ) :
    ∃ x ∈ s, ⨍ a in s, f a ∂μ ≤ f x
-- Mathlib/Topology/Instances/EReal.lean
private lemma continuousAt_mul_top_ne_zero {a : ℝ} (h : a ≠ 0) :
    ContinuousAt (fun p : EReal × EReal ↦ p.1 * p.2) (⊤, a)
-- Mathlib/Analysis/Analytic/Basic.lean
theorem radius_eq_top_of_forall_nnreal_isBigO
    (h : ∀ r : ℝ≥0, (fun n => ‖p n‖ * (r : ℝ) ^ n) =O[atTop] fun _ => (1 : ℝ)) : p.radius = ∞
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_iInter {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderSpecialization (S i)) : StableUnderSpecialization (⋂ i, S i)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem of_decide_eq_false [inst : Decidable p] : Eq (decide p) false → Not p
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isBounded_iff_subset_smul_closedBall {s : Set E} :
    Bornology.IsBounded s ↔ ∃ a : 𝕜, s ⊆ a • Metric.closedBall (0 : E) 1
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma Even.neg_pow : Even n → ∀ a : α, (-a) ^ n = a ^ n
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem toBlocks_fromBlocks₁₂ (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α)
    (D : Matrix o m α) : (fromBlocks A B C D).toBlocks₁₂ = B
-- Mathlib/Probability/Kernel/IntegralCompProd.lean
theorem setIntegral_compProd_univ_left (f : β × γ → E) {t : Set γ} (ht : MeasurableSet t)
    (hf : IntegrableOn f (univ ×ˢ t) ((κ ⊗ₖ η) a)) :
    ∫ z in univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ x, ∫ y in t, f (x, y) ∂η (a, x) ∂κ a
-- Mathlib/Combinatorics/SetFamily/FourFunctions.lean
lemma le_collapse_of_mem (ha : a ∉ s) (hf : 0 ≤ f) (hts : t = s) (ht : t ∈ 𝒜) :
    f t ≤ collapse 𝒜 a f s
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma dual_mul_self :
    dual A K I * I = dual A K 1
-- Mathlib/Data/Prod/Basic.lean
theorem Bijective.prodMap (hf : Bijective f) (hg : Bijective g) : Bijective (map f g)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp] theorem Prod.map_snd (f : α → β) (g : γ → δ) (x) : (Prod.map f g x).2 = g x.2
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_true_left   : ∀(c f : Bool), cond c true f  = ( c || f)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fmod_eq_mod {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fmod a b = mod a b
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
/-- Down-compressing a family is idempotent. -/
@[simp]
theorem compression_idem (a : α) (𝒜 : Finset (Finset α)) : 𝓓 a (𝓓 a 𝒜) = 𝓓 a 𝒜
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem cauchySeq_finset_iff_prod_vanishing :
    (CauchySeq fun s : Finset β ↦ ∏ b ∈ s, f b) ↔
      ∀ e ∈ 𝓝 (1 : α), ∃ s : Finset β, ∀ t, Disjoint t s → (∏ b ∈ t, f b) ∈ e
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem equiv_refl : b.equiv b (Equiv.refl ι) = LinearEquiv.refl R M
-- Mathlib/Algebra/Module/Torsion.lean
/-- The `S`-torsion submodule is an `S`-torsion module. -/
theorem torsion'_isTorsion' : IsTorsion' (torsion' R M S) S
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
theorem seq_eq_bind {α β : Type u} [Monad m] [LawfulMonad m] (mf : m (α → β)) (x : m α) : mf <*> x = mf >>= fun f => f <$> x
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
@[simp]
theorem smul_mk0 {α : Type*} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem lintegral_withDensity_eq_lintegral_mul_non_measurable₀ (μ : Measure α) {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (h'f : ∀ᵐ x ∂μ, f x < ∞) (g : α → ℝ≥0∞) :
    ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem one_toNat : toNat 1 = 1
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem getLeft?_inl : (inl x : α ⊕ β).getLeft? = some x
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[ext high]
protected theorem bot_ext (x y : (⊥ : Submodule R M)) : x = y
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
/-- The type of ordinals in universe `u` is not `Small.{u}`. This is the type-theoretic analog of
the Burali-Forti paradox. -/
theorem not_small_ordinal : ¬Small.{u} Ordinal.{max u v}
-- Mathlib/Data/Int/ModEq.lean
protected theorem eq : a ≡ b [ZMOD n] → a % n = b % n
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem cocycle_fst_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫
      pullback.fst _ _ = pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _
-- Mathlib/Data/Matrix/Basic.lean
theorem scalar_commute_iff {r : α} {M : Matrix n n α} :
    Commute (scalar n r) M ↔ r • M = MulOpposite.op r • M
-- Mathlib/GroupTheory/CommutingProbability.lean
@[simp] lemma reciprocalFactors_zero : reciprocalFactors 0 = [0]
-- Mathlib/CategoryTheory/Sigma/Basic.lean
/-- Given a collection of functors `F i : C i ⥤ D`, we can produce a functor `(Σ i, C i) ⥤ D`.

The produced functor `desc F` satisfies: `incl i ⋙ desc F ≅ F i`, i.e. restricted to just the
subcategory `C i`, `desc F` agrees with `F i`, and it is unique (up to natural isomorphism) with
this property.

This witnesses that the sigma-type is the coproduct in Cat.
-/
@[simps obj]
def desc : (Σi, C i) ⥤ D
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem map_le_iff_le_comap {f : R →+* S} {s : Subring R} {t : Subring S} :
    s.map f ≤ t ↔ s ≤ t.comap f
-- Mathlib/Data/Sym/Sym2.lean
theorem mem_fromRel_irrefl_other_ne {sym : Symmetric r} (irrefl : Irreflexive r) {a : α}
    {z : Sym2 α} (hz : z ∈ fromRel sym) (h : a ∈ z) : Mem.other h ≠ a
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
@[ext]
theorem ext {p q : RingNorm R} : (∀ x, p x = q x) → p = q
-- Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean
@[simp]
lemma Γ₂N₂ToKaroubiIso_inv_app (X : SimplicialObject C) :
    Γ₂N₂ToKaroubiIso.inv.app X = Γ₂.map (toKaroubiCompN₂IsoN₁.inv.app X)
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
lemma isCondKernelCDF_condKernelCDF (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    IsCondKernelCDF (condKernelCDF κ) κ (fst κ)
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
lemma IsOrthogonal.symm : IsOrthogonal P i j ↔ IsOrthogonal P j i
-- Mathlib/Algebra/Ring/Basic.lean
theorem succ_ne_self {α : Type*} [NonAssocRing α] [Nontrivial α] (a : α) : a + 1 ≠ a
-- Mathlib/CategoryTheory/Groupoid/Basic.lean
theorem isThin_iff : Quiver.IsThin C ↔ ∀ c : C, Subsingleton (c ⟶ c)
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[simp] lemma nnnorm_ofMul (x : E) : ‖ofMul x‖₊ = ‖x‖₊
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem head_map (f : α → β) (l : List α) (w) :
    head (map f l) w = f (head l (by simpa using w))
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem frequently_and_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∃ᶠ x in f, p ∧ q x) ↔ p ∧ ∃ᶠ x in f, q x
-- Mathlib/NumberTheory/Dioph.lean
@[simp]
theorem const_apply (n) (x : α → ℕ) : const n x = n
-- Mathlib/RingTheory/Polynomial/GaussLemma.lean
theorem IsPrimitive.Int.dvd_iff_map_cast_dvd_map_cast (p q : ℤ[X]) (hp : p.IsPrimitive)
    (hq : q.IsPrimitive) : p ∣ q ↔ p.map (Int.castRingHom ℚ) ∣ q.map (Int.castRingHom ℚ)
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem u_nonneg (x : E) : 0 ≤ u x
-- Mathlib/LinearAlgebra/TensorAlgebra/Basis.lean
/-- A basis on `M` can be lifted to a basis on `TensorAlgebra R M` -/
@[simps! repr_apply]
noncomputable def _root_.Basis.tensorAlgebra (b : Basis κ R M) :
    Basis (FreeMonoid κ) R (TensorAlgebra R M)
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem image.factor_map :
    factorThruImage f.hom ≫ image.map sq = sq.left ≫ factorThruImage g.hom
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem mem_toArray {a : α} {l : List α} : a ∈ l.toArray ↔ a ∈ l
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- If the Lebesgue integral of a function is bounded by some constant on all sets with finite
measure and the measure is σ-finite, then the integral over the whole space is bounded by that same
constant. -/
theorem lintegral_le_of_forall_fin_meas_le [MeasurableSpace α] {μ : Measure α} [SigmaFinite μ]
    (C : ℝ≥0∞) {f : α → ℝ≥0∞}
    (hf : ∀ s, MeasurableSet s → μ s ≠ ∞ → ∫⁻ x in s, f x ∂μ ≤ C) : ∫⁻ x, f x ∂μ ≤ C
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
/-- The exponential in a Banach algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ` has Fréchet derivative
`1 : 𝔸 →L[𝕂] 𝔸` at zero. -/
theorem hasFDerivAt_exp_zero : HasFDerivAt (exp 𝕂) (1 : 𝔸 →L[𝕂] 𝔸) 0
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNorm_indicator_le (f : α → E) : eLpNorm (s.indicator f) p μ ≤ eLpNorm f p μ
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem toFinsupp_injective : Function.Injective (toFinsupp : R[X] → AddMonoidAlgebra _ _)
-- Mathlib/Init/Logic.lean
theorem InvImage.trans (f : α → β) (h : Transitive r) : Transitive (InvImage r f)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem mem_Iic_of_Iio (h : x ∈ Iio a) : x ∈ Iic a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem contDiff_cosh {n} : ContDiff ℂ n cosh
-- Mathlib/Algebra/FreeAlgebra.lean
theorem ι_injective [Nontrivial R] : Function.Injective (ι R : X → FreeAlgebra R X)