name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
control.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {n : Type u → Type w} [inst : MonadControlT m n] [inst_1 : Bind n] {α : Type u}
(f : ({β : Type u} → n β → m (stM m n β)) → m (stM m n α)), control f = controlAt m f | null | true |
Std.Rxc.Iterator.instIteratorLoop.loop._proof_2 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] (LargeEnough : α → Prop),
(∀ (a b : α), a ≤ b → LargeEnough a → LargeEnough b) →
∀ (next : α), LargeEnough next → ∀ (next' : α), Std.PRange.succ? next = some next... | null | false |
PowerSeries.IsWeierstrassFactorizationAt.algEquivQuotient_apply | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {f : Polynomial A} {h : PowerSeries A} {I : Ideal A}
(H : g.IsWeierstrassFactorizationAt f h I) [inst_1 : IsAdicComplete I A] (a : Polynomial A ⧸ Ideal.span {f}),
H.algEquivQuotient a =
(Ideal.quotientEquivAlgOfEq A ⋯) ((Ideal.quotientMapₐ (Ideal.span {↑f... | null | true |
CategoryTheory.Limits.Cocone.ofCotrident._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C}
(t : CategoryTheory.Limits.Cotrident fun j => F.map (CategoryTheory.Limits.WalkingParallelFamily.Hom.line j))
(j j' : CategoryTheory.Limits.WalkingParallelFa... | null | false |
Inclusion.InclusionM.Context | Mathlib.Tactic.Inclusion.Core.Types | Type | The fixed context of the `InclusionM` monad. | true |
CategoryTheory.Equivalence.instMonoidalInverseSymmOfFunctor._proof_7 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal],
autoParam
(∀ (X Y : C),
CategoryTheory.Catego... | null | false |
_private.Mathlib.Order.PartialSups.0.partialSups_eq_sup'_range._simp_1_1 | Mathlib.Order.PartialSups | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
_private.Mathlib.RingTheory.Polynomial.Pochhammer.0.ascPochhammer_nat_eval_succ.match_1_1 | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | null | false |
OnePoint.IsZeroAt | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | OnePoint ℝ → (UpperHalfPlane → ℂ) → ℤ → Prop | We say `f` is zero at `c` if, for all `g` with `g • ∞ = c`, the function `f ∣[k] g` is
zero at `∞`. | true |
Affine.Simplex.affineCombination_mem_closedInterior_face_iff_mem_Icc | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [inst_4 : PartialOrder k] {n : ℕ} (s : Affine.Simplex k P n) {fs : Finset (Fin (n + 1))}
{m : ℕ} (h : fs.card = m + 1) {w : Fin (n + 1) → k},
∑ i, w i = 1 →
((Finset.affineCo... | null | true |
FractionalIdeal.mul_right_strictMono | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_2} (K : Type u_3) [inst : CommRing A] [inst_1 : Field K] [IsDedekindDomain A] [inst_3 : Algebra A K]
[IsFractionRing A K] {I : FractionalIdeal (nonZeroDivisors A) K}, I ≠ 0 → StrictMono fun x => I * x | null | true |
complete_of_compact | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [inst : UniformSpace α] [CompactSpace α], CompleteSpace α | null | true |
Lean.instBEqLiteral | Lean.Expr | BEq Lean.Literal | null | true |
CategoryTheory.MorphismProperty.IsCardinalForSmallObjectArgument.locallySmall._autoParam | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | Lean.Syntax | null | false |
ENat.instIsTopologicalSemiring | Mathlib.Topology.Instances.ENat | IsTopologicalSemiring ℕ∞ | null | true |
isNilpotent_neg_iff | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {x : R} [inst : Ring R], IsNilpotent (-x) ↔ IsNilpotent x | null | true |
CategoryTheory.SimplicialObject.δ_δ₀Iter'._proof_8 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {n : ℕ} (j : ℕ) {m : ℕ}, autoParam (n + j = m) CategoryTheory.SimplicialObject.δ_δ₀Iter'._auto_1 → n + 1 + j = m + 1 | null | false |
Set.mem_powerset_iff._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (x s : Set α), (x ∈ 𝒫 s) = (x ⊆ s) | null | false |
MonoidHom.coeFn._proof_1 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ (α : Type u_1) (β : Type u_2) [inst : MulOneClass α] [inst_1 : CommMonoid β], ⇑1 = ⇑1 | null | false |
AddConstEquiv.recOn | Mathlib.Algebra.AddConstMap.Equiv | {G : Type u_1} →
{H : Type u_2} →
[inst : Add G] →
[inst_1 : Add H] →
{a : G} →
{b : H} →
{motive : AddConstEquiv G H a b → Sort u} →
(t : AddConstEquiv G H a b) →
((toEquiv : G ≃ H) →
(map_add_const' : ∀ (x : G), toEquiv.toFun ... | null | false |
Mathlib.Tactic.BicategoryLike.MonadCoherenceHom.mk | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.CoherenceHom → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
Mathlib.Tactic.BicategoryLike.MonadCoherenceHom m | null | true |
Lean.PersistentEnvExtension.ctorIdx | Lean.Environment | {α β σ : Type} → Lean.PersistentEnvExtension α β σ → ℕ | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCast.match_5 | Lean.Meta.CongrTheorems | (motive : Lean.Meta.EqInfo✝ → Sort u_1) →
(eq : Lean.Meta.EqInfo✝) →
((fvarId : Lean.FVarId) → motive (Lean.Meta.EqInfo.hyp✝ fvarId)) →
((lhsFVarId rhsFVarId : Lean.FVarId) → motive (Lean.Meta.EqInfo.decSubsingleton✝ lhsFVarId rhsFVarId)) → motive eq | null | false |
TopologicalSpace.Clopens.mk.sizeOf_spec | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] [inst_1 : SizeOf α] (carrier : Set α) (isClopen' : IsClopen carrier),
sizeOf { carrier := carrier, isClopen' := isClopen' } = 1 + sizeOf isClopen' | null | true |
Batteries.Tactic.Lemma.elabLemma | Batteries.Tactic.Lemma | Lean.Elab.Command.CommandElab | Elaborator for the `lemma` command, if the option `lang.lemmaCmd` is false the command
emits a warning and code action instructing the user to use `theorem` instead. | true |
Polynomial.instInhabitedSplittingField | Mathlib.FieldTheory.SplittingField.Construction | {K : Type u_1} → [inst : Field K] → (f : Polynomial K) → Inhabited f.SplittingField | null | true |
Units.instMinOfLinearOrder.eq_1 | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : LinearOrder α],
Units.instMinOfLinearOrder = { min := fun a b => if a ≤ b then a else b } | null | true |
Std.TreeSet.Raw.min!_eq_minD_default | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.min! = t.minD default | null | true |
Lean.Meta.Grind.Arith.Linear.isLinearOrder | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.Meta.Grind.Arith.Linear.LinearM Bool | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.dimension_level_one._proof_1_10 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ (k : ℕ), 12 ≤ k → (k - 12) % 12 = k % 12 | null | false |
_private.Mathlib.Data.Multiset.Pi.0.Multiset.Pi.cons_swap._simp_1_1 | Mathlib.Data.Multiset.Pi | ∀ {α : Sort u_1} {a b : α}, (a ≍ b) = (a = b) | null | false |
Nat.cast_id | Mathlib.Data.Nat.Cast.Basic | ∀ (n : ℕ), ↑n = n | null | true |
CategoryTheory.Functor.mapComposableArrowsObjMk₂Iso._proof_5 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(((G.mapComposableArrows 2).obj (CategoryTheory.ComposableArrows.mk₂ f g)).map'... | null | false |
IsWeakLowerModularLattice | Mathlib.Order.ModularLattice | (α : Type u_2) → [Lattice α] → Prop | A weakly lower modular lattice is a lattice where `a` and `b` cover `a ⊓ b` if `a ⊔ b` covers
both `a` and `b`. | true |
Filter.tendsto_Ioi_atTop | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [IsDirectedOrder α] {a : α} {f : β → ↑(Set.Ioi a)} {l : Filter β},
Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atTop | null | true |
CategoryTheory.ReflPrefunctor.«_aux_Mathlib_Combinatorics_Quiver_ReflQuiver___macroRules_CategoryTheory_ReflPrefunctor_term𝟭rq_1» | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.Macro | null | false |
Lean.Parser.Tactic.instInhabitedMCasesPat | Std.Tactic.Do.Syntax | Inhabited Lean.Parser.Tactic.MCasesPat | null | true |
_private.Mathlib.Data.List.Destutter.0.List.isChain_destutter.match_1_1 | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (_ : Unit), motive []) → (∀ (h : α) (l : List α), motive (h :: l)) → motive x | null | false |
Nucleus.instSemilatticeInf._proof_2 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] {x y : Nucleus X}, ⇑y < ⇑x ↔ ⇑y < ⇑x | null | false |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.integral_Icc_deriv_smul_of_deriv_nonneg._proof_1_3 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {f : ℝ → ℝ} {a b : ℝ}, f '' Set.Icc a b \ f '' Set.Ioo a b ⊆ {f a, f b} | null | false |
Lean.Server.FileWorker.SignatureHelp.Candidate.kind | Lean.Server.FileWorker.SignatureHelp | Lean.Server.FileWorker.SignatureHelp.Candidate → Lean.Server.FileWorker.SignatureHelp.CandidateKind | null | true |
CategoryTheory.Limits.Cowedge.ext._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)}
{W₁ W₂ : CategoryTheory.Limits.Cowedge F} (e : W₁.pt ≅ W₂.pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp (CategoryT... | null | false |
_private.Mathlib.CategoryTheory.EffectiveEpi.Comp.0.CategoryTheory.effectiveEpiFamilyStructCompIso_aux._proof_1_1 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B B' : C} {α : Type u_3} (X : α → C)
(π : (a : α) → X a ⟶ B) (i : B ⟶ B') {W : C} (e : (a : α) → X a ⟶ W),
(∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (π a₁) i)... | null | false |
CategoryTheory.PreGaloisCategory.autMap_comp | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.PreGaloisCategory.IsConnected X] [inst_3 : CategoryTheory.PreGaloisCategory.IsGalois Y]
[inst_4 : CategoryTheory.PreGaloisCategory.IsGalois Z] (f : X ⟶ Y) (g : Y ⟶ Z),
Catego... | null | true |
_private.Mathlib.Order.Filter.AtTopBot.Interval.0.Finset.tendsto_Icc_atBot_prod_atTop._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {m : α → β} {f : Filter α},
Filter.Tendsto m f Filter.atTop = ∀ (b : β), ∀ᶠ (a : α) in f, b ≤ m a | null | false |
CategoryTheory.Limits.FormalCoproduct.eval._proof_9 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasCoproducts A]
{X Y Z : CategoryTheory.Functor C A} (f : X ⟶ Y) (g : Y ⟶ Z),
{ app := fun f_1 => CategoryTheory.Limits.Sigma.map fun i => (CategoryTheory.... | null | false |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.initGrindNorm._regBuiltin.Lean.Parser.Command.initGrindNorm.parenthesizer_9 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
_private.Mathlib.Data.Multiset.MapFold.0.Multiset.exists_multiset_eq_map_quot_mk.match_1_1 | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {r : α → α → Prop} (_s : Multiset (Quot r)) (motive : (∃ t, _s = Multiset.map (Quot.mk r) t) → Prop)
(x : ∃ t, _s = Multiset.map (Quot.mk r) t),
(∀ (t : Multiset α) (ht : _s = Multiset.map (Quot.mk r) t), motive ⋯) → motive x | null | false |
List.swap.eq_4 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (a : α) (xs : List α) (i : ℕ), (a :: xs).swap i.succ 0 = xs[i]?.getD a :: xs.set i a | null | true |
Std.TreeMap.Raw.Equiv.keyAtIdxD_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {i : ℕ}
{fallback : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.keyAtIdxD i fallback = t₂.keyAtIdxD i fallback | null | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.ofRestrict | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : TopCat} (Y : AlgebraicGeometry.SheafedSpace C)
{f : X ⟶ ↑Y.toPresheafedSpace} (hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (Y.ofRestrict hf) | null | true |
CategoryTheory.Functor.commShiftIso_hom_naturality | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : F.CommShift A] {X Y : C}
(f :... | null | true |
CategoryTheory.ReflexiveRelation._sizeOf_inst | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{R X : C} → (p₁ p₂ : R ⟶ X) → [SizeOf C] → SizeOf (CategoryTheory.ReflexiveRelation p₁ p₂) | null | false |
Std.Http.Internal.Mock.Server._sizeOf_inst | Std.Http.Transport | SizeOf Std.Http.Internal.Mock.Server | null | false |
Lean.instBEqSourceInfo_lean | Lean.Syntax | BEq Lean.SourceInfo | null | true |
Lean.ConstructorVal.cidx | Lean.Declaration | Lean.ConstructorVal → ℕ | Constructor index (i.e., Position in the inductive declaration) | true |
_private.Lean.Meta.Basic.0.Lean.Meta.fvarsSizeLtMaxFVars.match_1 | Lean.Meta.Basic | (motive : Option ℕ → Sort u_1) →
(maxFVars? : Option ℕ) → ((maxFVars : ℕ) → motive (some maxFVars)) → (Unit → motive none) → motive maxFVars? | null | false |
Algebra.Generators.ofComp.eq_1 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{ι' : Type u_3} {T : Type u_7} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (Q : Algebra.Generators S T ι') (P : Algebra.Generators R S ι),
Q.ofComp P = {... | null | true |
RpcEncodablePacket._@.Mathlib.Tactic.Widget.Calc.1713132172._hygCtx._hyg.1 | Mathlib.Tactic.Widget.Calc | Type | null | false |
CategoryTheory.Iso.app._proof_4 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C),
CategoryTheory.CategoryStruct.comp (α.inv.app X) (α.hom.app X) = CategoryTheory.CategoryStruct.id (G.obj X) | null | false |
KaehlerDifferential.polynomialEquiv._proof_5 | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u_1) [inst : CommRing R], RingHomInvPair (RingHom.id (Polynomial R)) (RingHom.id (Polynomial R)) | null | false |
Lean.Elab.Tactic.simpOnlyBuiltins | Lean.Elab.Tactic.Simp | List Lean.Name | null | true |
Option.attachWith.match_1 | Init.Data.Option.Attach | {α : Type u_1} →
(P : α → Prop) →
(motive : (xs : Option α) → (∀ (x : α), xs = some x → P x) → Sort u_2) →
(xs : Option α) →
(H : ∀ (x : α), xs = some x → P x) →
((H : ∀ (x : α), none = some x → P x) → motive none H) →
((x : α) → (H : ∀ (x_1 : α), some x = some x_1 → P x_1) → m... | null | false |
_private.Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic.0.DomMulAct.dist_smul_Lp._simp_1_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_1} {α : Type u_3} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure α} {p : ENNReal} [inst_2 : SMul M α] [inst_3 : MeasureTheory.SMulInvariantMeasure M α μ]
[inst_4 : MeasurableConstSMul M α] (c : Mᵈᵐᵃ) (f : ↥(MeasureTheory.Lp E p μ)), -(c • f) = c • ... | null | false |
SimpleGraph.neighborFinset_def | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)],
G.neighborFinset v = (G.neighborSet v).toFinset | null | true |
Std.Internal.List.minKeyD_insertEntryIfNew_le_minKeyD | 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 →
∀ {k : α} {v : β k} {fallback : α},
(compare (Std.Internal.List.minKeyD (Std.Internal.List.insertEntryIfNew k v l... | null | true |
extDeriv_apply_vectorField | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ} {x : E}
{ω : E → E [⋀^Fin (n + 1)]→L[𝕜] F} {V : Fin (n + 2) → E → E},
DifferentiableAt 𝕜 ω x →
(... | If `ω` is a differentiable `(n + 1)`-form and `V i` are `n + 2` differentiable vector fields, then
$$
dω(V_0(x), \dots, V_{n + 1}(x)) =
\sum_{i=0}^{n + 1} (-1)^i •
D_x\left(ω\big(x; V_0(x), \dots, \widehat{V_i(x)}, \dots, V_{n + 1}(x)\big)\right)(V_i(x)) -
\sum_{0 \le i \le j\le n} (-1)^{i + j}
... | true |
NonUnitalSubsemiring.mem_iInf._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {ι : Sort u_1} {S : ι → NonUnitalSubsemiring R} {x : R},
(x ∈ ⨅ i, S i) = ∀ (i : ι), x ∈ S i | null | false |
AlgebraicGeometry.Scheme.Hom.stalkMap_hom_inv | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y) (y : ↥Y),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.stalkMap e.hom (e.inv y))
(AlgebraicGeometry.Scheme.Hom.stalkMap e.inv y) =
(Y.presheaf.stalkCongr ⋯).hom | null | true |
Std.Internal.List.getValueCast? | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [inst : BEq α] → [LawfulBEq α] → (a : α) → List ((a : α) × β a) → Option (β a) | Internal implementation detail of the hash map | true |
KStar.rec | Mathlib.Algebra.Order.Kleene | {α : Type u_5} → {motive : KStar α → Sort u} → ((kstar : α → α) → motive { kstar := kstar }) → (t : KStar α) → motive t | null | false |
ProfiniteGrp.ofProfinite | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | (G : Profinite) → [inst : Group ↑G.toTop] → [IsTopologicalGroup ↑G.toTop] → ProfiniteGrp.{u_1} | Construct a term of `ProfiniteGrp` from a type endowed with the structure of a
profinite topological group. | true |
MonoidWithZeroHom.instCommGroupWithZeroValueGroup₀._proof_1 | Mathlib.Algebra.GroupWithZero.Range | ∀ {B : Type u_1} [inst : CommGroupWithZero B], SubmonoidClass (Subgroup Bˣ) Bˣ | null | false |
MeasureTheory.LevyProkhorov.instPseudoEMetricSpaceMeasure | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | {Ω : Type u_1} →
[inst : MeasurableSpace Ω] →
[inst_1 : PseudoEMetricSpace Ω] →
[OpensMeasurableSpace Ω] → PseudoEMetricSpace (MeasureTheory.LevyProkhorov (MeasureTheory.Measure Ω)) | The Lévy-Prokhorov distance `levyProkhorovEDist` makes `Measure Ω` a pseudoemetric
space. The instance is recorded on the type synonym `LevyProkhorov (Measure Ω) := Measure Ω`. | true |
Finsupp.support_nonempty_iff._simp_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M}, f.support.Nonempty = (f ≠ 0) | null | false |
Submonoid.saturation | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → [inst : MulOneClass M] → Submonoid M → SaturatedSubmonoid M | The saturation of a submonoid `s` is the intersection of all saturated submonoids that contain
`s`.
If `M` is a commutative monoid, then this is `{x : M | ∃ y : M, x * y ∈ s}`. | true |
Equiv.monoid.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Monoid β], e.monoid = Function.Injective.monoid ⇑e ⋯ ⋯ ⋯ ⋯ | null | true |
CategoryTheory.Limits.WalkingParallelPairHom | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | CategoryTheory.Limits.WalkingParallelPair → CategoryTheory.Limits.WalkingParallelPair → Type | The type family of morphisms for the diagram indexing a (co)equalizer. | true |
Lean.SCC.Data._sizeOf_1 | Lean.Util.SCC | Lean.SCC.Data → ℕ | null | false |
AddSubgroup.comap_inf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] (H K : AddSubgroup N) (f : G →+ N),
AddSubgroup.comap f (H ⊓ K) = AddSubgroup.comap f H ⊓ AddSubgroup.comap f K | null | true |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.obj_succ_eq | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : Type u} [inst_1 : LinearOrder J]
[inst_2 : SuccOrder J] {j : J},
¬IsMax j →
∀ (F : CategoryTheory.Functor (↑(Set.Iic j)) C) (X : C),
CategoryTheory.SmallObject.SuccStruct.extendToSucc.obj F X ⟨Order.succ j, ⋯⟩ = X | null | true |
AlgebraNorm.restriction._proof_3 | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_2} [inst : SeminormedCommRing R] {S : Type u_1} [inst_1 : Ring S] [inst_2 : Algebra R S]
(A : Subalgebra R S) (f : AlgebraNorm R S) (x y : ↥A), f (↑x + ↑y) ≤ f ↑x + f ↑y | null | false |
AddSubmonoid.IsLocalizationMap.exists_of_eq | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {N : Type u_2} [inst_1 : AddCommMonoid N] {S : AddSubmonoid M} {f : M → N},
S.IsLocalizationMap f → ∀ {x y : M}, f x = f y → ∃ c, ↑c + x = ↑c + y | null | true |
ImportGraph.Widget.GoToModuleProps.mk.inj | ImportGraph.Widget.GoToModule | ∀ {modName : Lean.Name} {pos : Lean.Lsp.Position} {overrideText : Option String} {modName_1 : Lean.Name}
{pos_1 : Lean.Lsp.Position} {overrideText_1 : Option String},
{ modName := modName, pos := pos, overrideText := overrideText } =
{ modName := modName_1, pos := pos_1, overrideText := overrideText_1 } →
... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_filterMap_of_getKey?_eq_some._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
NumberField.hermiteTheorem.finite_of_discr_bdd_of_isComplex | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ (A : Type u_2) [inst : Field A] [inst_1 : CharZero A] (N : ℕ),
{K | {w | w.IsComplex}.Nonempty ∧ |NumberField.discr ↥↑K| ≤ ↑N}.Finite | null | true |
OmegaCompletePartialOrder.ωScottContinuous_iff_monotone_map_ωSup | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β] {f : α → β},
OmegaCompletePartialOrder.ωScottContinuous f ↔
∃ (hf : Monotone f),
∀ (c : OmegaCompletePartialOrder.Chain α),
f (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSu... | `ωScottContinuous f` asserts that `f` is both monotone and distributes over ωSup. | true |
SNum.bit_zero | Mathlib.Data.Num.Bitwise | ∀ (b : Bool), SNum.bit b (SNum.zero b) = SNum.zero b | null | true |
NonarchAddGroupSeminorm._sizeOf_1 | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} → {inst : AddGroup G} → [SizeOf G] → NonarchAddGroupSeminorm G → ℕ | null | false |
CategoryTheory.ShortComplex.Homotopy.compRight_h₃ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)
(ψ : S₂ ⟶ S₃), (h.compRight ψ).h₃ = CategoryTheory.CategoryStruct.comp h.h₃ ψ.τ₃ | null | true |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.IsCoprime.mulVecSL._simp_1_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalCommSemiring α] [inst_1 : Fintype n] (A : Matrix m n α)
(x : n → α), A.mulVec x = Matrix.vecMul x A.transpose | null | false |
_private.Mathlib.Data.Set.NAry.0.Set.image2_subset_iff_right._simp_1_1 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (f '' s ⊆ t) = (s ⊆ f ⁻¹' t) | null | false |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.liftOption._sparseCasesOn_1 | Std.Http.Protocol.H1.Parser | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.CategoryTheory.Abelian.SerreClass.Localization.0.CategoryTheory.ObjectProperty.SerreClassLocalization.isZero_obj_iff._simp_1_1 | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Mathlib.Tactic.Bicategory.eval_of | Mathlib.Tactic.CategoryTheory.Bicategory.Normalize | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl f).hom
(CategoryTheory.CategoryStruct.comp η (CategoryTheory.Iso.refl g).hom) | null | true |
CategoryTheory.FinCategory.asTypeEquivObjAsType._proof_6 | Mathlib.CategoryTheory.FinCategory.AsType | ∀ (α : Type u_1) [inst : Fintype α] [inst_1 : CategoryTheory.SmallCategory α] [inst_2 : CategoryTheory.FinCategory α]
(X : CategoryTheory.FinCategory.AsType α),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.FinCategory.asTypeToObjAsType α).map
((CategoryTheory.NatIso.ofComponents CategoryTheory.... | null | false |
AEMeasurable.mono_ac | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
{μ ν : MeasureTheory.Measure α}, AEMeasurable f μ → ν.AbsolutelyContinuous μ → AEMeasurable f ν | null | true |
LSeries.abscissaOfAbsConv_le_of_le_const | Mathlib.NumberTheory.LSeries.Convergence | ∀ {f : ℕ → ℂ}, (∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C) → LSeries.abscissaOfAbsConv f ≤ 1 | If `f` is bounded, then the abscissa of absolute convergence of `f` is bounded above by `1`. | true |
Ideal.ofRel | Mathlib.RingTheory.Ideal.Span | {α : Type u} → [inst : Semiring α] → (α → α → Prop) → Ideal α | The ideal generated by an arbitrary binary relation. | true |
Std.ExtDTreeMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{a fallback : α}, t.contains a = true → t.getKey? a = some (t.getKeyD a fallback) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.