name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.HasSubgaussianMGF.sum_of_iIndepFun | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_2} {X : ι → Ω → ℝ},
ProbabilityTheory.iIndepFun X μ →
∀ {c : ι → NNReal} {s : Finset ι},
(∀ i ∈ s, ProbabilityTheory.HasSubgaussianMGF (X i) (c i) μ) →
ProbabilityTheory.HasSubgaussianMGF (fun ω => ∑ i ∈ s, X i ω) (∑... | null | true |
CategoryTheory.Abelian.Ext.mk₀_addEquiv₀_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (f : CategoryTheory.Abelian.Ext X Y 0),
CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.Abelian.Ext.addEquiv₀ f) = f | null | true |
MonomialOrder.leadingCoeff_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι},
(∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.leadingCoeff (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingCoeff (P i) | null | true |
CategoryTheory.MonObj.casesOn | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.MonObj X → Sort u} →
(t : CategoryTheory.MonObj X) →
((one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
... | null | false |
Lean.Server.FileWorker.EditableDocumentCore.mk.inj | Lean.Server.FileWorker.Utils | ∀ {«meta» : Lean.Server.DocumentMeta} {initSnap : Lean.Language.Lean.InitialSnapshot}
{cmdSnaps : Lean.AsyncList IO.Error Lean.Server.Snapshots.Snapshot}
{diagnosticsMutex : Std.Mutex Lean.Server.FileWorker.DiagnosticsState} {meta_1 : Lean.Server.DocumentMeta}
{initSnap_1 : Lean.Language.Lean.InitialSnapshot}
{... | null | true |
nonpos_of_add_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : AddZeroClass α] [inst_1 : LE α] [AddLeftReflectLE α], a + b ≤ a → b ≤ 0 | null | true |
Std.HashMap.getKey!_diff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, (m₁ \ m₂).getKey! k = if k ∈ m₂ then default else m₁.getKey! k | null | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer.0.SubMulAction.ofStabilizer._simp_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
Float32.rec._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.333 | Mathlib.Util.CompileInductive | {motive : Float32 → Sort u} → ((toModel : Float32.Model) → motive { toModel := toModel }) → (t : Float32) → motive t | null | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.substRHS.match_1 | Lean.Meta.Match.SimpH | (motive : Lean.Meta.FVarSubst × Lean.MVarId → Sort u_1) →
(x : Lean.Meta.FVarSubst × Lean.MVarId) →
((subst : Lean.Meta.FVarSubst) → (mvarId : Lean.MVarId) → motive (subst, mvarId)) → motive x | null | false |
Vector.toList_ofFn | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → α}, (Vector.ofFn f).toList = List.ofFn f | null | true |
OpenPartialHomeomorph.continuousAt_iff_continuousAt_comp_right | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) {f : Y → Z} {x : Y},
x ∈ e.target → (ContinuousAt f x ↔ ContinuousAt (f ∘ ↑e) (↑e.symm x)) | Continuity at a point can be read under right composition with an open partial homeomorphism, if
the point is in its target | true |
IsQuotientCoveringMap.toPermFiber | Mathlib.Topology.Covering.Quotient | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{f : E → X} →
{G : Type u_3} →
[inst_2 : Group G] →
[inst_3 : MulAction G E] → IsQuotientCoveringMap f G → (x : X) → G →* Equiv.Perm ↑(f ⁻¹' {x}) | A quotient covering map `f` induces a permutation action on each fiber. | true |
Combinatorics.Line.coe_injective | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_2} {ι : Type u_3} [Nontrivial α], Function.Injective Combinatorics.Line.toFun | null | true |
Std.Http.Header.Name.casesOn | Std.Http.Data.Headers.Name | {motive : Std.Http.Header.Name → Sort u} →
(t : Std.Http.Header.Name) →
((value : String) →
(isValidHeaderValue : Std.Http.Header.IsValidHeaderName value) →
(isLowerCase : Std.Http.Internal.IsLowerCase value) →
motive { value := value, isValidHeaderValue := isValidHeaderValue, isLowe... | null | false |
Lean.Doc.Parser.document.formatter | Lean.DocString.Formatter | Lean.PrettyPrinter.Formatter | null | true |
Equiv.setDiffEquiv | Mathlib.Logic.Equiv.Fintype | {α : Type u_1} →
{s t : Set α} → [inst : Fintype ↑s] → [inst_1 : Fintype ↑t] → Fintype.card ↑s = Fintype.card ↑t → ↑(s \ t) ≃ ↑(t \ s) | If two sets have the same finite cardinality, their set differences are equivalent. | true |
ContinuousAt.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ} {x : α},
ContinuousAt f x → ContinuousAt (fun y => Complex.exp (f y)) x | null | true |
Lean.Elab.abortTermExceptionId | Lean.Elab.Exception | Lean.InternalExceptionId | null | true |
Module.DirectLimit.congr_symm_apply_of | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] {G' : ι → Type u_5} [inst_5 : (i : ι) → AddCommMonoid (G' i)]
[inst_6 : (i : ι)... | null | true |
apply_le_nnnorm_cfc_nnreal._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
AddEquiv.coprodAssoc._proof_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ (M : Type u_1) (N : Type u_2) (P : Type u_3) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddMonoid P],
(AddMonoid.Coprod.lift (AddMonoid.Coprod.map (AddMonoidHom.id M) AddMonoid.Coprod.inl)
(AddMonoid.Coprod.inr.comp AddMonoid.Coprod.inr)).comp
(AddMonoid.Coprod.lift (AddMonoid.Coprod.inl.... | null | false |
CategoryTheory.Functor.FullyFaithful.mapAddGrp._proof_4 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] (hF : F.FullyFaithful) {X Y... | null | false |
FGModuleRepr.instCategory._aux_5 | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | (R : Type u_1) → [inst : Ring R] → {X Y Z : FGModuleRepr R} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
Lean.Core.mkSnapshot?._auto_1 | Lean.CoreM | Lean.Syntax | null | false |
CategoryTheory.Functor.isDenseAt_iff | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : D},
F.isDenseAt X ↔
Nonempty
(CategoryTheory.Limits.IsColimit
((CategoryTheory.Functor.LeftExtension.mk (CategoryTheory.Functor.id D) F.righ... | null | true |
LipschitzWith.min_const | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ} {Kf : NNReal},
LipschitzWith Kf f → ∀ (a : ℝ), LipschitzWith Kf fun x => min (f x) a | null | true |
IsClosed.isCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyPseudoMetrizableSpace X] {s : Set X},
IsClosed s → TopologicalSpace.IsCompletelyPseudoMetrizableSpace ↑s | A closed subset of a completely pseudometrizable space is also completely pseudometrizable. | true |
Std.DHashMap.Internal.exists_bucket' | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α]
(self : Array (Std.DHashMap.Internal.AssocList α β)) (i : USize) (hi : i.toNat < self.size),
∃ l,
(List.flatMap Std.DHashMap.Internal.AssocList.toList self.toList).Perm (self[i.toNat].toList ++ l) ∧
∀ [LawfulHashable α],
Std.DHas... | null | true |
PrimeMultiset.prod_sup | Mathlib.Data.PNat.Factors | ∀ (u v : PrimeMultiset), (u ⊔ v).prod = u.prod.lcm v.prod | null | true |
MeasureTheory.Measure.restrict_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (s : Set α), MeasureTheory.Measure.restrict 0 s = 0 | null | true |
ModelWithCorners.t1Space | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst : TopologicalSpace M] [ChartedSpace H M], T1Space M | Every manifold is a Fréchet space (T1 space) -- regardless of whether it is
Hausdorff. | true |
Lean.Parser.Tactic.anyGoals | Init.Tactics | Lean.ParserDescr | `any_goals tac` applies the tactic `tac` to every goal,
concatenating the resulting goals for successful tactic applications.
If the tactic fails on all of the goals, the entire `any_goals` tactic fails.
This tactic is like `all_goals try tac` except that it fails if none of the applications of `tac` succeeds.
| true |
LinearMap.IsSymmetric.toMatrix_eigenvectorBasis | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] {n : ℕ} (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E = n),
(LinearMap.toMatrix (hT.eigenvectorBasis hn).toBasis (hT.eigenvectorBasis hn).toBasis)... | null | true |
WittVector.polyOfInterest | Mathlib.RingTheory.WittVector.MulCoeff | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℕ → MvPolynomial (Fin 2 × ℕ) ℤ | This is the polynomial whose degree we want to get a handle on. | true |
Lean.PersistentHashMap.Zipper.consCollision.noConfusion | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u} →
{β : Type v} →
{P : Sort u_1} →
{keys : Subarray α} →
{vals : Subarray β} →
{a : Std.Slice.size keys = Std.Slice.size vals} →
{a_1 : Lean.PersistentHashMap.Zipper α β} →
{keys' : Subarray α} →
{vals' : Subarray β} →
... | null | false |
_private.Mathlib.Algebra.MonoidAlgebra.Defs.0.MonoidAlgebra.single_inj._simp_1_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {x y : MonoidAlgebra R M}, (x = y) = (x.coeff = y.coeff) | null | false |
_private.Lean.Level.0.Lean.Level.addOffsetAux.match_1 | Lean.Level | (motive : ℕ → Lean.Level → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Level) → ((u : Lean.Level) → motive 0 u) → ((n : ℕ) → (u : Lean.Level) → motive n.succ u) → motive x x_1 | null | false |
_private.Init.Data.Array.Range.0.Array.mk_add_mem_zipIdx_iff_getElem?._simp_1_2 | Init.Data.Array.Range | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | null | false |
TwoSidedIdeal.mem_mk | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {x : R} {c : RingCon R}, x ∈ TwoSidedIdeal.mk c ↔ c x 0 | null | true |
Lean.MetavarDecl | Lean.MetavarContext | Type | Information about a metavariable. | true |
Std.Internal.List.containsKey_maxKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false → ∀ {fallback : α}, Std.Internal.List.containsKey (Std.Internal.List.maxKeyD l fallback) l = true | null | true |
NonemptyFinLinOrd.instLargeCategory._proof_9 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(∀ {W X Y Z : NonemptyFinLinOrd} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | null | false |
setOf_minimal_antichain | Mathlib.Order.Antichain | ∀ {α : Type u_1} [inst : PartialOrder α] (P : α → Prop), IsAntichain (fun x1 x2 => x1 ≤ x2) {x | Minimal P x} | **Alias** of `setOfPred_minimal_antichain`. | true |
AddSubgroup.centralizer.eq_1 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.centralizer s = { toAddSubmonoid := AddSubmonoid.centralizer s, neg_mem' := ⋯ } | null | true |
IntermediateField.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B C : IntermediateField F E},
A ⊓ C = B ⊓ C → A.relrank C = B.relrank C | null | true |
AddMonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : M →+ N) (g : M →+ P), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
CategoryTheory.ObjectProperty.limitsClosure.of_isoClosure | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] {X Y : C} (e : X ≅ Y),
P.limitsClosure J X → P.limitsClosure J Y | null | true |
Std.TreeMap.keyAtIdx? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → ℕ → Option α | Returns the `n`-th smallest key, or `none` if `n` is at least `t.size`. | true |
Matrix.conjTransposeRingEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (α : Type v) [inst : NonUnitalNonAssocSemiring α] [inst_1 : StarRing α] [inst_2 : Fintype m]
(a : (Matrix m m α)ᵐᵒᵖ), (Matrix.conjTransposeRingEquiv m α).symm a = (MulOpposite.unop a).conjTranspose | null | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | null | false |
_private.Lean.Environment.0.Lean.importModulesCore.match_3 | Lean.Environment | (motive : Option Lean.ImportedModule✝ → Sort u_1) →
(x : Option Lean.ImportedModule✝) →
((mod : Lean.ImportedModule✝) → motive (some mod)) → ((x : Option Lean.ImportedModule✝) → motive x) → motive x | null | false |
CategoryTheory.Mon.instSymmetricCategory.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C],
CategoryTheory.Mon.instSymmetricCategory =
{ braiding := fun X Y => CategoryTheory.Mon.mkIso' (β_ X.X Y.X), braiding_naturality_right := ⋯,
braiding_natur... | null | true |
AddGroupNormClass.casesOn | Mathlib.Algebra.Order.Hom.GroupNorm | {F : Type u_4} →
{α : Type u_5} →
{β : Type u_6} →
[inst : AddGroup α] →
[inst_1 : AddCommMonoid β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : AddGroupNormClass F α β → Sort u} →
(t : AddGroupNormClass F α β) →
... | null | false |
Real.«_aux_Mathlib_Analysis_Real_Sqrt___macroRules_Real_term√__1» | Mathlib.Analysis.Real.Sqrt | Lean.Macro | null | false |
_private.Lean.Expr.0.Lean.Expr.getForallBody._sparseCasesOn_1 | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.evaluationLeftAdjoint_map_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {x d₂ : D} (f : x ⟶ d₂)
(x_1 : C),
((CategoryTheory.evaluationLeftAdjoint D c).map f).app x_1 =
CategoryT... | null | true |
Mathlib.Notation3.MatchState.getBinders | Mathlib.Util.Notation3 | Mathlib.Notation3.MatchState → Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinderParenthesized) | Get the accumulated array of delaborated terms for a given foldr/foldl.
Returns `#[]` if nothing has been pushed yet. | true |
NumberField.instCommRingInfiniteAdeleRing._proof_43 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | ∀ (K : Type u_1) [inst : Field K] (a b : NumberField.InfiniteAdeleRing K), a * b = b * a | null | false |
Lean.Server.Reference.aliases._default | Lean.Server.References | Array Lean.Lsp.RefIdent | null | false |
BoxIntegral.unitPartition.box_upper | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] (ν : ι → ℤ),
(BoxIntegral.unitPartition.box n ν).upper = fun i => (↑(ν i) + 1) / ↑n | null | true |
CategoryTheory.MonoidalCategory.selfRightAction_actionHomRight | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(x x_1 x_2 : C) (f : x_1 ⟶ x_2),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight x f =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft x f | null | true |
ContinuousLinearMap.toLinearMap₁₂ | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | {R : Type u_1} →
{𝕜₂ : Type u_3} →
{𝕜₃ : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
{G : Type u_7} →
[inst : Semiring R] →
[inst_1 : NormedField 𝕜₂] →
[inst_2 : NormedField 𝕜₃] →
[inst_3 : AddCommMonoid E] →
... | Send a continuous sesquilinear map to an abstract sesquilinear map (forgetting continuity). | true |
_private.Mathlib.FieldTheory.KummerExtension.0.exists_root_adjoin_eq_top_of_isCyclic.match_1_5 | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_2) [inst : Field K] (L : Type u_1) [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : ↥(OrderDual.ofDual ⊥) → Prop) (h : ↥(OrderDual.ofDual ⊥)),
(∀ (σ' : Gal(L/K)) (hσ' : σ' ∈ OrderDual.ofDual ⊥), motive ⟨σ', hσ'⟩) → motive h | null | false |
FreeSemigroup.noConfusion | Mathlib.Algebra.Free | {P : Sort u_1} →
{α : Type u} →
{t : FreeSemigroup α} →
{α' : Type u} → {t' : FreeSemigroup α'} → α = α' → t ≍ t' → FreeSemigroup.noConfusionType P t t' | null | false |
_private.Mathlib.RingTheory.Ideal.Over.0.Ideal.Quotient.ker_stabilizerHom._simp_1_2 | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {x y : R} [inst_1 : I.IsTwoSided],
((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) = (x - y ∈ I) | null | false |
Real.mk_zero | Mathlib.Basic.Real.Basic | Real.mk 0 = 0 | null | true |
List.Perm.union | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {l₁ l₂ t₁ t₂ : List α}, l₁.Perm l₂ → t₁.Perm t₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₂) | null | true |
OrderIso.map_ciInf | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddBelow (Set.range f) → e (⨅ i, f i) = ⨅ i, e (f i) | null | true |
meromorphicOrderAt_const_smul_eq_meromorphicOrderAt | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 𝕜} {f : 𝕜 → E} {s : 𝕜}, s ≠ 0 → meromorphicOrderAt (s • f) x = meromorphicOrderAt f x | meromorphicOrderAt is invariant under scaling. | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation._proof_1 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice),
WellFounded (InvImage WellFoundedRelation.rel fun it => it.internalState.currPos) | null | false |
_private.Std.Http.Data.Body.Full.0.Std.Http.Body.Full.mk.inj | Std.Http.Data.Body.Full | ∀ {data : ByteArray} {state : Std.Mutex Std.Http.Body.Full.State✝} {data_1 : ByteArray}
{state_1 : Std.Mutex Std.Http.Body.Full.State✝},
{ data := data, state := state } = { data := data_1, state := state_1 } → data = data_1 ∧ state = state_1 | null | true |
Std.Sat.CNF.sat_empty._simp_1 | Std.Sat.CNF.Sat | ∀ {α : Type u_1} {assign : α → Bool}, Std.Sat.CNF.Sat assign Std.Sat.CNF.empty = True | null | false |
Lean.Core.State.messages | Lean.CoreM | Lean.Core.State → Lean.MessageLog | Message log. | true |
List.reflBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], ReflBEq (List α) ↔ ReflBEq α | null | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.not_isNonloop_iff_closure._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e = (M.closure {e} = M.loops ∧ e ∈ M.E) | null | false |
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp_assoc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F G : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j ... | null | true |
Std.ExtTreeSet.mem_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k : α}, k ∈ t.insertMany l ↔ k ∈ t ∨ l.contains k = true | null | true |
Lean.Grind.AC.Seq.endsWithVar_k_var | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var), (Lean.Grind.AC.Seq.var y).endsWithVar_k x = (x == y) | null | true |
Aesop.SimpTheorems.foldSimpEntries | Aesop.Util.Basic | {σ : Type u_1} → (σ → Lean.Meta.SimpEntry → σ) → σ → Lean.Meta.SimpTheorems → σ | null | true |
_private.Mathlib.Topology.Algebra.MetricSpace.Lipschitz.0.LocallyLipschitzOn.exists_lipschitzOnWith_of_compact.match_1_5 | Mathlib.Topology.Algebra.MetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {s : Set α}
(ε : (x : α) → x ∈ s → ℝ) (x : α) (hx : x ∈ s)
(motive : BddAbove ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx))) → Prop)
(x_1 : BddAbove ((fun y => dist (f x) (f y) / dist ... | null | false |
IntervalIntegrable.iff_comp_neg._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | null | false |
Ideal.ramificationIdx_le_finrank | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] (S : Type v) [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDedekindDomain S]
(K : Type u_1) (L : Type u_2) [inst_4 : Field K] [inst_5 : Field L] [IsDedekindDomain R] [inst_7 : Algebra R K]
[IsFractionRing R K] [inst_9 : Algebra S L] [IsFractionRing S L] [inst_11 : Algebra K L] [... | null | true |
LieAlgebra.Orthogonal.JD | Mathlib.Algebra.Lie.Classical | (l : Type u_4) → (R : Type u₂) → [DecidableEq l] → [CommRing R] → Matrix (l ⊕ l) (l ⊕ l) R | A matrix defining a canonical even-rank symmetric bilinear form.
It looks like this as a `2l x 2l` matrix of `l x l` blocks:
```
[ 0 1 ]
[ 1 0 ]
```
| true |
Nat.any._f | Init.Data.Nat.Fold | (x : ℕ) → Nat.below (motive := fun x => ((i : ℕ) → i < x → Bool) → Bool) x → ((i : ℕ) → i < x → Bool) → Bool | null | false |
εNFA.stepSet | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → Set σ → α → Set σ | `M.stepSet S a` is the union of the ε-closure of `M.step s a` for all `s ∈ S`. | true |
CategoryTheory.Subobject.inf_comp_right_assoc | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A : C}
(f g : CategoryTheory.Subobject A) {Z : C} (h : A ⟶ Z),
CategoryTheory.CategoryStruct.comp ((f ⊓ g).ofLE g ⋯) (CategoryTheory.CategoryStruct.comp g.arrow h) =
CategoryTheory.CategoryStruct.comp (f... | null | true |
CategoryTheory.Functor.hasPointwiseRightKanExtensionAt_of_equivalence | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {D' : Type u_3} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} D']
[inst_3 : CategoryTheory.Category.{v_4, u_4} H] (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor ... | null | true |
Turing.TM2to1.StAct.push.sizeOf_spec | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {σ : Type u_4} {k : K} [inst : SizeOf K] [inst_1 : (a : K) → SizeOf (Γ a)]
[inst_2 : SizeOf σ] (a : σ → Γ k), sizeOf (Turing.TM2to1.StAct.push a) = 1 | null | true |
Std.Do.SPred.and_or_elim_l | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R T : Std.Do.SPred σs}, (P ∧ R ⊢ₛ T) → (Q ∧ R ⊢ₛ T) → (P ∨ Q) ∧ R ⊢ₛ T | null | true |
differentiableWithinAt_sub_const_iff | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithin... | null | true |
Continuous.measurable | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ] [BorelSpace γ] {f : α → γ}, Continuous f → Measurable f | A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is measurable. | true |
CategoryTheory.Discrete.functor_obj_eq_as | Mathlib.CategoryTheory.Discrete.Basic | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (X : CategoryTheory.Discrete I),
(CategoryTheory.Discrete.functor F).obj X = F X.as | null | true |
Lean.IR.IRType._sizeOf_3_eq | Lean.Compiler.IR.Basic | ∀ (x : List Lean.IR.IRType), Lean.IR.IRType._sizeOf_3 x = sizeOf x | null | false |
_private.Mathlib.Algebra.SkewPolynomial.Basic.0.SkewPolynomial.monomial_eq_monomial_iff._simp_1_1 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k),
(fun₀ | a => b) = (SkewMonoidAlgebra.single a b).coeff | null | false |
CategoryTheory.Under.isLeftAdjoint_post | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : CategoryTheory.Functor T D) [F.IsLeftAdjoint], (CategoryTheory.Under.post F).IsLeftAdjoint | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functor_ext._proof_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C]
{F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C},
(∀ (i : J.L),
F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) =
G.obj (CategoryTheory.Limits.WalkingMultico... | null | false |
groupHomology.cyclesOfIsCycle₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (x : G →₀ A),
groupHomology.IsCycle₁ x → x ∈ groupHomology.cycles₁ (Rep.ofDistribMulAction k G A) | null | false |
Finset.sum_indicator_subset | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] (f : ι → β) {s t : Finset ι},
s ⊆ t → ∑ i ∈ t, (↑s).indicator f i = ∑ i ∈ s, f i | Summing an indicator function over a possibly larger `Finset` is the same as
summing the original function over the original finset. | true |
SupHom.mk.sizeOf_spec | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_6} {β : Type u_7} [inst : Max α] [inst_1 : Max β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b), sizeOf { toFun := toFun, map_sup' := map_sup' } = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.