name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Kernel.borelMarkovFromReal.congr_simp | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {mα : MeasurableSpace α} (Ω : Type u_5) [inst : Nonempty Ω] [inst_1 : MeasurableSpace Ω]
[inst_2 : StandardBorelSpace Ω] (η η_1 : ProbabilityTheory.Kernel α ℝ),
η = η_1 → ProbabilityTheory.Kernel.borelMarkovFromReal Ω η = ProbabilityTheory.Kernel.borelMarkovFromReal Ω η_1 | null | true |
Lean.Meta.UnificationHintEntry.mk.sizeOf_spec | Lean.Meta.UnificationHint | ∀ (keys : Array Lean.Meta.UnificationHintKey) (val : Lean.Name),
sizeOf { keys := keys, val := val } = 1 + sizeOf keys + sizeOf val | null | true |
Equiv.pemptyArrowEquivPUnit | Mathlib.Logic.Equiv.Defs | (α : Sort u_1) → (PEmpty.{u_2} → α) ≃ PUnit.{u} | The sort of maps from `PEmpty` is equivalent to `PUnit`. | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff_ae_restrict'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {a b : Prop}, (a = b) = (a ↔ b) | null | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.next_reverse_eq_prev._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (hs : s.Nodup) (x : α) (hx : x ∈ s),
s.next hs x hx = s.reverse.prev ⋯ x ⋯ | null | false |
CategoryTheory.Cat.FreeRefl.lift | Mathlib.CategoryTheory.Category.ReflQuiv | {V : Type u_1} →
[inst : CategoryTheory.ReflQuiver V] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
V ⥤rq D → CategoryTheory.Functor (CategoryTheory.Cat.FreeRefl V) D | Constructor for functors from `FreeRefl`.
(See also `lift'` for which the data is unbundled.) | true |
PerfectClosure.instNeg | Mathlib.FieldTheory.PerfectClosure | (K : Type u) →
[inst : CommRing K] → (p : ℕ) → [inst_1 : Fact (Nat.Prime p)] → [inst_2 : CharP K p] → Neg (PerfectClosure K p) | null | true |
CategoryTheory.LocalizerMorphism.RightResolution._sizeOf_1 | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | null | false |
AddSubsemigroup.coe_op | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (x : AddSubsemigroup M), ↑x.op = AddOpposite.unop ⁻¹' ↑x | null | true |
CategoryTheory.monoidalUnopUnop._proof_14 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᵒᵖᵒᵖ} (X' : Cᵒᵖᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' ... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | @Orientation.definition✝ = @Orientation.definition✝ | null | false |
Polynomial.mapRingHom_comp_C | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(Polynomial.mapRingHom f).comp Polynomial.C = Polynomial.C.comp f | null | true |
CategoryTheory.instBicategoryMonoidalSingleObj._proof_6 | Mathlib.CategoryTheory.Bicategory.SingleObj | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b : CategoryTheory.MonoidalSingleObj C} {f g : C} (η : f ⟶ g),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) η =
CategoryTheory.CategoryStruct.c... | null | false |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [... | null | true |
CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) | The forgetful functor from rings to semirings preserves all limits.
| true |
_private.Init.Data.List.Basic.0.List.getLastD.match_1.eq_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → α → Sort u_2) (a₀ : α) (h_1 : (a₀ : α) → motive [] a₀)
(h_2 : (a : α) → (as : List α) → (x : α) → motive (a :: as) x),
(match [], a₀ with
| [], a₀ => h_1 a₀
| a :: as, x => h_2 a as x) =
h_1 a₀ | null | true |
VectorBundleCore.moduleFiber._proof_3 | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_4} (Z : VectorBundleCore R B F ι) (x : B)
(x_1 y : R) (b : Z.Fiber x), (x_1 * y) • b = x_1 • y • b | null | false |
Aesop.Script.Tactic.sTactic? | Aesop.Script.Tactic | Aesop.Script.Tactic → Option Aesop.Script.STactic | null | true |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.recommendedSpellingByNameExt.match_1 | Lean.Parser.Term.Doc | (motive : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name → Sort u_1) →
(x : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name) →
((rec : Lean.Parser.Term.Doc.RecommendedSpelling) → (xs : Array Lean.Name) → motive (rec, xs)) → motive x | null | false |
TrivSqZeroExt.instL1NormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsBoundedSMul R M] [inst_5 : IsBoundedSMul Rᵐᵒᵖ M]
[inst_6 : SMulCommClass R Rᵐᵒᵖ M] {x y : TrivSqZeroExt R M}, dist x y = 0 → x = y | null | false |
Real.convexOn_log_Gamma | Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup | ConvexOn ℝ (Set.Ioi 0) (Real.log ∘ Real.Gamma) | null | true |
_private.Init.Data.Array.Range.0.Array.mem_zipIdx._proof_1 | Init.Data.Array.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : Array α} {k : ℕ},
k ≤ (x, i).2 → (x, i).2 < k + xs.size → ¬i - k < xs.size → False | null | false |
Array.beq_eq_decide | Init.Data.Array.DecidableEq | ∀ {α : Type u_1} [inst : BEq α] (xs ys : Array α),
(xs == ys) = if h : xs.size = ys.size then decide (∀ (i : ℕ) (h' : i < xs.size), (xs[i] == ys[i]) = true) else false | null | true |
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp | Mathlib.CategoryTheory.Localization.Monoidal.Functor | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[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} E] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[inst_4 : Category... | Monoidal structure on `F`, given that `F` lifts along `L` to a monoidal functor `G`,
where `L` is a monoidal localization functor.
| true |
SimpleGraph.le_chromaticNumber_iff_coloring | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ}, ↑n ≤ G.chromaticNumber ↔ ∀ (m : ℕ) (a : G.Coloring (Fin m)), n ≤ m | null | true |
HomogeneousIdeal.instMax._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (I.toIdeal ⊔ J.toIdeal) | null | false |
Subgroup.Commensurable.eq_1 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), H.Commensurable K = (H.relIndex K ≠ 0 ∧ K.relIndex H ≠ 0) | null | true |
SimpleGraph.induceHomOfLE | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → (G : SimpleGraph V) → {s s' : Set V} → s ≤ s' → SimpleGraph.induce s G ↪g SimpleGraph.induce s' G | Given an inclusion of vertex subsets, the induced embedding on induced graphs.
This is not an abbreviation for `induceHom` since we get an embedding in this case. | true |
Unitization.instNonAssocRing._proof_9 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Std.Iter.toIter_toIterM | Init.Data.Iterators.Basic | ∀ {α β : Type w} (it : Std.Iter β), it.toIterM.toIter = it | null | true |
LinearIsometry.strictConvexSpace_range | Mathlib.Analysis.Convex.LinearIsometry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F]
[StrictConvexSpace 𝕜 E] (e : E →ₗᵢ[𝕜] F), StrictConvexSpace 𝕜 ↥(↑e).range | null | true |
Monoid.CoprodI.Word.rcons_eq_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (p : Monoid.CoprodI.Word.Pair M i),
Monoid.CoprodI.Word.rcons p = Monoid.CoprodI.of p.head • p.tail | null | true |
AlgEquiv.isTranscendenceBasis | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
IsTranscendenceBasis R x → IsTranscendenceBasis R (⇑e ∘ x) | Also see `IsTranscendenceBasis.algebraMap_comp`
for the composition with an algebraic extension. | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.instIsIsoInvApp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (U : TopologicalSpace.Opens ↑↑X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp f U) | null | true |
Std.TreeMap.getKeyD_eq_fallback | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getKeyD a fallback = fallback | null | true |
monotoneOn_of_le_add_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : One α]
[inst_4 : SuccAddOrder α] [IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → a + 1 ∈ s → f a ≤ f (a + 1)) → MonotoneOn f s | null | true |
Lean.Environment.Visibility._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.Visibility | null | false |
ContinuousAlternatingMap.ofSubsingleton_toAlternatingMap | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ (R : Type u_1) (M : Type u_2) (N : Type u_4) {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : Subsingleton ι] (i : ι) (f : M →L[R] N),
((ContinuousAlternating... | null | true |
BoxIntegral.Box.coe_subset_coe._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (↑I ⊆ ↑J) = (I ≤ J) | null | false |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy._proof_40 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {n : ℕ} (i j k : Fin (n + 1)) (hk : j.rev = k) (l : ℕ) (hl : ↑j + l = ↑i), ↑i = ↑⟨l, ⋯⟩ + ↑j.castSucc | null | false |
Filter.bliminf_or_le_inf_aux_right._simp_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {p q : β → Prop} {u : β → α},
((Filter.bliminf u f fun x => p x ∨ q x) ≤ Filter.bliminf u f q) = True | null | false |
definition._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[Fintype ι] →
[FiniteDimensional 𝕜 E] →
{n : ℕ} →
Module.finrank 𝕜 E = n →
... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.EqCnstr.collectDecVars.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | (motive : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) →
((a zero : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) →
((a b : Lean.Expr) →
(p₁ p₂ : Int.Linear.Poly) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCns... | null | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusionType P t t' | null | false |
Lean.guardMsgsPositions | Init.Notation | Lean.ParserDescr | Position reporting for `#guard_msgs`:
- `positions := true` will report the positions of messages with the line numbers computed
relative to the line of the `#guard_msgs` token, e.g.
```
@ +3:7...+4:2
info: <message>
```
Note that the reported column is absolute.
- `positions := false` (the default) will no... | true |
subset_tangentConeAt_prod_left | Mathlib.Analysis.Calculus.TangentCone.Prod | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] [ContinuousConstSMul 𝕜 E] [inst_6 : AddCommGroup F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [ContinuousAdd F] [ContinuousConstSMul 𝕜 F]... | The tangent cone of a product contains the tangent cone of its left factor. | true |
OrderTopology.t5Space | Mathlib.Topology.Order.T5 | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X], T5Space X | null | true |
AlgebraicGeometry.Scheme.kerAdjunction_counit_app | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (f : (CategoryTheory.Over Y)ᵒᵖ),
Y.kerAdjunction.counit.app f =
(CategoryTheory.Over.homMk (AlgebraicGeometry.Scheme.Hom.toImage (Opposite.unop f).hom) ⋯).op | null | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(X Y Z : P.FullSubcategory),
P
(CategoryTheory.MonoidalCategoryStru... | null | false |
ZFSet.card_empty | Mathlib.SetTheory.ZFC.Cardinal | ∅.card = 0 | null | true |
Std.DHashMap.Internal.Raw₀.contains_insertMany_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List ((a : α) × β a)} {k : α},
(↑(m.insertMany l)).contains k = (m.contains k || (List.map Sigma.fst l).contains k) | null | true |
SeparatelyContinuousMul.rec | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : SeparatelyContinuousMul M → Sort u} →
((continuous_const_mul : ∀ {a : M}, Continuous fun x => a * x) →
(continuous_mul_const : ∀ {a : M}, Continuous fun x => x * a) → motive ⋯) →
(t : SeparatelyContinuo... | null | false |
_private.Lean.Server.Rpc.RequestHandling.0.Lean.Server.wrapRpcProcedure.match_1 | Lean.Server.Rpc.RequestHandling | (respType : Type) →
(motive : Except Lean.Server.RequestError respType → Sort u_1) →
(x : Except Lean.Server.RequestError respType) →
((e : Lean.Server.RequestError) → motive (Except.error e)) →
((ret : respType) → motive (Except.ok ret)) → motive x | null | false |
Subring.mem_toSubsemiring._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Subring R} {x : R}, (x ∈ s.toSubsemiring) = (x ∈ s) | null | false |
Lean.Syntax.ident.inj | Init.Core | ∀ {info : Lean.SourceInfo} {rawVal : Substring.Raw} {val : Lean.Name} {preresolved : List Lean.Syntax.Preresolved}
{info_1 : Lean.SourceInfo} {rawVal_1 : Substring.Raw} {val_1 : Lean.Name}
{preresolved_1 : List Lean.Syntax.Preresolved},
Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident info_1 rawV... | null | true |
convexHullAddMonoidHom | Mathlib.Analysis.Convex.Combination | (R : Type u_1) →
(E : Type u_3) →
[inst : Field R] →
[inst_1 : AddCommGroup E] → [Module R E] → [inst_3 : LinearOrder R] → [IsStrictOrderedRing R] → Set E →+ Set E | `convexHull` is an additive monoid morphism under pointwise addition. | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.instMulActionLeftTransversal._simp_1 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
instRingUniversalEnvelopingAlgebra._aux_8 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → ℕ → UniversalEnvelopingAlgebra R L → UniversalEnvelopingAlgebra R L | null | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.e | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → Lean.Expr | The underlying expression of the variable. | true |
HomotopicalAlgebra.instIsStableUnderBaseChangeFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlge... | null | true |
CliffordAlgebra.reverse_mem_evenOdd_iff | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.rec | Lean.Meta.LetToHave | {motive : Lean.Meta.LetToHave.State✝ → Sort u} →
((count : ℕ) →
(results : Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝) →
motive { count := count, results := results }) →
(t : Lean.Meta.LetToHave.State✝) → motive t | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.getElem?_toList_eq.match_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (next : α), x = some next → motive (some next)) → motive x | null | false |
QuadraticAlgebra.algebraMap_norm_eq_mul_star | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommRing R] (z : QuadraticAlgebra R a b),
(algebraMap R (QuadraticAlgebra R a b)) (QuadraticAlgebra.norm z) = z * star z | null | true |
Module.DirectLimit.addCommGroup._proof_12 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] [inst_2 : DecidableEq ι] (G : ι → Type u_3)
[inst_3 : (i : ι) → AddCommGroup (G i)] [inst_4 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
(a b : Module.DirectLimit G f), a + b = b + a | null | false |
CategoryTheory.Idempotents.Karoubi.decompId_p._proof_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ }.p
(CategoryTheory.CategoryStruct.comp P.p P.p) =
P.p | null | false |
Std.DTreeMap.Internal.Impl.get!_eq_getValueCast! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [instBEq : BEq α] [inst : Ord α] [inst_1 : Std.LawfulBEqOrd α] [Std.TransOrd α]
[inst_3 : Std.LawfulEqOrd α] {k : α} [inst_4 : Inhabited (β k)] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get! k = Std.Internal.List.getValueCast! k t.toListModel | null | true |
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_1 | Mathlib.Order.Filter.Bases.Finite | ∀ {α : Type u} {s : Set (Set α)} {U : Set α}, (U ∈ Filter.generate s) = ∃ t ⊆ s, t.Finite ∧ ⋂₀ t ⊆ U | null | false |
HahnSeries.orderTop_embDomain | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ' : Type u_2} {R : Type u_3} [inst : Zero R] [inst_1 : PartialOrder Γ'] {Γ : Type u_5} [inst_2 : LinearOrder Γ]
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).orderTop = WithTop.map (⇑f) x.orderTop | null | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sheafedSpace_pullback_fst_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (CategoryTheory.Limits.pullback.fst g f) | null | true |
CategoryTheory.FreeBicategory.comp_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g | null | true |
orthogonalFamily_iff_pairwise | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : 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ₗᵢ) ↔ Pairwise (Function.onFun (fun x1 x2 => x1 ⟂ x2) V) | null | true |
ProofWidgets.MakeEditLinkProps.ctorIdx | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → ℕ | null | false |
Pi.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) → {n : (i : I) → Zero (f i)} → [(i : I) → SMulZeroClass α (f i)] → SMulZeroClass α ((i : I) → f i) | null | true |
Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {hd : α} {tl : List α},
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity (hd :: tl)) =
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertIfNew hd ... | null | true |
Int.zsmul_eq_mul | Mathlib.Algebra.Group.Int.Defs | ∀ (n a : ℤ), n • a = n * a | null | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.nonIndicesFirst.match_1 | Lean.Elab.PreDefinition.Structural.FindRecArg | (motive : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo → Sort u_1) →
(x : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo) →
((indices nonIndices : Array Lean.Elab.Structural.RecArgInfo) → motive (indices, nonIndices)) → motive x | null | false |
Fin.partialProd_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_3} [inst : Monoid G] {n : ℕ} (g : Fin (n + 1) → G) (a : Fin (n + 1)),
Fin.partialProd (a.contractNth (fun x1 x2 => x1 * x2) g) = Fin.partialProd g ∘ a.succ.succAbove | null | true |
uniqueMDiffWithinAt_iff_uniqueDiffWithinAt | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E},
UniqueMDiffWithinAt (modelWithCornersSelf 𝕜 E) s x ↔ UniqueDiffWithinAt 𝕜 s x | null | true |
MeromorphicOn.neg | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → MeromorphicOn (-f) U | null | true |
Topology.WithLawson.isOpen_preimage_ofLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] {S : Set α},
IsOpen (⇑Topology.WithLawson.ofLawson ⁻¹' S) ↔ TopologicalSpace.IsOpen S | null | true |
«term{}» | Init.Core | Lean.ParserDescr | `∅` or `{}` is the empty set or empty collection.
It is supported by the `EmptyCollection` typeclass.
Conventions for notations in identifiers:
* The recommended spelling of `{}` in identifiers is `empty`. | true |
List.nil_lt_cons | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] (a : α) (l : List α), [] < a :: l | null | true |
Lean.Meta.Match.mkAppDiscrEqs | Lean.Meta.Match.MatchEqs | Lean.Expr → Array Lean.Expr → ℕ → Lean.MetaM Lean.Expr | Given an application of an matcher arm `alt` that is expecting the `numDiscrEqs`, and
an array of `discr = pattern` equalities (one for each discriminant), apply those that
are expected by the alternative.
| true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqMon.beq.match_1.eq_1 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Sort u_1)
(h_1 : Unit → motive Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit)
(h_2 :
(a : Lean.Grind.CommRing.Power) →
(a_1 : Lean.Grind.CommRing.Mon) →
(b : Lean.Grind.CommRing.Power) →
(b_1 : Lean.Grind.CommRin... | null | true |
enorm_mul_le' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedMonoid E] (a b : E), ‖a * b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ | null | true |
CategoryTheory.Bicategory.postcomposing._proof_2 | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y : b ⟶ c} (η : X ⟶ Y) ⦃X_1 Y_1 : a ⟶ b⦄
(f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Bicategory.postcomp a X).map f)
(CategoryTheory.Bicategory.whiskerLeft Y_1 η) =
CategoryTheory.CategoryStruct.comp (CategoryThe... | null | false |
Finset.Ioi_nonempty | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α], (Finset.Ioi a).Nonempty ↔ ¬IsMax a | null | true |
ContinuousStar.rec | Mathlib.Topology.Algebra.Star | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : Star R] →
{motive : ContinuousStar R → Sort u} →
((continuous_star : Continuous star) → motive ⋯) → (t : ContinuousStar R) → motive t | null | false |
ValuativeRel.valueSetoid._proof_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : ValuativeRel R],
Equivalence fun x x_1 =>
match x with
| (x, s) =>
match x_1 with
| (y, t) => x * ↑t ≤ᵥ y * ↑s ∧ y * ↑s ≤ᵥ x * ↑t | null | false |
ContRepresentation.Equiv.refl_apply | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : Ring R] [inst_2 : AddCommGroup V]
[inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V] {ρ : ContRepresentation R G V}
(v : V), (ContRepresentation.Equiv.refl ρ) v = v | null | true |
Std.LawfulOrderLT | Init.Data.Order.Classes | (α : Type u) → [LT α] → [LE α] → Prop | This typeclass states that the synthesized `LT α` instance is compatible with the `LE α`
instance. This means that `LT.lt a b` holds if and only if `a` is less or equal to `b` according
to the `LE α` instance, but `b` is not less or equal to `a`.
`LawfulOrderLT α` automatically entails that `LT α` is asymmetric: `a < ... | true |
LinearGrowth.tendsto_atTop_of_linearGrowthInf_natCast_pos | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {v : ℕ → ℕ}, (LinearGrowth.linearGrowthInf fun n => ↑(v n)) ≠ 0 → Filter.Tendsto v Filter.atTop Filter.atTop | null | true |
IsTotallySeparated.isTotallyDisconnected | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsTotallySeparated s → IsTotallyDisconnected s | **Alias** of `isTotallyDisconnected_of_isTotallySeparated`. | true |
Polynomial.derivation_ext | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ | null | true |
Convexity.ConvexSpace.convexCombination_single | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u} {M : Type v} {inst₁ : PartialOrder R} {inst₂ : Semiring R} {inst₃ : IsStrictOrderedRing R}
[self : Convexity.ConvexSpace R M] (x : M), Convexity.sConvexComb (Convexity.StdSimplex.single x) = x | **Alias** of `Convexity.ConvexSpace.sConvexComb_single`.
---
A convex combination of a single point is that point. | true |
CommGroup.mem_primaryComponent_iff_orderOf | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommGroup G] {p : ℕ} [Fact (Nat.Prime p)] {g : G},
g ∈ CommGroup.primaryComponent G p ↔ ∃ n, orderOf g = p ^ n | For prime `p`, `g` lies in the `p`-primary component iff its order is a power of `p`. | true |
WType.Listα.nil.elim | Mathlib.Data.W.Constructions | {γ : Type u} →
{motive : WType.Listα γ → Sort u_1} → (t : WType.Listα γ) → t.ctorIdx = 0 → motive WType.Listα.nil → motive t | null | false |
LinearMap.smulRight_zero | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {S : Type u_3} {M : Type u_4} {M₁ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [inst_5 : Semiring S] [inst_6 : Module R S]
[inst_7 : Module S M] [inst_8 : IsScalarTower R S M] (f : M₁ →ₗ[R] S), f.smulRight 0 = 0 | null | true |
SSet.Truncated.Edge.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge._proof_1 })} →
{motive : SSet.Truncated.Edge x₀ x₁ → Sort u_1} →
((edge : X.obj (Opposite.op { obj := { len := 1 }, property := SSet.Truncated.Edge._proof_2 })) →
(src_eq :
(Ca... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.