name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddCommGroup.DirectLimit.map._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (G i)]
{f : (i j : ι) → i ≤ j → G i →+ G j} [inst_2 : DecidableEq ι] {G' : ι → Type u_2}
[inst_3 : (i : ι) → AddCommMonoid (G' i)] {f' : (i j : ι) → i ≤ j → G' i →+ G' j} (g : (i : ι) → G i →+ G' i),
(∀ (i j : ι) (h : i ≤ j)... | null | false |
CategoryTheory.evaluationAdjunctionLeft._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) {X : CategoryTheory.Functor C D}
{Y Y' : D} (f : ((CategoryTheory.evaluation C D).obj c).obj X ⟶ Y) (g : ... | null | false |
_private.Mathlib.Analysis.Analytic.Within.0.analyticOn_of_locally_analyticOn._simp_1_4 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Lean.LeanOptions.mk.noConfusion | Lean.Util.LeanOptions | {P : Sort u} →
{values values' : Lean.NameMap Lean.LeanOptionValue} →
{ values := values } = { values := values' } → (values = values' → P) → P | null | false |
Subgroup.instNormalSubtypeMemFocalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroupOf.Normal | Lemma: H* is a normal subgroup of H. | true |
FintypeCat.toLightProfinite | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.Functor FintypeCat LightProfinite | The natural functor from `Fintype` to `LightProfinite`, endowing a finite type with the
discrete topology. | true |
Matrix.liftLinear_comp_singleLinearMap | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} (S : Type u_6) {α : Type u_7} {β : Type u_8} [inst : DecidableEq m]
[inst_1 : DecidableEq n] [inst_2 : Fintype m] [inst_3 : Fintype n] [inst_4 : Semiring R] [inst_5 : Semiring S]
[inst_6 : AddCommMonoid α] [inst_7 : AddCommMonoid β] [inst_8 : Module R α] [inst_9 : Modu... | null | true |
ULift.recOn | Init.Prelude | {α : Type s} →
{motive : ULift.{r, s} α → Sort u} → (t : ULift.{r, s} α) → ((down : α) → motive { down := down }) → motive t | null | false |
ISize.toInt16_not | Init.Data.SInt.Bitwise | ∀ (a : ISize), (~~~a).toInt16 = ~~~a.toInt16 | null | true |
LinOrd.ext | Mathlib.Order.Category.LinOrd | ∀ {X Y : LinOrd} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g | null | true |
AffineEquiv.instCoeOutEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | null | true |
_private.Mathlib.CategoryTheory.SmallObject.Iteration.Basic.0.CategoryTheory.SmallObject.SuccStruct.Iteration.subsingleton._simp_5 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
List.Cursor.current.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (c : l.Cursor) (h : 0 < c.suffix.length), c.current h = c.suffix[0] | null | true |
CategoryTheory.Limits.Cofork.IsColimit.desc'.congr_simp | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : Y ⟶ X} {s : CategoryTheory.Limits.Cofork f g}
(hs hs_1 : CategoryTheory.Limits.IsColimit s),
hs = hs_1 →
∀ {W : C} (k : X ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Lim... | null | true |
Lean.Widget.MsgEmbed.brecOn_3.go | Lean.Widget.InteractiveDiagnostic | {motive_1 : Lean.Widget.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u} →
{motive... | null | true |
SubAddAction.fixingAddSubgroupInsertEquiv._proof_6 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : AddGroup M] [inst_1 : AddAction M α] (a : α)
(s : Set ↥(SubAddAction.ofStabilizer M a)) (x : ↥(fixingAddSubgroup M (insert a (Subtype.val '' s)))),
(fun m => ⟨↑↑m, ⋯⟩) ((fun m => ⟨⟨↑m, ⋯⟩, ⋯⟩) x) = x | null | false |
Mathlib.instReprIneq | Mathlib.Data.Ineq | Repr Mathlib.Ineq | null | true |
Shrink.instAdd | Mathlib.Algebra.Group.Shrink | {α : Type u_2} → [inst : Small.{v, u_2} α] → [Add α] → Add (Shrink.{v, u_2} α) | null | true |
Pi.commMonoidWithZero._proof_3 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → CommMonoidWithZero (α i)] (a : (i : ι) → α i), a * 0 = 0 | null | false |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Iio_True._simp_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
ZeroHom.coe_copy | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {x : Zero M} {x_1 : Zero N} (f : ZeroHom M N) (f' : M → N) (h : f' = ⇑f),
⇑(f.copy f' h) = f' | null | true |
Real.fourier_continuousMultilinearMap_apply | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] [inst_6 : FiniteDimensional ℝ V]
{ι : Type u_4} [inst_7 : Fintype ι] {M : ι → Type u_5} [inst_8 : (i : ι) → N... | null | true |
Set.iUnion_setOf | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} (P : ι → α → Prop), ⋃ i, {x | P i x} = {x | ∃ i, P i x} | **Alias** of `Set.iUnion_ofPred`. | true |
String.Slice.Pattern.ForwardSliceSearcher.startsWith | Init.Data.String.Pattern.String | String.Slice → String.Slice → Bool | null | true |
_private.Mathlib.LinearAlgebra.Span.Basic.0.LinearMap.submoduleOf_span_singleton_of_mem._simp_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
Affine.Simplex.Equilateral.angle_eq_pi_div_three | Mathlib.Geometry.Euclidean.Simplex | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} {s : Affine.Simplex ℝ P n},
s.Equilateral →
∀ {i₁ i₂ i₃ : Fin (n + 1)},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → EuclideanGeometry.angle (s.points i₁) (s.poin... | null | true |
summable_of_absolute_convergence_real | Mathlib.Analysis.Normed.Ring.InfiniteSum | ∀ {f : ℕ → ℝ}, (∃ r, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)) → Summable f | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.exact? | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Elab.ConfigEval.HandlerTrie✝ → Option Lean.Elab.ConfigEval.EvalConfigItemHandler | The `EvalConfigItemHandlerKind.exact` handler for this trie position's key. | true |
Mathlib.Tactic.ClickSuggestions.Context | Mathlib.Tactic.ClickSuggestions.Util | Type | The information required for pasting a suggestion into the editor. | true |
LinearMap.BilinForm.tmul.eq_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₁ : Type uM₁} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R A] [inst_5 : Module R M₁]
[inst_6 : Module A M₁] [inst_7 : SMulCommClass R A M₁] [inst_8 : IsScalarTower R A M₁] [inst_9 : Modul... | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{lhs rhs : Lean.Expr} →
{configKey : UInt64} →
{lhs' rhs' : Lean.Expr} →
{configKey' : UInt64} →
{ lhs := lhs, rhs := rhs, configKey := configKey } = { lhs := lhs', rhs := rhs', configKey := configKey' } →
(lhs = lhs' → rhs = rhs' → configKey = configKey' → P) → ... | null | false |
List.Cursor.tail.congr_simp | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (s s_1 : l.Cursor) (e_s : s = s_1) (h : 0 < s.suffix.length), s.tail h = s_1.tail ⋯ | null | true |
CategoryTheory.Functor.isoCopyObj | Mathlib.CategoryTheory.NatIso | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → (obj : C → D) → (e : (X : C) → F.obj X ≅ obj X) → F ≅ F.copyObj obj e | The functor constructed with `copyObj` is isomorphic to the given functor. | true |
Finset.mulETransformLeft_inv | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommGroup α] (e : α) (x : Finset α × Finset α),
Finset.mulETransformLeft e⁻¹ x = (Finset.mulETransformRight e x.swap).swap | null | true |
Fin.predAbove_le_predAbove | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} {p q : Fin n}, p ≤ q → ∀ {i j : Fin (n + 1)}, i ≤ j → p.predAbove i ≤ q.predAbove j | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_toArray._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Int.divisorsAntidiag.eq_2 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
(Int.negSucc n).divisorsAntidiag =
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
(n + 1).divisorsAntidiagonal).disjUnion
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
(n +... | null | true |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_40 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Besicovitch.BallPackage.ctorIdx | Mathlib.MeasureTheory.Covering.Besicovitch | {β : Type u_1} → {α : Type u_2} → Besicovitch.BallPackage β α → ℕ | null | false |
MeasureTheory.Lp.edist_toLp_zero | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f : α → E) (hf : MeasureTheory.MemLp f p μ),
edist (MeasureTheory.MemLp.toLp f hf) 0 = MeasureTheory.eLpNorm f p μ | null | true |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.vars | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Meta.Simp.Arith.Nat.ToLinear.State → Array Lean.Expr | null | true |
Std.DTreeMap.Internal.Impl.insertMany_eq_foldl_impl | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t₁ : Std.DTreeMap.Internal.Impl α β} (h₁ : t₁.Balanced)
{t₂ : Std.DTreeMap.Internal.Impl α β},
↑(t₁.insertMany t₂ h₁) =
Std.DTreeMap.Internal.Impl.foldl (fun acc k v => Std.DTreeMap.Internal.Impl.insert! k v acc) t₁ t₂ | null | true |
_private.Mathlib.Computability.Reduce.0.ManyOneEquiv.trans.match_1_1 | Mathlib.Computability.Reduce | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop} (motive : ManyOneEquiv p q → ManyOneEquiv q r → Prop)
(x : ManyOneEquiv p q) (x_1 : ManyOneEquiv q r),
(∀ (pq : p ≤₀ q) (qp : q ≤₀ p) (qr : q ≤₀ r) (... | null | false |
LowerSet.instSProd | Mathlib.Order.UpperLower.Prod | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → SProd (LowerSet α) (LowerSet β) (LowerSet (α × β)) | null | true |
MeasureTheory.Measure.IsAddLeftInvariant.comap | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] {H : Type u_3} [inst_3 : AddGroup H]
{mH : MeasurableSpace H} [MeasurableAdd H] (μ : MeasureTheory.Measure H) [μ.IsAddLeftInvariant] {f : G →+ H},
MeasurableEmbedding ⇑f → (MeasureTheory.Measure.comap (⇑f) μ).IsAddLeftInvariant | null | true |
Matrix.SpecialLinearGroup.instCoeInt | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → Coe (Matrix.SpecialLinearGroup n ℤ) (Matrix.SpecialLinearGroup n R) | Coercion of SL `n` `ℤ` to SL `n` `R` for a commutative ring `R`. | true |
List.getLast?_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {n : ℕ}, (List.replicate n a).getLast? = if n = 0 then none else some a | null | true |
neg_one_pow_eq_neg_one_iff_odd | Mathlib.Algebra.Ring.Parity | ∀ {R : Type u_4} [inst : Monoid R] [inst_1 : HasDistribNeg R] {n : ℕ}, -1 ≠ 1 → ((-1) ^ n = -1 ↔ Odd n) | null | true |
_private.Mathlib.Geometry.Convex.ConvexSpace.Defs.0.Convexity.StdSimplex.mem_range_map_iff._simp_1_6 | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
unitsCentralizerEquiv._proof_8 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 x_2 : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ = ⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ | null | false |
PeriodPair.derivWeierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | PeriodPair → ℂ → ℂ | The derivative of Weierstrass `℘` function.
This has the notation `℘'[L]` in the namespace `PeriodPairs`. | true |
SMulCon.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {P : Sort u} →
{S : Type u_2} →
{M : Type u_3} →
{inst : SMul S M} →
{t : SMulCon S M} →
{S' : Type u_2} →
{M' : Type u_3} →
{inst' : SMul S' M'} →
{t' : SMulCon S' M'} → S = S' → M = M' → inst ≍ inst' → t ≍ t' → SMulCon.noConfusionType P t t' | null | false |
Aesop.Frontend.RuleExpr.elab | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.RuleExpr | null | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.Pos.Splits.le_iff_exists_eq_append._simp_1_3 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey.c | Lean.Meta.FunInfo | Lean.Meta.FunInfoEnvCacheKey✝ → Lean.Name | null | true |
_private.Mathlib.Algebra.Category.CommHopfAlgCat.0.CommHopfAlgCat.Hom.ext.match_1 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u_2} {inst : CommRing R} {A B : CommHopfAlgCat R} (motive : A.Hom B → Prop) (h : A.Hom B),
(∀ (hom' : ↑A →ₐc[R] ↑B), motive { hom' := hom' }) → motive h | null | false |
ValuationRing.instLEValueGroup._proof_1 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_1) [inst_1 : Field K] [inst_2 : Algebra A K] (a₁ a₂ b₁ b₂ : K),
(MulAction.orbitRel Aˣ K) a₁ b₁ → (MulAction.orbitRel Aˣ K) a₂ b₂ → (∃ c, c • a₂ = a₁) = ∃ c, c • b₂ = b₁ | null | false |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_14 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a < x ∧ x < b → (x - (a + 1)).toNat < (b - a - 1).toNat ∧ a + 1 + ↑(x - (a + 1)).toNat = x | null | false |
TopCommRingCat._sizeOf_inst | Mathlib.Topology.Category.TopCommRingCat | SizeOf TopCommRingCat | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Minimal.0.termAbsR | Mathlib.Analysis.InnerProductSpace.Projection.Minimal | Lean.ParserDescr | null | true |
isLocalMax_of_deriv' | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) ... | The First-Derivative Test from calculus, maxima version,
expressed in terms of left and right filters. | true |
OrthogonalFamily.independent | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E}, (OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) → iSupIndep V | An orthogonal family forms an independent family of subspaces; that is, any collection of
elements each from a different subspace in the family is linearly independent. In particular, the
pairwise intersections of elements of the family are 0. | true |
NonUnitalSubsemiring.mem_prod | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
{s : NonUnitalSubsemiring R} {t : NonUnitalSubsemiring S} {p : R × S}, p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t | null | true |
BitVec.not_sub_one_eq_not_add_one | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, ~~~(x - 1#w) = ~~~x + 1#w | null | true |
Diffeomorph.coe_toHomeomorph | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_7} [inst_6 : TopologicalSpace G] {I : ModelWithCorners ... | null | true |
MeasureTheory.eLpNorm'_mono_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {G : Type u_7} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
0 ≤ q → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖) → MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ | null | true |
Filter.eventually_mem_set._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s) = (s ∈ l) | null | false |
AddSubgroup.normalCore._proof_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x x_1 : G},
x ∈ {a | ∀ (b : G), b + a + -b ∈ H} → x_1 ∈ {a | ∀ (b : G), b + a + -b ∈ H} → ∀ (c : G), c + (x + x_1) + -c ∈ H | null | false |
isFullyInvariant_iff_sSup_isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
{m : Submodule R M}, m.IsFullyInvariant ↔ ∃ s ⊆ isotypicComponents R M, m = sSup s | null | true |
PointedCone.IsSimplicial.hull | Mathlib.Geometry.Convex.Cone.Simplicial | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {s : Set M},
s.Finite → LinearIndepOn R id s → (PointedCone.hull R s).IsSimplicial | The conic hull of a finite linearly independent set is simplicial. | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.termTM | Mathlib.Geometry.Manifold.VectorBundle.Tangent | Lean.ParserDescr | null | true |
List.alternatingSum_nil | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G], [].alternatingSum = 0 | null | true |
Lean.Meta.Grind.mkEqHEqProof | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | Returns a proof that `a = b` if they have the same type. Otherwise, returns a proof of `a ≍ b`.
It assumes `a` and `b` are in the same equivalence class.
| true |
WithLp._sizeOf_inst | Mathlib.Analysis.Normed.Lp.WithLp | (p : ENNReal) → (V : Type u_1) → [SizeOf V] → SizeOf (WithLp p V) | null | false |
continuous_clm_apply | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type w} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace 𝕜]
{X : Type u_1} [inst_6 : TopologicalSpace X] [FiniteDimensional 𝕜 E] {f : X → E →L[𝕜] F},
Conti... | null | true |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.sharesVar._unary.eq_def | Lean.Meta.Sym.Arith.Poly | ∀ (_x : (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.sharesVar._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Lean.Grind.CommRing.Mon.unit, x => false
| x, Lean.Grind.CommRing.Mon.unit => false
| Lean.Grind.CommRing.Mon.mult pw₁ m₁, Lea... | null | false |
SSet.Subcomplex.Pairing.RankFunction.Cell.ι_t_app_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] {f : P.RankFunction ι}
[inst_1 : P.IsProper] {j : ι} (c : f.Cell j) (x : SimplexCategoryᵒᵖ) {Z : Type u}
(h : (f.filtration j).toSSet.obj x ⟶ Z),
CategoryTheory.CategoryStruct.comp (c.ιSigmaHorn.app x) (CategoryTheory.CategoryStru... | null | true |
CategoryTheory.Monoidal.functorCategoryMonoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
... | null | false |
Std.TreeSet.min!_insert_le_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(cmp (t.insert k).min! k).isLE = true | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.inner_eq_norm_mul_iff_div._simp_1_6 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.DTreeMap.Internal.Impl.Const.toListModel_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α] {l : List α}
{t : Std.DTreeMap.Internal.Impl α fun x => Unit},
t.WF →
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)).toListModel.Perm
(Std.Internal.List.insertListIfNewUnit t.toListModel l) | null | true |
BitVec.sub_add_comm | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {z x y : BitVec w}, x - y + z = x + z - y | null | true |
SimpleGraph.isAcyclic_sup_fromEdgeSet_iff | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
(G ⊔ SimpleGraph.edge u v).IsAcyclic ↔ G.IsAcyclic ∧ (G.Reachable u v → u = v ∨ G.Adj u v) | Adding an edge results in an acyclic graph iff the original graph was acyclic and
the edge connects vertices that previously had no path between them. | true |
_private.Mathlib.Analysis.Calculus.VectorField.0.VectorField.lieBracketWithin_add_left._abel_1_2 | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {V W V₁ : E → E} {s : Set E} {x : E},
(fderivWithin 𝕜 W s x) (V x) + (fderivWithin 𝕜 W s x) (V₁ x) -
((fderivWithin 𝕜 V s x) (W x) + (fderivWithin 𝕜 V₁ s x) (W x)) =
(fderiv... | null | false |
_private.Mathlib.RingTheory.Coalgebra.Basic.0.Coalgebra.sum_tmul_tmul_eq._simp_1_1 | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) {α : Type u_9} (s : Finset α)
(n : α → N), ∑ a ∈ s, m ⊗ₜ[R] n a = m ⊗ₜ[R] ∑ a ∈ s, n a | null | false |
Lean.Elab.Do.DoElemContKind._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.DoElemContKind | null | false |
Array.le_sum_div_length_of_min?_eq_some_nat | Init.Data.Array.Nat | ∀ {x : ℕ} {xs : Array ℕ}, xs.min? = some x → x ≤ xs.sum / xs.size | null | true |
ULiftable.recOn | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} →
{g : Type v₀ → Type v₁} →
{motive : ULiftable f g → Sort u} →
(t : ULiftable f g) →
((congr : {α : Type u₀} → {β : Type v₀} → α ≃ β → f α ≃ g β) → motive { congr := congr }) → motive t | null | false |
Module.End.hasEigenvalue_iff_isRoot_charpoly | Mathlib.LinearAlgebra.Eigenspace.Charpoly | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Free R M] [inst_5 : Module.Finite R M] (f : Module.End R M) (μ : R),
f.HasEigenvalue μ ↔ (LinearMap.charpoly f).IsRoot μ | The roots of the characteristic polynomial are exactly the eigenvalues.
`R` is required to be an integral domain, otherwise there is the counterexample:
R = M = Z/6Z, f(x) = 2x, v = 3, μ = 4, but p = X - 2.
| true |
_private.Batteries.Tactic.Lint.Simp.0.Batteries.Tactic.Lint.formatLemmas._sparseCasesOn_2 | Batteries.Tactic.Lint.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lat.Iso.mk._proof_3 | Mathlib.Order.Category.Lat | ∀ {α β : Lat} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.mk._flat_ctor | Std.Sync.Channel | {α : Type} →
Std.Queue (IO.Promise Bool) →
Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α) →
(capacity : ℕ) →
Vector (IO.Ref (Option α)) capacity →
ℕ →
(sendIdx : ℕ) →
sendIdx < capacity → (recvIdx : ℕ) → recvIdx < capacity → Bool → Std.CloseableChannel.Bound... | null | false |
groupHomology.shortComplexH0 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → CategoryTheory.ShortComplex (ModuleCat k) | The (exact) short complex `(G →₀ A) ⟶ A ⟶ A.ρ.coinvariants`. | true |
WithBot.instIsOrderedRing | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [IsOrderedRing α]
[inst_4 : CanonicallyOrderedAdd α] [inst_5 : NoZeroDivisors α] [inst_6 : Nontrivial α], IsOrderedRing (WithBot α) | null | true |
Algebra.TensorProduct.tensorTensorTensorComm_symm | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {R' : Type u_1} {S : Type uS} {T : Type u_2} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD}
[inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A]
[inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst... | null | true |
UInt8.sub_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, b ≤ a → a - b ≤ a | null | true |
RingCat.Colimits.Prequotient.ctorElim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(ctorIdx : ℕ) →
(t : RingCat.Colimits.Prequotient F) →
ctorIdx = t.ctorIdx → RingCat.Colimits.Prequotient.ctorElimType ctorIdx ... | null | false |
AbsoluteValue.isAbsoluteValue | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_4} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_5} [inst_2 : Semiring R]
(abv : AbsoluteValue R S), IsAbsoluteValue ⇑abv | A bundled absolute value is an absolute value. | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.OwnReason.functionCallArg | Lean.Compiler.LCNF.InferBorrow | Lean.FVarId → Lean.Compiler.LCNF.OwnReason✝ | Argument to a function whose corresponding parameter is owned. | true |
Matroid.Indep.rankPos_of_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I.Nonempty → M.RankPos | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.