ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
    ⋃ (i) (hi : p i), Ico (f i hi) a = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- A union indexed by a finite set is totally bounded
if and only if each set of the family is totally bounded. -/
lemma totallyBounded_biUnion {ι : Type*} {I : Set ι} (hI : I.Finite) {s : ι → Set α} :
    TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i)
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem aroots_smul_nonzero [CommRing S] [IsDomain S] [Algebra T S]
    [NoZeroSMulDivisors T S] {a : T} (p : T[X]) (ha : a ≠ 0) :
    (a • p).aroots S = p.aroots S
-- Mathlib/Logic/Function/Basic.lean
protected theorem Bijective.injective {f : α → β} (hf : Bijective f) : Injective f
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- If two elements are pseudo-equal, then their composition with a morphism is, too. -/
theorem pseudoApply_aux {P Q : C} (f : P ⟶ Q) (a b : Over P) : a ≈ b → app f a ≈ app f b
-- Mathlib/Analysis/Calculus/Deriv/Inverse.lean
/-- If `f (g y) = y` for `y` in some neighborhood of `a`, `g` is continuous at `a`, and `f` has an
invertible derivative `f'` at `g a`, then `g` has the derivative `f'⁻¹` at `a`.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. -/
theorem HasDerivAt.of_local_left_inverse {f g : 𝕜 → 𝕜} {f' a : 𝕜} (hg : ContinuousAt g a)
    (hf : HasDerivAt f f' (g a)) (hf' : f' ≠ 0) (hfg : ∀ᶠ y in 𝓝 a, f (g y) = y) :
    HasDerivAt g f'⁻¹ a
-- Mathlib/RingTheory/Polynomial/RationalRoot.lean
theorem scaleRoots_aeval_eq_zero_of_aeval_mk'_eq_zero {p : A[X]} {r : A} {s : M}
    (hr : aeval (mk' S r s) p = 0) : aeval (algebraMap A S r) (scaleRoots p s) = 0
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem mk_ord_out (c : Cardinal) : #c.ord.out.α = c
-- Mathlib/Data/List/Sigma.lean
theorem nodup_enum_map_fst (l : List α) : (l.enum.map Prod.fst).Nodup
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma mapEmbedding_basis_iff {f : α ↪ β} {I X : Set β} :
    (M.mapEmbedding f).Basis I X ↔ M.Basis (f ⁻¹' I) (f ⁻¹' X) ∧ I ⊆ X ∧ X ⊆ range f
-- Mathlib/Data/Option/NAry.lean
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).map g'
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
@[simp]
theorem weightedVSubVSubWeights_self [DecidableEq ι] (i : ι) :
    weightedVSubVSubWeights k i i = 0
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_segments (a b c d : E) :
    convexJoin 𝕜 (segment 𝕜 a b) (segment 𝕜 c d) = convexHull 𝕜 {a, b, c, d}
-- Mathlib/Order/SupClosed.lean
@[simp] lemma supClosed_preimage_ofDual {s : Set α} :
    SupClosed (ofDual ⁻¹' s) ↔ InfClosed s
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem le_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
    b ≤ lift.{v, u} a ↔ ∃ a', lift.{v, u} a' = b ∧ a' ≤ a
-- Mathlib/Data/Set/Image.lean
theorem eq_preimage_iff_image_eq {f : α → β} (hf : Bijective f) {s t} :
    s = f ⁻¹' t ↔ f '' s = t
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotientInfEquivQuotientProd_snd (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I ⊓ J) :
    (quotientInfEquivQuotientProd I J coprime x).snd =
      Ideal.Quotient.factor (I ⊓ J) J inf_le_right x
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem coe_iicsInfHom : (iicsInfHom : α → LowerSet α) = Iic
-- Mathlib/Logic/Equiv/Fintype.lean
theorem extendSubtype_not_mem (e : { x // p x } ≃ { x // q x }) (x) (hx : ¬p x) :
    ¬q (e.extendSubtype x)
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
theorem coe_derivation :
    ⇑(X : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = (X : C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯)
-- Mathlib/Algebra/Polynomial/Eval.lean
lemma isRoot_comp {R} [CommSemiring R] {p q : R[X]} {r : R} :
    (p.comp q).IsRoot r ↔ p.IsRoot (q.eval r)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem iteratedPDeriv_succ_right {n : ℕ} (m : Fin (n + 1) → E) (f : 𝓢(E, F)) :
    iteratedPDeriv 𝕜 m f = iteratedPDeriv 𝕜 (Fin.init m) (pderivCLM 𝕜 (m (Fin.last n)) f)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem nndist_eq_iSup : nndist f g = ⨆ x : α, nndist (f x) (g x)
-- Mathlib/LinearAlgebra/Basis/VectorSpace.lean
theorem range_ofVectorSpace : range (ofVectorSpace K V) = ofVectorSpaceIndex K V
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem coeff_mirror (n : ℕ) :
    p.mirror.coeff n = p.coeff (revAt (p.natDegree + p.natTrailingDegree) n)
-- Mathlib/Logic/Nontrivial/Defs.lean
theorem exists_ne [Nontrivial α] (x : α) : ∃ y, y ≠ x
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp]
theorem deg_neg (c : NumDenSameDeg 𝒜 x) : (-c).deg = c.deg
-- Mathlib/Data/Int/ModEq.lean
@[trans]
protected theorem trans : a ≡ b [ZMOD n] → b ≡ c [ZMOD n] → a ≡ c [ZMOD n]
-- Mathlib/Logic/Equiv/Basic.lean
theorem swap_apply_ne_self_iff {a b x : α} : swap a b x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem smul_apply (f : ModularForm Γ k) (n : α) (z : ℍ) : (n • f) z = n • f z
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem unit_mul_pow_congr_pow {p q : R} (hp : Irreducible p) (hq : Irreducible q) (u v : Rˣ)
    (m n : ℕ) (h : ↑u * p ^ m = v * q ^ n) : m = n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem pred_one {n : Nat} :
    Fin.pred (1 : Fin (n + 2)) (Ne.symm (Fin.ne_of_lt one_pos)) = 0
-- Mathlib/Order/Monotone/Monovary.lean
theorem monovaryOn_comm : MonovaryOn f g s ↔ MonovaryOn g f s
-- Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean
@[fun_prop]
theorem IsBoundedBilinearMap.differentiableOn (h : IsBoundedBilinearMap 𝕜 b) :
    DifferentiableOn 𝕜 b u
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem lt_mul_of_lt_mul_of_nonneg_right [MulPosMono α] (h : a < b * c) (hle : b ≤ d) (c0 : 0 ≤ c) :
    a < d * c
-- Mathlib/Algebra/Polynomial/Coeff.lean
@[simp] lemma coeff_natCast_mul {a k : ℕ} :
  coeff ((a : R[X]) * p) k = a * coeff p k
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem mod_add_mod (m n k : Nat) : (m % n + k) % n = (m + k) % n
-- Mathlib/Order/Filter/Extr.lean
theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter f l a
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem neg_apply (m : ∀ i, M₁ i) : (-f) m = -f m
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
@[simp]
theorem id_apply_of_ne (M : Mat_ C) (i j : M.ι) (h : i ≠ j) : (𝟙 M : Hom M M) i j = 0
-- Mathlib/GroupTheory/FixedPointFree.lean
theorem prod_pow_eq_one (hφ : FixedPointFree φ) {n : ℕ} (hn : φ^[n] = _root_.id) (g : G) :
    ((List.range n).map (fun k ↦ φ^[k] g)).prod = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem sin_zero : sin (0 : Angle) = 0
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem image_isVonNBounded_iff {α : Type*} {f : α → E} {s : Set α} :
    Bornology.IsVonNBounded 𝕜 (f '' s) ↔ ∃ r : ℝ, ∀ x ∈ s, ‖f x‖ ≤ r
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem toQuadraticMap_add (B₁ B₂ : BilinMap R M N) :
    (B₁ + B₂).toQuadraticMap = B₁.toQuadraticMap + B₂.toQuadraticMap
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem toEnd_zero : (0 : CentroidHom α).toEnd = 0
-- Mathlib/Data/Sum/Basic.lean
@[simp]
theorem swap_leftInverse : Function.LeftInverse (@swap α β) swap
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem mk_leftMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).leftMovesEquiv = L
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem iUnion_closedBall_nat (x : α) : ⋃ n : ℕ, closedBall x n = univ
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem exists_reduced_word (w : W) : ∃ ω, ω.length = ℓ w ∧ w = π ω
-- Mathlib/Analysis/Convex/Basic.lean
theorem Antitone.convex_lt (hf : Antitone f) (r : β) : Convex 𝕜 { x | f x < r }
-- Mathlib/Tactic/CongrExclamation.lean
private theorem heq_imp_of_eq_imp {α : Sort*} {x y : α} {p : HEq x y → Prop}
    (h : (he : x = y) → p (heq_of_eq he)) (he : HEq x y) : p he
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma inl_v_fst_v (p q : ℤ) (hpq : q + 1 = p) :
    (inl φ).v p q (by rw [← hpq, add_neg_cancel_right]) ≫
      (fst φ : Cochain (mappingCone φ) F 1).v q p hpq = 𝟙 _
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem appr_lt (x : ℤ_[p]) (n : ℕ) : x.appr n < p ^ n
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
protected theorem mul_zero [Fintype n] (M : Matrix m n α) : M * (0 : Matrix n o α) = 0
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem degree_of_c_ne_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c ≠ 0) : P.toPoly.degree = 1
-- Mathlib/Algebra/Ring/Equiv.lean
theorem symm_toRingHom_apply_toRingHom_apply (e : R ≃+* S) :
    ∀ x : R, e.symm.toRingHom (e.toRingHom x) = x
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem Nat.norm_cast_le : ∀ n : ℕ, ‖(n : α)‖ ≤ n * ‖(1 : α)‖
-- Mathlib/Data/Int/Defs.lean
lemma add_emod_eq_add_mod_right {m n k : ℤ} (i : ℤ) (H : m % n = k % n) :
    (m + i) % n = (k + i) % n
-- Mathlib/Data/Setoid/Partition.lean
/-- A set of disjoint sets covering α partition α (classical). -/
theorem eqv_classes_of_disjoint_union {c : Set (Set α)} (hu : Set.sUnion c = @Set.univ α)
    (H : c.PairwiseDisjoint id) (a) : ∃! b ∈ c, a ∈ b
-- Mathlib/SetTheory/Game/PGame.lean
theorem neg_fuzzy_iff {x y : PGame} : -x ‖ y ↔ x ‖ -y
-- Mathlib/RingTheory/RingHomProperties.lean
theorem StableUnderBaseChange.mk (h₁ : RespectsIso @P)
    (h₂ :
      ∀ ⦃R S T⦄ [CommRing R] [CommRing S] [CommRing T],
        ∀ [Algebra R S] [Algebra R T],
          P (algebraMap R T) →
            P (Algebra.TensorProduct.includeLeftRingHom : S →+* TensorProduct R S T)) :
    StableUnderBaseChange @P
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem coprime_self_add_left {m n : ℕ} : Coprime (m + n) m ↔ Coprime n m
-- Mathlib/Analysis/Convex/Slope.lean
theorem ConvexOn.secant_mono_aux2 (hf : ConvexOn 𝕜 s f) {x y z : 𝕜} (hx : x ∈ s) (hz : z ∈ s)
    (hxy : x < y) (hyz : y < z) : (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[reassoc]
theorem coevaluation_comp_leftAdjointMate {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) :
    η_ (ᘁY) Y ≫ (ᘁf) ▷ Y = η_ (ᘁX) X ≫ (ᘁX) ◁ f
-- Mathlib/Algebra/Category/Ring/Basic.lean
lemma ext {X Y : RingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem re_add_im (z : ℍ) : (z.re + z.im * Complex.I : ℂ) = z
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem bind_zero : s.bind (fun _ => 0 : α → Multiset β) = 0
-- Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
theorem Fix.ind_aux (a : q.P.A) (f' : q.P.drop.B a ⟹ α) (f : q.P.last.B a → q.P.W α) :
    Fix.mk (abs ⟨a, q.P.appendContents f' fun x => ⟦f x⟧⟩) = ⟦q.P.wMk a f' f⟧
-- Mathlib/Data/Finset/Basic.lean
theorem nonempty_range_succ : (range <| n + 1).Nonempty
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpIndL1Fin_add (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x y : G) :
    condexpIndL1Fin hm hs hμs (x + y) =
    condexpIndL1Fin hm hs hμs x + condexpIndL1Fin hm hs hμs y
-- Mathlib/Logic/Pairwise.lean
theorem Pairwise.imp (h : s.Pairwise r) (hpq : ∀ ⦃a b : α⦄, r a b → p a b) : s.Pairwise p
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of a point
in the source is a neighborhood of the preimage, within a set. -/
theorem extend_preimage_mem_nhdsWithin {x : M} (h : x ∈ f.source) (ht : t ∈ 𝓝[s] x) :
    (f.extend I).symm ⁻¹' t ∈ 𝓝[(f.extend I).symm ⁻¹' s ∩ range I] f.extend I x
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem frequently_ae_mem_iff {s : Set α} : (∃ᵐ a ∂μ, a ∈ s) ↔ μ s ≠ 0
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem repr_unitsSMul (e : Basis ι R₂ M) (w : ι → R₂ˣ) (v : M) (i : ι) :
    (e.unitsSMul w).repr v i = (w i)⁻¹ • e.repr v i
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem le_of_mul_le_mul_left [PosMulReflectLE α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_lt_mul_iff_left {a b c : Ordinal} (a0 : 0 < a) : a * b < a * c ↔ b < c
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem one_left : (1 : N ⋊[φ] G).left = 1
-- Mathlib/Algebra/Ring/Hom/Basic.lean
/-- Pullback `IsDomain` instance along an injective function. -/
protected theorem Function.Injective.isDomain [Ring α] [IsDomain α] [Ring β] (f : β →+* α)
    (hf : Injective f) : IsDomain β
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem isPerm_iff : ∀ {l₁ l₂ : List α}, l₁.isPerm l₂ ↔ l₁ ~ l₂
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem dvd_natAbs_self {a : Int} : a ∣ (a.natAbs : Int)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_one : ((1 : S) : A) = 1
-- Mathlib/Tactic/Zify.lean
@[zify_simps] lemma natCast_ne (a b : Nat) : a ≠ b ↔ (a : Int) ≠ (b : Int)
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast] lemma coe_nnqsmul (s : S) (q : ℚ≥0) (x : s) : ↑(q • x) = q • (x : K)
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem smul_sup (a : M) (S T : Subsemiring R) : a • (S ⊔ T) = a • S ⊔ a • T
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp, nolint simpNF]
theorem intermediateFieldMap_symm_apply_coe (e : L ≃ₐ[K] L') (E : IntermediateField K L)
    (a : E.map e.toAlgHom) : ↑((intermediateFieldMap e E).symm a) = e.symm a
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_add_left' (a b : α) : toIcoMod hp (p + a) b = p + toIcoMod hp a b
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a
-- Mathlib/Data/Finset/Grade.lean
lemma covBy_insert (ha : a ∉ s) : s ⋖ insert a s
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem unitLattice_inter_ball_finite (r : ℝ) :
    ((unitLattice K : Set ({ w : InfinitePlace K // w ≠ w₀} → ℝ)) ∩
      Metric.closedBall 0 r).Finite
-- Mathlib/Analysis/Convex/Side.lean
theorem SOppSide.wOppSide {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    s.WOppSide x y
-- Mathlib/Data/List/Intervals.lean
@[simp]
theorem filter_le (n m l : ℕ) : ((Ico n m).filter fun x => l ≤ x) = Ico (max n l) m
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem dvd_add_left {a b c : Int} (H : a ∣ c) : a ∣ b + c ↔ a ∣ b
-- Mathlib/Order/Monotone/Basic.lean
protected theorem monotone [Subsingleton α] (f : α → β) : Monotone f
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
/-- Taking the cartesian product of two continuous multilinear maps is a bounded linear
operation. -/
theorem isBoundedLinearMap_prod_multilinear {E : ι → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, NormedSpace 𝕜 (E i)] :
    IsBoundedLinearMap 𝕜 fun p : ContinuousMultilinearMap 𝕜 E F × ContinuousMultilinearMap 𝕜 E G =>
      p.1.prod p.2
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem eventually_nhds_iff_ball {p : α → Prop} :
    (∀ᶠ y in 𝓝 x, p y) ↔ ∃ ε > 0, ∀ y ∈ ball x ε, p y
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivComm_comp_quotQuotMk :
    RingHom.comp (↑(quotQuotEquivComm I J)) (quotQuotMk I J) = quotQuotMk J I
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- In a normed vector space, the addition of a strongly measurable function and a measurable
function is measurable. Note that this is not true without further second-countability assumptions
for the addition of two measurable functions. -/
theorem _root_.Measurable.stronglyMeasurable_add
    {α E : Type*} {_ : MeasurableSpace α} [AddGroup E] [TopologicalSpace E]
    [MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [PseudoMetrizableSpace E]
    {g f : α → E} (hg : Measurable g) (hf : StronglyMeasurable f) :
    Measurable (f + g)
-- Mathlib/FieldTheory/IntermediateField.lean
/-- If `F ≤ E` are two intermediate fields of `L / K` such that `[F : K] = [E : K]` are finite,
then `F = E`. -/
theorem eq_of_le_of_finrank_eq [FiniteDimensional K E] (h_le : F ≤ E)
    (h_finrank : finrank K F = finrank K E) : F = E
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma equalizerSieve_mem_of_equalizerSieve_app_mem
    {X : Cᵒᵖ} (x y : F₁.obj X) (h : equalizerSieve (φ.app _ x) (φ.app _ y) ∈ J X.unop)
    [IsLocallyInjective J φ] :
    equalizerSieve x y ∈ J X.unop
-- Mathlib/Logic/Basic.lean
theorem congr_refl_left {α β : Sort*} (f : α → β) {a b : α} (h : a = b) :
    congr (Eq.refl f) h = congr_arg f h
-- Mathlib/Algebra/Module/Submodule/Basic.lean
protected theorem coe_neg (x : p) : ((-x : p) : M) = -x
-- Mathlib/Data/Nat/Squarefree.lean
theorem minSqFac_le_of_dvd {n d : ℕ} (h : n.minSqFac = some d) {m} (m2 : 2 ≤ m) (md : m * m ∣ n) :
    d ≤ m
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem mk_mul_mk (x y : ℕ × K) :
    mk K p x * mk K p y =
      mk K p (x.1 + y.1, (frobenius K p)^[y.1] x.2 * (frobenius K p)^[x.1] y.2)
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem asIso_inv (f : X ⟶ Y) {_ : IsIso f} : (asIso f).inv = inv f
-- Mathlib/NumberTheory/PythagoreanTriples.lean
/-- by assuming `x` is odd and `z` is positive we get a slightly more precise classification of
the Pythagorean triple `x ^ 2 + y ^ 2 = z ^ 2`-/
theorem coprime_classification' {x y z : ℤ} (h : PythagoreanTriple x y z)
    (h_coprime : Int.gcd x y = 1) (h_parity : x % 2 = 1) (h_pos : 0 < z) :
    ∃ m n,
      x = m ^ 2 - n ^ 2 ∧
        y = 2 * m * n ∧
          z = m ^ 2 + n ^ 2 ∧
            Int.gcd m n = 1 ∧ (m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0) ∧ 0 ≤ m
-- Mathlib/Order/WithBot.lean
theorem le_coe_unbot' : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem support_neg {p : R[X]} : (-p).support = p.support
-- Mathlib/Order/Filter/Prod.lean
theorem prod_map_map_eq.{u, v, w, x} {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x}
    {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂} :
    map m₁ f₁ ×ˢ map m₂ f₂ = map (fun p : α₁ × α₂ => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂)
-- Mathlib/Order/Filter/CardinalInter.lean
/-- A filter `l` has the cardinal `c` intersection property if for any collection
of less than `c` sets `s ∈ l`, their intersection belongs to `l` as well. -/
class CardinalInterFilter (l : Filter α) (c : Cardinal.{u}) : Prop where
  /-- For a collection of sets `s ∈ l` with cardinality below c,
  their intersection belongs to `l` as well. -/
  cardinal_sInter_mem : ∀ S : Set (Set α), (#S < c) → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.map_aux {β} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t a₁ a₂}
    (h : Valid' a₁ t a₂) :
    Valid' (Option.map f a₁) (map f t) (Option.map f a₂) ∧ (map f t).size = t.size
-- Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean
theorem integral_comp_neg_Iic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (c : ℝ) (f : ℝ → E) : (∫ x in Iic c, f (-x)) = ∫ x in Ioi (-c), f x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma baseChange_addY (x₁ x₂ y₁ L : A) :
    (W.baseChange B).toAffine.addY (f x₁) (f x₂) (f y₁) (f L) =
      f ((W.baseChange A).toAffine.addY x₁ x₂ y₁ L)
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.exists_maximal {α : Type*} [Preorder α] (s : Finset α) (h : s.Nonempty) :
    ∃ m ∈ s, ∀ x ∈ s, ¬m < x
-- Mathlib/Combinatorics/Colex.lean
lemma lt_iff_exists_forall_lt {s t : Colex α} :
    s < t ↔ ∃ a ∈ ofColex t, a ∉ ofColex s ∧ ∀ b ∈ ofColex s, b ∉ ofColex t → b < a
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem predictablePart_process_ae_eq (ℱ : Filtration ℕ m0) (μ : Measure Ω) (s : ℕ → Set Ω)
    (n : ℕ) : predictablePart (process s) ℱ μ n =
    ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator (1 : Ω → ℝ)|ℱ k]
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem lt_div_iff_of_neg' (hc : c < 0) : a < b / c ↔ b < c * a
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
/-- Transport a `HasColimitsOfShape` instance across an equivalence. -/
theorem hasColimitsOfShape_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfShape J D] :
    HasColimitsOfShape J C
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
@[simp, nolint simpNF]
theorem homEquiv_naturality_left (f : X' ⟶ X) (g : F.obj X ⟶ Y) :
    (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem lift_mk {i : ℕ} :
    Cardinal.lift.{v,u} #(Sequence₂ a₀ a₁ a₂ i)
      = #(Sequence₂ (ULift.{v,u} a₀) (ULift.{v,u} a₁) (ULift.{v,u} a₂) i)
-- Mathlib/ModelTheory/Satisfiability.lean
theorem SemanticallyEquivalent.realize_iff {φ ψ : L.Formula α} {M : Type max u v} [Nonempty M]
    [L.Structure M] (_hM : T.Model M) (h : T.SemanticallyEquivalent φ ψ) {v : α → M} :
    φ.Realize v ↔ ψ.Realize v
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem measure_pos_of_nonempty_interior (h : (interior s).Nonempty) : 0 < μ s
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lTensor_refl_apply : (refl R N).lTensor M x = x
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem coe_starAe : ⇑(starAe : ℍ[R] ≃ₐ[R] ℍ[R]ᵐᵒᵖ) = op ∘ star
-- Mathlib/Data/Multiset/Basic.lean
theorem zero_le (s : Multiset α) : 0 ≤ s
-- Mathlib/Data/Nat/Periodic.lean
/-- An interval of length `a` filtered over a periodic predicate of period `a` has cardinality
equal to the number naturals below `a` for which `p a` is true. -/
theorem filter_multiset_Ico_card_eq_of_periodic (n a : ℕ) (p : ℕ → Prop) [DecidablePred p]
    (pp : Periodic p a) : card (filter p (Ico n (n + a))) = a.count p
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
theorem lcm_mono {s₁ s₂ : Multiset α} (h : s₁ ⊆ s₂) : s₁.lcm ∣ s₂.lcm
-- Mathlib/Data/List/Forall2.lean
theorem forall₂_drop : ∀ (n) {l₁ l₂}, Forall₂ R l₁ l₂ → Forall₂ R (drop n l₁) (drop n l₂)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
/-- The linear map on the result of subtracting two points is the
result of subtracting the result of the affine map on those two
points. -/
@[simp]
theorem linearMap_vsub (f : P1 →ᵃ[k] P2) (p1 p2 : P1) : f.linear (p1 -ᵥ p2) = f p1 -ᵥ f p2
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- Coercion of a multilinear map to a function as an additive monoid homomorphism. -/
@[simps] def coeAddMonoidHom : MultilinearMap R M₁ M₂ →+ (((i : ι) → M₁ i) → M₂)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
lemma apply_le_norm (f : α →ᵇ ℝ) (x : α) :
    f x ≤ ‖f‖
-- Mathlib/Probability/ConditionalProbability.lean
/-- The conditional probability measure of any finite measure on any set of positive measure
is a probability measure. -/
theorem cond_isProbabilityMeasure [IsFiniteMeasure μ] (hcs : μ s ≠ 0) :
    IsProbabilityMeasure μ[|s]
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainBotCoeff_add_chainTopCoeff :
    chainBotCoeff α β + chainTopCoeff α β = chainLength α β
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem neg_left_iff (x y : R) : IsCoprime (-x) y ↔ IsCoprime x y
-- Mathlib/Algebra/ModEq.lean
protected theorem sub_left (c : α) (h : a ≡ b [PMOD p]) : c - a ≡ c - b [PMOD p]
-- Mathlib/Probability/Process/PartitionFiltration.lean
lemma measurableSet_countableFiltration_of_mem (n : ℕ) {s : Set α}
    (hs : s ∈ countablePartition α n) :
    MeasurableSet[countableFiltration α n] s
-- Mathlib/Data/TypeVec.lean
theorem appendFun_comp  {α₀ α₁ α₂ : TypeVec n}
    {β₀ β₁ β₂ : Type*}
    (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
    (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
    (f₁ ⊚ f₀ ::: g₁ ∘ g₀) = (f₁ ::: g₁) ⊚ (f₀ ::: g₀)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem ciInf_const [Nonempty ι] {a : α} : ⨅ _ : ι, a = a
-- Mathlib/Data/Set/Basic.lean
theorem subset_def : (s ⊆ t) = ∀ x, x ∈ s → x ∈ t
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem measure_toMeasurable_union : μ (toMeasurable μ s ∪ t) = μ (s ∪ t)