ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp]
theorem map_ratCast [DivisionRing α] [DivisionRing β] [RingHomClass F α β] (f : F) (q : ℚ) :
    f q = q
-- Mathlib/Topology/Sequences.lean
theorem seqClosure_eq_closure [FrechetUrysohnSpace X] (s : Set X) : seqClosure s = closure s
-- Mathlib/MeasureTheory/Constructions/Projective.lean
lemma congr_cylinder (hP : IsProjectiveMeasureFamily P)
    {S : Set (∀ i : I, α i)} {T : Set (∀ i : J, α i)} (hS : MeasurableSet S) (hT : MeasurableSet T)
    (h_eq : cylinder I S = cylinder J T) :
    P I S = P J T
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIso_hom_snd :
    (pullbackDiagonalMapIso f i i₁ i₂).hom ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag'_sub [AddGroup α] (M N : Matrix (Σi, m' i) (Σi, n' i) α) :
    blockDiag' (M - N) = blockDiag' M - blockDiag' N
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem disjoint_bot_left : Disjoint ⊥ a
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem hnot_apply [∀ i, HNot (π i)] (a : ∀ i, π i) (i : ι) : (￢a) i = ￢a i
-- Mathlib/Order/Atoms.lean
theorem isAtomic_of_orderBot_wellFounded_lt [OrderBot α]
    (h : WellFounded ((· < ·) : α → α → Prop)) : IsAtomic α
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem chromaticNumber_mono (G' : SimpleGraph V)
    (h : G ≤ G') : G.chromaticNumber ≤ G'.chromaticNumber
-- Mathlib/LinearAlgebra/Basis.lean
/-- Two bases are equal if they assign the same coordinates. -/
theorem eq_ofRepr_eq_repr {b₁ b₂ : Basis ι R M} (h : ∀ x i, b₁.repr x i = b₂.repr x i) : b₁ = b₂
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem kahler_rightAngleRotation_right (x y : E) :
    o.kahler x (J y) = Complex.I * o.kahler x y
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
/-- Given sieve `S` and presheaf `P : Cᵒᵖ ⥤ A`, their natural associated cone is a limit cone
    iff `Hom (E, P -)` is a sheaf of types for the sieve `S` and all `E : A`. -/
theorem isLimit_iff_isSheafFor :
    Nonempty (IsLimit (P.mapCone S.arrows.cocone.op)) ↔
      ∀ E : Aᵒᵖ, IsSheafFor (P ⋙ coyoneda.obj E) S.arrows
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem add_mul_emod_self_left (a b c : Int) : (a + b * c) % b = a % b
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand the square -/
theorem norm_add_mul_self_real (x y : F) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- `val_v(v^n) = n` for every `n ∈ ℕ`. -/
theorem count_pow_self (n : ℕ) :
    count K v ((v.asIdeal : FractionalIdeal R⁰ K) ^ n) = n
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem tendsto_atBot_of_leadingCoeff_nonpos (hdeg : 0 < P.degree) (hnps : P.leadingCoeff ≤ 0) :
    Tendsto (fun x => eval x P) atTop atBot
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma _root_.MeasurableEmbedding.gaussianReal_comap_apply (hv : v ≠ 0)
    {f : ℝ → ℝ} (hf : MeasurableEmbedding f)
    {f' : ℝ → ℝ} (h_deriv : ∀ x, HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s) :
    (gaussianReal μ v).comap f s
      = ENNReal.ofReal (∫ x in s, |f' x| * gaussianPDFReal μ v (f x))
-- Mathlib/Algebra/Quaternion.lean
theorem algebraMap_eq (r : R) : algebraMap R ℍ[R,c₁,c₂] r = ⟨r, 0, 0, 0⟩
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[inherit_doc True.intro] theorem trivial : True
-- Mathlib/Data/Int/GCD.lean
@[simp]
theorem lcm_one_left (i : ℤ) : lcm 1 i = natAbs i
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Iff version of extensionality rule for congruence relations. -/
@[to_additive "Iff version of extensionality rule for additive congruence relations."]
protected theorem ext_iff {c d : Con M} : c = d ↔ (∀ x y, c x y ↔ d x y)
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_sub_abs_le_abs_sub (a b : α) : |a| - |b| ≤ |a - b|
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma totalShift₁Iso_hom_naturality [L.HasTotal (up ℤ)] :
    total.map ((shiftFunctor₁ C x).map f) (up ℤ) ≫ (L.totalShift₁Iso x).hom =
      (K.totalShift₁Iso x).hom ≫ (total.map f (up ℤ))⟦x⟧'
-- Mathlib/Algebra/Module/PID.lean
/-- A finitely generated torsion module over a PID is an internal direct sum of its
`p i ^ e i`-torsion submodules for some primes `p i` and numbers `e i`. -/
theorem Submodule.isInternal_prime_power_torsion_of_pid [Module.Finite R M]
    (hM : Module.IsTorsion R M) :
    DirectSum.IsInternal fun p : (factors (⊤ : Submodule R M).annihilator).toFinset =>
      torsionBy R M
        (IsPrincipal.generator (p : Ideal R) ^
          (factors (⊤ : Submodule R M).annihilator).count ↑p)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem iff_comp_neg :
    IntervalIntegrable f volume a b ↔ IntervalIntegrable (fun x => f (-x)) volume (-a) (-b)
-- Mathlib/Order/Hom/Basic.lean
/-- Diagonal embedding of `α` into `α × α` as an `OrderHom`. -/
@[simps!]
def diag : α →o α × α
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem edist_pi_const_le (a b : α) : (edist (fun _ : β => a) fun _ => b) ≤ edist a b
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem copy_eq (G' : Subgraph G) (V'' : Set V) (hV : V'' = G'.verts)
    (adj' : V → V → Prop) (hadj : adj' = G'.Adj) : G'.copy V'' hV adj' hadj = G'
-- Mathlib/Algebra/CharZero/Lemmas.lean
theorem sub_half (a : R) : a - a / 2 = a / 2
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem isSubgraph_eq_le : (IsSubgraph : SimpleGraph V → SimpleGraph V → Prop) = (· ≤ ·)
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubgroup A} :
    a • S ≤ a • T ↔ S ≤ T
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem blsub_type {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
    (f : ∀ a < type r, Ordinal.{max u v}) :
    blsub.{_, v} (type r) f = lsub.{_, v} fun a => f (typein r a) (typein_lt_type _ _)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem source_inter_preimage_target_inter (s : Set β) :
    e.source ∩ e ⁻¹' (e.target ∩ s) = e.source ∩ e ⁻¹' s
-- Mathlib/Algebra/Module/Submodule/Ker.lean
@[simp]
protected theorem ker : LinearMap.ker (e : M →ₛₗ[σ₁₂] M₂) = ⊥
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem add_le_of_le {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a ≤ c) (h2 : b ≤ c) : a + b ≤ c
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The cosine of an angle in a right-angled triangle as a ratio of sides, version subtracting
vectors. -/
theorem cos_oangle_sub_right_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    Real.Angle.cos (o.oangle y (y - x)) = ‖y‖ / ‖y - x‖
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivAt_const (c : M') (x : M) :
    HasMFDerivAt I I' (fun _ : M => c) x (0 : TangentSpace I x →L[𝕜] TangentSpace I' c)
-- Mathlib/Topology/Bornology/Constructions.lean
lemma IsBounded.image_eval {s : Set (∀ i, π i)} (hs : IsBounded s) (i : ι) :
    IsBounded (eval i '' s)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem coe_symm_mk (f : α → β) (g s t ml mr il ir) :
    ((PartialEquiv.mk f g s t ml mr il ir).symm : β → α) = g
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
lemma dist_anti_left_pi : AntitoneOn (dist · y) (Iic y)
-- Mathlib/ModelTheory/Substructures.lean
theorem range_le_iff_comap {f : M →[L] N} {p : L.Substructure N} : range f ≤ p ↔ comap f p = ⊤
-- Mathlib/Probability/Independence/Conditional.lean
theorem CondIndepSets.iUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    (hyp : ∀ n, CondIndepSets m' hm' (s n) s' μ) :
    CondIndepSets m' hm' (⋃ n, s n) s' μ
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- Two measures are equal if they are equal on the π-system generating the σ-algebra,
  and they are both finite on an increasing spanning sequence of sets in the π-system.
  This lemma is formulated using `sUnion`. -/
theorem ext_of_generateFrom_of_cover_subset {S T : Set (Set α)} (h_gen : ‹_› = generateFrom S)
    (h_inter : IsPiSystem S) (h_sub : T ⊆ S) (hc : T.Countable) (hU : ⋃₀ T = univ)
    (htop : ∀ s ∈ T, μ s ≠ ∞) (h_eq : ∀ s ∈ S, μ s = ν s) : μ = ν
-- Mathlib/Data/List/Sigma.lean
theorem nodupKeys_of_nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} (h : NodupKeys (s :: l)) :
    NodupKeys l
-- Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean
theorem isIntegrallyClosed_dvd_iff {s : S} (hs : IsIntegral R s) (p : R[X]) :
    Polynomial.aeval s p = 0 ↔ minpoly R s ∣ p
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_union_both (h : a ≤ b) : Ioo a b ∪ {a, b} = Icc a b
-- Mathlib/Data/Finset/Sups.lean
theorem forall_infs_iff {p : α → Prop} : (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b)
-- Mathlib/Topology/Algebra/Star.lean
theorem ContinuousWithinAt.star (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => star (f x)) s x
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem Smooth.comp_smoothOn {f : M → M'} {g : M' → M''} {s : Set M} (hg : Smooth I' I'' g)
    (hf : SmoothOn I I' f s) : SmoothOn I I'' (g ∘ f) s
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem projKerOfRightInverse_comp_inv [TopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂)
    (f₂ : M₂ →SL[σ₂₁] M) (h : Function.RightInverse f₂ f₁) (y : M₂) :
    f₁.projKerOfRightInverse f₂ h (f₂ y) = 0
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_eq_zero_iff {f : α → E} (hf : AEStronglyMeasurable f μ) (h0 : p ≠ 0) :
    eLpNorm f p μ = 0 ↔ f =ᵐ[μ] 0
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_nil : toFinset (@nil α) = ∅
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem PolyCnstr.denote_combine {ctx : Context} {c₁ c₂ : PolyCnstr} (h₁ : c₁.denote ctx) (h₂ : c₂.denote ctx) : (c₁.combine c₂).denote ctx
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem valMinAbs_eq_zero {n : ℕ} (x : ZMod n) : x.valMinAbs = 0 ↔ x = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem dist_map_zero_lt_of_semiconjBy {f g₁ g₂ : CircleDeg1Lift} (h : SemiconjBy f g₁ g₂) :
    dist (g₁ 0) (g₂ 0) < 2
-- Mathlib/Algebra/DirectSum/Basic.lean
theorem finite_support (A : ι → S) (x : DirectSum ι fun i => A i) :
    (Function.support fun i => (x i : M)).Finite
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem carry_succ (i : Nat) (x y : BitVec w) (c : Bool) :
    carry (i+1) x y c = atLeastTwo (x.getLsb i) (y.getLsb i) (carry i x y c)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
/-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse {S₁ : Type*} [Semiring S₁] [MulSemiringAction M S₁]
    (f : R →+*[M] S₁) (g : S₁ → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S₁ →+*[M] R
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.sub (hs : Balanced 𝕜 s) (ht : Balanced 𝕜 t) : Balanced 𝕜 (s - t)
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
@[simp]
theorem card [Fintype G] : Fintype.card (ConjAct G) = Fintype.card G
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem guard_eq_some' {p : Prop} [Decidable p] (u) : _root_.guard p = some u ↔ p
-- Mathlib/Order/Interval/Set/Basic.lean
@[gcongr]
theorem Ico_subset_Ico_right (h : b₁ ≤ b₂) : Ico a b₁ ⊆ Ico a b₂
-- Mathlib/Order/RelClasses.lean
protected theorem IsAsymm.isAntisymm (r) [IsAsymm α r] : IsAntisymm α r
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem inner_conj_symm (x y : E) : ⟪y, x⟫† = ⟪x, y⟫
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem dvd_mul_right (a b : Int) : a ∣ a * b
-- Mathlib/LinearAlgebra/Ray.lean
/-- If two vectors are on the same ray then both scaled by the same action are also on the same
ray. -/
theorem smul {S : Type*} [Monoid S] [DistribMulAction S M] [SMulCommClass R S M]
    (h : SameRay R x y) (s : S) : SameRay R (s • x) (s • y)
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem map_map_right : ((map f).map g).right = g.right
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
theorem range_arg : Set.range arg = Set.Ioc (-π) π
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem cardDistinctFactors_apply_prime_pow {p k : ℕ} (hp : p.Prime) (hk : k ≠ 0) :
    ω (p ^ k) = 1
-- Mathlib/Algebra/Category/Ring/Instances.lean
theorem IsLocalization.epi {R : Type*} [CommRing R] (M : Submonoid R) (S : Type _) [CommRing S]
    [Algebra R S] [IsLocalization M S] : Epi (CommRingCat.ofHom <| algebraMap R S)
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem ramificationIdx_eq_factors_count (hp0 : map f p ≠ ⊥) (hP : P.IsPrime) (hP0 : P ≠ ⊥) :
    ramificationIdx f p P = (factors (map f p)).count P
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma iSup_basicOpen_eq_top_iff' {s : Set R} :
    (⨆ i ∈ s, PrimeSpectrum.basicOpen i) = ⊤ ↔ Ideal.span s = ⊤
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem contDiff_cos {n} : ContDiff ℝ n cos
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem isOpen_extChartAt_preimage (x : M) {s : Set E} (hs : IsOpen s) :
    IsOpen ((chartAt H x).source ∩ extChartAt I x ⁻¹' s)
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem degree_minpoly [Nontrivial A] (pb : PowerBasis A S) :
    degree (minpoly A pb.gen) = pb.dim
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_mono_nnnorm_ae {f : α → F} {g : α → G} (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNorm f p μ ≤ eLpNorm g p μ
-- Mathlib/Topology/Sober.lean
@[simp]
theorem IsIrreducible.genericPoint_closure_eq [QuasiSober α] {S : Set α} (hS : IsIrreducible S) :
    closure ({hS.genericPoint} : Set α) = closure S
-- Mathlib/Data/Multiset/Nodup.lean
theorem nodup_of_le {s t : Multiset α} (h : s ≤ t) : Nodup t → Nodup s
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
lemma evaluation_coevaluation'' :
    η_ X Y ▷ X ⊗≫ X ◁ ε_ X Y = ⊗𝟙
-- Mathlib/Data/Finsupp/Basic.lean
@[simp, norm_cast]
theorem cast_finsupp_prod [Field R] [CharZero R] (g : α → M → ℚ) :
    (↑(f.prod g) : R) = f.prod fun a b => ↑(g a b)
-- Mathlib/Algebra/Lie/Quotient.lean
@[simp]
theorem mk_bracket (x y : L) : mk ⁅x, y⁆ = ⁅(mk x : L ⧸ I), (mk y : L ⧸ I)⁆
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.map_intNormAux [IsIntegrallyClosed A] [Algebra.IsSeparable K L] (x : B) :
    algebraMap A K (Algebra.intNormAux A K L B x) = Algebra.norm K (algebraMap B L x)
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.swap_mul {α : Type*} [DecidableEq α] {f : Perm α} (hf : IsCycle f) {x : α}
    (hx : f x ≠ x) (hffx : f (f x) ≠ x) : IsCycle (swap x (f x) * f)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp]
theorem inf_ae_iff : μ.FiniteAtFilter (f ⊓ ae μ) ↔ μ.FiniteAtFilter f
-- Mathlib/Order/Bounds/Basic.lean
/-- If `s` has a least element, then it is bounded below. -/
theorem IsLeast.bddBelow (h : IsLeast s a) : BddBelow s
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem continuous_condexpIndL1 : Continuous fun x : G => condexpIndL1 hm μ s x
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem logEmbeddingQuot_injective :
    Function.Injective (logEmbeddingQuot K)
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc (attr := simp)]
theorem map_π {F G : J ⥤ C} (c : Cone F) {d : Cone G} (hd : IsLimit d) (α : F ⟶ G) (j : J) :
    hd.map c α ≫ d.π.app j = c.π.app j ≫ α.app j
-- Mathlib/Data/Matroid/Closure.lean
lemma closure_biUnion_closure_eq_closure_biUnion (M : Matroid α) (Xs : ι → Set α) (A : Set ι) :
    M.closure (⋃ i ∈ A, M.closure (Xs i)) = M.closure (⋃ i ∈ A, Xs i)
-- Mathlib/CategoryTheory/Yoneda.lean
theorem obj_map_id {X Y : C} (f : op X ⟶ op Y) :
    (yoneda.obj X).map f (𝟙 X) = (yoneda.map f.unop).app (op Y) (𝟙 Y)
-- Mathlib/Computability/Primrec.lean
theorem nat_casesOn₁ {f : ℕ → α} (a : α) (hf : Primrec f) :
    Primrec (fun (n : ℕ) => (n.casesOn a f : α))
-- Mathlib/AlgebraicGeometry/Gluing.lean
@[simp, reassoc]
theorem ι_glueMorphisms {Y : Scheme} (f : ∀ x, 𝒰.obj x ⟶ Y)
    (hf : ∀ x y, pullback.fst (𝒰.map x) (𝒰.map y) ≫ f x = pullback.snd _ _ ≫ f y)
    (x : 𝒰.J) : 𝒰.map x ≫ 𝒰.glueMorphisms f hf = f x
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_add (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ)
    (hg : Integrable g μ) : setToFun μ T hT (f + g) = setToFun μ T hT f + setToFun μ T hT g
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem contSupp_cons₁ (fs k) :
    contSupp (Cont'.cons₁ fs k) =
      trStmts₁
          (move₂ (fun _ => false) main aux <|
            move₂ (fun s => s = Γ'.consₗ) stack main <|
              move₂ (fun _ => false) aux stack <| trNormal fs (Cont'.cons₂ k)) ∪
        codeSupp fs (Cont'.cons₂ k)
-- Mathlib/FieldTheory/Adjoin.lean
theorem bot_eq_top_of_finrank_adjoin_eq_one (h : ∀ x : E, finrank F F⟮x⟯ = 1) :
    (⊥ : IntermediateField F E) = ⊤
-- Mathlib/Topology/MetricSpace/Dilation.lean
lemma tendsto_cobounded : Filter.Tendsto f (cobounded α) (cobounded β)
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_floor_right_pure (n : ℤ) : Tendsto (floor : α → ℤ) (𝓝[≥] n) (pure n)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma equation_some (X Y : R) : W.Equation ![X, Y, 1] ↔ W.toAffine.Equation X Y
-- Mathlib/Data/List/ReduceOption.lean
theorem reduceOption_mem_iff {l : List (Option α)} {x : α} : x ∈ l.reduceOption ↔ some x ∈ l
-- Mathlib/Order/Interval/Basic.lean
/-- The nonempty closed intervals in an order.

We define intervals by the pair of endpoints `fst`, `snd`. To convert intervals to the set of
elements between these endpoints, use the coercion `NonemptyInterval α → Set α`. -/
@[ext (flat := false)]
structure NonemptyInterval (α : Type*) [LE α] extends Prod α α where
  /-- The starting point of an interval is smaller than the endpoint. -/
  fst_le_snd : fst ≤ snd
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableOn.continuousOn (h : MDifferentiableOn I I' f s) : ContinuousOn f s
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
/-- The exponential map in `𝕂 = ℝ` or `𝕂 = ℂ` has strict derivative `1` at zero. -/
theorem hasStrictDerivAt_exp_zero : HasStrictDerivAt (exp 𝕂) (1 : 𝕂) 0
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma rTensor.inverse_of_rightInverse_apply
    {h : P → N} (hgh : Function.RightInverse h g) (y : N ⊗[R] Q) :
    (rTensor.inverse_of_rightInverse Q hfg hgh) ((rTensor Q g) y) =
      Submodule.Quotient.mk (p := LinearMap.range (rTensor Q f)) y
-- Mathlib/Algebra/BigOperators/Fin.lean
theorem sum_const [AddCommMonoid α] (n : ℕ) (x : α) : ∑ _i : Fin n, x = n • x
-- Mathlib/Data/Multiset/Fintype.lean
/-- The embedding from a multiset into `α × ℕ` where the second coordinate enumerates repeats.
If you are looking for the function `m → α`, that would be plain `(↑)`. -/
@[simps]
def Multiset.coeEmbedding (m : Multiset α) : m ↪ α × ℕ
-- Mathlib/Order/Lattice.lean
theorem inf_def [Inf α] [Inf β] (p q : α × β) : p ⊓ q = (p.fst ⊓ q.fst, p.snd ⊓ q.snd)
-- Mathlib/Data/Nat/Totient.lean
theorem totient_dvd_of_dvd {a b : ℕ} (h : a ∣ b) : φ a ∣ φ b
-- Mathlib/AlgebraicTopology/CechNerve.lean
/-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F
-- Mathlib/Order/Filter/Lift.lean
@[simp]
theorem lift'_top (h : Set α → Set β) : (⊤ : Filter α).lift' h = 𝓟 (h univ)
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[reassoc]
theorem associativity_app (m₁ m₂ m₃ : M) (X : C) :
    (F.obj m₃).map ((F.μ m₁ m₂).app X) ≫
        (F.μ (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
      (F.μ m₂ m₃).app ((F.obj m₁).obj X) ≫ (F.μ m₁ (m₂ ⊗ m₃)).app X
-- Mathlib/Data/Fin/Basic.lean
theorem pred_lt_castPred {a : Fin (n + 1)} (h₁ : a ≠ 0) (h₂ : a ≠ last n) :
    pred a h₁ < castPred a h₂
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[simp] theorem countP_true {l : List α} : (l.countP fun _ => true) = l.length
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_congr_left (T T' : Set α → E →L[ℝ] F)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s) (f : α →₁ₛ[μ] E) :
    setToL1S T f = setToL1S T' f
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem smul_apply (r : R) (v : VectorMeasure α M) (i : Set α) : (r • v) i = r • v i
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
protected theorem HasMFDerivAt.mfderiv (h : HasMFDerivAt I I' f x f') : mfderiv I I' f x = f'
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem natAbs_add_le (a b : Int) : natAbs (a + b) ≤ natAbs a + natAbs b
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- The sum of a subgroup of the units of a field is 1 if the subgroup is trivial and 1 otherwise -/
@[simp]
theorem sum_subgroup_units [Ring K] [NoZeroDivisors K]
    {G : Subgroup Kˣ} [Fintype G] [Decidable (G = ⊥)] :
    ∑ x : G, (x.val : K) = if G = ⊥ then 1 else 0
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
theorem associator_monoidal (X₁ X₂ X₃ Y₁ Y₂ Y₃ : C) :
    tensor_μ C (X₁ ⊗ X₂, X₃) (Y₁ ⊗ Y₂, Y₃) ≫
        (tensor_μ C (X₁, X₂) (Y₁, Y₂) ▷ (X₃ ⊗ Y₃)) ≫ (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
      ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
        tensor_μ C (X₁, X₂ ⊗ X₃) (Y₁, Y₂ ⊗ Y₃) ≫ ((X₁ ⊗ Y₁) ◁ tensor_μ C (X₂, X₃) (Y₂, Y₃))
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
/-- This is not an instance due to complaints by the `fails_quickly` linter. At any rate, we only
really care about the `TopologicalRing` instance below. -/
theorem topologicalSemiring [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M]
    [TopologicalSemiring R] [ContinuousAdd M] [ContinuousSMul R M] [ContinuousSMul Rᵐᵒᵖ M] :
    TopologicalSemiring (tsze R M)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem ne_nil_of_take_ne_nil {as : List α} {i : Nat} (h: as.take i ≠ []) : as ≠ []
-- Mathlib/Order/Interval/Finset/Box.lean
@[simp] lemma card_box_succ (n : ℕ) :
    (box (n + 1) : Finset (α × β)).card =
      (Icc (-n.succ : α) n.succ).card * (Icc (-n.succ : β) n.succ).card -
        (Icc (-n : α) n).card * (Icc (-n : β) n).card
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/-- A function `f : β → α` with upper topology in the codomain is continuous
if and only if the preimage of every interval `Set.Iic a` is a closed set. -/
lemma continuous_iff_Iic [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ a, IsClosed (f ⁻¹' (Iic a))
-- Mathlib/Order/Filter/Bases.lean
theorem countable_biInf_principal_eq_seq_iInf {B : Set (Set α)} (Bcbl : B.Countable) :
    ∃ x : ℕ → Set α, ⨅ t ∈ B, 𝓟 t = ⨅ i, 𝓟 (x i)
-- Mathlib/RingTheory/Filtration.lean
theorem submodule_eq_span_le_iff_stable_ge (n₀ : ℕ) :
    F.submodule = Submodule.span _ (⋃ i ≤ n₀, single R i '' (F.N i : Set M)) ↔
      ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[mono, gcongr]
theorem mono'' {m₁ m₂ : OuterMeasure α} {s₁ s₂ : Set α} (hm : m₁ ≤ m₂) (hs : s₁ ⊆ s₂) :
    m₁ s₁ ≤ m₂ s₂
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- The separable degree of a polynomial is equal to
the number of distinct roots of it over any algebraically closed field. -/
theorem natSepDegree_eq_of_isAlgClosed [IsAlgClosed E] :
    f.natSepDegree = (f.aroots E).toFinset.card
-- Mathlib/Algebra/DualNumber.lean
@[simp] theorem coe_lift_symm_apply (F : A[ε] →ₐ[R] B) :
    (lift.symm F).val = (F.comp (inlAlgHom _ _ _), F ε)
-- Mathlib/Order/ULift.lean
@[simp] theorem up_compare [Ord α] (a b : α) : compare (up a) (up b) = compare a b
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma hasDerivAt_jacobiTheta₂_fst (z : ℂ) {τ : ℂ} (hτ : 0 < im τ) :
    HasDerivAt (jacobiTheta₂ · τ) (jacobiTheta₂' z τ) z
-- Mathlib/Data/Finsupp/Defs.lean
theorem card_support_eq_one' {f : α →₀ M} :
    card f.support = 1 ↔ ∃ a, ∃ b ≠ 0, f = single a b
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_halfspace_le {f : E → β} (h : IsLinearMap 𝕜 f) (r : β) : Convex 𝕜 { w | f w ≤ r }
-- Mathlib/RingTheory/WittVector/Compare.lean
theorem commutes_symm' {m : ℕ} (hm : n ≤ m) (x : TruncatedWittVector p m (ZMod p)) :
    (zmodEquivTrunc p n).symm (truncate hm x) =
      ZMod.castHom (pow_dvd_pow p hm) _ ((zmodEquivTrunc p m).symm x)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem nonneg_of_mul_nonneg_left [MulPosStrictMono α]
    (h : 0 ≤ a * b) (hb : 0 < b) : 0 ≤ a