ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem of_targetAffineLocally_of_isPullback
    {P : AffineTargetMorphismProperty} [P.IsLocal]
    {X Y UX UY : Scheme.{u}} [IsAffine UY] {f : X ⟶ Y} {iY : UY ⟶ Y} [IsOpenImmersion iY]
    {iX : UX ⟶ X} {f' : UX ⟶ UY} (h : IsPullback iX f' f iY) (hf : targetAffineLocally P f) :
    P f'
-- Mathlib/RingTheory/FiniteType.lean
/-- If a set `S` generates, as algebra, `MonoidAlgebra R M`, then the set of supports of elements
of `S` generates `MonoidAlgebra R M`. -/
theorem support_gen_of_gen {S : Set (MonoidAlgebra R M)} (hS : Algebra.adjoin R S = ⊤) :
    Algebra.adjoin R (⋃ f ∈ S, of R M '' (f.support : Set M)) = ⊤
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
theorem isTotallyDisconnected_of_isTotallySeparated {s : Set α} (H : IsTotallySeparated s) :
    IsTotallyDisconnected s
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
@[simp] lemma zero_τ₁ : Hom.τ₁ (0 : S₁ ⟶ S₂) = 0
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem injOn_singleton (f : α → β) (a : α) : InjOn f {a}
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem dist_midpoint_midpoint_le' (p₁ p₂ p₃ p₄ : P) :
    dist (midpoint 𝕜 p₁ p₂) (midpoint 𝕜 p₃ p₄) ≤ (dist p₁ p₃ + dist p₂ p₄) / ‖(2 : 𝕜)‖
-- Mathlib/Data/Multiset/Pi.lean
protected theorem Nodup.pi {s : Multiset α} {t : ∀ a, Multiset (β a)} :
    Nodup s → (∀ a ∈ s, Nodup (t a)) → Nodup (pi s t)
-- Mathlib/Order/LatticeIntervals.lean
protected lemma disjoint_iff [SemilatticeInf α] [OrderBot α] {x y : Iic a} :
    Disjoint x y ↔ Disjoint (x : α) (y : α)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[simp]
theorem toSubgraph_reverse (p : G.Walk u v) : p.reverse.toSubgraph = p.toSubgraph
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)] lemma image_coe : ((↑) : G → Q) '' N = 1
-- Mathlib/Order/GaloisConnection.lean
theorem le_iff_le {a : α} {b : β} : l a ≤ b ↔ a ≤ u b
-- .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean
@[simp] theorem ForInStep.bindList_nil [Monad m] (f : α → β → m (ForInStep β))
    (s : ForInStep β) : s.bindList f [] = pure s
-- Mathlib/Topology/Sets/Closeds.lean
/--
The equivalence between `IrreducibleCloseds α` and `{x : Set α // IsIrreducible x ∧ IsClosed x }`.
-/
@[simps apply symm_apply]
def equivSubtype : IrreducibleCloseds α ≃ { x : Set α // IsIrreducible x ∧ IsClosed x }
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_C (n : ℕ) (a : R) : coeff R n (C R a : R⟦X⟧) = if n = 0 then a else 0
-- Mathlib/GroupTheory/Submonoid/Center.lean
@[simp]
theorem center_eq_top : center M = ⊤
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
private lemma XYIdeal'_mul_inv {x y : F} (h : W.Nonsingular x y) :
    XYIdeal W x (C y) * (XYIdeal W x (C <| W.negY x y) *
        (XIdeal W x : FractionalIdeal W.CoordinateRing⁰ W.FunctionField)⁻¹) = 1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem card_supp_le_succ_natDegree (p : R[X]) : p.support.card ≤ p.natDegree + 1
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma X_u₁_spec : S.X ^ 3 * S.u₁ = S.x
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
theorem Submodule.finrank_le_one_iff_isPrincipal
    (W : Submodule K V) [Module.Free K W] [Module.Finite K W] :
    finrank K W ≤ 1 ↔ W.IsPrincipal
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma primeSpectrumProd_symm_inl (x) :
    (primeSpectrumProd R S).symm (.inl x) = comap (RingHom.fst R S) x
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.and_self (b : Bool) : (b && b) = b
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_smul_measure {f : α → β} {c : ℝ≥0∞} (hc : c ≠ 0) :
    essSup f (c • μ) = essSup f μ
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem achart_def (x : M) : achart H x = ⟨chartAt H x, chart_mem_atlas H x⟩
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The sine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
opposite side, version subtracting vectors. -/
theorem sin_angle_sub_mul_norm_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) :
    Real.sin (angle x (x - y)) * ‖x - y‖ = ‖y‖
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem transpose_nonsing_inv : A⁻¹ᵀ = Aᵀ⁻¹
-- Mathlib/CategoryTheory/Elements.lean
@[simp]
theorem toStructuredArrow_obj (X) :
    (toStructuredArrow F).obj X =
      { left := ⟨⟨⟩⟩
        right := X.1
        hom := fun _ => X.2 }
-- Mathlib/CategoryTheory/Abelian/LeftDerived.lean
@[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_hom_inv_id_app (X : C) :
    F.fromLeftDerivedZero.app X ≫ F.leftDerivedZeroIsoSelf.inv.app X = 𝟙 _
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem pow_lt_self_of_lt_one (h₀ : 0 < a) (h₁ : a < 1) (hn : 1 < n) : a ^ n < a
-- Mathlib/Data/Set/Basic.lean
theorem setOf_set {s : Set α} : setOf s = s
-- Mathlib/Data/Real/ConjExponents.lean
protected lemma inv_pos : 0 < p⁻¹
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- If the distance between any two points in a set is bounded by some constant, this constant
bounds the diameter. -/
theorem diam_le {d : ℝ≥0∞} (h : ∀ x ∈ s, ∀ y ∈ s, edist x y ≤ d) : diam s ≤ d
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem isClosed_setOf_map_one [One M₁] [One M₂] : IsClosed { f : M₁ → M₂ | f 1 = 1 }
-- Mathlib/Data/Nat/Pairing.lean
theorem pair_lt_max_add_one_sq (m n : ℕ) : pair m n < (max m n + 1) ^ 2
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma setLIntegral_stieltjesOfMeasurableRat [IsFiniteKernel κ] (hf : IsRatCondKernelCDF f κ ν)
    (a : α) (x : ℝ) {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ b in s, ENNReal.ofReal (stieltjesOfMeasurableRat f hf.measurable (a, b) x) ∂(ν a)
      = κ a (s ×ˢ Iic x)
-- Mathlib/Order/ModularLattice.lean
theorem IsModularLattice.inf_sup_inf_assoc {x y z : α} : x ⊓ z ⊔ y ⊓ z = (x ⊓ z ⊔ y) ⊓ z
-- Mathlib/Topology/List.lean
theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
    Continuous fun p : α × Vector α n => Vector.insertNth p.1 i p.2
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_lt_mul'`. -/
@[to_additive Right.add_pos' "Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos'`."]
theorem Right.one_lt_mul' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 < a)
    (hb : 1 < b) :
    1 < a * b
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem HasEigenvalue.exists_hasEigenvector {f : End R M} {μ : R} (hμ : f.HasEigenvalue μ) :
    ∃ v, f.HasEigenvector μ v
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem mem_map_equiv {f : M ≃* N} {K : Subsemigroup M} {x : N} :
    x ∈ K.map (f : M →ₙ* N) ↔ f.symm x ∈ K
-- Mathlib/Order/SuccPred/Limit.lean
@[simp]
theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a)
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- The `ratio` is equal to the distance ratio for any two points
with nonzero finite distance; `dist` version -/
theorem ratio_unique_of_dist_ne_zero {α β} {F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
    [FunLike F α β] [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (hxy : dist x y ≠ 0)
    (hr : dist (f x) (f y) = r * dist x y) : r = ratio f
-- Mathlib/LinearAlgebra/Basis.lean
/-- Any basis is a maximal linear independent set.
-/
theorem maximal [Nontrivial R] (b : Basis ι R M) : b.linearIndependent.Maximal
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- The right unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.rightUnitor (P : C) [HasBinaryProduct P (⊤_ C)] : P ⨯ ⊤_ C ≅ P
-- Mathlib/Order/CompleteLattice.lean
theorem lt_iInf_iff : a < iInf f ↔ ∃ b, a < b ∧ ∀ i, b ≤ f i
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem RingEquiv.bot_maximal_iff (e : R ≃+* S) :
    (⊥ : Ideal R).IsMaximal ↔ (⊥ : Ideal S).IsMaximal
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
theorem hasLimitsOfShape_iff_isLeftAdjoint_const :
    HasLimitsOfShape J C ↔ IsLeftAdjoint (const J : C ⥤ _)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- In the specific case of multilinear maps on spaces indexed by `Fin (n+1)`, where one can build
an element of `∀ (i : Fin (n+1)), M i` using `cons`, one can express directly the multiplicativity
of a multilinear map along the first variable. -/
theorem cons_smul (f : MultilinearMap R M M₂) (m : ∀ i : Fin n, M i.succ) (c : R) (x : M 0) :
    f (cons (c • x) m) = c • f (cons x m)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem USize.toNat_add (x y : USize) : (x + y).toNat = (x.toNat + y.toNat) % USize.size
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem countable_meas_level_set_pos {α β : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] [MeasurableSpace β] [MeasurableSingletonClass β] {g : α → β}
    (g_mble : Measurable g) : Set.Countable { t : β | 0 < μ { a : α | g a = t } }
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma Even.mul_right (ha : Even a) (b) : Even (a * b)
-- Mathlib/Algebra/Group/Aut.lean
@[simp]
theorem conj_apply [AddGroup G] (g h : G) : conj g h = g + h + -g
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem log_div_log : log x / log b = logb b x
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem norm_eq_padic_norm {q : ℚ_[p]} (hq : ‖q‖ ≤ 1) : @norm ℤ_[p] _ ⟨q, hq⟩ = ‖q‖
-- Mathlib/CategoryTheory/Localization/HomEquiv.lean
@[simp]
lemma homMap_homMap (f : L₁.obj X ⟶ L₁.obj Y) :
    Ψ.homMap L₂ L₃ (Φ.homMap L₁ L₂ f) = (Φ.comp Ψ).homMap L₁ L₃ f
-- Mathlib/LinearAlgebra/Determinant.lean
theorem Basis.det_apply (v : ι → M) : e.det v = Matrix.det (e.toMatrix v)
-- Mathlib/Algebra/Polynomial/Div.lean
theorem modByMonic_eq_sub_mul_div :
    ∀ (p : R[X]) {q : R[X]} (_hq : Monic q), p %ₘ q = p - q * (p /ₘ q)
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem geom_sum_X_comp_X_add_one_eq_sum (n : ℕ) :
    (∑ i ∈ range n, (X : R[X]) ^ i).comp (X + 1) =
      (Finset.range n).sum fun i : ℕ => (n.choose (i + 1) : R[X]) * X ^ i
-- Mathlib/Topology/Instances/ENNReal.lean
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem pointToPoint_zeroLocus_le (I : Ideal (MvPolynomial σ k)) :
    pointToPoint '' MvPolynomial.zeroLocus I ≤ PrimeSpectrum.zeroLocus ↑I
-- Mathlib/Data/Ordmap/Ordset.lean
theorem pos_size_of_mem {x : α} {t : Ordset α} (h_mem : x ∈ t) : 0 < size t
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
-- Porting note: removed `protected` (needs to be in namespace)
theorem topologicalGroup_induced {F : Type*} [Group H] [FunLike F H G] [MonoidHomClass F H G]
    (f : F) :
    @TopologicalGroup H (induced f ‹_›) _
-- Mathlib/RingTheory/ClassGroup.lean
theorem ClassGroup.mk0_eq_mk0_iff [IsDedekindDomain R] {I J : (Ideal R)⁰} :
    ClassGroup.mk0 I = ClassGroup.mk0 J ↔
      ∃ (x y : R) (_hx : x ≠ 0) (_hy : y ≠ 0), Ideal.span {x} * (I : Ideal R) =
      Ideal.span {y} * J
-- Mathlib/CategoryTheory/Localization/Resolution.lean
/-- The category of right resolutions of an object in the target category
of a localizer morphism. -/
structure RightResolution (X₂ : C₂) where
  /-- an object in the source category -/
  {X₁ : C₁}
  /-- a morphism to an object of the form `Φ.functor.obj X₁` -/
  w : X₂ ⟶ Φ.functor.obj X₁
  hw : W₂ w
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem exists_erase_eq [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l) :
    ∃ l₁ l₂, a ∉ l₁ ∧ l = l₁ ++ a :: l₂ ∧ l.erase a = l₁ ++ l₂
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mul_by_divBy (s : S) (p : LocalizedModule S M) :
    algebraMap R (Module.End R (LocalizedModule S M)) s (divBy s p) = p
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
@[simp]
theorem isSymm_adjMatrix [Zero α] [One α] : (G.adjMatrix α).IsSymm
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem oneCoboundaries_of_mem_range_apply {f : G → A} (h : f ∈ LinearMap.range (dZero A)) :
    (oneCoboundariesOfMemRange h).1.1 = f
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv β] (f : α →ₛ β) : ⇑(f⁻¹) = (⇑f)⁻¹
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_ord (c) : (ord c).card = c
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_top : a ∆ ⊤ = aᶜ
-- Mathlib/Topology/Sheaves/Presheaf.lean
lemma id_pushforward (X : TopCat.{w}) : pushforward C (𝟙 X) = 𝟭 (X.Presheaf C)
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_union_of_disjoint (h : Disjoint s t) (f : α → M) :
    mulIndicator (s ∪ t) f = fun a => mulIndicator s f a * mulIndicator t f a
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.mul_dvd (H : IsCoprime x y) (H1 : x ∣ z) (H2 : y ∣ z) : x * y ∣ z
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_comm {f : ι → ι' → α} : ⨅ (i) (j), f i j = ⨅ (j) (i), f i j
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem IsBlock.mk_mem {B : Set X} :
    IsBlock G B ↔ ∀ (g : G) (a : X) (_ : a ∈ B) (_ : g • a ∈ B), g • B = B
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem true_beq  : ∀b, (true  == b) =  b
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
theorem NormedAddGroupHom.ker_le_ker_completion (f : NormedAddGroupHom G H) :
    (toCompl.comp <| incl f.ker).range ≤ f.completion.ker
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsRatCondKernelCDFAux.integrable_iInf_rat_gt (hf : IsRatCondKernelCDFAux f κ ν)
    [IsFiniteKernel ν] (a : α) (q : ℚ) :
    Integrable (fun t ↦ ⨅ r : Ioi q, f (a, t) r) (ν a)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- To show `j` and `k` agree on the whole localization, it suffices to show they agree
on the image of the base ring, if they preserve `1` and `*`. -/
protected theorem ext (j k : S → P) (hj1 : j 1 = 1) (hk1 : k 1 = 1)
    (hjm : ∀ a b, j (a * b) = j a * j b) (hkm : ∀ a b, k (a * b) = k a * k b)
    (h : ∀ a, j (algebraMap R S a) = k (algebraMap R S a)) : j = k
-- Mathlib/Algebra/Module/Hom.lean
theorem smul_apply (r : R) (f : AddMonoid.End A) (x : A) : (r • f) x = r • f x
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- Prefer putting constants to the left of `X ^ n`.

This lemma is the loop-avoiding `simp` version of `X_pow_mul`. -/
@[simp]
theorem X_pow_mul_C (r : R) (n : ℕ) : X ^ n * C r = C r * X ^ n
-- Mathlib/Order/SuccPred/Basic.lean
lemma pred_lt_pred_of_not_isMin (h : a < b) (ha : ¬ IsMin a) : pred a < pred b
-- Mathlib/Computability/Partrec.lean
theorem comp₂ {f : γ → δ →. σ} {g : α → β → γ} {h : α → β → δ} (hf : Partrec₂ f)
    (hg : Computable₂ g) (hh : Computable₂ h) : Partrec₂ fun a b => f (g a b) (h a b)
-- Mathlib/FieldTheory/RatFunc/Degree.lean
theorem intDegree_add {x y : RatFunc K} (hxy : x + y ≠ 0) :
    (x + y).intDegree =
      (x.num * y.denom + x.denom * y.num).natDegree - (x.denom * y.denom).natDegree
-- Mathlib/Algebra/ModEq.lean
@[simp]
theorem modEq_iff_int_modEq {a b z : ℤ} : a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z]
-- Mathlib/Order/RelSeries.lean
theorem length_pos (irrefl : Irreflexive r) : 0 < s.length ↔ {x | x ∈ s}.Nontrivial
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem measure_eq_top_of_lintegral_ne_top {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hμf : ∫⁻ x, f x ∂μ ≠ ∞) : μ {x | f x = ∞} = 0
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.forall_mem_mem (h : HasBasis l p s) {x : α} :
    (∀ t ∈ l, x ∈ t) ↔ ∀ i, p i → x ∈ s i
-- Mathlib/Data/Set/Image.lean
theorem subset_image_symmDiff : (f '' s) ∆ (f '' t) ⊆ f '' s ∆ t
-- Mathlib/Topology/Semicontinuous.lean
theorem LowerSemicontinuous.comp_continuous {f : α → β} {g : ι → α}
    (hf : LowerSemicontinuous f) (hg : Continuous g) : LowerSemicontinuous fun x ↦ f (g x)
-- Mathlib/RingTheory/HahnSeries/Summable.lean
@[simp]
theorem coe_sub : ⇑(s - t) = s - t
-- Mathlib/Data/Rel.lean
theorem inv_comp (r : Rel α β) (s : Rel β γ) : inv (r • s) = inv s • inv r
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
/-- Typeclass for multiplicative actions on multiplicative structures. This generalizes
conjugation actions. -/
@[ext]
class MulDistribMulAction (M : Type*) (A : Type*) [Monoid M] [Monoid A] extends
  MulAction M A where
  /-- Distributivity of `•` across `*` -/
  smul_mul : ∀ (r : M) (x y : A), r • (x * y) = r • x * r • y
  /-- Multiplying `1` by a scalar gives `1` -/
  smul_one : ∀ r : M, r • (1 : A) = 1
-- Mathlib/CategoryTheory/EqToHom.lean
@[simp]
theorem eqToHom_refl (X : C) (p : X = X) : eqToHom p = 𝟙 X
-- Mathlib/Order/OrderIsoNat.lean
theorem exists_not_acc_lt_of_not_acc {a : α} {r} (h : ¬Acc r a) : ∃ b, ¬Acc r b ∧ r b a
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem borel_eq_generateFrom_Iic :
    borel α = MeasurableSpace.generateFrom (range Iic)
-- Mathlib/CategoryTheory/Sites/Discrete.lean
lemma isDiscrete_iff_isIso_counit_app {L : A ⥤ Sheaf J A} (adj : L ⊣ (sheafSections J A).obj ⟨t⟩)
    (F : Sheaf J A) :
    IsDiscrete J ht F ↔ IsIso (adj.counit.app F)
-- Mathlib/Topology/SeparatedMap.lean
lemma isSeparatedMap_iff_disjoint_nhds {f : X → Y} : IsSeparatedMap f ↔
    ∀ x₁ x₂, f x₁ = f x₂ → x₁ ≠ x₂ → Disjoint (𝓝 x₁) (𝓝 x₂)
-- Mathlib/Data/Set/Pairwise/Basic.lean
@[simp]
theorem pairwise_bot_iff : s.Pairwise (⊥ : α → α → Prop) ↔ (s : Set α).Subsingleton
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
@[simp]
theorem iteratedFDerivWithin_zero_fun (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) {i : ℕ} :
    iteratedFDerivWithin 𝕜 i (fun _ : E ↦ (0 : F)) s x = 0
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem nsmul_apply (r : ℕ) (f : NormedAddGroupHom V₁ V₂) (v : V₁) : (r • f) v = r • f v
-- Mathlib/Data/Finset/Pointwise.lean
theorem Nonempty.div_zero (hs : s.Nonempty) : s / 0 = 0
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem coe_inf (f g : CauSeq α abs) : ⇑(f ⊓ g) = (f : ℕ → α) ⊓ g
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.prod_left_same (hf : IsBigOWith c l f' k') (hg : IsBigOWith c l g' k') :
    IsBigOWith c l (fun x => (f' x, g' x)) k'
-- Mathlib/Analysis/Complex/Asymptotics.lean
@[simp, norm_cast]
theorem isBigO_ofReal_right {f : α → E} {g : α → ℝ} : f =O[l] (g · : α → ℂ) ↔ f =O[l] g
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_of_add_right_lt {n m k : Nat} (h : n + k < m) : n < m
-- Mathlib/Topology/ContinuousOn.lean
@[fun_prop]
theorem ContinuousOn.prod {f : α → β} {g : α → γ} {s : Set α} (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) : ContinuousOn (fun x => (f x, g x)) s
-- Mathlib/Algebra/Symmetrized.lean
theorem sym_mul_self [Semiring α] [Invertible (2 : α)] (a : α) : sym (a * a) = sym a * sym a
-- Mathlib/Analysis/Convex/Side.lean
theorem sSameSide_smul_vsub_vadd_right {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : 0 < t) : s.SSameSide x (t • (x -ᵥ p₁) +ᵥ p₂)
-- Mathlib/Data/ZMod/Basic.lean
theorem coe_intCast (a : ℤ) : cast (a : ZMod n) = a % n
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem map_comp {f : T ⟶ T'} {f' : T' ⟶ T''} {h : CostructuredArrow S T} :
    (map (f ≫ f')).obj h = (map f').obj ((map f).obj h)
-- Mathlib/GroupTheory/CosetCover.lean
/-- Let the group `G` be the union of finitely many left cosets `g i • H i`.
Then at least one subgroup `H i` has finite index in `G`. -/
@[to_additive]
theorem exists_finiteIndex_of_leftCoset_cover : ∃ k ∈ s, (H k).FiniteIndex
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem apply_same : stdBasisMatrix i j c i j = c
-- Mathlib/GroupTheory/PGroup.lean
theorem card_orbit (a : α) [Finite (orbit G a)] : ∃ n : ℕ, Nat.card (orbit G a) = p ^ n
-- Mathlib/Order/Basic.lean
@[simp]
theorem update_le_update_iff' : update x i a ≤ update x i b ↔ a ≤ b
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem assoc_aux_2 : (TensorProduct.assoc R A B C) ((1 ⊗ₜ[R] 1) ⊗ₜ[R] 1) = 1
-- Mathlib/CategoryTheory/Functor/Currying.lean
lemma uncurry_obj_curry_obj_flip_flip (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
    uncurry.obj (F₂ ⋙ (F₁ ⋙ curry.obj G).flip).flip = (F₁.prod F₂) ⋙ G
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive addCHaar_empty]
theorem chaar_empty (K₀ : PositiveCompacts G) : chaar K₀ ⊥ = 0
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
protected lemma id {p : 𝒳 ⥤ 𝒮} {R : 𝒮} {a : 𝒳} (ha : p.obj a = R) : p.IsHomLift (𝟙 R) (𝟙 a)
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- The supremum of two congruence relations equals the smallest congruence relation containing
    the supremum of the underlying binary operations. -/
theorem sup_def {c d : RingCon R} : c ⊔ d = ringConGen (⇑c ⊔ ⇑d)
-- Mathlib/CategoryTheory/Bicategory/Coherence.lean
@[simp]
theorem preinclusion_map₂ {a b : B} (f g : Discrete (Path.{v + 1} a b)) (η : f ⟶ g) :
    (preinclusion B).map₂ η = eqToHom (congr_arg _ (Discrete.ext _ _ (Discrete.eq_of_hom η)))
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
/-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.

See <https://stacks.math.columbia.edu/tag/001C>.
-/
class Faithful (F : C ⥤ D) : Prop where
  /-- `F.map` is injective for each `X Y : C`. -/
  map_injective : ∀ {X Y : C}, Function.Injective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) := by
    aesop_cat
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_div_of_neg_of_lt (hc : c < 0) (h : b < a) : a / c < b / c
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem comap_map_mk_uniformity : comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) = 𝓤 α
-- Mathlib/Topology/Connected/Clopen.lean
theorem QuotientMap.image_connectedComponent [TopologicalSpace β] {f : α → β} (hf : QuotientMap f)
    (h_fibers : ∀ y : β, IsConnected (f ⁻¹' {y})) (a : α) :
    f '' connectedComponent a = connectedComponent (f a)
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem self_comp_ofInjective_symm {α β} {f : α → β} (hf : Injective f) :
    f ∘ (ofInjective f hf).symm = Subtype.val
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem comapDomain_apply [∀ i, Zero (β i)] (h : κ → ι) (hh : Function.Injective h) (f : Π₀ i, β i)
    (k : κ) : comapDomain h hh f k = f (h k)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsTrail.rotate {u v : V} {c : G.Walk v v} (hc : c.IsTrail) (h : u ∈ c.support) :
    (c.rotate h).IsTrail
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem skewProd_symm_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
    (e.skewProd e' f).symm x = (e.symm x.1, e'.symm (x.2 - f (e.symm x.1)))
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_eq_on_Ico' (n : ℤ) : ∀ a ∈ Set.Ico (n : α) (n + 1), (⌊a⌋ : α) = n
-- Mathlib/AlgebraicGeometry/Restrict.lean
theorem morphismRestrict_app {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : U.toScheme.Opens) :
    (f ∣_ U).app V = f.app (U.ι ''ᵁ V) ≫
        X.presheaf.map (eqToHom (image_morphismRestrict_preimage f U V)).op
-- Mathlib/Computability/Language.lean
theorem le_add_congr {l₁ l₂ m₁ m₂ : Language α} : l₁ ≤ m₁ → l₂ ≤ m₂ → l₁ + l₂ ≤ m₁ + m₂
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem iUnion_div (s : ι → Set α) (t : Set α) : (⋃ i, s i) / t = ⋃ i, s i / t
-- Mathlib/Order/Antisymmetrization.lean
@[trans]
theorem AntisymmRel.trans [IsTrans α r] {a b c : α} (hab : AntisymmRel r a b)
    (hbc : AntisymmRel r b c) : AntisymmRel r a c
-- Mathlib/LinearAlgebra/Ray.lean
/-- If a vector `v₂` is on the same ray as a nonzero vector `v₁`, then it is equal to `c • v₁` for
some nonnegative `c`. -/
theorem exists_nonneg_left (h : SameRay R x y) (hx : x ≠ 0) : ∃ r : R, 0 ≤ r ∧ r • x = y
-- Mathlib/Analysis/RCLike/Basic.lean
theorem im_eq_conj_sub (z : K) : ↑(im z) = I * (conj z - z) / 2
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem isLeft_map (f : α → β) (g : γ → δ) (x : α ⊕ γ) :
    isLeft (x.map f g) = isLeft x
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
@[simp]
theorem descPochhammer_natDegree (n : ℕ) [NoZeroDivisors R] [Nontrivial R] :
    (descPochhammer R n).natDegree = n
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem toIso_inv {e : X ≃ Y} : e.toIso.inv = e.symm
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem differentiableAt_inv' {x : R} (hx : x ≠ 0) : DifferentiableAt 𝕜 Inv.inv x