ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- A global integer is in the local integers. -/
lemma coe_mem_adicCompletionIntegers (r : R) :
    (r : adicCompletion K v) ∈ adicCompletionIntegers K v
-- Mathlib/Algebra/Group/Embedding.lean
@[to_additive]
theorem mulLeftEmbedding_eq_mulRightEmbedding [CommSemigroup G] [IsCancelMul G] (g : G) :
    mulLeftEmbedding g = mulRightEmbedding g
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma map_rightHomologyMap' : F.map (ShortComplex.rightHomologyMap' φ hr₁ hr₂) =
    ShortComplex.rightHomologyMap' (F.mapShortComplex.map φ) (hr₁.map F) (hr₂.map F)
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem invFun_eq_symm {e : A ≃⋆+* B} : EquivLike.inv e = e.symm
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem elim_eq_iff {u u' : α → γ} {v v' : β → γ} :
    Sum.elim u v = Sum.elim u' v' ↔ u = u' ∧ v = v'
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem inf'_singleton {b : β} : ({b} : Finset β).inf' (singleton_nonempty _) f = f b
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem foldlM_eq [Monad m] (f : δ → α → β → m δ) (init l) :
    foldlM f init l = l.toList.foldlM (fun d (a, b) => f d a b) init
-- Mathlib/Order/CompleteLattice.lean
theorem iSup₂_mono' {f : ∀ i, κ i → α} {g : ∀ i', κ' i' → α} (h : ∀ i j, ∃ i' j', f i j ≤ g i' j') :
    ⨆ (i) (j), f i j ≤ ⨆ (i) (j), g i j
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem sum_incMatrix_apply_of_not_mem_edgeSet [Fintype α] (h : e ∉ G.edgeSet) :
    ∑ a, G.incMatrix R a e = 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem bne_left_inj  : ∀ (x y z : Bool), (x != y) = (x != z) ↔ y = z
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma exists_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∃ a, p a) ↔ ∃ b, q b
-- Mathlib/RingTheory/Polynomial/Tower.lean
@[simp]
theorem aeval_map_algebraMap (x : B) (p : R[X]) : aeval x (map (algebraMap R A) p) = aeval x p
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Ioi (x : ℝ) : Real.toEReal ⁻¹' Ioi x = Ioi x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_sum_univ {ι : Type*} [Fintype ι] (f : ι → R → R) (a : A)
    (hf : ∀ i, ContinuousOn (f i) (spectrum R a) := by cfc_cont_tac) :
    cfc (∑ i, f i) a = ∑ i, cfc (f i) a
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem Tendsto.const_mul {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 b)) (hb : b ≠ 0 ∨ a ≠ ∞) : Tendsto (fun b => a * m b) f (𝓝 (a * b))
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
@[simp]
theorem coe_toOrthonormalBasis [Fintype ι] (b : HilbertBasis ι 𝕜 E) :
    (b.toOrthonormalBasis : ι → E) = b
-- Mathlib/GroupTheory/FreeGroup/IsFreeGroup.lean
/-- If two morphisms on `G` coincide on the elements of a basis, then they coincide. -/
lemma ext_hom (b : FreeGroupBasis ι G) (f g : G →* H) (h : ∀ i, f (b i) = g (b i)) : f = g
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem range_pow_padicValNat_subset_divisors {n : ℕ} (hn : n ≠ 0) :
    (Finset.range (padicValNat p n + 1)).image (p ^ ·) ⊆ n.divisors
-- Mathlib/Probability/Distributions/Gamma.lean
/-- The gamma pdf is measurable. -/
@[measurability]
lemma measurable_gammaPDFReal (a r : ℝ) : Measurable (gammaPDFReal a r)
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_pow : ∀ (x) (n : ℕ), v (x ^ n) = v x ^ n
-- Mathlib/LinearAlgebra/TensorProduct/Matrix.lean
/-- The matrix built from `Matrix.kronecker` corresponds to the linear map built from
`TensorProduct.map`. -/
theorem Matrix.toLin_kronecker (A : Matrix ι' ι R) (B : Matrix κ' κ R) :
    toLin (bM.tensorProduct bN) (bM'.tensorProduct bN') (A ⊗ₖ B) =
      TensorProduct.map (toLin bM bM' A) (toLin bN bN' B)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem _root_.Set.algebraMap_mem_center (r : R) : algebraMap R A r ∈ Set.center A
-- Mathlib/CategoryTheory/Limits/FunctorCategory.lean
/-- A variant of `limitIsoFlipCompLim` where the arguments of `F` are flipped. -/
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem tan_two_mul {z : ℂ} : tan (2 * z) = (2 : ℂ) * tan z / ((1 : ℂ) - tan z ^ 2)
-- Mathlib/Tactic/Ring/Basic.lean
theorem pow_bit1 {k : ℕ} {d : R} (_ : (a : R) ^ k = b) (_ : b * b = c) (_ : c * a = d) :
    a ^ (Nat.add (Nat.mul (nat_lit 2) k) (nat_lit 1)) = d
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem inv {f : Perm α} (h : IsThreeCycle f) : IsThreeCycle f⁻¹
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp] lemma ofEpiOfIsIsoOfMono'_H : (ofEpiOfIsIsoOfMono' φ h).H = h.H
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp]
theorem coe_mk (f : A →ₐ[R] B) (h) : (mk f h : A →ₐ[R] B) = f
-- Mathlib/Analysis/Analytic/Basic.lean
@[simp]
theorem norm_changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    ‖p.changeOriginSeriesTerm k l s hs‖ = ‖p (k + l)‖
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma castAdd_inj {a b : Fin m} : castAdd n a = castAdd n b ↔ a = b
-- Mathlib/LinearAlgebra/Prod.lean
theorem prod_comp (f : M₂ →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄)
    (h : M →ₗ[R] M₂) : (f.prod g).comp h = (f.comp h).prod (g.comp h)
-- Mathlib/Algebra/Category/AlgebraCat/Basic.lean
@[simp] theorem AlgHom.id_algebraCat_comp
    {R} [CommRing R] {G : Type u} [Ring G] [Algebra R G] {H : AlgebraCat.{u} R} (f : G →ₐ[R] H) :
    AlgHom.comp (𝟙 H) f = f
-- Mathlib/Data/List/ToFinsupp.lean
theorem toFinsupp_apply_fin (n : Fin l.length) : l.toFinsupp n = l.get n
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_eq_right : (∃ a, p a ∧ a = a') ↔ p a'
-- Mathlib/Order/SuccPred/Limit.lean
theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a
-- Mathlib/LinearAlgebra/Ray.lean
/-- Scaling by an inverse unit is the same as scaling by itself. -/
@[simp]
theorem units_inv_smul (u : Rˣ) (v : Module.Ray R M) : u⁻¹ • v = u • v
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.mem_homogeneousCore_of_homogeneous_of_mem {x : A} (h : SetLike.Homogeneous 𝒜 x)
    (hmem : x ∈ I) : x ∈ I.homogeneousCore 𝒜
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem doublingGamma_add_one (s : ℝ) (hs : s ≠ 0) :
    doublingGamma (s + 1) = s * doublingGamma s
-- Mathlib/Data/Nat/Digits.lean
/-- Any non-zero natural number `m` is greater than
b^((number of digits in the base b representation of m) - 1)
-/
theorem base_pow_length_digits_le (b m : ℕ) (hb : 1 < b) :
    m ≠ 0 → b ^ (digits b m).length ≤ b * m
-- Mathlib/Init/Logic.lean
theorem cast_proof_irrel {β : Sort u} (h₁ h₂ : α = β) (a : α) : cast h₁ a = cast h₂ a
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
lemma subset_shatterer (h : IsLowerSet (𝒜 : Set (Finset α))) : 𝒜 ⊆ 𝒜.shatterer
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
/-- A variant of `mul_inv_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
lemma eq_mul_of_mul_inv_eq₀ (hb : b ≠ 0) (h : a * c⁻¹ = b) : a = b * c
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_top : (⊤ : L.BoundedFormula α l).Realize v xs ↔ True
-- Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean
theorem closedBall_rpow_sub_one_eq_empty_aux {r t : ℝ} (hr : 0 < r) (ht : 1 < t) :
    Metric.closedBall (0 : E) (t ^ (-r⁻¹) - 1) = ∅
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma divInt_self' {n : ℤ} (hn : n ≠ 0) : n /. n = 1
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_eq_norm_sq (x : E) : re ⟪x, x⟫ = ‖x‖ ^ 2
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma nonsingular_zero_of_Δ_ne_zero (h : W.Equation 0 0) (hΔ : W.Δ ≠ 0) : W.Nonsingular 0 0
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected theorem map [BorelSpace α] [MeasurableSpace β] [TopologicalSpace β]
    [BorelSpace β] [InnerRegular μ] (f : α ≃ₜ β) : (Measure.map f μ).InnerRegular
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isClosed_range_comap_of_surjective (hf : Surjective f) :
    IsClosed (Set.range (comap f))
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem aemeasurable_restrict_of_antitoneOn [LinearOrder β] [OrderClosedTopology β] {μ : Measure β}
    {s : Set β} (hs : MeasurableSet s) {f : β → α} (hf : AntitoneOn f s) :
    AEMeasurable f (μ.restrict s)
-- Mathlib/Logic/Function/Iterate.lean
@[simp high]
theorem iterate_one : f^[1] = f
-- Mathlib/Data/Finset/Card.lean
lemma card_ne_zero : s.card ≠ 0 ↔ s.Nonempty
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem zero_eq_ofReal {p : ℝ} : 0 = ENNReal.ofReal p ↔ p ≤ 0
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The adjoint is unique: a map `A` is the adjoint of `B` iff it satisfies `⟪A x, y⟫ = ⟪x, B y⟫`
for all `x` and `y`. -/
theorem eq_adjoint_iff (A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E) :
    A = LinearMap.adjoint B ↔ ∀ x y, ⟪A x, y⟫ = ⟪x, B y⟫
-- Mathlib/Topology/Order/ExtendFrom.lean
theorem eq_lim_at_left_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [T2Space β] {f : α → β} {a b : α} {la : β} (hab : a < b)
    (ha : Tendsto f (𝓝[>] a) (𝓝 la)) : extendFrom (Ioo a b) f a = la
-- Mathlib/Order/Filter/AtTopBot.lean
theorem map_div_atTop_eq_nat (k : ℕ) (hk : 0 < k) : map (fun a => a / k) atTop = atTop
-- Mathlib/Order/Bounds/Basic.lean
theorem isLeast_Icc (h : a ≤ b) : IsLeast (Icc a b) a
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (τ : ∀ i, F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i) : F ⟶ G
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem mem_attach (s : Sym α n) (x : { x // x ∈ s }) : x ∈ s.attach
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The span of a union of an indexed family of sets is the sup of their spans. -/
theorem span_iUnion {ι : Type*} (s : ι → Set P) :
    affineSpan k (⋃ i, s i) = ⨆ i, affineSpan k (s i)
-- Mathlib/Topology/Order/LeftRight.lean
theorem nhds_left_sup_nhds_right (a : α) : 𝓝[≤] a ⊔ 𝓝[≥] a = 𝓝 a
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem mapsTo_extend (hs : s ⊆ f.source) :
    MapsTo (f.extend I) s ((f.extend I).symm ⁻¹' s ∩ range I)
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem monotone_comap {f : M →ₙ* N} : Monotone (comap f)
-- Mathlib/FieldTheory/Adjoin.lean
theorem isAlgebraic_adjoin_simple {x : L} (hx : IsIntegral K x) : Algebra.IsAlgebraic K K⟮x⟯
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive mem_closedBall_iff_norm]
theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r
-- Mathlib/Topology/UniformSpace/Completion.lean
private theorem compRel_gen_gen_subset_gen_compRel {s t : Set (α × α)} :
    compRel (gen s) (gen t) ⊆ (gen (compRel s t) : Set (CauchyFilter α × CauchyFilter α))
-- Mathlib/Algebra/DualNumber.lean
/-- When applied to `ε`, `DualNumber.lift` produces the element of `B` that squares to 0. -/
@[simp] theorem lift_apply_eps
    (fe : {fe : (A →ₐ[R] B) × B // fe.2 * fe.2 = 0 ∧ ∀ a, Commute fe.2 (fe.1 a)}) :
    lift fe (ε : A[ε]) = fe.val.2
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem norm_integral_le_of_norm_le_const' {f : ℂ → E} {c : ℂ} {R C : ℝ}
    (hf : ∀ z ∈ sphere c |R|, ‖f z‖ ≤ C) : ‖∮ z in C(c, R), f z‖ ≤ 2 * π * |R| * C
-- Mathlib/Data/PFunctor/Univariate/Basic.lean
theorem liftp_iff' {α : Type u} (p : α → Prop) (a : P.A) (f : P.B a → α) :
    @Liftp.{u} P.Obj _ α p ⟨a, f⟩ ↔ ∀ i, p (f i)
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
theorem trace_mul_comm [AddCommMonoid R] [CommSemigroup R] (A : Matrix m n R) (B : Matrix n m R) :
    trace (A * B) = trace (B * A)
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simp]
theorem associator_hom_apply {M N K : ModuleCat.{u} R} (m : M) (n : N) (k : K) :
    ((α_ M N K).hom : (M ⊗ N) ⊗ K ⟶ M ⊗ N ⊗ K) (m ⊗ₜ n ⊗ₜ k) = m ⊗ₜ (n ⊗ₜ k)
-- Mathlib/Data/ULift.lean
@[simp] lemma map_bijective : Bijective (PLift.map f) ↔ Bijective f
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toDualTopEquiv_bot [LE α] : WithBot.toDualTopEquiv (⊥ : WithBot αᵒᵈ) = ⊥
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_congr (h₀ : s = t) (h₁ : ∀ x ∈ t, f x = g x) :
    ∏ᶠ i ∈ s, f i = ∏ᶠ i ∈ t, g i
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem!_cons_succ [Inhabited α] {l : List α} : (a::l)[n+1]! = l[n]!
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
lemma IsHamiltonianCycle.map {H : SimpleGraph β} (f : G →g H) (hf : Bijective f)
    (hp : p.IsHamiltonianCycle) : (p.map f).IsHamiltonianCycle
-- Mathlib/Order/Filter/Lift.lean
theorem lift'_inf (f g : Filter α) {s : Set α → Set β} (hs : ∀ t₁ t₂, s (t₁ ∩ t₂) = s t₁ ∩ s t₂) :
    (f ⊓ g).lift' s = f.lift' s ⊓ g.lift' s
-- Mathlib/Computability/Reduce.lean
theorem OneOneReducible.of_equiv {α β} [Primcodable α] [Primcodable β] {e : α ≃ β} (q : β → Prop)
    (h : Computable e) : (q ∘ e) ≤₁ q
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
@[simp]
theorem rank_ulift : Module.rank R (ULift.{w} M) = Cardinal.lift.{w} (Module.rank R M)
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[simp]
theorem realize_term_substructure {α : Type*} {S : L.Substructure M} (v : α → S) (t : L.Term α) :
    t.realize ((↑) ∘ v) = (↑(t.realize v) : M)
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- If `C` has all colimits of diagrams `parallelFamily f`, then it has all wide coequalizers -/
theorem hasWideCoequalizers_of_hasColimit_parallelFamily
    [∀ {J : Type w} {X Y : C} {f : J → (X ⟶ Y)}, HasColimit (parallelFamily f)] :
    HasWideCoequalizers.{w} C
-- Mathlib/Algebra/LinearRecurrence.lean
/-- `E.mkSol init`'s first `E.order` terms are `init`. -/
theorem mkSol_eq_init (init : Fin E.order → α) : ∀ n : Fin E.order, E.mkSol init n = init n
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem star_eq_neg {a : ℍ[R]} : star a = -a ↔ a.re = 0
-- Mathlib/Topology/ContinuousFunction/CocompactMap.lean
@[simp]
theorem comp_id (f : CocompactMap α β) : f.comp (CocompactMap.id _) = f
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem genEigenspace_le_maximal (f : End R M) (μ : R) (k : ℕ) :
    f.genEigenspace μ k ≤ f.maxGenEigenspace μ
-- Mathlib/Topology/MetricSpace/Ultra/Basic.lean
lemma frontier_ball_eq_empty : frontier (ball x r) = ∅
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Ioo (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioo a b = Ioo (a / c) (b / c)
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem uniformGroup_iInf {ι : Sort*} {us' : ι → UniformSpace β}
    (h' : ∀ i, @UniformGroup β (us' i) _) : @UniformGroup β (⨅ i, us' i) _
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
/-- The map `fun t ↦ exp (t * I)` from `ℝ` to the unit circle in `ℂ` is smooth. -/
theorem contMDiff_expMapCircle : ContMDiff 𝓘(ℝ, ℝ) (𝓡 1) ∞ expMapCircle
-- Mathlib/LinearAlgebra/Semisimple.lean
theorem IsSemisimple.add_of_commute : (f + g).IsSemisimple
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem dfinsupp_sumAddHom_mem {β : ι → Type*} [∀ i, AddZeroClass (β i)] (S : Submodule R N)
    (f : Π₀ i, β i) (g : ∀ i, β i →+ N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) :
    DFinsupp.sumAddHom g f ∈ S
-- Mathlib/Data/Finset/Grade.lean
lemma covBy_iff_exists_cons : s ⋖ t ↔ ∃ a, ∃ ha : a ∉ s, s.cons a ha = t
-- Mathlib/FieldTheory/Separable.lean
/-- If `n ≠ 0` in `F`, then `X ^ n - a` is separable for any `a ≠ 0`. -/
theorem separable_X_pow_sub_C {n : ℕ} (a : F) (hn : (n : F) ≠ 0) (ha : a ≠ 0) :
    Separable (X ^ n - C a)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem aleph0_add_nat (n : ℕ) : ℵ₀ + n = ℵ₀
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem neg_norm_le_apply (f : C(α, ℝ)) (x : α) : -‖f‖ ≤ f x
-- Mathlib/GroupTheory/Coset.lean
@[to_additive rightAddCoset_zero]
theorem rightCoset_one : op (1 : α) • s = s
-- Mathlib/CategoryTheory/Sites/Coherent/ExtensiveSheaves.lean
/--
A presheaf on a category which is `FinitaryExtensive` is a sheaf iff it preserves finite products.
-/
theorem Presheaf.isSheaf_iff_preservesFiniteProducts (F : Cᵒᵖ ⥤ D) :
    IsSheaf (extensiveTopology C) F ↔ Nonempty (PreservesFiniteProducts F)
-- Mathlib/Order/Disjoint.lean
lemma Codisjoint.ne_iff (hab : Codisjoint a b) : a ≠ b ↔ a ≠ ⊤ ∨ b ≠ ⊤
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem mem_inf {p p' : L.Substructure M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem UniformIntegrable.spec (hp : p ≠ 0) (hp' : p ≠ ∞) (hfu : UniformIntegrable f p μ) {ε : ℝ}
    (hε : 0 < ε) :
    ∃ C : ℝ≥0, ∀ i, eLpNorm ({ x | C ≤ ‖f i x‖₊ }.indicator (f i)) p μ ≤ ENNReal.ofReal ε
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem subset_of_cons_subset {a : α} {l₁ l₂ : List α} : a :: l₁ ⊆ l₂ → l₁ ⊆ l₂
-- Mathlib/Algebra/Star/CentroidHom.lean
@[simp] lemma star_apply (f : CentroidHom α) (a : α) : (star f) a = star (f (star a))
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem map_comap_eq_self {f : M →ₙ* N} {S : Subsemigroup N} (h : S ≤ f.srange) :
    (S.comap f).map f = S
-- Mathlib/Data/Prod/TProd.lean
@[simp]
theorem elim_of_ne (hj : j ∈ i :: l) (hji : j ≠ i) (v : TProd α (i :: l)) :
    v.elim hj = TProd.elim v.2 ((List.mem_cons.mp hj).resolve_left hji)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.comp_tendsto (hcfg : IsBigOWith c l f g) {k : β → α} {l' : Filter β}
    (hk : Tendsto k l' l) : IsBigOWith c l' (f ∘ k) (g ∘ k)
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem isPWO_union : IsPWO (s ∪ t) ↔ IsPWO s ∧ IsPWO t
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
theorem stereo_right_inv (hv : ‖v‖ = 1) (w : (ℝ ∙ v)ᗮ) : stereoToFun v (stereoInvFun hv w) = w
-- Mathlib/Data/Finset/Lattice.lean
theorem comp_inf'_eq_inf'_comp [SemilatticeInf γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_inf : ∀ x y, g (x ⊓ y) = g x ⊓ g y) : g (s.inf' H f) = s.inf' H (g ∘ f)
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive tsum_pos]
theorem one_lt_tprod (hsum : Multipliable g) (hg : ∀ i, 1 ≤ g i) (i : ι) (hi : 1 < g i) :
    1 < ∏' i, g i
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma add_of_Y_ne {x₁ x₂ y₁ y₂ : F} {h₁ : W.Nonsingular x₁ y₁} {h₂ : W.Nonsingular x₂ y₂}
    (hy : y₁ ≠ W.negY x₂ y₂) :
    some h₁ + some h₂ = some (nonsingular_add h₁ h₂ fun _ ↦ hy)
-- Mathlib/Order/Cover.lean
theorem wcovBy_iff_Ioo_eq : a ⩿ b ↔ a ≤ b ∧ Ioo a b = ∅
-- Mathlib/Order/Bounds/Basic.lean
theorem subset_lowerBounds_upperBounds (s : Set α) : s ⊆ lowerBounds (upperBounds s)
-- Mathlib/RingTheory/PowerBasis.lean
theorem degree_minpolyGen [Nontrivial A] (pb : PowerBasis A S) :
    degree (minpolyGen pb) = pb.dim
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
theorem hasTrivialRadical_iff_no_abelian_ideals :
    HasTrivialRadical R L ↔ ∀ I : LieIdeal R L, IsLieAbelian I → I = ⊥
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
@[reassoc]
theorem map_on_summand₀ {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) {θ : Δ ⟶ Δ'}
    {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''} {i : Δ'' ⟶ A.1.unop} [Epi e] [Mono i]
    (fac : e ≫ i = θ.unop ≫ A.e) :
    Sigma.ι (summand K Δ) A ≫ map K θ =
      Termwise.mapMono K i ≫ Sigma.ι (summand K Δ') (Splitting.IndexSet.mk e)
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem mul_one_div_le_one {I : FractionalIdeal R₁⁰ K} : I * (1 / I) ≤ 1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
lemma nextCoeff_eq_zero :
    p.nextCoeff = 0 ↔ p.natDegree = 0 ∨ 0 < p.natDegree ∧ p.coeff (p.natDegree - 1) = 0
-- Mathlib/ModelTheory/Algebra/Ring/Basic.lean
theorem zero_def (α : Type*) : (0 : Language.ring.Term α) = Constants.term zeroFunc
-- Mathlib/Topology/TietzeExtension.lean
/-- **Tietze extension theorem** for real-valued bounded continuous maps, a version for a closed
embedding. Let `e` be a closed embedding of a nonempty topological space `X` into a normal
topological space `Y`. Let `f` be a bounded continuous real-valued function on `X`. Let `t` be
a nonempty convex set of real numbers (we use `OrdConnected` instead of `Convex` to automatically
deduce this argument by typeclass search) such that `f x ∈ t` for all `x`. Then there exists
a bounded continuous real-valued function `g : Y →ᵇ ℝ` such that `g y ∈ t` for all `y` and
`g ∘ e = f`. -/
theorem exists_extension_forall_mem_of_closedEmbedding (f : X →ᵇ ℝ) {t : Set ℝ} {e : X → Y}
    [hs : OrdConnected t] (hf : ∀ x, f x ∈ t) (hne : t.Nonempty) (he : ClosedEmbedding e) :
    ∃ g : Y →ᵇ ℝ, (∀ y, g y ∈ t) ∧ g ∘ e = f
-- Mathlib/Data/Complex/ExponentialBounds.lean
theorem exp_one_near_10 : |exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10
-- Mathlib/Algebra/Associated/Basic.lean
theorem associated_mul_unit_right {β : Type*} [Monoid β] (a u : β) (hu : IsUnit u) :
    Associated a (a * u)
-- Mathlib/Algebra/Field/Basic.lean
@[simp]
theorem neg_div_self {a : K} (h : a ≠ 0) : -a / a = -1
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem image_eq_one_of_nmem_mulTSupport {f : X → α} {x : X} (hx : x ∉ mulTSupport f) : f x = 1
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem uniformEquicontinuous_unique [Unique ι] {F : ι → β → α} :
    UniformEquicontinuous F ↔ UniformContinuous (F default)
-- Mathlib/Data/Int/Cast/Lemmas.lean
theorem intCast_apply (n : ℤ) (i : ι) : (n : ∀ i, π i) i = n
-- Mathlib/Algebra/Order/Monovary.lean
lemma Monovary.div_right₀ (hg₁ : 0 ≤ g₁) (hg₂ : StrongLT 0 g₂) (h₁ : Monovary f g₁)
    (h₂ : Antivary f g₂) : Monovary f (g₁ / g₂)
-- Mathlib/Order/Antichain.lean
theorem image (hs : IsStrongAntichain r s) {f : α → β} (hf : Surjective f)
    (h : ∀ a b, r' (f a) (f b) → r a b) : IsStrongAntichain r' (f '' s)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem neg_ediv_of_dvd : ∀ {a b : Int}, b ∣ a → (-a) / b = -(a / b)
-- Mathlib/Algebra/Field/Subfield.lean
theorem map_fieldRange : f.fieldRange.map g = (g.comp f).fieldRange
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_zero {op : Ordinal → Ordinal → Ordinal} : Principal op 0
-- Mathlib/Algebra/Group/Units/Equiv.lean
/-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Submonoid M} : (↑(⨅ i, S i) : Set M) = ⋂ i, S i
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_restrict_iUnion_iff [Countable ι] (s : ι → Set α) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i, s i), p x) ↔ ∀ i, ∀ᵐ x ∂μ.restrict (s i), p x
-- Mathlib/Data/FunLike/Equiv.lean
theorem inv_injective : Function.Injective (EquivLike.inv : E → β → α)
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiffAt_comp_diffeomorph_iff {m} (h : M ≃ₘ^n⟮I, J⟯ N) {f : N → M'} {x} (hm : m ≤ n) :
    ContMDiffAt I I' m (f ∘ h) x ↔ ContMDiffAt J I' m f (h x)
-- Mathlib/Computability/Partrec.lean
theorem option_map {f : α → Option β} {g : α → β → σ} (hf : Computable f) (hg : Computable₂ g) :
    Computable fun a => (f a).map (g a)
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
/--
`HasAffineProperty P Q` is a type class asserting that `P` is local at the target, and over affine
schemes, it is equivalent to `Q : AffineTargetMorphismProperty`.
To make the proofs easier, we state it instead as
1. `Q` is local at the target
2. `P f` if and only if `∀ U, Q (f ∣_ U)` ranging over all affine opens of `U`.
See `HasAffineProperty.iff`.
-/
class HasAffineProperty (P : MorphismProperty Scheme)
    (Q : outParam AffineTargetMorphismProperty) : Prop where
  isLocal_affineProperty : Q.IsLocal
  eq_targetAffineLocally' : P = targetAffineLocally Q
-- Mathlib/Data/Nat/Pairing.lean
theorem pair_lt_pair_right (a) {b₁ b₂} (h : b₁ < b₂) : pair a b₁ < pair a b₂
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem add (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ + ψ)