ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem add_le_add_iff_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < Cardinal.aleph0) :
    α + γ ≤ β + γ ↔ α ≤ β
-- Mathlib/Algebra/Group/Action/Basic.lean
/-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B)
-- Mathlib/Data/Finset/Basic.lean
theorem mem_insert_coe {s : Finset α} {x y : α} : x ∈ insert y s ↔ x ∈ insert y (s : Set α)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem le_iff_nonempty_imp_le_and_iUnion_subset :
    π₁ ≤ π₂ ↔
      (∀ J ∈ π₁, ∀ J' ∈ π₂, (J ∩ J' : Set (ι → ℝ)).Nonempty → J ≤ J') ∧ π₁.iUnion ⊆ π₂.iUnion
-- Mathlib/Analysis/Convex/EGauge.lean
@[simp] lemma egauge_zero_left_eq_top : egauge 𝕜 0 x = ∞ ↔ x ≠ 0
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[simp]
lemma inl_snd :
    (inl φ).comp (snd φ) (add_zero (-1)) = 0
-- Mathlib/CategoryTheory/GuitartExact/Basic.lean
/-- Given `w : TwoSquare T L R B` and `X₃ : C₃`, this is the obvious functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)`. -/
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)
-- Mathlib/Probability/Distributions/Exponential.lean
lemma lintegral_exponentialPDF_eq_antiDeriv {r : ℝ} (hr : 0 < r) (x : ℝ) :
    ∫⁻ y in Iic x, exponentialPDF r y
    = ENNReal.ofReal (if 0 ≤ x then 1 - exp (-(r * x)) else 0)
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
theorem map_eq_one_iff [OneHomClass F M N] (f : F) (hf : Function.Injective f)
    {x : M} :
    f x = 1 ↔ x = 1
-- Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean
/--
(Implementation) Given the appropriate product and equalizer cones, build the cone for `F` which is
limiting if the given cones are also.
-/
@[simps]
def buildLimit
    (hs : ∀ f : Σp : J × J, p.1 ⟶ p.2, s ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.1⟩ ≫ F.map f.2)
    (ht : ∀ f : Σp : J × J, p.1 ⟶ p.2, t ≫ c₂.π.app ⟨f⟩ = c₁.π.app ⟨f.1.2⟩)
    (i : Fork s t) : Cone F
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b
-- Mathlib/Topology/LocallyClosed.lean
lemma IsClosed.isLocallyClosed (hs : IsClosed s) : IsLocallyClosed s
-- Mathlib/Analysis/SpecialFunctions/PolarCoord.lean
/-- The polar coordinates partial homeomorphism in `ℝ^2`, mapping `(r cos θ, r sin θ)` to `(r, θ)`.
It is a homeomorphism between `ℝ^2 - (-∞, 0]` and `(0, +∞) × (-π, π)`. -/
@[simps]
def polarCoord : PartialHomeomorph (ℝ × ℝ) (ℝ × ℝ)
-- Mathlib/Algebra/Quaternion.lean
theorem normSq_zpow (z : ℤ) : normSq (a ^ z) = normSq a ^ z
-- Mathlib/Deprecated/Subfield.lean
theorem isSubfield_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set F}
    (hs : ∀ i, IsSubfield (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubfield (⋃ i, s i)
-- Mathlib/Order/Defs.lean
theorem lt_of_le_not_le : ∀ {a b : α}, a ≤ b → ¬b ≤ a → a < b
-- Mathlib/Analysis/NormedSpace/RieszLemma.lean
/--
A version of Riesz lemma: given a strict closed subspace `F`, one may find an element of norm `≤ R`
which is at distance at least `1` of every element of `F`. Here, `R` is any given constant
strictly larger than the norm of an element of norm `> 1`. For a version without an `R`, see
`riesz_lemma`.

Since we are considering a general nontrivially normed field, there may be a gap in possible norms
(for instance no element of norm in `(1,2)`). Hence, we can not allow `R` arbitrarily close to `1`,
and require `R > ‖c‖` for some `c : 𝕜` with norm `> 1`.
-/
theorem riesz_lemma_of_norm_lt {c : 𝕜} (hc : 1 < ‖c‖) {R : ℝ} (hR : ‖c‖ < R) {F : Subspace 𝕜 E}
    (hFc : IsClosed (F : Set E)) (hF : ∃ x : E, x ∉ F) :
    ∃ x₀ : E, ‖x₀‖ ≤ R ∧ ∀ y ∈ F, 1 ≤ ‖x₀ - y‖
-- Mathlib/Logic/Embedding/Basic.lean
/-- Composition of `f : α ↪ β` and `g : β ↪ γ`. -/
@[trans, simps (config := { simpRhs := true })]
protected def trans {α β γ} (f : α ↪ β) (g : β ↪ γ) : α ↪ γ
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumArrowEquivProdArrow_symm_apply_inr (f : α → γ) (g : β → γ) (b : β) :
    ((sumArrowEquivProdArrow α β γ).symm (f, g)) (inr b) = g b
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem map_bot : map m ⊥ = ⊥
-- Mathlib/Probability/Independence/Conditional.lean
theorem CondIndepFun.neg_left {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'} [Neg β]
    [MeasurableNeg β] (hfg : CondIndepFun m' hm' f g μ) :
    CondIndepFun m' hm' (-f) g μ
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem BinaryBiproduct.bicone_inl : (BinaryBiproduct.bicone X Y).inl = biprod.inl
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem dvd_lcm_right (x y : R) : y ∣ lcm x y
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem associator_hom_hom (X Y Z : Mon_ C) : (α_ X Y Z).hom.hom = (α_ X.X Y.X Z.X).hom
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem UniformContinuous.inv [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    UniformContinuous fun x => (f x)⁻¹
-- Mathlib/Data/Set/Prod.lean
lemma compl_prod_eq_union {α β : Type*} (s : Set α) (t : Set β) :
    (s ×ˢ t)ᶜ = (sᶜ ×ˢ univ) ∪ (univ ×ˢ tᶜ)
-- Mathlib/RingTheory/LocalRing/Module.lean
theorem map_mkQ_eq_top {N : Submodule R M} [Module.Finite R M] :
    N.map (Submodule.mkQ (𝔪 • ⊤)) = ⊤ ↔ N = ⊤
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := mono)]
theorem smul_subset_smul : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ • t₁ ⊆ s₂ • t₂
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem restrict_preimage (f : α →ₛ β) {s : Set α} (hs : MeasurableSet s) {t : Set β}
    (ht : (0 : β) ∉ t) : restrict f s ⁻¹' t = s ∩ f ⁻¹' t
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem degrees_esymm [Nontrivial R] (n : ℕ) (hpos : 0 < n) (hn : n ≤ Fintype.card σ) :
    (esymm σ R n).degrees = (univ : Finset σ).val
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem insert_nonempty (u v : ZFSet) : (insert u v).Nonempty
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem mem_fieldRange {y : L'} : y ∈ f.fieldRange ↔ ∃ x, f x = y
-- Mathlib/Algebra/Module/Torsion.lean
theorem IsTorsionBy.quotient (N : Submodule R M) {r : R}
    (h : IsTorsionBy R M r) : IsTorsionBy R (M⧸N) r
-- Mathlib/Combinatorics/SetFamily/LYM.lean
/-- The shadow of `falling m 𝒜` is disjoint from the `n`-sized elements of `𝒜`, thanks to the
antichain property. -/
theorem IsAntichain.disjoint_slice_shadow_falling {m n : ℕ}
    (h𝒜 : IsAntichain (· ⊆ ·) (𝒜 : Set (Finset α))) : Disjoint (𝒜 # m) (∂ (falling n 𝒜))
-- Mathlib/Algebra/MonoidAlgebra/ToDirectSum.lean
@[simp]
theorem toAddMonoidAlgebra_add [Semiring M] [∀ m : M, Decidable (m ≠ 0)] (f g : ⨁ _ : ι, M) :
    (f + g).toAddMonoidAlgebra = toAddMonoidAlgebra f + toAddMonoidAlgebra g
-- Mathlib/Data/Nat/Defs.lean
lemma eq_one_of_mul_eq_one_right (H : m * n = 1) : m = 1
-- Mathlib/NumberTheory/LucasPrimality.lean
/-- If `a^(p-1) = 1 mod p`, but `a^((p-1)/q) ≠ 1 mod p` for all prime factors `q` of `p-1`, then `p`
is prime. This is true because `a` has order `p-1` in the multiplicative group mod `p`, so this
group must itself have order `p-1`, which only happens when `p` is prime.
-/
theorem lucas_primality (p : ℕ) (a : ZMod p) (ha : a ^ (p - 1) = 1)
    (hd : ∀ q : ℕ, q.Prime → q ∣ p - 1 → a ^ ((p - 1) / q) ≠ 1) : p.Prime
-- Mathlib/Topology/Algebra/MvPolynomial.lean
theorem MvPolynomial.continuous_eval : Continuous fun x ↦ eval x p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] theorem sub_eq : Nat.sub x y = x - y
-- Mathlib/GroupTheory/CosetCover.lean
theorem Submodule.exists_finiteIndex_of_cover :
    ∃ k ∈ s, (p k).toAddSubgroup.FiniteIndex
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_surjective_eq_arrow_of_le (le : #β ≤ #α) : #{f : α → β | Surjective f} = #(α → β)
-- Mathlib/Analysis/Analytic/Basic.lean
theorem summable_norm_apply (p : FormalMultilinearSeries 𝕜 E F) {x : E}
    (hx : x ∈ EMetric.ball (0 : E) p.radius) : Summable fun n : ℕ => ‖p n fun _ => x‖
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem mul_apply [MulZeroClass β] [ContinuousMul β] (f g : C₀(α, β)) : (f * g) x = f x * g x
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- The `simp` normal form for a quadratic map is `DFunLike.coe`, not `toFun`. -/
@[simp]
theorem toFun_eq_coe : Q.toFun = ⇑Q
-- Mathlib/Data/Stream/Init.lean
theorem cycle_eq : ∀ (l : List α) (h : l ≠ []), cycle l h = l ++ₛ cycle l h
-- Mathlib/Data/Multiset/Basic.lean
theorem eq_replicate {a : α} {n} {s : Multiset α} :
    s = replicate n a ↔ card s = n ∧ ∀ b ∈ s, b = a
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem LinearMap.withSeminorms_induced [hι : Nonempty ι] {q : SeminormFamily 𝕜₂ F ι}
    (hq : WithSeminorms q) (f : E →ₛₗ[σ₁₂] F) :
    WithSeminorms (topology := induced f inferInstance) (q.comp f)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem map_equiv_eq_comap_symm (f : R ≃+* S) (K : NonUnitalSubring R) :
    K.map (f : R →ₙ+* S) = K.comap f.symm
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp]
theorem forget₂_bialgebra_obj (X : HopfAlgebraCat R) :
    (forget₂ (HopfAlgebraCat R) (BialgebraCat R)).obj X = BialgebraCat.of R X
-- Mathlib/Data/List/Forall2.lean
theorem forall₂_and_left {p : α → Prop} :
    ∀ l u, Forall₂ (fun a b => p a ∧ R a b) l u ↔ (∀ a ∈ l, p a) ∧ Forall₂ R l u
-- Mathlib/Data/Sign.lean
@[simp, norm_cast]
lemma coe_neg {α : Type*} [One α] [SubtractionMonoid α] (s : SignType) :
    (↑(-s) : α) = -↑s
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem prod.leftUnitor_inv_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    (prod.leftUnitor X).inv ≫ prod.map (𝟙 _) f = f ≫ (prod.leftUnitor Y).inv
-- Mathlib/Algebra/Order/Module/Defs.lean
@[simp]
lemma smul_lt_iff_lt_one_left [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    a • b < b ↔ a < 1
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
/-- A finite-dimensional subspace is complete. -/
theorem Submodule.complete_of_finiteDimensional (s : Submodule 𝕜 E) [FiniteDimensional 𝕜 s] :
    IsComplete (s : Set E)
-- Mathlib/Order/Hom/Basic.lean
/-- Note that this goal could also be stated `(Codisjoint on f) a b` -/
theorem Codisjoint.map_orderIso [SemilatticeSup α] [OrderTop α] [SemilatticeSup β] [OrderTop β]
    {a b : α} (f : α ≃o β) (ha : Codisjoint a b) : Codisjoint (f a) (f b)
-- Mathlib/Order/Fin/Basic.lean
/-- If `e` is an `orderIso` between `Fin n` and `Fin m`, then `n = m` and `e` is the identity
map. In this lemma we state that for each `i : Fin n` we have `(e i : ℕ) = (i : ℕ)`. -/
@[simp] lemma coe_orderIso_apply (e : Fin n ≃o Fin m) (i : Fin n) : (e i : ℕ) = i
-- Mathlib/FieldTheory/Adjoin.lean
theorem exists_finset_of_mem_iSup {ι : Type*} {f : ι → IntermediateField F E} {x : E}
    (hx : x ∈ ⨆ i, f i) : ∃ s : Finset ι, x ∈ ⨆ i ∈ s, f i
-- Mathlib/Data/Matroid/Restrict.lean
theorem Basis.base_of_base_subset (hIX : M.Basis I X) (hB : M.Base B) (hBX : B ⊆ X) : M.Base I
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
theorem numerator_isUnit (s : S) : IsUnit (numeratorHom (s : R) : R[S⁻¹])
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_inj : (D : Set α) = ↑E ↔ D = E
-- Mathlib/Order/Bounds/Basic.lean
/-- If `s ⊆ t` and `t` is bounded below, then so is `s`. -/
theorem BddBelow.mono ⦃s t : Set α⦄ (h : s ⊆ t) : BddBelow t → BddBelow s
-- Mathlib/LinearAlgebra/Basis.lean
@[simp high]
theorem coe_sumCoords_of_fintype [Fintype ι] : (b.sumCoords : M → R) = ∑ i, b.coord i
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem append_nil (as : Array α) : as ++ #[] = as
-- Mathlib/Topology/Constructions.lean
theorem continuous_swap : Continuous (Prod.swap : X × Y → Y × X)
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem volume_pi [∀ i, MeasureSpace (α i)] :
    (volume : Measure (∀ i, α i)) = Measure.pi fun _ => volume
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_add_one (x y : Nat) : gcd (x + 1) y = gcd (y % (x + 1)) (x + 1)
-- Mathlib/Algebra/AddTorsor.lean
theorem pointReflection_apply (x y : P) : pointReflection x y = x -ᵥ y +ᵥ x
-- Mathlib/Analysis/Analytic/Basic.lean
theorem changeOriginSeries_summable_aux₂ (hr : (r : ℝ≥0∞) < p.radius) (k : ℕ) :
    Summable fun s : Σl : ℕ, { s : Finset (Fin (k + l)) // s.card = l } =>
      ‖p (k + s.1)‖₊ * r ^ s.1
-- Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean
@[to_additive]
private lemma wellFoundedOn_devosMulRel :
    {x : Finset α × Finset α | x.1.Nonempty ∧ x.2.Nonempty}.WellFoundedOn
      (DevosMulRel : Finset α × Finset α → Finset α × Finset α → Prop)
-- Mathlib/Order/RelClasses.lean
lemma superset_antisymm [IsAntisymm α (· ⊆ ·)] : a ⊆ b → b ⊆ a → b = a
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp]
theorem num_mul (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 * c2).num : A) = c1.num * c2.num
-- Mathlib/Data/Set/NAry.lean
/-- The other direction does not hold because of the `u`-`u` cross terms on the RHS. -/
theorem image2_distrib_subset_right {f : δ → γ → ε} {g : α → β → δ} {f₁ : α → γ → α'}
    {f₂ : β → γ → β'} {g' : α' → β' → ε} (h_distrib : ∀ a b c, f (g a b) c = g' (f₁ a c) (f₂ b c)) :
    image2 f (image2 g s t) u ⊆ image2 g' (image2 f₁ s u) (image2 f₂ t u)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
theorem dist_inversion_mul_dist_center_eq (hx : x ≠ c) (hy : y ≠ c) :
    dist (inversion c R x) y * dist x c = dist x (inversion c R y) * dist y c
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is twice differentiable on `ℝ`, and `f''` is nonnegative on `ℝ`,
then `f` is convex on `ℝ`. -/
theorem convexOn_univ_of_deriv2_nonneg {f : ℝ → ℝ} (hf' : Differentiable ℝ f)
    (hf'' : Differentiable ℝ (deriv f)) (hf''_nonneg : ∀ x, 0 ≤ (deriv^[2] f) x) :
    ConvexOn ℝ univ f
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
/-- This will be a special case of `LinearMap.toMatrix_id_eq_basis_toMatrix`. -/
theorem LinearMap.toMatrix_id : LinearMap.toMatrix v₁ v₁ id = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[simp]
theorem cocone_inl (s : CommSq f g h i) : s.cocone.inl = h
-- Mathlib/Data/Set/Sigma.lean
theorem sigma_eq_empty_iff : s.sigma t = ∅ ↔ ∀ i ∈ s, t i = ∅
-- Mathlib/Data/Multiset/Pi.lean
@[simp]
theorem pi_cons (m : Multiset α) (t : ∀ a, Multiset (β a)) (a : α) :
    pi (a ::ₘ m) t = (t a).bind fun b => (pi m t).map <| Pi.cons m a b
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- If a multilinear map in finitely many variables on normed spaces satisfies the inequality
`‖f m‖ ≤ C * ∏ i, ‖m i‖` on a shell `ε i / ‖c i‖ < ‖m i‖ < ε i` for some positive numbers `ε i`
and elements `c i : 𝕜`, `1 < ‖c i‖`, then it satisfies this inequality for all `m`. -/
theorem bound_of_shell {ε : ι → ℝ} {C : ℝ} (hε : ∀ i, 0 < ε i) {c : ι → 𝕜} (hc : ∀ i, 1 < ‖c i‖)
    (hf : ∀ m : ∀ i, E i, (∀ i, ε i / ‖c i‖ ≤ ‖m i‖) → (∀ i, ‖m i‖ < ε i) → ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m : ∀ i, E i) : ‖f m‖ ≤ C * ∏ i, ‖m i‖
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_ball (a r : ℝ) : volume (Metric.ball a r) = ofReal (2 * r)
-- Mathlib/Order/Hom/Lattice.lean
@[simp, norm_cast]
lemma coe_withBot (f : LatticeHom α β) : ⇑f.withBot = Option.map f
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem symm_toNonUnitalRingHom_comp_toNonUnitalRingHom (e : R ≃+* S) :
    e.symm.toNonUnitalRingHom.comp e.toNonUnitalRingHom = NonUnitalRingHom.id _
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
theorem prod_Ico_succ_div_top (hmn : m ≤ n) :
    (∏ i ∈ Ico m (n + 1), f i) / f n = ∏ i ∈ Ico m n, f i
-- Mathlib/Order/Filter/Germ/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem prod_mono {S T : NonUnitalSubalgebra R A} {S₁ T₁ : NonUnitalSubalgebra R B} :
    S ≤ T → S₁ ≤ T₁ → prod S S₁ ≤ prod T T₁
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_hasFPowerSeriesAt_zero : HasFPowerSeriesAt (exp 𝕂) (expSeries 𝕂 𝔸) 0
-- Mathlib/Order/SymmDiff.lean
theorem bihimp_def [Inf α] [HImp α] (a b : α) : a ⇔ b = (b ⇨ a) ⊓ (a ⇨ b)
-- Mathlib/Order/Chain.lean
theorem ChainClosure.succ_fixpoint (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂)
    (hc : SuccChain r c₂ = c₂) : c₁ ⊆ c₂
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem basis_toMatrix_mul_linearMap_toMatrix_mul_basis_toMatrix
    [Fintype κ'] [DecidableEq ι] [DecidableEq ι'] :
    c.toMatrix c' * LinearMap.toMatrix b' c' f * b'.toMatrix b = LinearMap.toMatrix b c f
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_copy (f : InfTopHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Algebra/ModEq.lean
protected theorem add_nsmul (n : ℕ) : a ≡ b [PMOD p] → a + n • p ≡ b [PMOD p]
-- Mathlib/CategoryTheory/Yoneda.lean
@[simp]
theorem naturality {X Y : Cᵒᵖ} (α : coyoneda.obj X ⟶ coyoneda.obj Y) {Z Z' : C} (f : Z' ⟶ Z)
    (h : unop X ⟶ Z') : α.app Z' h ≫ f = α.app Z (h ≫ f)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem sum_const_nat {m : ℕ} {f : α → ℕ} (h₁ : ∀ x ∈ s, f x = m) :
    ∑ x ∈ s, f x = card s * m
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_mono (h : I ≤ J) : map f I ≤ map f J
-- Mathlib/Data/PNat/Factors.lean
theorem coe_prod (v : PrimeMultiset) : (v.prod : ℕ) = (v : Multiset ℕ).prod
-- Mathlib/Data/Real/GoldenRatio.lean
/-- The conjugate of the golden ratio is irrational. -/
theorem goldConj_irrational : Irrational ψ
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
@[simp] protected theorem lt_irrefl (a : Char) : ¬ a < a
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- The sets of `s`-factored and of `s ∪ {N}`-factored numbers are the same when `N` is not prime.
See `Nat.equivProdNatFactoredNumbers` for when `N` is prime. -/
lemma factoredNumbers_insert (s : Finset ℕ) {N : ℕ} (hN : ¬ N.Prime) :
    factoredNumbers (insert N s) = factoredNumbers s
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_sInf_arrows {s : Set (Subgroupoid C)} {c d : C} {p : c ⟶ d} :
    p ∈ (sInf s).arrows c d ↔ ∀ S ∈ s, p ∈ S.arrows c d
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem zero_le_powHalf (n : ℕ) : 0 ≤ powHalf n
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The proposition that a square
```
  P --fst--> X
  |          |
 snd         f
  |          |
  v          v
  Y ---g---> Z

```
is a pullback square. (Also known as a fibered product or cartesian square.)
-/
structure IsPullback {P X Y Z : C} (fst : P ⟶ X) (snd : P ⟶ Y) (f : X ⟶ Z) (g : Y ⟶ Z) extends
  CommSq fst snd f g : Prop where
  /-- the pullback cone is a limit -/
  isLimit' : Nonempty (IsLimit (PullbackCone.mk _ _ w))
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem dist_right_pointReflection (p q : P) :
    dist q (Equiv.pointReflection p q) = ‖(2 : 𝕜)‖ * dist p q
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := mono)]
theorem toSubmonoid_strictMono : StrictMono (toSubmonoid : Subgroup G → Submonoid G)
-- Mathlib/Topology/StoneCech.lean
theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.extend f)
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- The Radon-Nikodym derivative of `f ν` with respect to `ν` is `f`. -/
theorem rnDeriv_withDensity₀ (ν : Measure α) [SigmaFinite ν] {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) :
    (ν.withDensity f).rnDeriv ν =ᵐ[ν] f
-- Mathlib/Order/OrderIsoNat.lean
theorem WellFounded.iSup_eq_monotonicSequenceLimit [CompleteLattice α]
    (h : WellFounded ((· > ·) : α → α → Prop)) (a : ℕ →o α) :
    iSup a = monotonicSequenceLimit a
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem place_conjugate (φ : K →+* ℂ) : place (conjugate φ) = place φ
-- Mathlib/Algebra/Homology/DerivedCategory/HomologySequence.lean
lemma mono_homologyMap_mor₁_iff :
    Mono ((homologyFunctor C n₁).map T.mor₁) ↔ δ T n₀ n₁ h = 0
-- Mathlib/Data/Set/Basic.lean
theorem Nonempty.eq_univ [Subsingleton α] : s.Nonempty → s = univ
-- Mathlib/Order/Lattice.lean
theorem inf_left_idem (a b : α) : a ⊓ (a ⊓ b) = a ⊓ b
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive]
theorem is_left_invariant_prehaar {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty)
    (g : G) (K : Compacts G) :
    prehaar (K₀ : Set G) U (K.map _ <| continuous_mul_left g) = prehaar (K₀ : Set G) U K
-- Mathlib/Algebra/Polynomial/Mirror.lean
@[simp]
theorem mirror_trailingCoeff : p.mirror.trailingCoeff = p.leadingCoeff
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ofReal' (no_index (OfNat.ofNat n)) = OfNat.ofNat n
-- Mathlib/ModelTheory/Complexity.lean
theorem semanticallyEquivalent_toPrenex (φ : L.BoundedFormula α n) :
    (∅ : L.Theory).SemanticallyEquivalent φ φ.toPrenex
-- Mathlib/Order/Filter/Prod.lean
@[simp] theorem prod_bot : f ×ˢ (⊥ : Filter β) = ⊥
-- Mathlib/CategoryTheory/Equivalence.lean
/-- If `C` is equivalent to `D`, then `C ⥤ E` is equivalent to `D ⥤ E`. -/
@[simps! functor inverse unitIso counitIso]
def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- Division of rational functions. -/
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
-- Mathlib/Order/MinMax.lean
theorem lt_max_of_lt_left (h : a < b) : a < max b c
-- Mathlib/Data/Fintype/Fin.lean
theorem card_filter_univ_succ' (p : Fin (n + 1) → Prop) [DecidablePred p] :
    (univ.filter p).card = ite (p 0) 1 0 + (univ.filter (p ∘ Fin.succ)).card
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- If a set belongs to the algebra of sets generated by `𝒜` then it can be written as a finite
union of finite intersections of sets which are in `𝒜` or have their complement in `𝒜`. -/
theorem mem_generateSetAlgebra_elim (s_mem : s ∈ generateSetAlgebra 𝒜) :
    ∃ A : Set (Set (Set α)), A.Finite ∧ (∀ a ∈ A, a.Finite) ∧
    (∀ᵉ (a ∈ A) (t ∈ a), t ∈ 𝒜 ∨ tᶜ ∈ 𝒜) ∧ s = ⋃ a ∈ A, ⋂ t ∈ a, t
-- Mathlib/Data/Finsupp/Basic.lean
theorem snd_sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] (f : α ⊕ β →₀ γ) (y : β) :
    (sumFinsuppEquivProdFinsupp f).2 y = f (Sum.inr y)
-- Mathlib/Algebra/Ring/Ext.lean
theorem toNonUnitalRing_injective :
    Function.Injective (@toNonUnitalRing R)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem HasFTaylorSeriesUpToOn.restrictScalars (h : HasFTaylorSeriesUpToOn n f p' s) :
    HasFTaylorSeriesUpToOn n f (fun x => (p' x).restrictScalars 𝕜) s
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem smul_of [MulOneClass G] (g : G) (r : k) : r • of k G g = single g r
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem differentiable_sin : Differentiable ℝ sin
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma measurable_measure_stieltjesOfMeasurableRat (hf : Measurable f) :
    Measurable fun a ↦ (stieltjesOfMeasurableRat f hf a).measure
-- Mathlib/Data/SetLike/Basic.lean
@[simp, norm_cast]
theorem coe_subset_coe {S T : A} : (S : Set B) ⊆ T ↔ S ≤ T
-- Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
theorem continuous_coe_fun :
    Continuous (DFunLike.coe : ContinuousMultilinearMap 𝕜 E F → (Π i, E i) → F)
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
/-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
protected theorem dense (hp_ne_top : p ≠ ∞) : Dense (Lp.simpleFunc E p μ : Set (Lp E p μ))
-- Mathlib/Order/Monotone/Basic.lean
@[simp]
theorem strictAnti_comp_ofDual_iff : StrictAnti (f ∘ ofDual) ↔ StrictMono f
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp, reassoc]
lemma eqToHom_comp_homOfLE {a b c : X} (hab : a = b) (hbc : b ≤ c) :
    eqToHom hab ≫ homOfLE hbc = homOfLE ((le_of_eq hab).trans hbc)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem conj_eq_one_iff : a * b * a⁻¹ = 1 ↔ b = 1
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_smul_right (x y : F) {r : 𝕜} : ⟪x, r • y⟫ = r * ⟪x, y⟫