ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem or_iff_right (ha : ¬a) : a ∨ b ↔ b
-- .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean
theorem nonzeroMinimum_le_iff {xs : List Nat} {y : Nat} :
    xs.nonzeroMinimum ≤ y ↔ xs.nonzeroMinimum = 0 ∨ ∃ x ∈ xs, x ≤ y ∧ x ≠ 0
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem map_one_of_isMulOneCocycle {f : G → M} (hf : IsMulOneCocycle f) :
    f 1 = 1
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- A `red` node with the red-red invariant has balanced children. -/
protected theorem RedRed.of_red : RedRed p (node red a x b) n →
    ∃ c₁ c₂, Balanced a c₁ n ∧ Balanced b c₂ n
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem edgeDensity_nonneg (s : Finset α) (t : Finset β) : 0 ≤ edgeDensity r s t
-- Mathlib/Topology/Connected/PathConnected.lean
/-- If `x` and `y` are joined in the set `F`, then they are joined in the subtype `F`. -/
theorem JoinedIn.joined_subtype (h : JoinedIn F x y) :
    Joined (⟨x, h.source_mem⟩ : F) (⟨y, h.target_mem⟩ : F)
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem BinaryCofan.mk_inl {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : (BinaryCofan.mk ι₁ ι₂).inl = ι₁
-- Mathlib/Algebra/Homology/TotalComplex.lean
/-- The total complex of a bicomplex. -/
@[simps d]
noncomputable def total : HomologicalComplex C c₁₂
-- Mathlib/Algebra/Group/Commute/Defs.lean
/--
Two elements `a` and `b` commute if `a * b = b * a`.
-/
@[to_additive]
theorem commute_iff_eq [Mul S] (a b : S) : Commute a b ↔ a * b = b * a
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem inr_sub [SubNegZeroMonoid R] [Sub M] (m₁ m₂ : M) :
    (inr (m₁ - m₂) : tsze R M) = inr m₁ - inr m₂
-- Mathlib/Data/Int/Defs.lean
lemma natCast_dvd {m : ℕ} : (m : ℤ) ∣ n ↔ m ∣ n.natAbs
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem tendsto_norm_zpow_nhdsWithin_0_atTop {𝕜 : Type*} [NormedDivisionRing 𝕜] {m : ℤ}
    (hm : m < 0) :
    Tendsto (fun x : 𝕜 ↦ ‖x ^ m‖) (𝓝[≠] 0) atTop
-- Mathlib/Topology/Filter.lean
theorem mem_nhds_iff' {l : Filter α} {S : Set (Filter α)} :
    S ∈ 𝓝 l ↔ ∃ t ∈ l, ∀ ⦃l' : Filter α⦄, t ∈ l' → l' ∈ S
-- Mathlib/Algebra/Group/Hom/End.lean
lemma AddMonoidHom.mulLeft_eq_mulRight_iff_forall_commute {a : R} :
    mulLeft a = mulRight a ↔ ∀ b, Commute a b
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem Filter.Tendsto.pow {l : Filter α} {f : α → M} {x : M} (hf : Tendsto f l (𝓝 x)) (n : ℕ) :
    Tendsto (fun x => f x ^ n) l (𝓝 (x ^ n))
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
/-- `orthogonal.orthogonal` preserves the `≤` ordering of two
subspaces. -/
theorem orthogonal_orthogonal_monotone {K₁ K₂ : Submodule 𝕜 E} (h : K₁ ≤ K₂) : K₁ᗮᗮ ≤ K₂ᗮᗮ
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem suppBddBelow_supp_PWO (f : Γ → R) (hf : BddBelow (Function.support f)) :
    (Function.support f).IsPWO
-- Mathlib/Logic/Equiv/List.lean
@[nolint unusedHavesSuffices] -- Porting note: false positive
theorem denumerable_list_aux : ∀ n : ℕ, ∃ a ∈ @decodeList α _ n, encodeList a = n
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem mul_inv {a b : ℝ≥0∞} (ha : a ≠ 0 ∨ b ≠ ∞) (hb : a ≠ ∞ ∨ b ≠ 0) :
    (a * b)⁻¹ = a⁻¹ * b⁻¹
-- Mathlib/Topology/Bornology/Hom.lean
/-- The type of bounded maps from `α` to `β`, the maps which send a bounded set to a bounded set. -/
structure LocallyBoundedMap (α β : Type*) [Bornology α] [Bornology β] where
  /-- The function underlying a locally bounded map -/
  toFun : α → β
  /-- The pullback of the `Bornology.cobounded` filter under the function is contained in the
  cobounded filter. Equivalently, the function maps bounded sets to bounded sets. -/
  comap_cobounded_le' : (cobounded β).comap toFun ≤ cobounded α
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
/--
If `s ⊆ fixedBy α g`, then `g • s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g • x ≠ x` and `g • x ∈ s`).
-/
@[to_additive "If `s ⊆ fixedBy α g`, then `g +ᵥ s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g +ᵥ x ≠ x` and `g +ᵥ x ∈ s`)."]
theorem set_mem_fixedBy_of_subset_fixedBy {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ fixedBy α g) :
    s ∈ fixedBy (Set α) g
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem eq_one_of_map_eq_one {S : Type*} [Semiring S] [Nontrivial S] (f : R →+* S) (hp : p.Monic)
    (map_eq : p.map f = 1) : p = 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem lt_of_mul_lt_of_one_le_right [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
    (h : a * b < c) (hle : 1 ≤ a) :
    b < c
-- Mathlib/Data/List/AList.lean
theorem union_comm_of_disjoint {s₁ s₂ : AList β} (h : Disjoint s₁ s₂) :
    (s₁ ∪ s₂).entries ~ (s₂ ∪ s₁).entries
-- Mathlib/MeasureTheory/Integral/Asymptotics.lean
/-- If `f` is locally integrable, and `f =O[cocompact] g` for some `g` integrable at `cocompact`,
then `f` is integrable. -/
theorem LocallyIntegrable.integrable_of_isBigO_cocompact [IsMeasurablyGenerated (cocompact α)]
    (hf : LocallyIntegrable f μ) (ho : f =O[cocompact α] g)
    (hg : IntegrableAtFilter g (cocompact α) μ) : Integrable f μ
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp)]
theorem mulSingle_eq_same (i : I) (x : f i) : mulSingle i x i = x
-- Mathlib/Topology/Order/OrderClosed.lean
theorem le_of_tendsto {x : Filter β} [NeBot x] (lim : Tendsto f x (𝓝 a))
    (h : ∀ᶠ c in x, f c ≤ b) : a ≤ b
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem toSesqForm_apply_coe (f : E →L[𝕜] E') (x : E') : toSesqForm f x = (innerSL 𝕜 x).comp f
-- Mathlib/Topology/Basic.lean
@[simp]
theorem closure_union : closure (s ∪ t) = closure s ∪ closure t
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a
-- Mathlib/Data/Nat/Totient.lean
@[simp]
theorem totient_one : φ 1 = 1
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem map.id (x : FreeGroup α) : map id x = x
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem nhds_basis_closed_eball : (𝓝 x).HasBasis (fun ε : ℝ≥0∞ => 0 < ε) (closedBall x)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem AEDisjoint.preimage {ν : Measure β} {f : α → β} {s t : Set β} (ht : AEDisjoint ν s t)
    (hf : QuasiMeasurePreserving f μ ν) : AEDisjoint μ (f ⁻¹' s) (f ⁻¹' t)
-- Mathlib/Topology/LocallyConstant/Algebra.lean
theorem coe_charFn (hU : IsClopen U) : (charFn Y hU : X → Y) = Set.indicator U 1
-- Mathlib/Topology/LocallyClosed.lean
lemma isLocallyClosed_iff_isOpen_coborder : IsLocallyClosed s ↔ IsOpen (coborder s)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_floor_zero : (floor : α → ℕ) ⁻¹' {0} = Iio 1
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem one_iff_ker_inv {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a * b⁻¹) = 1
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem nnnorm_ofSubsingleton_id_le [Subsingleton ι] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖₊ ≤ 1
-- Mathlib/Order/UpperLower/Basic.lean
lemma sdiff_le_left : s.sdiff t ≤ s
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- The sets of `N`-smooth and of `(N+1)`-smooth numbers are the same when `N` is not prime.
See `Nat.equivProdNatSmoothNumbers` for when `N` is prime. -/
lemma smoothNumbers_succ {N : ℕ} (hN : ¬ N.Prime) : N.succ.smoothNumbers = N.smoothNumbers
-- Mathlib/Data/Finset/Interval.lean
theorem Iic_eq_powerset : Iic s = s.powerset
-- Mathlib/MeasureTheory/Measure/Tilted.lean
lemma tilted_apply_eq_ofReal_integral [SFinite μ] (f : α → ℝ) (s : Set α) :
    μ.tilted f s = ENNReal.ofReal (∫ a in s, exp (f a) / ∫ x, exp (f x) ∂μ ∂μ)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem range_comp_val : (f.comp S.val).range = S.map f
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_lowerBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    a ∈ upperBounds s → a ∈ t → f a ∈ lowerBounds (f '' s)
-- Mathlib/Probability/Kernel/Invariance.lean
@[simp]
theorem bind_smul (κ : Kernel α β) (μ : Measure α) (r : ℝ≥0∞) : (r • μ).bind κ = r • μ.bind κ
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem add_le_right_iff_mul_omega_le {a b : Ordinal} : a + b ≤ b ↔ a * omega ≤ b
-- Mathlib/Algebra/Homology/Homotopy.lean
theorem mkInductiveAux₃ (i j : ℕ) (h : i + 1 = j) :
    (mkInductiveAux₂ e zero comm_zero one comm_one succ i).2.1 ≫ (Q.xPrevIso h).hom =
      (P.xNextIso h).inv ≫ (mkInductiveAux₂ e zero comm_zero one comm_one succ j).1
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_map_measure {f : α → δ} {g : δ → β}
    (hg : AEStronglyMeasurable g (Measure.map f μ)) (hf : AEMeasurable f μ) :
    Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma toMvPolynomial_add (f g : M₁ →ₗ[R] M₂) :
    (f + g).toMvPolynomial b₁ b₂ = f.toMvPolynomial b₁ b₂ + g.toMvPolynomial b₁ b₂
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
theorem χ₈'_nat_eq_if_mod_eight (n : ℕ) :
    χ₈' n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1
-- Mathlib/Data/Fin/Basic.lean
theorem le_iff_val_le_val {a b : Fin n} : a ≤ b ↔ (a : ℕ) ≤ b
-- Mathlib/Data/Matrix/Block.lean
theorem blockDiagonal'_eq_blockDiagonal (M : o → Matrix m n α) {k k'} (i j) :
    blockDiagonal M (i, k) (j, k') = blockDiagonal' M ⟨k, i⟩ ⟨k', j⟩
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem eval_X : eval f a X = a
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst
-- Mathlib/Data/Matrix/Basic.lean
theorem algebraMap_eq_diagonalRingHom :
    algebraMap R (Matrix n n α) = (diagonalRingHom n α).comp (algebraMap R _)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem inv_mk [Inv G] [Inv H] (a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹)
-- Mathlib/Analysis/Seminorm.lean
/-- If there is a scalar `c` with `‖c‖>1`, then any element with nonzero norm can be
moved by scalar multiplication to any shell of width `‖c‖`. Also recap information on the norm of
the rescaling element that shows up in applications. -/
lemma rescale_to_shell_semi_normed {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε)
    {x : E} (hx : ‖x‖ ≠ 0) :
    ∃d : 𝕜, d ≠ 0 ∧ ‖d • x‖ < ε ∧ (ε/‖c‖ ≤ ‖d • x‖) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖)
-- Mathlib/Analysis/Convex/Gauge.lean
/-- If `s` is a convex neighborhood of the origin in a topological real vector space, then `gauge s`
is continuous. If the ambient space is a normed space, then `gauge s` is Lipschitz continuous, see
`Convex.lipschitz_gauge`. -/
@[continuity]
theorem continuous_gauge (hc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) : Continuous (gauge s)
-- Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean
/-- The resolution maps intertwine the descent of a morphism and that morphism. -/
@[reassoc (attr := simp)]
theorem desc_commutes {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y)
    (J : InjectiveResolution Z) : J.ι ≫ desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.subset_basis'_of_subset (hI : M.Indep I) (hIX : I ⊆ X) :
    ∃ J, M.Basis' J X ∧ I ⊆ J
-- Mathlib/CategoryTheory/Limits/Creates.lean
/-- If `F` creates colimits, and `D` has all colimits, then `C` has all colimits. -/
theorem hasColimits_of_hasColimits_createsColimits (F : C ⥤ D) [HasColimitsOfSize.{w, w'} D]
    [CreatesColimitsOfSize.{w, w'} F] : HasColimitsOfSize.{w, w'} C
-- .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean
@[simp] theorem map_empty (f : α → β) : map f #[] = #[]
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- Equation theorem for `Int.mod` -/
private theorem Int.negSucc_emod (m : Nat) (n : Int) :
    -(m + 1) % n = Int.subNatNat (Int.natAbs n) ((m % Int.natAbs n) + 1)
-- Mathlib/Order/CompleteSublattice.lean
theorem coe_sInf' (S : Set L) : (↑(sInf S) : α) = ⨅ N ∈ S, (N : α)
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
theorem eval_eq_zero_of_eval₂_denom_eq_zero {x : RatFunc K}
    (h : Polynomial.eval₂ f a (denom x) = 0) : eval f a x = 0
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem eq_pow_of_pell_lem {a y k : ℕ} (hy0 : y ≠ 0) (hk0 : k ≠ 0) (hyk : y ^ k < a) :
    (↑(y ^ k) : ℤ) < 2 * a * y - y * y - 1
-- Mathlib/Analysis/Normed/Operator/Banach.lean
/-- If a bounded linear map is a bijection, then its inverse is also a bounded linear map. -/
@[continuity]
theorem continuous_symm (e : E ≃ₛₗ[σ] F) (h : Continuous e) : Continuous e.symm
-- Mathlib/Combinatorics/SimpleGraph/Dart.lean
@[simp]
theorem Dart.edge_mem (d : G.Dart) : d.edge ∈ G.edgeSet
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem cauchySeq_iff_tendsto_dist_atTop_0 [Nonempty β] [SemilatticeSup β] {u : β → α} :
    CauchySeq u ↔ Tendsto (fun n : β × β => dist (u n.1) (u n.2)) atTop (𝓝 0)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- A base angle of an isosceles triangle is acute, oriented angle-at-point form. -/
theorem abs_oangle_left_toReal_lt_pi_div_two_of_dist_eq {p₁ p₂ p₃ : P}
    (h : dist p₁ p₂ = dist p₁ p₃) : |(∡ p₂ p₃ p₁).toReal| < π / 2
-- Mathlib/Algebra/Lie/UniversalEnveloping.lean
@[simp]
theorem ι_comp_lift : lift R f ∘ ι R = f
-- Mathlib/Data/Set/Finite.lean
@[simp high]
protected theorem toFinset_setOf [Fintype α] (p : α → Prop) [DecidablePred p]
    (h : { x | p x }.Finite) : h.toFinset = Finset.univ.filter p
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem monic_ascPochhammer (n : ℕ) [Nontrivial S] [NoZeroDivisors S] :
    Monic <| ascPochhammer S n
-- Mathlib/ModelTheory/Complexity.lean
theorem IsQF.isPrenex {φ : L.BoundedFormula α n} : IsQF φ → IsPrenex φ
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- If the indicators of measurable sets `Aᵢ` tend pointwise almost everywhere to the indicator
of a measurable set `A` and we eventually have `Aᵢ ⊆ B` for some set `B` of finite measure, then
the measures of `Aᵢ` tend to the measure of `A`. -/
lemma tendsto_measure_of_ae_tendsto_indicator {μ : Measure α} (A_mble : MeasurableSet A)
    (As_mble : ∀ i, MeasurableSet (As i)) {B : Set α} (B_mble : MeasurableSet B)
    (B_finmeas : μ B ≠ ∞) (As_le_B : ∀ᶠ i in L, As i ⊆ B)
    (h_lim : ∀ᵐ x ∂μ, ∀ᶠ i in L, x ∈ As i ↔ x ∈ A) :
    Tendsto (fun i ↦ μ (As i)) L (𝓝 (μ A))
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_ne_bot : degree p ≠ ⊥ ↔ p ≠ 0
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem MonoidHom.comp_id [MulOneClass M] [MulOneClass N] (f : M →* N) :
    f.comp (MonoidHom.id M) = f
-- Mathlib/Order/Interval/Set/Basic.lean
theorem nonempty_Ioo_subtype [DenselyOrdered α] (h : a < b) : Nonempty (Ioo a b)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
lemma _root_.Function.HasTemperateGrowth.const (c : F) :
    Function.HasTemperateGrowth (fun _ : E ↦ c)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem symm_comp_self : e.symm ∘ e = id
-- Mathlib/Computability/Primrec.lean
theorem list_foldl {f : α → List β} {g : α → σ} {h : α → σ × β → σ} :
    Primrec f →
      Primrec g → Primrec₂ h → Primrec fun a => (f a).foldl (fun s b => h a (s, b)) (g a)
-- Mathlib/Data/Multiset/Fintype.lean
@[simp]
theorem Multiset.map_univ_coe (m : Multiset α) :
    (Finset.univ : Finset m).val.map (fun x : m ↦ (x : α)) = m
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem back_push [Inhabited α] (a : Array α) : (a.push x).back = x
-- Mathlib/Combinatorics/SimpleGraph/Prod.lean
/-- The embedding of `H` into `G □ H` given by `a`. -/
@[simps]
def boxProdRight (a : α) : H ↪g G □ H
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
theorem mapBiprod_hom : (mapBiprod F X Y).hom = biprod.lift (F.map biprod.fst) (F.map biprod.snd)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biprod.inrCokernelCofork_π : Cofork.π (biprod.inrCokernelCofork X Y) = biprod.fst
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[reassoc]
theorem uncurry_natural_left (f : X ⟶ X') (g : X' ⟶ A ⟶[C] Y) :
    uncurry (f ≫ g) = _ ◁ f ≫ uncurry g
-- Mathlib/CategoryTheory/Elements.lean
/-- The unit of the equivalence `F.Elementsᵒᵖ ≅ (yoneda, F)` is indeed iso. -/
theorem from_toCostructuredArrow_eq (F : Cᵒᵖ ⥤ Type v) :
    (toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F = 𝟭 _
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_mono (H : s ⊆ t) : adjoin R s ≤ adjoin R t
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem add_nat (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (x + n)
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem map_id' (f : Ultrafilter α) : (f.map fun x => x) = f
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
/-- A variant of `app_inv_app` that gives an `eqToHom` instead of `homOfLe`. -/
@[reassoc]
theorem app_inv_app' (U : Opens Y) (hU : (U : Set Y) ⊆ Set.range f.base) :
    f.c.app (op U) ≫ invApp f ((Opens.map f.base).obj U) =
      Y.presheaf.map
        (eqToHom
            (le_antisymm (Set.image_preimage_subset f.base U.1) <|
              (Set.image_preimage_eq_inter_range (f := f.base) (t := U.1)).symm ▸
                Set.subset_inter_iff.mpr ⟨fun _ h => h, hU⟩)).op
-- Mathlib/Topology/Instances/ENNReal.lean
theorem continuous_ofReal : Continuous ENNReal.ofReal
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem Nonempty.vsub : s.Nonempty → t.Nonempty → (s -ᵥ t : Set α).Nonempty
-- Mathlib/FieldTheory/Separable.lean
theorem Separable.isCoprime {f g : R[X]} (h : (f * g).Separable) : IsCoprime f g
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
protected lemma _root_.MeasurableEmbedding.isProbabilityMeasure_comap (hf : MeasurableEmbedding f)
    (hf' : ∀ᵐ a ∂μ, a ∈ range f) : IsProbabilityMeasure (μ.comap f)
-- Mathlib/RingTheory/Flat/Basic.lean
/-- An `R`-module `M` is flat iff for all ideals `I` of `R`, the tensor product of the
inclusion `I → R` and the identity `M → M` is injective. See `iff_rTensor_injective` to
restrict to finitely generated ideals `I`. --/
theorem iff_rTensor_injective' :
    Flat R M ↔ ∀ I : Ideal R, Function.Injective (rTensor M I.subtype)
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem exp_four_lt : exp 4 < 64
-- Mathlib/Topology/Category/CompHaus/Limits.lean
lemma finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
    ∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r
-- Mathlib/NumberTheory/Pell.lean
/-- The proof that `a` is a solution to the Pell equation `x^2 - d*y^2 = 1` -/
theorem prop (a : Solution₁ d) : a.x ^ 2 - d * a.y ^ 2 = 1
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lid_eq_rid : TensorProduct.lid R R = TensorProduct.rid R R
-- Mathlib/Data/Bool/Basic.lean
theorem and_elim_left : ∀ {a b : Bool}, a && b → a
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Real.lean
/-- Pull-out property of the conditional expectation. -/
theorem condexp_stronglyMeasurable_mul {f g : α → ℝ} (hf : StronglyMeasurable[m] f)
    (hfg : Integrable (f * g) μ) (hg : Integrable g μ) : μ[f * g|m] =ᵐ[μ] f * μ[g|m]
-- Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean
/-- Riesz content λ (associated with a positive linear functional Λ) is
monotone: if `K₁ ⊆ K₂` are compact subsets in X, then `λ(K₁) ≤ λ(K₂)`. -/
theorem rieszContentAux_mono {K₁ K₂ : Compacts X} (h : K₁ ≤ K₂) :
    rieszContentAux Λ K₁ ≤ rieszContentAux Λ K₂
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsMaxOn.lineDeriv_eq_zero (h : IsMaxOn f s a) (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) :
    lineDeriv ℝ f a b = 0
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap_comp_lTensor {N' : Submodule R S} (hN : N' ≤ N) :
    mulMap M N ∘ₗ (inclusion hN).lTensor M = mulMap M N'
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem hasGradientWithinAt_iff_isLittleO :
    HasGradientWithinAt f f' s x ↔
    (fun x' : F => f x' - f x - ⟪f', x' - x⟫) =o[𝓝[s] x] fun x' => x' - x
-- Mathlib/Analysis/Complex/Circle.lean
@[simp]
theorem abs_coe_circle (z : circle) : abs z = 1
-- Mathlib/FieldTheory/IntermediateField.lean
theorem range_val : S.val.range = S.toSubalgebra
-- Mathlib/Data/Set/Pointwise/Basic.lean
theorem mul_zero_subset (s : Set α) : s * 0 ⊆ 0
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem div_singleton : s / {b} = (· / b) '' s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem neg_emod {a b : Int} : -a % b = (b - a) % b
-- Mathlib/Data/Set/Finite.lean
theorem forall_finite_image_eval_iff {δ : Type*} [Finite δ] {κ : δ → Type*} {s : Set (∀ d, κ d)} :
    (∀ d, (eval d '' s).Finite) ↔ s.Finite
-- Mathlib/Data/Nat/Cast/Basic.lean
lemma cast_dvd_cast (h : m ∣ n) : (m : α) ∣ (n : α)
-- Mathlib/NumberTheory/LucasLehmer.lean
@[norm_cast]
theorem coe_mul (n m : ℤ) : ((n * m : ℤ) : X q) = (n : X q) * (m : X q)
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem leftUnitor_comp_inv (f : a ⟶ b) (g : b ⟶ c) :
    (λ_ (f ≫ g)).inv = (λ_ f).inv ▷ g ≫ (α_ (𝟙 a) f g).hom
-- Mathlib/ModelTheory/Order.lean
@[simp]
theorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :
    RelMap (leSymb : L.Relations 2) ![a, b] ↔ a ≤ b
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mk_mem_iff {x y : PSet} : mk x ∈ mk y ↔ x ∈ y
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem nonempty_toSet_iff {u : ZFSet} : u.toSet.Nonempty ↔ u.Nonempty
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Suppose a set of vectors spans `V`.  Then a point `p`, together with those vectors added to `p`,
spans `P`. -/
theorem affineSpan_singleton_union_vadd_eq_top_of_span_eq_top {s : Set V} (p : P)
    (h : Submodule.span k (Set.range ((↑) : s → V)) = ⊤) :
    affineSpan k ({p} ∪ (fun v => v +ᵥ p) '' s) = ⊤
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/-- A Scheme is affine if the canonical map `X ⟶ Spec Γ(X)` is an isomorphism. -/
class IsAffine (X : Scheme) : Prop where
  affine : IsIso (ΓSpec.adjunction.unit.app X)
-- Mathlib/Data/Int/ModEq.lean
theorem exists_unique_equiv (a : ℤ) {b : ℤ} (hb : 0 < b) :
    ∃ z : ℤ, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b]
-- Mathlib/Topology/Order/ScottTopology.lean
lemma scottHausdorff_le_lower : scottHausdorff α ≤ lower α
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
/--
[Lemma 3.8](https://ncatlab.org/nlab/show/injective+object#preservation_of_injective_objects)
-/
lemma EnoughInjectives.of_adjunction {C : Type u₁} {D : Type u₂}
    [Category.{v₁} C] [Category.{v₂} D]
    {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) [L.PreservesMonomorphisms] [L.ReflectsMonomorphisms]
    [EnoughInjectives D] : EnoughInjectives C
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem IsOrtho.comap (f : E →ₗᵢ[𝕜] F) {U V : Submodule 𝕜 F} (h : U ⟂ V) :
    U.comap f ⟂ V.comap f
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem integrableOn_Ioc_of_intervalIntegral_norm_bounded {I a₀ b₀ : ℝ}
    (hfi : ∀ i, IntegrableOn f <| Ioc (a i) (b i)) (ha : Tendsto a l <| 𝓝 a₀)
    (hb : Tendsto b l <| 𝓝 b₀) (h : ∀ᶠ i in l, (∫ x in Ioc (a i) (b i), ‖f x‖) ≤ I) :
    IntegrableOn f (Ioc a₀ b₀)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
theorem inl_isoPushout_inv (h : IsPushout f g inl inr) [HasPushout f g] :
    pushout.inl _ _ ≫ h.isoPushout.inv = inl
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
theorem fderiv_list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, DifferentiableAt 𝕜 (f i ·) x) :
    fderiv 𝕜 (fun x ↦ (l.map (f · x)).prod) x =
      ∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (fderiv 𝕜 (fun x ↦ f (l.get i) x) x)
          ((l.drop (.succ i)).map (f · x)).prod
-- Mathlib/Data/List/Zip.lean
@[deprecated getElem_zipWith (since := "2024-06-12")]
theorem get_zipWith {f : α → β → γ} {l : List α} {l' : List β} {i : Fin (zipWith f l l').length} :
    (zipWith f l l').get i =
      f (l.get ⟨i, lt_length_left_of_zipWith i.isLt⟩)
        (l'.get ⟨i, lt_length_right_of_zipWith i.isLt⟩)
-- Mathlib/RingTheory/Polynomial/IntegralNormalization.lean
@[simp]
theorem integralNormalization_zero : integralNormalization (0 : R[X]) = 0
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
theorem coe_inv (e : X ≃ᵈ X) : ⇑(e⁻¹) = e.symm
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem le_iff_le {a b} : f a ≤ f b ↔ a ≤ b