ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem ord_card_le (o : Ordinal) : o.card.ord ≤ o
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem linear_surjective_iff (f : P1 →ᵃ[k] P2) :
    Function.Surjective f.linear ↔ Function.Surjective f
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
/-- `slope f a b` is an affine combination of `slope f a (lineMap a b r)` and
`slope f (lineMap a b r) b`. We use `lineMap` to express this property. -/
theorem lineMap_slope_lineMap_slope_lineMap (f : k → PE) (a b r : k) :
    lineMap (slope f (lineMap a b r) b) (slope f a (lineMap a b r)) r = slope f a b
-- Mathlib/LinearAlgebra/Dimension/DivisionRing.lean
/-- This is mostly an auxiliary lemma for `Submodule.rank_sup_add_rank_inf_eq`. -/
theorem rank_add_rank_split (db : V₂ →ₗ[K] V) (eb : V₃ →ₗ[K] V) (cd : V₁ →ₗ[K] V₂)
    (ce : V₁ →ₗ[K] V₃) (hde : ⊤ ≤ LinearMap.range db ⊔ LinearMap.range eb) (hgd : ker cd = ⊥)
    (eq : db.comp cd = eb.comp ce) (eq₂ : ∀ d e, db d = eb e → ∃ c, cd c = d ∧ ce c = e) :
    Module.rank K V + Module.rank K V₁ = Module.rank K V₂ + Module.rank K V₃
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
@[local instance] theorem instIsAlgClosed : IsAlgClosed (AlgebraicClosureAux k)
-- Mathlib/Data/PFun.lean
theorem image_mono {s t : Set α} (h : s ⊆ t) : f.image s ⊆ f.image t
-- Mathlib/Data/Finset/Sups.lean
lemma subset_sups_self : s ⊆ s ⊻ s
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arcsin`, version subtracting vectors. -/
theorem oangle_sub_left_eq_arcsin_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle (x - y) x = Real.arcsin (‖y‖ / ‖x - y‖)
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem exists_pow_lt_factorial (c : ℕ) : ∃ n0 > 1, ∀ n ≥ n0, c ^ n < (n - 1)!
-- Mathlib/LinearAlgebra/Dimension/Localization.lean
lemma IsLocalizedModule.lift_rank_eq :
    Cardinal.lift.{v} (Module.rank S N) = Cardinal.lift.{v'} (Module.rank R M)
-- Mathlib/CategoryTheory/Sites/PreservesSheafification.lean
@[reassoc (attr := simp)]
lemma sheafComposeIso_hom_fac :
    toSheafify J (P ⋙ F) ≫ (sheafifyComposeIso J F P).hom =
      whiskerRight (toSheafify J P) F
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_eq_iInter_thickening' {δ : ℝ} (δ_nn : 0 ≤ δ) (s : Set ℝ) (hsδ : s ⊆ Ioi δ)
    (hs : ∀ ε, δ < ε → (s ∩ Ioc δ ε).Nonempty) (E : Set α) :
    cthickening δ E = ⋂ ε ∈ s, thickening ε E
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_sInf {S : Set (Subsemiring R)} {x : R} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Mathlib/MeasureTheory/Integral/DominatedConvergence.lean
theorem continuous_parametric_primitive_of_continuous
    {a₀ : ℝ} (hf : Continuous f.uncurry) :
    Continuous fun p : X × ℝ ↦ ∫ t in a₀..p.2, f p.1 t ∂μ
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma inr_comp_binaryCoproductIso_inv_apply (a : C) (x : G.obj a) :
    (binaryCoproductIso F G).inv.app a (.inr x) = (Limits.coprod.inr (X := F)).app a x
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem positivize?_eq_some (w : positivize? (s, x) = some (s', x')) :
    positivizeConstraint s x = s' ∧ positivizeCoeffs s x = x'
-- Mathlib/NumberTheory/LSeries/Basic.lean
@[simp]
lemma LSeries_zero : LSeries 0 = 0
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- A variant of `incl_lift` with `Z` a terminal object. -/
@[simps!]
def inclLiftToTerminal {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsTerminal Z) :
    incl ⋙ liftToTerminal F hZ ≅ F
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem coeIdeal_pow (I : Ideal R) (n : ℕ) : ↑(I ^ n) = (I : FractionalIdeal S P) ^ n
-- Mathlib/Analysis/Seminorm.lean
/-- A seminorm is continuous at `0` if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`. -/
theorem continuousAt_zero_of_forall [TopologicalSpace E] {p : Seminorm 𝕝 E}
    (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    ContinuousAt p 0
-- Mathlib/Data/PNat/Defs.lean
theorem eq {m n : ℕ+} : (m : ℕ) = n → m = n
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem mem_singleton_iff {a b : α} : a ∈ ({b} : Set α) ↔ a = b
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem map_eq_bot_iff : I.map f = ⊥ ↔ I ≤ f.ker
-- Mathlib/MeasureTheory/Measure/Dirac.lean
@[simp]
theorem dirac_apply [MeasurableSingletonClass α] (a : α) (s : Set α) :
    dirac a s = s.indicator 1 a
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
@[simp]
theorem ascPochhammer_one : ascPochhammer S 1 = X
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAntiOn.mapsTo_Ioi (h : StrictAntiOn f (Ici a)) : MapsTo f (Ioi a) (Iio (f a))
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableAt_fst {x : M × M'} : MDifferentiableAt (I.prod I') I Prod.fst x
-- Mathlib/Data/Nat/Periodic.lean
theorem _root_.Function.Periodic.map_mod_nat {α : Type*} {f : ℕ → α} {a : ℕ} (hf : Periodic f a) :
    ∀ n, f (n % a) = f n
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem _root_.Set.Infinite.not_bddBelow {s : Set α} : s.Infinite → ¬BddBelow s
-- Mathlib/Analysis/Normed/Group/Basic.lean
/-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of an additive subgroup `s` of a seminormed
additive group `E`, its norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem derivWithin_finset_prod (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hf : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (f i) s x) :
    derivWithin (∏ i ∈ u, f i ·) s x =
      ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • derivWithin (f i) s x
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem pow_subst {α} [CommRing α] {n e1 t1 k l : α} {e2 : ℕ}
    (h1 : n * e1 = t1) (h2 : l * n ^ e2 = k) : k * (e1 ^ e2) = l * t1 ^ e2
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem measurableSet_of_null [μ.IsComplete] (hs : μ s = 0) : MeasurableSet s
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem conj_I : conj (I : K) = -I
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem isBoundedBilinearMap_mul : IsBoundedBilinearMap 𝕜 fun p : 𝕜 × 𝕜 => p.1 * p.2
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem IsGLB.csInf_eq (H : IsGLB s a) (ne : s.Nonempty) : sInf s = a
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem contDiffWithinAt_inter' (h : t ∈ 𝓝[s] x) :
    ContDiffWithinAt 𝕜 n f (s ∩ t) x ↔ ContDiffWithinAt 𝕜 n f s x
-- Mathlib/LinearAlgebra/Determinant.lean
@[simp]
theorem Basis.det_map (b : Basis ι R M) (f : M ≃ₗ[R] M') (v : ι → M') :
    (b.map f).det v = b.det (f.symm ∘ v)
-- Mathlib/Algebra/Ring/Parity.lean
lemma iterate_eq_id (hf : Involutive f) (hne : f ≠ id) : f^[n] = id ↔ Even n
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem union_smul [DecidableEq α] : (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t
-- Mathlib/Order/Filter/Cofinite.lean
/-- For an injective function `f`, inverse images of finite sets are finite. See also
`Filter.comap_cofinite_le` and `Function.Injective.comap_cofinite_eq`. -/
theorem Function.Injective.tendsto_cofinite {f : α → β} (hf : Injective f) :
    Tendsto f cofinite cofinite
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
lemma const (x : β) : IsCauSeq abv fun _ ↦ x
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive]
theorem stronglyMeasurable_one {α β} {_ : MeasurableSpace α} [TopologicalSpace β] [One β] :
    StronglyMeasurable (1 : α → β)
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- Extensionality. Since `MulChar`s always take the value zero on non-units, it is sufficient
to compare the values on units. -/
@[ext]
theorem ext {χ χ' : MulChar R R'} (h : ∀ a : Rˣ, χ a = χ' a) : χ = χ'
-- Mathlib/Algebra/Algebra/Basic.lean
/-- If there is a linear map `f : A →ₗ[R] B` that preserves `1`, then `algebraMap R B r` is
a unit when `algebraMap R A r` is. -/
lemma IsUnit.algebraMap_of_algebraMap (f : A →ₗ[R] B) (hf : f 1 = 1) {r : R}
    (h : IsUnit (algebraMap R A r)) : IsUnit (algebraMap R B r)
-- Mathlib/Algebra/Module/Torsion.lean
lemma torsion_int {G} [AddCommGroup G] :
    (torsion ℤ G).toAddSubgroup = AddCommGroup.torsion G
-- Mathlib/Data/Seq/WSeq.lean
theorem mem_of_mem_dropn {s : WSeq α} {a} : ∀ {n}, a ∈ drop s n → a ∈ s
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem inductionOn_cons {C : ∀ {n : ℕ}, Vector α n → Sort*} {n : ℕ} (x : α) (v : Vector α n)
    (nil : C nil) (cons : ∀ {n : ℕ} {x : α} {w : Vector α n}, C w → C (x ::ᵥ w)) :
    (x ::ᵥ v).inductionOn nil cons = cons (v.inductionOn nil cons : C v)
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
lemma ExactAt.of_iso (hK : K.ExactAt i) {L : HomologicalComplex C c} (e : K ≅ L) :
    L.ExactAt i
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
@[simp high]
theorem comp_id_id (B : BilinForm R M) : B.comp LinearMap.id LinearMap.id = B
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem compMeasurePreserving_toGerm [MeasurableSpace β] {f : α → β} {ν}
    (g : β →ₘ[ν] γ) (hf : MeasurePreserving f μ ν) :
    (g.compMeasurePreserving f hf).toGerm =
      g.toGerm.compTendsto f hf.quasiMeasurePreserving.tendsto_ae
-- Mathlib/Data/Set/Lattice.lean
lemma iInf_sUnion (S : Set (Set α)) (f : α → β) :
    (⨅ x ∈ ⋃₀ S, f x) = ⨅ (s ∈ S) (x ∈ s), f x
-- Mathlib/Computability/Language.lean
theorem kstar_def_nonempty (l : Language α) :
    l∗ = { x | ∃ S : List (List α), x = S.join ∧ ∀ y ∈ S, y ∈ l ∧ y ≠ [] }
-- Mathlib/CategoryTheory/Yoneda.lean
lemma yonedaEquiv_comp {X : C} {F G : Cᵒᵖ ⥤ Type v₁} (α : yoneda.obj X ⟶ F) (β : F ⟶ G) :
    yonedaEquiv (α ≫ β) = β.app _ (yonedaEquiv α)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_smul_left (x y : E) (r : 𝕜) : ⟪r • x, y⟫ = r† * ⟪x, y⟫
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffOn.div_const {f : E → 𝕜'} {n} (hf : ContDiffOn 𝕜 n f s) (c : 𝕜') :
    ContDiffOn 𝕜 n (fun x => f x / c) s
-- Mathlib/Analysis/RCLike/Basic.lean
theorem inv_def (z : K) : z⁻¹ = conj z * ((‖z‖ ^ 2)⁻¹ : ℝ)
-- Mathlib/Data/Finsupp/Interval.lean
theorem Icc_eq : Icc f g = (f.support ∪ g.support).finsupp (f.rangeIcc g)
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
lemma integrable_const_add_iff [IsFiniteMeasure μ] {f : α → β} {c : β} :
    Integrable (fun x ↦ c + f x) μ ↔ Integrable f μ
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumCongr_swap_refl {α β : Sort _} [DecidableEq α] [DecidableEq β] (i j : α) :
    Equiv.Perm.sumCongr (Equiv.swap i j) (Equiv.refl β) = Equiv.swap (Sum.inl i) (Sum.inl j)
-- Mathlib/Order/SupClosed.lean
@[simp] lemma latticeClosure_eq_self : latticeClosure s = s ↔ IsSublattice s
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.dvd_of_dvd_mul_right_of_isPrimal (H1 : IsRelPrime x z) (H2 : x ∣ y * z)
    (h : IsPrimal x) : x ∣ y
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma congr_φH {γ₁ γ₂ : LeftHomologyMapData φ h₁ h₂} (eq : γ₁ = γ₂) : γ₁.φH = γ₂.φH
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem transnumAuxSeq_zero : f.transnumAuxSeq 0 = f 0
-- Mathlib/Data/Int/Log.lean
/-- `Int.clog b` and `zpow b` (almost) form a Galois connection. -/
theorem zpow_lt_iff_lt_clog {b : ℕ} (hb : 1 < b) {x : ℤ} {r : R} (hr : 0 < r) :
    (b : R) ^ x < r ↔ x < clog b r
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
@[simp]
theorem restrictScalars.smul_def {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    {M : ModuleCat.{v} S} (r : R) (m : (restrictScalars f).obj M) : r • m = (f r • m : M)
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
/-- `NonarchAddGroupNormClass F α` states that `F` is a type of nonarchimedean norms on the
additive group `α`.

You should extend this class when you extend `NonarchAddGroupNorm`. -/
class NonarchAddGroupNormClass (F : Type*) (α : outParam Type*) [AddGroup α] [FunLike F α ℝ]
    extends NonarchAddGroupSeminormClass F α : Prop where
  /-- If the image under the norm is zero, then the argument is zero. -/
  protected eq_zero_of_map_eq_zero (f : F) {a : α} : f a = 0 → a = 0
-- Mathlib/Data/Finset/Fold.lean
theorem le_fold_min : c ≤ s.fold min b f ↔ c ≤ b ∧ ∀ x ∈ s, c ≤ f x
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma natCast_self (n : ℕ) [NeZero n] : (n : Fin n) = 0
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive (attr := simp)]
theorem fromLeftInv_eq_inv (x : S.leftInv) : (S.fromLeftInv x : M) = (x : M)⁻¹
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
-- Porting note: `simp`-normal form of `coe_comp_lattice_hom`
theorem coe_comp_lattice_hom' (f : BoundedLatticeHom β γ) (g : BoundedLatticeHom α β) :
    (⟨(f : SupHom β γ).comp g, map_inf (f.comp g)⟩ : LatticeHom α γ) =
      (f : LatticeHom β γ).comp g
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- Multiplication by a nonzero element `a` on the right
as a `DilationEquiv` of a normed division ring. -/
@[simps!]
def DilationEquiv.mulRight (a : α) (ha : a ≠ 0) : α ≃ᵈ α
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem coe_singletonOneHom : (singletonOneHom : α → Finset α) = singleton
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The `v`-adic valuation of `1 : R` equals 1. -/
theorem intValuation.map_one' : v.intValuationDef 1 = 1
-- Mathlib/Data/Int/Interval.lean
theorem card_Ioo_of_lt (h : a < b) : ((Ioo a b).card : ℤ) = b - a - 1
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem fderivWithin_aeval (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x => aeval x q) s x = smulRight (1 : 𝕜 →L[𝕜] 𝕜) (aeval x (derivative q))
-- Mathlib/Algebra/Order/CompleteField.lean
@[simp]
theorem inducedMap_self (b : β) : inducedMap β β b = b
-- Mathlib/Order/CompleteLattice.lean
theorem le_sInf : (∀ b ∈ s, a ≤ b) → a ≤ sInf s
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
lemma Subgroup.coe_topologicalClosure_bot :
    ((⊥ : Subgroup G).topologicalClosure : Set G) = _root_.closure ({1} : Set G)
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem IsRelPrime.of_squarefree_mul [CommMonoid R] {m n : R} (h : Squarefree (m * n)) :
    IsRelPrime m n
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma lift_lt_comp : lift a < comp b ↔ Disjoint a b
-- Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean
theorem nonarchimedean (I : Ideal R) : @NonarchimedeanRing R _ I.adicTopology
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem contractLeft_apply (f : Module.Dual R M) (m : M) : contractLeft R M (f ⊗ₜ m) = f m
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.is_linear_image (hs : Convex 𝕜 s) {f : E → F} (hf : IsLinearMap 𝕜 f) :
    Convex 𝕜 (f '' s)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid.merge {l r} (hl : Valid l) (hr : Valid r)
    (sep : l.All fun x => r.All fun y => x < y) : Valid (@merge α l r)
-- Mathlib/GroupTheory/Perm/ViaEmbedding.lean
theorem viaEmbeddingHom_apply : viaEmbeddingHom ι e = viaEmbedding e ι
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformlyOn.prod {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'} {f' : α → β'}
    {p' : Filter ι'} (h : TendstoUniformlyOn F f p s) (h' : TendstoUniformlyOn F' f' p' s) :
    TendstoUniformlyOn (fun (i : ι × ι') a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a))
      (p.prod p') s
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp]
protected theorem ratCast (x : ℚ) : IsSelfAdjoint (x : R)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem eq_inv_of_mul_eq_one_right (h : a * b = 1) : b = a⁻¹
-- Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean
@[reassoc (attr := simp)]
lemma liftHomotopyZeroZero_comp {Y Z : C} {P : ProjectiveResolution Y} {Q : ProjectiveResolution Z}
    (f : P.complex ⟶ Q.complex) (comm : f ≫ Q.π = 0) :
    liftHomotopyZeroZero f comm ≫ Q.complex.d 1 0 = f.f 0
-- Mathlib/Algebra/Ring/Center.lean
@[simp]
theorem natCast_mem_center [NonAssocSemiring M] (n : ℕ) : (n : M) ∈ Set.center M
-- Mathlib/GroupTheory/Frattini.lean
/-- When `G` is finite, the Frattini subgroup is nilpotent. -/
theorem frattini_nilpotent [Finite G] : Group.IsNilpotent (frattini G)
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Iio_insert [DecidableEq α] (b : α) : insert b (Iio b) = Iic b
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem int_mul (h : LiouvilleWith p x) (hm : m ≠ 0) : LiouvilleWith p (m * x)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- A right homology map data for a morphism of short complexes in the opposite category
induces a left homology map data in the original category. -/
@[simps]
def RightHomologyMapData.unop {S₁ S₂ : ShortComplex Cᵒᵖ} {φ : S₁ ⟶ S₂}
    {h₁ : S₁.RightHomologyData} {h₂ : S₂.RightHomologyData}
    (ψ : RightHomologyMapData φ h₁ h₂) : LeftHomologyMapData (unopMap φ) h₂.unop h₁.unop
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
/-- The change-of-basis matrix between two orthonormal bases with the same orientation has
determinant 1. -/
theorem det_to_matrix_orthonormalBasis_of_same_orientation
    (h : e.toBasis.orientation = f.toBasis.orientation) : e.toBasis.det f = 1
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- The `n`-smooth numbers agree with the `Finset.range n`-factored numbers. -/
lemma smoothNumbers_eq_factoredNumbers (n : ℕ) :
    smoothNumbers n = factoredNumbers (Finset.range n)
-- Mathlib/RingTheory/FreeCommRing.lean
theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
    (hxs : IsSupported x s) : map (↑) (restriction s x) = x
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
lemma sparsePairs_mono {ε ε' : 𝕜} (h : ε ≤ ε') : P.sparsePairs G ε ⊆ P.sparsePairs G ε'
-- Mathlib/Topology/Algebra/OpenSubgroup.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_comap (H : OpenSubgroup N) (f : G →* N) (hf : Continuous f) :
    (H.comap f hf : Set G) = f ⁻¹' H
-- Mathlib/Algebra/Star/Module.lean
protected lemma IsSelfAdjoint.algebraMap {r : R} (hr : IsSelfAdjoint r) :
    IsSelfAdjoint (algebraMap R A r)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem LieIdeal.coe_toSubalgebra (I : LieIdeal R L) : ((I : LieSubalgebra R L) : Set L) = I
-- Mathlib/Combinatorics/SetFamily/FourFunctions.lean
/-- The **Fortuin-Kastelyn-Ginibre Inequality**. -/
lemma fkg (hμ₀ : 0 ≤ μ) (hf₀ : 0 ≤ f) (hg₀ : 0 ≤ g) (hf : Monotone f) (hg : Monotone g)
    (hμ : ∀ a b, μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)) :
    (∑ a, μ a * f a) * ∑ a, μ a * g a ≤ (∑ a, μ a) * ∑ a, μ a * (f a * g a)
-- Mathlib/Data/List/TFAE.lean
@[simp]
theorem tfae_singleton (p) : TFAE [p]
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem mk_mul_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i j} :
    (mk xl xr xL xR * mk yl yr yL yR).moveRight (Sum.inl (i, j)) =
      xL i * mk yl yr yL yR + mk xl xr xL xR * yR j - xL i * yR j
-- Mathlib/Topology/Germ.lean
theorem forall_restrictGermPredicate_iff {P : ∀ x : X, Germ (𝓝 x) Y → Prop} :
    (∀ x, RestrictGermPredicate P A x f) ↔ ∀ᶠ x in 𝓝ˢ A, P x f
-- Mathlib/Computability/Reduce.lean
@[simp]
protected theorem liftOn_eq {φ} (p : Set ℕ) (f : Set ℕ → φ)
    (h : ∀ p q, ManyOneEquiv p q → f p = f q) : (of p).liftOn f h = f p
-- Mathlib/Computability/TuringMachine.lean
theorem Reaches₁.to₀ {σ} {f : σ → Option σ} {a b : σ} (h : Reaches₁ f a b) : Reaches₀ f a b
-- Mathlib/LinearAlgebra/Ray.lean
@[nontriviality]
theorem of_subsingleton' [Subsingleton R] (x y : M) : SameRay R x y
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem cyclicPermutations_ne_nil : ∀ l : List α, cyclicPermutations l ≠ []
-- Mathlib/Order/GaloisConnection.lean
theorem u_inf : u (b₁ ⊓ b₂) = u b₁ ⊓ u b₂
-- Mathlib/Algebra/Lie/Weights/Killing.lean
@[simp] lemma isZero_neg : (-α).IsZero ↔ α.IsZero
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
theorem mkHom_apply {M N : SemiNormedGrp} (f : M ⟶ N) (i : f.NormNoninc) (x) :
    mkHom f i x = f x
-- Mathlib/Data/Finset/Prod.lean
@[mono]
theorem offDiag_mono : Monotone (offDiag : Finset α → Finset (α × α))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem sin_sub_pi_div_two (θ : Angle) : sin (θ - ↑(π / 2)) = -cos θ
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem differentiableWithinAt_inter (ht : t ∈ 𝓝 x) :
    DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Topology/Homotopy/Basic.lean
@[simp] theorem homotopicRel_empty {f₀ f₁ : C(X, Y)} : HomotopicRel f₀ f₁ ∅ ↔ Homotopic f₀ f₁
-- Mathlib/Order/Max.lean
protected theorem IsMax.eq_of_le (ha : IsMax a) (h : a ≤ b) : a = b
-- Mathlib/Algebra/QuaternionBasis.lean
theorem lift_one : q.lift (1 : ℍ[R,c₁,c₂]) = 1
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Memℒp.integrable_norm_rpow {f : α → β} {p : ℝ≥0∞} (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) : Integrable (fun x : α => ‖f x‖ ^ p.toReal) μ
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem cardFactors_multiset_prod {s : Multiset ℕ} (h0 : s.prod ≠ 0) :
    Ω s.prod = (Multiset.map Ω s).sum
-- Mathlib/Data/List/Forall2.lean
theorem Forall₂.imp (H : ∀ a b, R a b → S a b) {l₁ l₂} (h : Forall₂ R l₁ l₂) : Forall₂ S l₁ l₂
-- Mathlib/Topology/Bases.lean
/-- In a second-countable space, an open set, given as a union of open sets,
is equal to the union of countably many of those sets.
In particular, any open covering of `α` has a countable subcover: α is a Lindelöf space. -/
theorem isOpen_iUnion_countable [SecondCountableTopology α] {ι} (s : ι → Set α)
    (H : ∀ i, IsOpen (s i)) : ∃ T : Set ι, T.Countable ∧ ⋃ i ∈ T, s i = ⋃ i, s i
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem const_compTendsto' {l : Filter α} (b : β) {lc : Filter γ} {g : Germ lc α}
    (hg : g.Tendsto l) : (↑b : Germ l β).compTendsto' g hg = ↑b
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
theorem comp_symm_eq {α : Type*} (e : M ≃* N) (f : N → α) (g : M → α) :
    g ∘ e.symm = f ↔ g = f ∘ e
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Ideal R} (i : ι) : ∀ {x : R}, x ∈ S i → x ∈ iSup S
-- Mathlib/Topology/AlexandrovDiscrete.lean
@[simp] lemma exterior_exterior (s : Set α) : exterior (exterior s) = exterior s
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
/-- A sequential limit of measurable `ℝ≥0∞` valued functions is measurable. -/
theorem measurable_of_tendsto {f : ℕ → α → ℝ≥0∞} {g : α → ℝ≥0∞} (hf : ∀ i, Measurable (f i))
    (lim : Tendsto f atTop (𝓝 g)) : Measurable g
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
@[simp]
theorem mem_finsupport {i : ι} : i ∈ ρ.finsupport x₀ ↔ i ∈ support fun i ↦ ρ i x₀
-- Mathlib/Order/UpperLower/Basic.lean
theorem not_bddBelow_Iio : ¬BddBelow (Iio a)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
@[simp]
theorem degreeOf_zero (n : σ) : degreeOf n (0 : MvPolynomial σ R) = 0
-- Mathlib/Order/CompleteLattice.lean
theorem IsLUB.iSup_eq (h : IsLUB (range f) a) : ⨆ j, f j = a
-- Mathlib/Data/List/Basic.lean
theorem get_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {n : ℕ}
    (hn : n < (pmap f l h).length) :
    get (pmap f l h) ⟨n, hn⟩ =
      f (get l ⟨n, @length_pmap _ _ p f l h ▸ hn⟩)
        (h _ (get_mem l n (@length_pmap _ _ p f l h ▸ hn)))
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem iff_of_iSup_eq_top {ι} (U : ι → X.Opens) (hU : iSup U = ⊤) :
    P f ↔ ∀ i, P ((U i).ι ≫ f)
-- Mathlib/Order/PartialSups.lean
theorem le_partialSups (f : ℕ → α) : f ≤ partialSups f
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.comp_addHom [Add α] [Add γ] (h : Periodic f c) (g : AddHom γ α) (g_inv : α → γ)
    (hg : RightInverse g_inv g) : Periodic (f ∘ g) (g_inv c)
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem mulHead_prod {i j : ι} (w : NeWord M i j) (x : M i) (hnotone : x * w.head ≠ 1) :
    (mulHead w x hnotone).prod = of x * w.prod
-- Mathlib/Logic/Small/Set.lean
theorem small_subset {α : Type v} {s t : Set α} (hts : t ⊆ s) [Small.{u} s] : Small.{u} t
-- Mathlib/Algebra/Lie/TensorProduct.lean
@[simp]
theorem lie_tmul_right (x : L) (m : M) (n : N) : ⁅x, m ⊗ₜ[R] n⁆ = ⁅x, m⁆ ⊗ₜ n + m ⊗ₜ ⁅x, n⁆
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingular_iff_of_Y_eq_negY {P : Fin 3 → F} (hPz : P z ≠ 0) (hy : P y = W.negY P) :
    W.Nonsingular P ↔ W.Equation P ∧ eval P W.polynomialX ≠ 0