ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Flat/EquationalCriterion.lean
/-- **Equational criterion for flatness** [Stacks 00HK](https://stacks.math.columbia.edu/tag/00HK),
combined form.

Let $M$ be a module over a commutative ring $R$. The following are equivalent:
* $M$ is flat.
* For all ideals $I \subseteq R$, the map $I \otimes M \to M$ is injective.
* Every $\sum_i f_i \otimes x_i$ that vanishes in $R \otimes M$ vanishes trivially.
* Every relation $\sum_i f_i x_i = 0$ in $M$ is trivial.
* For all finite index types $\iota$, all elements $f \in R^{\iota}$, and all homomorphisms
$x \colon R^{\iota} \to M$ such that $x(f) = 0$, there exist a finite index type $\kappa$ and module
homomorphisms $a \colon R^{\iota} \to R^{\kappa}$ and $y \colon R^{\kappa} \to M$ such
that $x = y \circ a$ and $a(f) = 0$.
* For all finite free modules $N$, all elements $f \in N$, and all homomorphisms $x \colon N \to M$
such that $x(f) = 0$, there exist a finite index type $\kappa$ and module homomorphisms
$a \colon N \to R^{\kappa}$ and $y \colon R^{\kappa} \to M$ such that $x = y \circ a$ and
$a(f) = 0$. -/
theorem tfae_equational_criterion : List.TFAE [
    Flat R M,
    ∀ (I : Ideal R), Function.Injective ⇑(rTensor M (Submodule.subtype I)),
    ∀ {ι : Type u} [Fintype ι] {f : ι → R} {x : ι → M}, ∑ i, f i ⊗ₜ x i = (0 : R ⊗[R] M) →
      VanishesTrivially R f x,
    ∀ {ι : Type u} [Fintype ι] {f : ι → R} {x : ι → M}, ∑ i, f i • x i = 0 → IsTrivialRelation f x,
    ∀ {ι : Type u} [Fintype ι] {f : ι →₀ R} {x : (ι →₀ R) →ₗ[R] M}, x f = 0 →
      ∃ (κ : Type u) (_ : Fintype κ) (a : (ι →₀ R) →ₗ[R] (κ →₀ R)) (y : (κ →₀ R) →ₗ[R] M),
        x = y ∘ₗ a ∧ a f = 0,
    ∀ {N : Type u} [AddCommGroup N] [Module R N] [Free R N] [Finite R N] {f : N} {x : N →ₗ[R] M},
      x f = 0 →
        ∃ (κ : Type u) (_ : Fintype κ) (a : N →ₗ[R] (κ →₀ R)) (y : (κ →₀ R) →ₗ[R] M),
          x = y ∘ₗ a ∧ a f = 0]
-- Mathlib/Topology/Maps/Basic.lean
theorem OpenEmbedding.continuousAt_iff (hf : OpenEmbedding f) {x : X} :
    ContinuousAt (g ∘ f) x ↔ ContinuousAt g (f x)
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProd_eq_sum_compProd_left (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ) :
    κ ⊗ₖ η = Kernel.sum fun n => seq κ n ⊗ₖ η
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivWithinAt.sin (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
lemma hausdorffMeasure_of_finrank_lt [MeasurableSpace E] [BorelSpace E] {d : ℝ}
    (hd : finrank ℝ E < d) : (μH[d] : Measure E) = 0
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp]
theorem preimage_cast_Ioc (p q : ℚ) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q
-- Mathlib/Order/CompleteLatticeIntervals.lean
/-- The `sSup` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
    (h_bdd : BddAbove t) : sSup ((↑) '' t : Set α) ∈ s
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- If `G` is closed under restriction, the transition function between
  the restriction of two charts `e` and `e'` lies in `G`. -/
theorem StructureGroupoid.trans_restricted {e e' : PartialHomeomorph M H} {G : StructureGroupoid H}
    (he : e ∈ atlas H M) (he' : e' ∈ atlas H M)
    [HasGroupoid M G] [ClosedUnderRestriction G] {s : Opens M} (hs : Nonempty s) :
    (e.subtypeRestr hs).symm ≫ₕ e'.subtypeRestr hs ∈ G
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
protected theorem IntegrableAtFilter.sub {f g : α → E}
    (hf : IntegrableAtFilter f l μ) (hg : IntegrableAtFilter g l μ) :
    IntegrableAtFilter (f - g) l μ
-- Mathlib/Data/Sum/Interval.lean
@[simp]
theorem Ioc_inl_inr : Ioc (inl a₁) (inr b₂) = ∅
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
@[simp]
theorem measure_Ioo {a b : ℝ} : f.measure (Ioo a b) = ofReal (leftLim f b - f a)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive le_add_of_nonneg_right]
theorem le_mul_of_one_le_right' [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (h : 1 ≤ b) :
    a ≤ a * b
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem PosMulReflectLT.toPosMulReflectLE [PosMulReflectLT α] : PosMulReflectLE α
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem of_measure_le {μ' : Measure α} (h : μ ≤ μ') (hT : DominatedFinMeasAdditive μ T C)
    (hC : 0 ≤ C) : DominatedFinMeasAdditive μ' T C
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem argmax_eq_none : l.argmax f = none ↔ l = []
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem map_smul₂ (f : M₂ →ₗ[R] N₂ →ₛₗ[σ₁₂] P₂) (r : R) (x y) : f (r • x) y = r • f x y
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- Being cofiltered or empty is preserved by equivalence of categories. -/
theorem of_equivalence (h : C ≌ D) : IsCofilteredOrEmpty D
-- .lake/packages/batteries/Batteries/Logic.lean
theorem congrFun₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
    {f g : ∀ a b, γ a b} (h : f = g) (a : α) (b : β a) :
    f a b = g a b
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The angle between a nonzero vector and its negation is `π`. -/
@[simp]
theorem oangle_neg_self_right {x : V} (hx : x ≠ 0) : o.oangle x (-x) = π
-- Mathlib/Order/Partition/Finpartition.lean
/-- Restricts a finpartition to avoid a given element. -/
@[simps!]
def avoid (b : α) : Finpartition (a \ b)
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem Memℒp.memℒp_of_exponent_le {p q : ℝ≥0∞} [IsFiniteMeasure μ] {f : α → E} (hfq : Memℒp f q μ)
    (hpq : p ≤ q) : Memℒp f p μ
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
lemma bot_toAddSubgroup {R M} [Ring R] [AddCommGroup M] [Module R M] :
    (⊥ : Submodule R M).toAddSubgroup = ⊥
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem degree_le' (G' G'' : Subgraph G) (h : G' ≤ G'') (v : V) [Fintype (G'.neighborSet v)]
    [Fintype (G''.neighborSet v)] : G'.degree v ≤ G''.degree v
-- Mathlib/Logic/Equiv/Fin.lean
theorem Fin.preimage_apply_01_prod' {α : Type u} (s t : Set α) :
    (fun f : Fin 2 → α => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.pi Set.univ ![s, t]
-- Mathlib/Order/Closure.lean
lemma conjBy_trans {α β γ} [Preorder α] [Preorder β] [Preorder γ]
    (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : ClosureOperator α) :
    c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem map_comap_map {f : M →[L] N} : ((S.map f).comap f).map f = S.map f
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
lemma _root_.ContinuousLinearMap.hasTemperateGrowth (f : E →L[ℝ] F) :
    Function.HasTemperateGrowth f
-- Mathlib/Computability/Primrec.lean
theorem prec1 {f} (m : ℕ) (hf : Nat.Primrec f) :
    Nat.Primrec fun n => n.rec m fun y IH => f <| Nat.pair y IH
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean
theorem antideriv_cos_comp_const_mul (hz : z ≠ 0) (x : ℝ) :
    HasDerivAt (fun y : ℝ => Complex.sin (2 * z * y) / (2 * z)) (Complex.cos (2 * z * x)) x
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem pow_cast_right (a : Cardinal.{u}) (n : ℕ) : a ^ (↑n : Cardinal.{u}) = a ^ n
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
theorem HasSum.smul (hf : HasSum f s) (hg : HasSum g t)
    (hfg : Summable fun x : ι × κ ↦ f x.1 • g x.2) :
    HasSum (fun x : ι × κ ↦ f x.1 • g x.2) (s • t)
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
@[simp]
theorem equivOfEquiv_symm_comp_algebraMap (hSR : S ≃+* R) :
    ((equivOfEquiv L M hSR).symm : M →+* L).comp (algebraMap R M) =
      (algebraMap S L).comp hSR.symm
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem and_pow_two_is_mod (x n : Nat) : x &&& (2^n-1) = x % 2^n
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
protected theorem strict_mono (hf : IsFundamentalSequence a o f) {i j} :
    ∀ hi hj, i < j → f i hi < f j hj
-- Mathlib/Data/Finsupp/Defs.lean
theorem mem_support_single (a a' : α) (b : M) : a ∈ (single a' b).support ↔ a = a' ∧ b ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem tan_ne_zero_iff {θ : ℝ} : tan θ ≠ 0 ↔ ∀ k : ℤ, k * π / 2 ≠ θ
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem coe_mk (f : α → β) (h) : ⇑(⟨f, h⟩ : α →ᵈ β) = f
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem mul_def (e e' : E ≃ₗᵢ[R] E) : (e * e' : E ≃ₗᵢ[R] E) = e'.trans e
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
/-- Basic hypothesis to talk about a smooth (Lie) monoid or a smooth semigroup.
A smooth monoid over `G`, for example, is obtained by requiring both the instances `Monoid G`
and `SmoothMul I G`. -/
@[to_additive]
class SmoothMul {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Mul G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_mul : Smooth (I.prod I) I fun p : G × G => p.1 * p.2
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
theorem continuousOn_stereoToFun :
    ContinuousOn (stereoToFun v) {x : E | innerSL _ v x ≠ (1 : ℝ)}
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem eq_zero_of_not_dvd {n : ℕ} (h : ¬p ∣ n) : padicValNat p n = 0
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem liftMonoidWithZeroHom_apply {L : Type*} [CommGroupWithZero L] (φ : K[X] →*₀ L)
    (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftMonoidWithZeroHom φ hφ f = φ f.num / φ f.denom
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square with `0 : 0 ⟶ 0` on the top and `𝟙 X` on the bottom is a pullback square. -/
@[simp]
theorem zero_top (X : C) : IsPullback (0 : (0 : C) ⟶ 0) (0 : 0 ⟶ X) (0 : 0 ⟶ X) (𝟙 X)
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
/-- `PInfty` induces a natural transformation, i.e. an endomorphism of
the functor `alternatingFaceMapComplex C`. -/
@[simps]
noncomputable def natTransPInfty : alternatingFaceMapComplex C ⟶ alternatingFaceMapComplex C
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bsup_const {o : Ordinal.{u}} (ho : o ≠ 0) (a : Ordinal.{max u v}) :
    (bsup.{_, v} o fun _ _ => a) = a
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
/-- This lemma is impractical to state in the dependent case. -/
@[simp]
theorem reindex_symm (e : ι ≃ ι₂) :
    (reindex R (fun _ ↦ M) e).symm = reindex R (fun _ ↦ M) e.symm
-- Mathlib/CategoryTheory/Abelian/Basic.lean
theorem epi_snd_of_isLimit [Epi f] {s : PullbackCone f g} (hs : IsLimit s) : Epi s.snd
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
/-- See `zero_lt_three'` for a version with the type explicit. -/
@[simp] lemma zero_lt_three : (0 : α) < 3
-- Mathlib/CategoryTheory/Sites/Over.lean
@[simp]
lemma functorPushforward_over_map {X Y : C} (f : X ⟶ Y) (Z : Over X) (S : Sieve Z.left) :
    Sieve.functorPushforward (Over.map f) ((Sieve.overEquiv Z).symm S) =
      (Sieve.overEquiv ((Over.map f).obj Z)).symm S
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
@[ext high]
theorem monoidWithZeroHom_ext ⦃f g : WithZero α →*₀ β⦄
    (h : f.toMonoidHom.comp coeMonoidHom = g.toMonoidHom.comp coeMonoidHom) :
    f = g
-- Mathlib/Data/Set/Basic.lean
theorem sep_eq_of_subset (h : s ⊆ t) : { x ∈ t | x ∈ s } = s
-- Mathlib/MeasureTheory/Constructions/Projective.lean
lemma isFiniteMeasure [∀ i, IsFiniteMeasure (P i)] (hμ : IsProjectiveLimit μ P) :
    IsFiniteMeasure μ
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
theorem ι_leftInverse : Function.LeftInverse ιInv (ι R : M → TensorAlgebra R M)
-- Mathlib/Computability/TMToPartrec.lean
theorem supports_singleton {S q} : Supports {q} S ↔ TM2.SupportsStmt S (tr q)
-- Mathlib/GroupTheory/Nilpotent.lean
/-- Any descending central series for a group is bounded below by the lower central series. -/
theorem descending_central_series_ge_lower (H : ℕ → Subgroup G) (hH : IsDescendingCentralSeries H) :
    ∀ n : ℕ, lowerCentralSeries G n ≤ H n
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem pos_of_mem_ball (hy : y ∈ ball x ε) : 0 < ε
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem mapsTo_ball (hf : Isometry f) (x : α) (r : ℝ) :
    MapsTo f (Metric.ball x r) (Metric.ball (f x) r)
-- Mathlib/Topology/Basic.lean
@[simp]
theorem closure_empty : closure (∅ : Set X) = ∅
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem zip_cons_cons : zip (a :: as) (b :: bs) = (a, b) :: zip as bs
-- Mathlib/Data/Fin/Basic.lean
/-- `pred` commutes with `succAbove`. -/
lemma pred_succAbove_pred {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ 0)
    (hk := succAbove_ne_zero ha hb) :
    (a.pred ha).succAbove (b.pred hb) = (a.succAbove b).pred hk
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem not_or : ¬(p ∨ q) ↔ ¬p ∧ ¬q
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem adj_inj {G H : SimpleGraph V} : G.Adj = H.Adj ↔ G = H
-- Mathlib/CategoryTheory/Sites/Discrete.lean
lemma sheafCompose_reflects_discrete [(sheafCompose J U).ReflectsIsomorphisms]
    [((sheafCompose J U).obj F).IsDiscrete J ht] :
    F.IsDiscrete J ht
-- Mathlib/Probability/Process/Stopping.lean
protected theorem min_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
    (hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => min (τ ω) i
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.mul {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =O[l] g₁) (h₂ : f₂ =O[l] g₂) :
    (fun x => f₁ x * f₂ x) =O[l] fun x => g₁ x * g₂ x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- The oriented angle between three points equals minus the unoriented angle if the sign is
negative. -/
theorem oangle_eq_neg_angle_of_sign_eq_neg_one {p₁ p₂ p₃ : P} (h : (∡ p₁ p₂ p₃).sign = -1) :
    ∡ p₁ p₂ p₃ = -∠ p₁ p₂ p₃
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
@[simp]
theorem id_comp (f : Q₁ →qᵢ Q₂) : (id Q₂).comp f = f
-- Mathlib/Analysis/Normed/Order/Lattice.lean
theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖
-- Mathlib/Algebra/Order/Floor.lean
theorem fract_eq_zero_or_add_one_sub_ceil (a : α) : fract a = 0 ∨ fract a = a + 1 - (⌈a⌉ : α)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_node' {P l x r} : @All α P (node' l x r) ↔ All P l ∧ P x ∧ All P r
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem modifyNth_eq_set_get? (f : α → α) :
    ∀ n (l : List α), l.modifyNth f n = ((fun a => l.set n (f a)) <$> l.get? n).getD l
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem sup_inf_bihimp : (a ⊔ b) ⊓ a ⇔ b = a ⊓ b
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem map_mul : (I * J).map g = I.map g * J.map g
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem eval_app (S₁ S₂ : SheafOfTypes.{u} typesGrothendieckTopology) (f : S₁ ⟶ S₂) (α : Type u)
    (s : S₁.1.obj (op α)) (x : α) :
    eval S₂.1 α (f.val.app (op α) s) x = f.val.app (op PUnit) (eval S₁.1 α s x)
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
/-- A function applied to a `ite` is a `ite` of that function applied to each of the branches. -/
theorem apply_ite (f : α → β) (P : Prop) [Decidable P] (x y : α) :
    f (ite P x y) = ite P (f x) (f y)
-- Mathlib/Topology/Constructions.lean
theorem isOpenMap_sigmaMk {i : ι} : IsOpenMap (@Sigma.mk ι σ i)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem conjugates_subset_normal {N : Subgroup G} [tn : N.Normal] {a : G} (h : a ∈ N) :
    conjugatesOf a ⊆ N
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
nonrec theorem map_apply (hf : MeasurableEmbedding f) (μ : Measure α) (s : Set β) :
    μ.map f s = μ (f ⁻¹' s)
-- Mathlib/Algebra/Order/Kleene.lean
theorem kstar_mul_le (hb : b ≤ c) (ha : a * c ≤ c) : a∗ * b ≤ c
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem comp_nsmul (n : ℕ) : f ≫ (n • g) = n • f ≫ g
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.mono (h₁ : a ≤ b) (h₂ : c ≤ d) : Codisjoint a c → Codisjoint b d
-- Mathlib/Data/Set/Constructions.lean
theorem finiteInterClosure_finiteInter : FiniteInter (finiteInterClosure S)
-- Mathlib/Algebra/Polynomial/Inductions.lean
theorem divX_add : divX (p + q) = divX p + divX q
-- Mathlib/Topology/UniformSpace/CompactConvergence.lean
theorem _root_.Filter.HasBasis.compactConvergenceUniformity {ι : Type*} {pi : ι → Prop}
    {s : ι → Set (β × β)} (h : (𝓤 β).HasBasis pi s) :
    HasBasis (𝓤 C(α, β)) (fun p : Set α × ι => IsCompact p.1 ∧ pi p.2) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ s p.2 }
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem map_comp {f : S ⟶ S'} {f' : S' ⟶ S''} {h : StructuredArrow S'' T} :
    (map (f ≫ f')).obj h = (map f).obj ((map f').obj h)
-- Mathlib/Order/SupClosed.lean
lemma IsSublattice.prod {t : Set β} (hs : IsSublattice s) (ht : IsSublattice t) :
    IsSublattice (s ×ˢ t)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem implies_dep_congr_ctx {p₁ p₂ q₁ : Prop} (h₁ : p₁ = p₂) {q₂ : p₂ → Prop} (h₂ : (h : p₂) → q₁ = q₂ h) : (p₁ → q₁) = ((h : p₂) → q₂ h)
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
@[simp]
theorem ordConnectedComponent_ordConnectedProj (s : Set α) (x : s) :
    ordConnectedComponent s (ordConnectedProj s x) = ordConnectedComponent s x
-- Mathlib/Data/List/Lex.lean
@[simp]
theorem not_nil_right (r : α → α → Prop) (l : List α) : ¬Lex r l []
-- Mathlib/GroupTheory/SemidirectProduct.lean
theorem inl_aut (g : G) (n : N) : (inl (φ g n) : N ⋊[φ] G) = inr g * inl n * inr g⁻¹
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_lt : ⌊a⌋ < z ↔ a < z
-- Mathlib/Algebra/GroupWithZero/Pi.lean
lemma single_mul_right_apply (i j : ι) (f : ∀ i, α i) (a : α i) :
    single i (f i * a) j = f j * single i a j
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_comp {f : α → β} {g : β → γ} :
    mapDomain (g ∘ f) v = mapDomain g (mapDomain f v)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A set, considered as a subset of its spanned affine subspace, spans the whole subspace. -/
@[simp]
theorem affineSpan_coe_preimage_eq_top (A : Set P) [Nonempty A] :
    affineSpan k (((↑) : affineSpan k A → P) ⁻¹' A) = ⊤
-- Mathlib/CategoryTheory/CofilteredSystem.lean
/-- The cofiltered limit of nonempty finite types is nonempty.

See `nonempty_sections_of_finite_inverse_system` for a specialization to inverse limits. -/
theorem nonempty_sections_of_finite_cofiltered_system {J : Type u} [Category.{w} J]
    [IsCofilteredOrEmpty J] (F : J ⥤ Type v) [∀ j : J, Finite (F.obj j)]
    [∀ j : J, Nonempty (F.obj j)] : F.sections.Nonempty
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem vsub_subset_vsub_right : s₁ ⊆ s₂ → s₁ -ᵥ t ⊆ s₂ -ᵥ t
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem inclusion_trans {R S T : Subgroupoid C} (k : R ≤ S) (h : S ≤ T) :
    inclusion (k.trans h) = inclusion k ⋙ inclusion h
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_deriv_one_sub_smoothingFn :
    deriv (fun x => 1 - ε x) =ᶠ[atTop] fun x => x⁻¹ / (log x ^ 2)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
/-- The restriction of the Killing form to a Cartan subalgebra, as a linear equivalence to the
dual. -/
@[simps! apply_apply]
noncomputable def cartanEquivDual :
    H ≃ₗ[K] Module.Dual K H
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem coe_mkContinuous (C : ℝ) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ⇑(f.mkContinuous C H) = f
-- Mathlib/Order/Atoms.lean
theorem isAtom_singleton (x : α) : IsAtom ({x} : Set α)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioo_subset_Ioo (ha : a₂ ≤ a₁) (hb : b₁ ≤ b₂) : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem isUnitTrinomial_iff'' (h : p * p.mirror = q * q.mirror) :
    p.IsUnitTrinomial ↔ q.IsUnitTrinomial
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem weightedSMul_null {s : Set α} (h_zero : μ s = 0) : (weightedSMul μ s : F →L[ℝ] F) = 0
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : ℤ_[p]) : ℚ_[p]) = 0
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The iterated derivative of the composition with a linear map on the right is
obtained by composing the iterated derivative with the linear map. -/
theorem ContinuousLinearMap.iteratedFDeriv_comp_right (g : G →L[𝕜] E) {f : E → F}
    (hf : ContDiff 𝕜 n f) (x : G) {i : ℕ} (hi : (i : ℕ∞) ≤ n) :
    iteratedFDeriv 𝕜 i (f ∘ g) x =
      (iteratedFDeriv 𝕜 i f (g x)).compContinuousLinearMap fun _ => g
-- Mathlib/Order/Filter/AtTopBot.lean
theorem OrderBot.atBot_eq (α) [PartialOrder α] [OrderBot α] : (atBot : Filter α) = pure ⊥
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[simp]
theorem intCast_apply [IntCast β] (n : ℤ) (x : α) : (n : C(α, β)) x = n
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem isRoot_gcd_iff_isRoot_left_right [DecidableEq R] {f g : R[X]} {α : R} :
    (EuclideanDomain.gcd f g).IsRoot α ↔ f.IsRoot α ∧ g.IsRoot α
-- Mathlib/Data/Ordmap/Ordset.lean
theorem delta_lt_false {a b : ℕ} (h₁ : delta * a < b) (h₂ : delta * b < a) : False
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem reverse_foldl {l : List α} : reverse (foldl (fun t h => h :: t) [] l) = l
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem zero_ascFactorial : ∀ (k : ℕ), (0 : ℕ).ascFactorial k.succ = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem join_nil : List.join ([] : List (List α)) = []
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
protected theorem eq' {a₁ b₁} {a₂ b₂ : S} :
    f.mk' a₁ a₂ = f.mk' b₁ b₂ ↔ Localization.r S (a₁, a₂) (b₁, b₂)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
lemma _root_.Set.Countable.measure_restrict_compl (h : s.Countable) (μ : Measure α) [NoAtoms μ] :
    μ.restrict sᶜ = μ
-- Mathlib/Computability/Partrec.lean
theorem list_concat : Computable₂ fun l (a : α) => l ++ [a]
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean
theorem braiding_naturality {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') :
    tensorHom ℬ f g ≫ (Limits.BinaryFan.braiding (ℬ Y Y').isLimit (ℬ Y' Y).isLimit).hom =
      (Limits.BinaryFan.braiding (ℬ X X').isLimit (ℬ X' X).isLimit).hom ≫ tensorHom ℬ g f
-- Mathlib/Algebra/Polynomial/Inductions.lean
@[simp]
theorem divX_C (a : R) : divX (C a) = 0
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- The canonical isomorphism `S.opcycles ≅ cokernel S.f`. -/
@[simps]
noncomputable def opcyclesIsoCokernel [HasCokernel S.f] : S.opcycles ≅ cokernel S.f
-- Mathlib/FieldTheory/PrimitiveElement.lean
theorem isAlgebraic_of_adjoin_eq_adjoin {α : E} {m n : ℕ} (hneq : m ≠ n)
    (heq : F⟮α ^ m⟯ = F⟮α ^ n⟯) : IsAlgebraic F α
-- Mathlib/Topology/Sequences.lean
/-- A sequentially continuous function defined on a sequential space is continuous. -/
protected theorem SeqContinuous.continuous [SequentialSpace X] {f : X → Y} (hf : SeqContinuous f) :
    Continuous f
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem tendsto_atTop [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞} {a : ℝ≥0∞}
    (ha : a ≠ ∞) : Tendsto f atTop (𝓝 a) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ∈ Icc (a - ε) (a + ε)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_one_left : IsCoprime 1 x
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem single_ne_zero (h : r ≠ 0) : single a r ≠ 0
-- Mathlib/CategoryTheory/Generator.lean
theorem isCodetecting_empty_of_groupoid [∀ {X Y : C} (f : X ⟶ Y), IsIso f] :
    IsCodetecting (∅ : Set C)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem prod_top (s : Subring R) : s.prod (⊤ : Subring S) = s.comap (RingHom.fst R S)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem image_eq_preimage (s : Set E) : e '' s = e.symm ⁻¹' s
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
@[simp]
theorem isUnits_det_units (A : (Matrix n n α)ˣ) : IsUnit (A : Matrix n n α).det
-- Mathlib/Order/Filter/Cofinite.lean
/-- The coproduct of the cofinite filters on two types is the cofinite filter on their product. -/
theorem coprod_cofinite : (cofinite : Filter α).coprod (cofinite : Filter β) = cofinite
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem castSucc_inj {a b : Fin n} : castSucc a = castSucc b ↔ a = b