ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/QuadraticForm/Real.lean
/-- **Sylvester's law of inertia**: A real quadratic form is equivalent to a weighted
sum of squares with the weights being ±1 or 0, `SignType` version. -/
theorem equivalent_signType_weighted_sum_squared {M : Type*} [AddCommGroup M] [Module ℝ M]
    [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) :
    ∃ w : Fin (FiniteDimensional.finrank ℝ M) → SignType,
      Equivalent Q (weightedSumSquares ℝ fun i ↦ (w i : ℝ))
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- Like `Finsupp.mapDomain_zero`, but for the `1` we define in this file -/
@[simp]
theorem mapDomain_one {α : Type*} {β : Type*} {α₂ : Type*} [Semiring β] [One α] [One α₂]
    {F : Type*} [FunLike F α α₂] [OneHomClass F α α₂] (f : F) :
    (mapDomain f (1 : MonoidAlgebra β α) : MonoidAlgebra β α₂) = (1 : MonoidAlgebra β α₂)
-- Mathlib/CategoryTheory/Equivalence.lean
theorem unit_app_inverse (e : C ≌ D) (Y : D) :
    e.unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y)
-- Mathlib/Data/ENNReal/Operations.lean
theorem top_mul' : ∞ * a = if a = 0 then 0 else ∞
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp, norm_cast]
theorem coe_smul_circle (z : circle) (w : 𝔻) : ↑(z • w) = (z * w : ℂ)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem lsub_eq_zero_iff {ι : Type u} (f : ι → Ordinal.{max u v}) :
    lsub.{_, v} f = 0 ↔ IsEmpty ι
-- Mathlib/CategoryTheory/Functor/ReflectsIso.lean
lemma isIso_iff_of_reflects_iso {A B : C} (f : A ⟶ B) (F : C ⥤ D) [F.ReflectsIsomorphisms] :
    IsIso (F.map f) ↔ IsIso f
-- Mathlib/Analysis/Analytic/Basic.lean
/-- A one-dimensional formal multilinear series representing a locally zero function is zero. -/
theorem HasFPowerSeriesAt.eq_zero_of_eventually {p : FormalMultilinearSeries 𝕜 𝕜 E} {f : 𝕜 → E}
    {x : 𝕜} (hp : HasFPowerSeriesAt f p x) (hf : f =ᶠ[𝓝 x] 0) : p = 0
-- Mathlib/CategoryTheory/Comma/Basic.lean
@[simp]
theorem comp_left : (f ≫ g).left = f.left ≫ g.left
-- Mathlib/Order/Filter/Basic.lean
theorem comap_eval_neBot_iff' {ι : Type*} {α : ι → Type*} {i : ι} {f : Filter (α i)} :
    (comap (eval i) f).NeBot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f
-- Mathlib/Algebra/Ring/NegOnePow.lean
@[simp]
lemma negOnePow_zero : negOnePow 0 = 1
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem prod_dvd_prod_of_subset_of_dvd [AddCommMonoid M] [CommMonoid N] {f1 f2 : α →₀ M}
    {g1 g2 : α → M → N} (h1 : f1.support ⊆ f2.support)
    (h2 : ∀ a : α, a ∈ f1.support → g1 a (f1 a) ∣ g2 a (f2 a)) : f1.prod g1 ∣ f2.prod g2
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- A slight strengthening of `exists_nontrivial_relation_sum_zero_of_rank_succ_lt_card`
available when working over an ordered field:
we can ensure a positive coefficient, not just a nonzero coefficient.
-/
theorem exists_relation_sum_zero_pos_coefficient_of_finrank_succ_lt_card [FiniteDimensional L W]
    {t : Finset W} (h : finrank L W + 1 < t.card) :
    ∃ f : W → L, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, 0 < f x
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem equiv_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
    equiv i j p x = (iterateFrobeniusEquiv M p n).symm (j y)
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem HasDerivAt.cexp (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.exp (f x)) (Complex.exp (f x) * f') x
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
lemma piecewise_apply_left {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂)
    (h : C₁ ∪ C₂ = Set.univ) (f : LocallyConstant C₁ Z) (g : LocallyConstant C₂ Z)
    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, hx.1⟩ = g ⟨x, hx.2⟩)
    [DecidablePred (· ∈ C₁)] (x : X) (hx : x ∈ C₁) :
    piecewise h₁ h₂ h f g hfg x = f ⟨x, hx⟩
-- Mathlib/RingTheory/Polynomial/IntegralNormalization.lean
theorem integralNormalization_eval₂_eq_zero {p : R[X]} (f : R →+* S) {z : S} (hz : eval₂ f z p = 0)
    (inj : ∀ x : R, f x = 0 → x = 0) :
    eval₂ f (z * f p.leadingCoeff) (integralNormalization p) = 0
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
/-- `Polynomial.C` as an `AlgHom`. -/
@[simps! apply]
def CAlgHom : A →ₐ[R] A[X]
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
@[simp]
protected theorem inv_mul_cancel (φ : k⟦X⟧) (h : constantCoeff k φ ≠ 0) : φ⁻¹ * φ = 1
-- Mathlib/Data/Matrix/Notation.lean
theorem vec3_add [Add α] (a₀ a₁ a₂ b₀ b₁ b₂ : α) :
    ![a₀, a₁, a₂] + ![b₀, b₁, b₂] = ![a₀ + b₀, a₁ + b₁, a₂ + b₂]
-- Mathlib/CategoryTheory/Category/Preorder.lean
lemma homOfLE_isIso_of_eq {x y : X} (h : x ≤ y) (heq : x = y) :
    IsIso (homOfLE h)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem eq_left_or_mem_Ioo_of_mem_Ico {x : α} (hmem : x ∈ Ico a b) : x = a ∨ x ∈ Ioo a b
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- The unit isomorphism of `equivalence`. -/
@[simps!]
def equivalenceUnitIso : 𝟭 A ≅ (F ⋙ eB.inverse) ⋙ G
-- Mathlib/Topology/Algebra/Module/Cardinality.lean
/-- A nontrivial module over a complete nontrivially normed field has cardinality at least
continuum. -/
theorem continuum_le_cardinal_of_module
    (𝕜 : Type u) (E : Type v) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
    [AddCommGroup E] [Module 𝕜 E] [Nontrivial E] : 𝔠 ≤ #E
-- Mathlib/Data/Finset/Basic.lean
theorem union_erase_of_mem (ha : a ∈ s) (t : Finset α) : s ∪ t.erase a = s ∪ t
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem le_comap_pow_ramificationIdx : p ≤ comap f (P ^ ramificationIdx f p P)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem disjoint_coe_of_mem (h₁ : J₁ ∈ π) (h₂ : J₂ ∈ π) (h : J₁ ≠ J₂) :
    Disjoint (J₁ : Set (ι → ℝ)) J₂
-- Mathlib/Algebra/GroupWithZero/Basic.lean
lemma zpow_sub_one₀ (ha : a ≠ 0) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹
-- Mathlib/RingTheory/Ideal/Over.lean
/-- `comap (algebraMap R S)` is a surjection from the max spec of `S` to max spec of `R`.
`hP : (algebraMap R S).ker ≤ P` is a slight generalization of the extension being injective -/
theorem exists_ideal_over_maximal_of_isIntegral [Algebra.IsIntegral R S]
    (P : Ideal R) [P_max : IsMaximal P] (hP : RingHom.ker (algebraMap R S) ≤ P) :
    ∃ Q : Ideal S, IsMaximal Q ∧ Q.comap (algebraMap R S) = P
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
theorem ι_mul_ι_comm (a b : M) :
    ι Q a * ι Q b = algebraMap R _ (QuadraticMap.polar Q a b) - ι Q b * ι Q a
-- Mathlib/Algebra/DirectSum/Algebra.lean
theorem algebraMap_toAddMonoid_hom :
    ↑(algebraMap R (⨁ i, A i)) = (DirectSum.of A 0).comp (GAlgebra.toFun : R →+ A 0)
-- Mathlib/Data/List/Basic.lean
/-- `splitOn x` is the left inverse of `intercalate [x]`, on the domain
  consisting of each nonempty list of lists `ls` whose elements do not contain `x`  -/
theorem splitOn_intercalate [DecidableEq α] (x : α) (hx : ∀ l ∈ ls, x ∉ l) (hls : ls ≠ []) :
    ([x].intercalate ls).splitOn x = ls
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma sqrt_eq_zero : sqrt x = 0 ↔ x = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem coe_toOrderIso (f : CircleDeg1Liftˣ) : ⇑(toOrderIso f) = f
-- Mathlib/Algebra/MvPolynomial/Cardinal.lean
/-- The cardinality of the multivariate polynomial ring, `MvPolynomial σ R` is at most the maximum
of `#R`, `#σ` and `ℵ₀` -/
theorem cardinal_mk_le_max : #(MvPolynomial σ R) ≤ max (max #R #σ) ℵ₀
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem sumFinsuppLEquivProdFinsupp_symm_inr {α β : Type*} (fg : (α →₀ M) × (β →₀ M)) (y : β) :
    ((sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma summable_f_nat (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_nat k a t)
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
@[simp]
theorem factorThru_self {X : C} (P : Subobject X) (h) : P.factorThru P.arrow h = 𝟙 (P : C)
-- .lake/packages/lean4/src/lean/Init/Grind/Norm.lean
@[grind_norm] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_le : succ n ≤ m ↔ n < m
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
lemma δ_neg_one_cochain (z : Cochain F G (-1)) :
    δ (-1) 0 z = Cochain.ofHom (Homotopy.nullHomotopicMap'
      (fun i j hij => z.v i j (by dsimp at hij; rw [← hij, add_neg_cancel_right])))
-- Mathlib/Data/DFinsupp/Basic.lean
/-- `DFinsupp.mapRange` as an `AddMonoidHom`. -/
@[simps apply]
def mapRange.addMonoidHom (f : ∀ i, β₁ i →+ β₂ i) : (Π₀ i, β₁ i) →+ Π₀ i, β₂ i
-- Mathlib/GroupTheory/Transfer.lean
theorem transferSylow_eq_pow (g : G) (hg : g ∈ P) :
    transferSylow P hP g =
      ⟨g ^ (P : Subgroup G).index, transfer_eq_pow_aux g (transferSylow_eq_pow_aux P hP g hg)⟩
-- Mathlib/Data/Finset/Basic.lean
theorem choose_mem (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_nat_mul_pi_sub (x : ℂ) (n : ℕ) : tan (n * π - x) = -tan x
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem card_map (f : α → β) (s) : card (map f s) = card s
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem coeToMvPowerSeries.algHom_apply :
    coeToMvPowerSeries.algHom A φ = MvPowerSeries.map σ (algebraMap R A) ↑φ
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem ExpChar.exists [Ring R] [IsDomain R] : ∃ q, ExpChar R q
-- Mathlib/Computability/Primrec.lean
theorem option_some : Primrec (@some α)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem lift_map (h : IsAdjoinRoot S f) (z : R[X]) : h.lift i x hx (h.map z) = z.eval₂ i x
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem symm_toPartialEquiv : e.symm.toPartialEquiv = e.toPartialEquiv.symm
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]]
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
@[simp] lemma in₂₁_iff : (graph t).Adj (in₂ c) (in₁ b) ↔ ∃ a, (a, b, c) ∈ t
-- Mathlib/Logic/IsEmpty.lean
theorem Function.extend_of_isEmpty [IsEmpty α] (f : α → β) (g : α → γ) (h : β → γ) :
    Function.extend f g h = h
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem assoc_symm_tmul (m : M) (n : N) (p : P) :
    (TensorProduct.assoc R M N P).symm (m ⊗ₜ (n ⊗ₜ p)) = m ⊗ₜ n ⊗ₜ p
-- Mathlib/FieldTheory/Galois.lean
theorem AlgEquiv.transfer_galois (f : E ≃ₐ[F] E') : IsGalois F E ↔ IsGalois F E'
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem pow_one (a : Nat) : a ^ 1 = a
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
/-- A variant of `eq_inv_mul_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
lemma mul_eq_of_eq_inv_mul₀ (hb : b ≠ 0) (h : b = a⁻¹ * c) : a * b = c
-- Mathlib/Algebra/ModEq.lean
theorem modEq_iff_eq_mod_zmultiples : a ≡ b [PMOD p] ↔ (b : α ⧸ AddSubgroup.zmultiples p) = a
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_indicator_ne_zero {f : α → ℝ≥0} (hf : Summable f) {s : Set α} (h : ∃ a ∈ s, f a ≠ 0) :
    (∑' x, (s.indicator f) x) ≠ 0
-- Mathlib/Data/Option/NAry.lean
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) :
    map₂ f a (b.map g) = (map₂ f' a b).map g'
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval.linearMap_apply : smeval.linearMap R x p = p.smeval x
-- Mathlib/Algebra/Opposites.lean
@[simp] lemma op_div [Div α] (a b : α) : op (a / b) = op a / op b
-- Mathlib/CategoryTheory/Triangulated/Subcategory.lean
lemma W.mk {T : Triangle C} (hT : T ∈ distTriang C) (h : S.P T.obj₃) : S.W T.mor₁
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem ord_eq (α) : ∃ (r : α → α → Prop) (wo : IsWellOrder α r), ord #α = @type α r wo
-- Mathlib/Order/Defs.lean
theorem eq_or_lt_of_le {a b : α} (hab : a ≤ b) : a = b ∨ a < b
-- Mathlib/Order/Monotone/Basic.lean
/-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
downright. -/
lemma not_monotone_not_antitone_iff_exists_le_le :
    ¬ Monotone f ∧ ¬ Antitone f ↔
      ∃ a b c, a ≤ b ∧ b ≤ c ∧ ((f a < f b ∧ f c < f b) ∨ (f b < f a ∧ f b < f c))
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
theorem aeval_verschiebungPoly (x : 𝕎 R) (n : ℕ) :
    aeval x.coeff (verschiebungPoly n) = (verschiebung x).coeff n
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem one_def : (1 : P₁ ≃ᵃ[k] P₁) = refl k P₁
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem mem_biSup_iff_exists_dfinsupp (p : ι → Prop) [DecidablePred p] (S : ι → Submodule R N)
    (x : N) :
    (x ∈ ⨆ (i) (_ : p i), S i) ↔
      ∃ f : Π₀ i, S i,
        DFinsupp.lsum ℕ (M := fun i ↦ ↥(S i)) (fun i => (S i).subtype) (f.filter p) = x
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem tsum_geometric_of_norm_lt_one (h : ‖ξ‖ < 1) : ∑' n : ℕ, ξ ^ n = (1 - ξ)⁻¹
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem pow_dvd_pow_of_dvd (h : a ∣ b) : ∀ n : ℕ, a ^ n ∣ b ^ n
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
lemma CFC.exists_sqrt_of_isSelfAdjoint_of_quasispectrumRestricts {A : Type*} [NonUnitalRing A]
    [StarRing A] [TopologicalSpace A] [Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A ]
    [NonUnitalContinuousFunctionalCalculus ℝ (IsSelfAdjoint : A → Prop)]
    {a : A} (ha₁ : IsSelfAdjoint a) (ha₂ : QuasispectrumRestricts a ContinuousMap.realToNNReal) :
    ∃ x : A, IsSelfAdjoint x ∧ QuasispectrumRestricts x ContinuousMap.realToNNReal ∧ x * x = a
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
@[simp] theorem log_eq_one_iff {x : ℝ≥0∞} : log x = 0 ↔ x = 1
-- Mathlib/Topology/Basic.lean
@[simp]
theorem closure_nonempty_iff : (closure s).Nonempty ↔ s.Nonempty
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem ediam_image_le (hf : LipschitzWith K f) (s : Set α) :
    EMetric.diam (f '' s) ≤ K * EMetric.diam s
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformContinuous.inf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ u₃ : UniformSpace β}
    (h₁ : UniformContinuous[u₁, u₂] f) (h₂ : UniformContinuous[u₁, u₃] f) :
    UniformContinuous[u₁, u₂ ⊓ u₃] f
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem coe_refl : ↑(refl M) = id
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem leftInvOn_piecewise {e' : PartialEquiv α β} [∀ i, Decidable (i ∈ s)]
    [∀ i, Decidable (i ∈ t)] (h : e.IsImage s t) (h' : e'.IsImage s t) :
    LeftInvOn (t.piecewise e.symm e'.symm) (s.piecewise e e') (s.ite e.source e'.source)
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc]
lemma d_fstX (i j k : ι) (hij : c.Rel i j) (hjk : c.Rel j k) :
    d φ i j ≫ fstX φ j k hjk = -fstX φ i j hij ≫ F.d j k
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem coe_injective : @Function.Injective (NormedAddGroupHom V₁ V₂) (V₁ → V₂) toFun
-- Mathlib/Data/Set/Lattice.lean
theorem Ici_iSup (f : ι → α) : Ici (⨆ i, f i) = ⋂ i, Ici (f i)
-- .lake/packages/lean4/src/lean/Init/Classical.lean
@[simp] theorem and_or_imp : a ∧ b ∨ (a → c) ↔ a → b ∨ c
-- Mathlib/ModelTheory/Types.lean
theorem isMaximal (p : T.CompleteType α) : IsMaximal (p : L[[α]].Theory)
-- Mathlib/LinearAlgebra/RootSystem/Basic.lean
/-- In characteristic zero if there is no torsion, the correspondence between roots and coroots is
unique.

Formally, the point is that the hypothesis `hc` depends only on the range of the coroot mappings. -/
@[ext]
protected lemma ext [CharZero R] [NoZeroSMulDivisors R M]
    {P₁ P₂ : RootPairing ι R M N}
    (he : P₁.toLin = P₂.toLin)
    (hr : P₁.root = P₂.root)
    (hc : range P₁.coroot = range P₂.coroot) :
    P₁ = P₂
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem coe_eq_one_iff : (φ : MvPowerSeries σ R) = 1 ↔ φ = 1
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The direction of `⊤` is the whole module as a submodule. -/
@[simp]
theorem direction_top : (⊤ : AffineSubspace k P).direction = ⊤
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
theorem map_smul (f : M →ₗ[R] M') (p : R[X]) (q : PolynomialModule R M) :
    map R' f (p • q) = p.map (algebraMap R R') • map R' f q
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem finset_sup_apply [SemilatticeSup β] [OrderBot β] {f : γ → α →ₛ β} (s : Finset γ) (a : α) :
    s.sup f a = s.sup fun c => f c a
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem ofRat_neg (x : β) : ofRat (-x) = (-ofRat x : Cauchy abv)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem PolyCnstr.eq_false_of_isUnsat (ctx : Context) {c : PolyCnstr} : c.isUnsat → c.denote ctx = False
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measureUnivNNReal_pos [IsFiniteMeasure μ] (hμ : μ ≠ 0) : 0 < measureUnivNNReal μ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_succ : m < succ n ↔ m ≤ n
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem rel_iff {H K : Subgroup G} {x y : G} :
    (setoid ↑H ↑K).Rel x y ↔ ∃ a ∈ H, ∃ b ∈ K, y = a * x * b
-- Mathlib/Computability/Reduce.lean
theorem transitive_manyOneReducible {α} [Primcodable α] : Transitive (@ManyOneReducible α α _ _)
-- Mathlib/Probability/Kernel/Composition.lean
theorem swapRight_apply (κ : Kernel α (β × γ)) (a : α) : swapRight κ a = (κ a).map Prod.swap
-- Mathlib/Topology/Bases.lean
/-- If `α` is a separable space and `f : α → β` is a continuous map with dense range, then `β` is
a separable space as well. E.g., the completion of a separable uniform space is separable. -/
protected theorem _root_.DenseRange.separableSpace [SeparableSpace α] [TopologicalSpace β]
    {f : α → β} (h : DenseRange f) (h' : Continuous f) : SeparableSpace β
-- Mathlib/Algebra/Lie/Rank.lean
lemma rank_eq_natTrailingDegree :
    rank R L M = (polyCharpoly φ b).natTrailingDegree
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem inter_union_self (s t : Finset α) : s ∩ (t ∪ s) = s
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem ker_coeSubmodule : LieSubmodule.toSubmodule (ker f) = LinearMap.ker (f : L →ₗ[R] L')
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
theorem prodComparison_comp :
    prodComparison (F ⋙ G) A B =
      G.map (prodComparison F A B) ≫ prodComparison G (F.obj A) (F.obj B)
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
lemma set_smul_le_of_le_le {s t : Set S} {p q : Submodule R M}
    (le_set : s ≤ t) (le_submodule : p ≤ q) : s • p ≤ t • q
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finSuccEquiv'_at (i : Fin (n + 1)) : (finSuccEquiv' i) i = none
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
theorem rpow_one (x : ℝ) : x ^ (1 : ℝ) = x
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if a = b then n else 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
/-- The cosine of `π / 3` is `1 / 2`. -/
@[simp]
theorem cos_pi_div_three : cos (π / 3) = 1 / 2
-- Mathlib/Order/LiminfLimsup.lean
theorem isCoboundedUnder_ge_finset_inf' [LinearOrder β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∃ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i)) :
    f.IsCoboundedUnder (· ≥ ·) (fun a ↦ inf' s hs (fun i ↦ F i a))
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_unit {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] (I : (Submodule R A)ˣ) :
    (I : Submodule R A).FG
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[simp]
theorem toOrderHom_mk {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1)) :
    (mk f).toOrderHom = f
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.ne_singleton_iff {l : List α} (h : Nodup l) (x : α) :
    l ≠ [x] ↔ l = [] ∨ ∃ y ∈ l, y ≠ x
-- Mathlib/Order/Filter/Basic.lean
theorem comap_comm (H : ψ ∘ φ = ρ ∘ θ) (G : Filter δ) :
    comap φ (comap ψ G) = comap θ (comap ρ G)
-- Mathlib/Data/Set/NAry.lean
/-- If `b` is a right identity for `f : α → β → α`, then `{b}` is a right identity for
`Set.image2 f`. -/
lemma image2_right_identity {f : α → β → α} {b : β} (h : ∀ a, f a b = a) (s : Set α) :
    image2 f s {b} = s
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem card_attach {m : Multiset α} : card (attach m) = card m
-- Mathlib/Data/Finset/Powerset.lean
theorem powerset_injective : Injective (powerset : Finset α → Finset (Finset α))
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma opcyclesIsoRightHomology_hom_inv_id (hg : S.g = 0) :
    (S.opcyclesIsoRightHomology hg).hom ≫ S.rightHomologyι  = 𝟙 _
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
/-- A lower block-triangular matrix is invertible iff both elements of its diagonal are.

This is a propositional form of `Matrix.fromBlocksZero₁₂InvertibleEquiv` forms an `iff`. -/
@[simp]
theorem isUnit_fromBlocks_zero₁₂ {A : Matrix m m α} {C : Matrix n m α} {D : Matrix n n α} :
    IsUnit (fromBlocks A 0 C D) ↔ IsUnit A ∧ IsUnit D
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.or_congr_right' [Decidable a] (h : ¬a → (b ↔ c)) : a ∨ b ↔ a ∨ c
-- Mathlib/Analysis/Convex/Exposed.lean
theorem ContinuousLinearMap.toExposed.isExposed : IsExposed 𝕜 A (l.toExposed A)
-- Mathlib/Data/Set/Image.lean
@[congr]
theorem image_congr {f g : α → β} {s : Set α} (h : ∀ a ∈ s, f a = g a) : f '' s = g '' s
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- This lemma shows that `restrict` and `toOuterMeasure` commute. Note that the LHS has a
restrict on measures and the RHS has a restrict on outer measures. -/
theorem restrict_toOuterMeasure_eq_toOuterMeasure_restrict (h : MeasurableSet s) :
    (μ.restrict s).toOuterMeasure = OuterMeasure.restrict s μ.toOuterMeasure
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem succ_lt_of_not_succ {o b : Ordinal} (h : ¬∃ a, o = succ a) : succ b < o ↔ b < o
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem le_geom {u : ℕ → ℝ} {c : ℝ} (hc : 0 ≤ c) (n : ℕ) (h : ∀ k < n, u (k + 1) ≤ c * u k) :
    u n ≤ c ^ n * u 0
-- Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean
theorem singletonFinsubgraph_le_adj_left {u v : V} {e : G.Adj u v} :
    singletonFinsubgraph u ≤ finsubgraphOfAdj e
-- Mathlib/Tactic/NormNum/LegendreSymbol.lean
/-- The symbol vanishes when both entries are even (and `b / 2 ≠ 0`). -/
theorem jacobiSymNat.even_even (a b : ℕ) (hb₀ : Nat.beq (b / 2) 0 = false) (ha : a % 2 = 0)
    (hb₁ : b % 2 = 0) : jacobiSymNat a b = 0
-- Mathlib/RingTheory/Generators.lean
@[simp] lemma val_of : (of w).val = w
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.linear_image (hs : StarConvex 𝕜 x s) (f : E →ₗ[𝕜] F) :
    StarConvex 𝕜 (f x) (f '' s)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
lemma den_mem_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) :
    (algebraMap R₁ K) (I.den : R₁) ∈ I⁻¹
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_neg (f : N →ₗ[R] P) : (-f).rTensor M = -f.rTensor M
-- Mathlib/Data/Finset/Basic.lean
theorem mem_of_mem_insert_of_ne (h : b ∈ insert a s) : b ≠ a → b ∈ s
-- Mathlib/Combinatorics/Derangements/Basic.lean
theorem RemoveNone.fiber_none : RemoveNone.fiber (@none α) = ∅
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.mul (hp : Monic p) (hq : Monic q) : Monic (p * q)
-- Mathlib/RingTheory/RingHom/FinitePresentation.lean
/-- Being finitely-presented is stable under composition. -/
theorem finitePresentation_stableUnderComposition : StableUnderComposition @FinitePresentation
-- Mathlib/Probability/Kernel/RadonNikodym.lean
/-- Radon-Nikodym derivative of the kernel `κ` with respect to the kernel `η`. -/
noncomputable
irreducible_def rnDeriv (κ η : Kernel α γ) (a : α) (x : γ) : ℝ≥0∞
-- Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean
theorem integral_comp_abs {f : ℝ → ℝ} :
    ∫ x, f |x| = 2 * ∫ x in Ioi (0 : ℝ), f x
-- Mathlib/Algebra/BigOperators/Ring/Multiset.lean
theorem multiset_sum_left (b : α) (h : ∀ a ∈ s, Commute a b) : Commute s.sum b
-- Mathlib/Analysis/Calculus/Darboux.lean
/-- **Darboux's theorem**: the image of a convex set under `f'` is a convex set,
`HasDerivWithinAt` version. -/
theorem Convex.image_hasDerivWithinAt {s : Set ℝ} (hs : Convex ℝ s)
    (hf : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x) : Convex ℝ (f' '' s)
-- Mathlib/Data/NNReal/Basic.lean
theorem zpow_pos {x : ℝ≥0} (hx : x ≠ 0) (n : ℤ) : 0 < x ^ n