name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.CosimplicialObject.augmentOfIsInitial_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {T : C}
(hT : CategoryTheory.Limits.IsInitial T), (X.augmentOfIsInitial hT).right = X | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Unitary.Connected.0.expUnitary_argSelfAdjoint._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | NormedSpace.exp = Complex.exp | null | false |
Lean.CodeAction.insertBuiltin | Lean.Server.CodeActions.Attr | Array Lean.Name → Lean.CodeAction.CommandCodeAction → IO Unit | null | true |
Lean.Parser.instCoeParserParserAliasValue | Lean.Parser.Extension | Coe Lean.Parser.Parser Lean.Parser.ParserAliasValue | null | true |
OpenPartialHomeomorph.trans._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_2} {Y : Type u_1} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) (e' : OpenPartialHomeomorph Y Z),
(e.symm.restrOpen e'.source ⋯).symm.target = (e'.restrOpen e.target ⋯).source | null | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_ennreal_mul._simp_1_3 | Mathlib.Data.EReal.Basic | ∀ (x y : NNReal), ↑x * ↑y = ↑(x * y) | null | false |
isClosed_sUnion | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {S : Set (Set α)},
(∀ s ∈ S, IsClosed s) → IsClosed (⋃₀ S) | null | true |
CategoryTheory.Functor.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_4, u_1} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{X Y : CategoryTheory.Functor D E} (τ : X ⟶ Y) (X_1 Y_1 : CategoryTheory.Functor C D) (f : X_1 ⟶ Y_1),
CategoryTheory.Categor... | null | false |
CategoryTheory.Functor.pointwiseLeftKanExtension._proof_4 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) [inst_3 : L.HasPointwiseLeftKanExtension F] (Y : D)
(g₁ g₂ ... | null | false |
_private.Mathlib.Tactic.SetNotationForOrder.0.Mathlib.Meta.SetNotationForOrder.elabSubsetLike | Mathlib.Tactic.SetNotationForOrder | Lean.Term → Lean.Term → Lean.Name → Lean.Name → Lean.Name → Lean.Name → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | Elaborate a notation like `a ⊆ b` by elaborating `a` and `b`, and then deciding
based on their type whether to return `a ⊆ b` or `a ≤ b`.
Use `a ≤ b` whenever `useSetNotationFor` returns true for the type.
If the type is not known, elaboration of this term is postponed.
We assume that `le` and `sub` are names for decl... | true |
String.Slice.Pattern.Model.Char.isLongestMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c | null | true |
Std.Sat.AIG.RefVec.map.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [inst_3 : Std.Sat.AIG.RefVec.LawfulMapOperator α f]
(_x : (aig : Std.Sat.AIG α) ×' (i : ℕ) ×' (_ : i ≤ len) ×' (_ : aig.Ref... | null | false |
BooleanSubalgebra.rec | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} →
[inst : BooleanAlgebra α] →
{motive : BooleanSubalgebra α → Sort u} →
((toSublattice : Sublattice α) →
(compl_mem' : ∀ {a : α}, a ∈ toSublattice.carrier → aᶜ ∈ toSublattice.carrier) →
(bot_mem' : ⊥ ∈ toSublattice.carrier) →
motive { toSublattice := toSubl... | null | false |
NormedGroup.induced.eq_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {𝓕 : Type u_1} (E : Type u_5) (F : Type u_6) [inst : FunLike 𝓕 E F] [inst_1 : Group E] [inst_2 : NormedGroup F]
[inst_3 : MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Function.Injective ⇑f),
NormedGroup.induced E F f h =
{ norm := fun a => ‖f a‖, toGroup := inst_1, dist := fun a a_1 => dist (f a) (f a_1), dist_self... | null | true |
Nat.log_monotone | Mathlib.Data.Nat.Log | ∀ {b : ℕ}, Monotone (Nat.log b) | null | true |
PEquiv.vecMul_toMatrix_toPEquiv | Mathlib.Data.Matrix.PEquiv | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : DecidableEq n] [inst_1 : Fintype m] [inst_2 : NonAssocSemiring α]
(σ : m ≃ n) (a : m → α), Matrix.vecMul a σ.toPEquiv.toMatrix = a ∘ ⇑σ.symm | null | true |
Lean.Lsp.instFromJsonSemanticTokenModifier | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SemanticTokenModifier | null | true |
SSet.Subcomplex.instDecidableEqObjOppositeSimplexCategoryToSSet._aux_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | {X : SSet} → (n : SimplexCategoryᵒᵖ) → (A : X.Subcomplex) → [DecidableEq (X.obj n)] → DecidableEq (A.toSSet.obj n) | null | false |
IsStrictlyPositive.sqrt | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsSemitopologicalRing A] [T2Space A] (a : A),
autoParam (... | null | true |
MeasureTheory.Lp_toLp_restrict_smul | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {F : Type u_4} {mX : MeasurableSpace X} {𝕜 : Type u_5} [inst : NormedRing 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : Module 𝕜 F] [inst_3 : IsBoundedSMul 𝕜 F] {p : ENNReal}
{μ : MeasureTheory.Measure X} (c : 𝕜) (f : ↥(MeasureTheory.Lp F p μ)) (s : Set X),
MeasureTheory.MemLp.toLp ↑↑(c • f) ... | For `f : Lp E p μ`, we can define an element of `Lp E p (μ.restrict s)` by
`(Lp.memLp f).restrict s).toLp f`. This map commutes with scalar multiplication. | true |
StarMulEquiv.ext_iff | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] {f g : A ≃⋆* B},
f = g ↔ ∀ (a : A), f a = g a | null | true |
Qq.QuotedDefEq | Qq.Typ | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Q(«$α») → Prop | `QuotedDefEq lhs rhs` says that the expressions `lhs` and `rhs` are definitionally equal.
You should usually write this using the notation `$lhs =Q $rhs`.
| true |
gc_sdiff_sup | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, GaloisConnection (fun x => x \ a) fun x => a ⊔ x | null | true |
Manifold.IsSubmersionOfComplement.isSubmersion | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E'' : Type u_3} {F : Type u_5} {H : Type u_7} {G : Type u_9} {E : Type u}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F] [... | If `f` is a submersion w.r.t. some complement `F`, it is a submersion.
Note that the proof contains a small formalisation-related subtlety: `F` can live in any universe,
while being a submersion requires the existence of a complement in the same universe as
the model normed space of `N`. This is solved by `smallComple... | true |
SmoothBumpFunction.mk.noConfusion | Mathlib.Geometry.Manifold.BumpFunction | {E : Type uE} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{H : Type uH} →
{inst_2 : TopologicalSpace H} →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
{inst_3 : TopologicalSpace M} →
{inst_4 : ChartedSpace H M} →
... | null | false |
intervalIntegral.norm_integral_min_max | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
(f : ℝ → E), ‖∫ (x : ℝ) in min a b..max a b, f x ∂μ‖ = ‖∫ (x : ℝ) in a..b, f x ∂μ‖ | null | true |
Substring.Raw.ValidFor.of_eq | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (s : Substring.Raw),
s.str.toList = l ++ m ++ r →
s.startPos.byteIdx = String.utf8Len l →
s.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Substring.Raw.ValidFor l m r s | null | true |
instComplementInt16 | Init.Data.SInt.Basic | Complement Int16 | null | true |
MvPolynomial.IsWeightedHomogeneous | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | {R : Type u_1} →
{M : Type u_2} → [inst : CommSemiring R] → {σ : Type u_3} → [AddCommMonoid M] → (σ → M) → MvPolynomial σ R → M → Prop | A multivariate polynomial `φ` is weighted homogeneous of weighted degree `m` if all monomials
occurring in `φ` have weighted degree `m`. | true |
Behrend.ceil_lt_mul | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {x : ℝ}, 50 / 19 ≤ x → ↑⌈x⌉₊ < 1.38 * x | null | true |
_private.Mathlib.Data.List.Defs.0.List.length_mapAccumr.match_1_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_3} {β : Type u_2} {γ : Type u_1} (motive : (α → γ → γ × β) → List α → γ → Prop) (x : α → γ → γ × β)
(x_1 : List α) (x_2 : γ),
(∀ (f : α → γ → γ × β) (head : α) (x : List α) (s : γ), motive f (head :: x) s) →
(∀ (x : α → γ → γ × β) (x_3 : γ), motive x [] x_3) → motive x x_1 x_2 | null | false |
Lean.Doc.CodeBlockSuggestion.casesOn | Lean.Elab.DocString | {motive : Lean.Doc.CodeBlockSuggestion → Sort u} →
(t : Lean.Doc.CodeBlockSuggestion) →
((name : Lean.Name) →
(args moreInfo : Option String) → motive { name := name, args := args, moreInfo := moreInfo }) →
motive t | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabNoMatch.loop._sunfold | Lean.Elab.Match | Lean.Syntax → List Lean.Term → Array Lean.Syntax → Lean.Elab.TermElabM Lean.Term | null | false |
MeasureTheory.measure_union_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
(s t : Set α), μ (s ∪ t) ≤ μ s + μ t | null | true |
sub_add_sub_comm | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c d : α), a - b + (c - d) = a + c - (b + d) | null | true |
PowerSeries.hasEvalIdeal.eq_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] [inst_2 : IsTopologicalRing S]
[inst_3 : IsLinearTopology S S],
PowerSeries.hasEvalIdeal = { carrier := {a | PowerSeries.HasEval a}, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ } | null | true |
CategoryTheory.ObjectProperty.limitsClosure_top | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type t} (J : α → Type u')
[inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)], ⊤.limitsClosure J = ⊤ | null | true |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.exists_isLeast_one_lt._simp_1_2 | Mathlib.GroupTheory.Archimedean | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ n * a = a ^ (n + 1) | null | false |
HomologicalComplex.cylinder.ι₀_desc | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F K : HomologicalComplex C c} [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasCylinder]
(φ₀ φ₁ : K... | null | true |
Lean.Lsp.DidChangeTextDocumentParams.mk | Lean.Data.Lsp.TextSync | Lean.Lsp.VersionedTextDocumentIdentifier →
Array Lean.Lsp.TextDocumentContentChangeEvent → Lean.Lsp.DidChangeTextDocumentParams | null | true |
_private.Init.Data.Array.Find.0.Array.get_find?_mem._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} (h : (List.find? p xs).isSome = true),
((List.find? p xs).get h ∈ xs) = True | null | false |
Mathlib.Tactic.Order.ToInt.toInt_nlt_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
¬Mathlib.Tactic.Order.ToInt.toInt val i < Mathlib.Tactic.Order.ToInt.toInt val j ↔ ¬val i < val j | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.cliqueFreeOn_two._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
Rep.quotientToInvariantsFunctor._proof_4 | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_3) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal]
{X Y : Rep.{u_2, u_3, u_1} k G} (f : X ⟶ Y) (g : G ⧸ S),
ModuleCat.Hom.hom ((Rep.invariantsFunctor k ↥S).map ((Rep.resFunctor S.subtype).map f)) ∘ₗ
(X.ρ.quotientToInvariants S) g =
(Y.ρ.quotientToIn... | null | false |
Primrec.nat_casesOn | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → ℕ} {g : α → β} {h : α → ℕ → β},
Primrec f → Primrec g → Primrec₂ h → Primrec fun a => Nat.casesOn (f a) (g a) (h a) | null | true |
BitVec.getLsbD_reverse | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x : BitVec w}, x.reverse.getLsbD i = x.getMsbD i | null | true |
IsSymmetricAlgebra.lift_eq | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A') (a : M), (h.lift g) ... | null | true |
Std.ExtHashMap.get?_eq_getElem? | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, m.get? a = m[a]? | null | true |
Lean.Lsp.instHashableResolvableCompletionItem | Lean.Data.Lsp.LanguageFeatures | Hashable Lean.Lsp.ResolvableCompletionItem | null | true |
HahnSeries.instLinearOrderLex | Mathlib.RingTheory.HahnSeries.Lex | {Γ : Type u_1} →
{R : Type u_2} → [inst : LinearOrder Γ] → [inst_1 : Zero R] → [LinearOrder R] → LinearOrder (Lex (HahnSeries Γ R)) | null | true |
ModuleCat.piIsoPi_hom_ker_subtype | Mathlib.Algebra.Category.ModuleCat.Products | ∀ {R : Type u} [inst : Ring R] {ι : Type v} (Z : ι → ModuleCat R) [inst_1 : CategoryTheory.Limits.HasProduct Z] (i : ι),
CategoryTheory.CategoryStruct.comp (ModuleCat.piIsoPi Z).hom (ModuleCat.ofHom (LinearMap.proj i)) =
CategoryTheory.Limits.Pi.π Z i | null | true |
monovary_iff_mul_rearrangement | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {f g : ι → α},
Monovary f g ↔ ∀ (i j : ι), f i * g j + f j * g i ≤ f i * g i + f j * g j | Two functions monovary iff the rearrangement inequality holds. | true |
FractionalIdeal.coeIdeal_inf | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[FaithfulSMul R P] (I J : Ideal R), ↑(I ⊓ J) = ↑I ⊓ ↑J | null | true |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.notMem_range_embeddingUpIntLE_iff._proof_1_2 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p n : ℤ), p < n → ∀ (i : ℕ), ¬p - ↑i = n | null | false |
Sum.Lex.mono | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {r₁ r₂ : α → α → Prop} {β : Type u_2} {s₁ s₂ : β → β → Prop} {x y : α ⊕ β},
(∀ (a b : α), r₁ a b → r₂ a b) → (∀ (a b : β), s₁ a b → s₂ a b) → Sum.Lex r₁ s₁ x y → Sum.Lex r₂ s₂ x y | null | true |
LinearIsometryEquiv._sizeOf_inst | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring R₂} →
(σ₁₂ : R →+* R₂) →
{σ₂₁ : R₂ →+* R} →
{inst_2 : RingHomInvPair σ₁₂ σ₂₁} →
{inst_3 : RingHomInvPair σ₂₁ σ₁₂} →
(E : Type u_11) →
(E₂ : Type u_12) →
... | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.sum_pow_add_indicator_eq_zero._proof_1_2 | Mathlib.NumberTheory.Bernoulli | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)], NeZero p | null | false |
AlgebraicGeometry.opensRestrict | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → (↑U).Opens ≃ { V // V ≤ U } | The open sets of an open subscheme corresponds to the open sets containing in the subset. | true |
_private.Lean.Widget.Diff.0.Lean.Widget.instAppendExprDiff | Lean.Widget.Diff | Append Lean.Widget.ExprDiff✝ | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Icc_sub._proof_1_11 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} {b : Fin n}, ↑b + 1 < n + 1 | null | false |
MulOpposite.op_le_op._simp_2 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (MulOpposite.op a ≤ MulOpposite.op b) = (a ≤ b) | null | false |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.FiniteMeasure.limsup_measure_closed_le_of_tendsto._simp_1_2 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Std.TreeSet._sizeOf_inst | Std.Data.TreeSet.Basic | (α : Type u) → (cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1) → [SizeOf α] → SizeOf (Std.TreeSet α cmp) | null | false |
AlgebraicClosure.instCommRing._aux_34 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | (k : Type u_1) → [inst : Field k] → AlgebraicClosure k → AlgebraicClosure k → AlgebraicClosure k | null | false |
ContinuousMap.instNorm | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
{E : Type u_3} → [inst : TopologicalSpace α] → [CompactSpace α] → [inst_2 : SeminormedAddCommGroup E] → Norm C(α, E) | null | true |
neg_sub_neg | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - -b = b - a | null | true |
LineDeriv.iteratedLineDerivOp_fin_zero | Mathlib.Analysis.Distribution.DerivNotation | ∀ {V : Type u_11} {E : Type u_12} [inst : LineDeriv V E E] (m : Fin 0 → V) (f : E),
LineDeriv.iteratedLineDerivOp m f = f | null | true |
Lean.Meta.Grind.Arith.Cutsat.State.nonlinearOccs._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentHashMap Int.Linear.Var (List Int.Linear.Var) | null | false |
Std.Rxi.HasSize.mk._flat_ctor | Init.Data.Range.Polymorphic.Basic | {α : Type u} → (α → ℕ) → Std.Rxi.HasSize α | null | false |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_sSup_of_directed._simp_1_1 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Type u} {s : Set α} {p : ↑s → Prop}, (∃ x, p x) = ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩ | null | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner_Basic___macroRules_MeasureTheory_term∫_,_∂__1» | Mathlib.MeasureTheory.Integral.Bochner.Basic | Lean.Macro | null | false |
Std.DTreeMap.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.extractLsb'_extractAndExtendAux._proof_1_7 | Init.Data.BitVec.Bitblast | ∀ {w len : ℕ} (n' : ℕ) {k : ℕ} (n' i : ℕ), i < k + 1 → ¬i < k → ¬i = k → False | null | false |
String.Slice.skipSuffix?_string_eq_some_iff' | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice} {pos : s.Pos}, s.skipSuffix? pat = some pos ↔ ∃ t, pos.Splits t pat | null | true |
MeasureTheory.Integrable.comp_snd_iff | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[MeasureTheory.IsFiniteMeasure μ] {f : β → E},
μ ≠ 0 → (MeasureTheory.Integrable (fun x => f ... | null | true |
_private.Mathlib.Topology.Algebra.Ring.Compact.0.Ideal.isOpen_of_isMaximal._proof_1_1 | Mathlib.Topology.Algebra.Ring.Compact | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : TopologicalSpace R] [IsTopologicalRing R] [CompactSpace R] [T2Space R]
[IsNoetherianRing R] (I : Ideal R) [I.IsMaximal], Finite (R ⧸ Submodule.toAddSubgroup I) | null | false |
AlgebraicGeometry.isLimitOpensCone._proof_1 | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u_1} [inst : CategoryTheory.Category.{u_1, u_1} I] (i : I),
CategoryTheory.IsConnected (CategoryTheory.Over i) | null | false |
Multiset.chooseX | Mathlib.Data.Multiset.Basic | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → (l : Multiset α) → (∃! a, a ∈ l ∧ p a) → { a // a ∈ l ∧ p a } | Given a proof `hp` that there exists a unique `a ∈ l` such that `p a`, `chooseX p l hp` returns
that `a` together with proofs of `a ∈ l` and `p a`. | true |
cfc_comp_zpow._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Lean.MonadRef.rec | Init.Prelude | {m : Type → Type} →
{motive : Lean.MonadRef m → Sort u} →
((getRef : m Lean.Syntax) →
(withRef : {α : Type} → Lean.Syntax → m α → m α) → motive { getRef := getRef, withRef := withRef }) →
(t : Lean.MonadRef m) → motive t | null | false |
ExtremallyDisconnected.open_closure | Mathlib.Topology.ExtremallyDisconnected | ∀ {X : Type u} {inst : TopologicalSpace X} [self : ExtremallyDisconnected X] (U : Set X), IsOpen U → IsOpen (closure U) | The closure of every open set is open. | true |
addConj_addCommutatorElement_left_addCommutatorElement_add | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (a b c : G),
a + ⁅⁅-a, b⁆, c⁆ + -a + c + ⁅⁅-c, a⁆, b⁆ + -c + b + ⁅⁅-b, c⁆, a⁆ + -b = 0 | **The Hall-Witt identity** | true |
Mathlib.Meta.FunProp.FunctionData._sizeOf_inst | Mathlib.Tactic.FunProp.FunctionData | SizeOf Mathlib.Meta.FunProp.FunctionData | null | false |
_private.Mathlib.Tactic.Linter.EmptyLine.0.Mathlib.Linter.EmptyLine.emptyLineLinter.match_1 | Mathlib.Tactic.Linter.EmptyLine | (motive : Lean.MessageSeverity → Sort u_1) →
(x : Lean.MessageSeverity) →
(Unit → motive Lean.MessageSeverity.information) → ((x : Lean.MessageSeverity) → motive x) → motive x | null | false |
MvPolynomial.IsWeightedHomogeneous.weightedHomogeneousComponent_ne | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] {w : σ → M} {m : M}
(n : M) {p : MvPolynomial σ R},
MvPolynomial.IsWeightedHomogeneous w p m → n ≠ m → (MvPolynomial.weightedHomogeneousComponent w n) p = 0 | null | true |
Submodule.annihilator_map_mkQ_eq_colon | Mathlib.RingTheory.Ideal.Colon | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N P : Submodule R M},
(Submodule.map N.mkQ P).annihilator = N.colon ↑P | null | true |
Lean.Lsp.FileEvent | Lean.Data.Lsp.Workspace | Type | null | true |
MeasureTheory.empty_mem_measurableCylinders | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} (α : ι → Type u_1) [inst : (i : ι) → MeasurableSpace (α i)], ∅ ∈ MeasureTheory.measurableCylinders α | null | true |
Std.ExtTreeMap.self_le_maxKey!_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β}, (cmp k (t.insertIfNew k v).maxKey!).isLE = true | null | true |
SimpleGraph.not_isTutteViolator_of_isPerfectMatching | Mathlib.Combinatorics.SimpleGraph.Tutte | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] {M : G.Subgraph},
M.IsPerfectMatching → ∀ (u : Set V), ¬G.IsTutteViolator u | Proves the necessity part of Tutte's theorem | true |
OpenSubgroup.instLattice.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : SeparatelyContinuousMul G],
OpenSubgroup.instLattice =
{ toSemilatticeSup := Function.Injective.semilatticeSup OpenSubgroup.toSubgroup ⋯ ⋯ ⋯ ⋯, inf := SemilatticeInf.inf,
inf_le_left := ⋯, inf_le_right := ⋯, le_inf := ⋯ } | null | true |
CategoryTheory.Limits.isoBiprodZero_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero Y),
(CategoryTheory.Limits.isoBiprodZero hY).inv = CategoryTheory.Limits.biprod.fst | null | true |
IsometryEquiv.divRight_toEquiv | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricSMul Gᵐᵒᵖ G] (c : G),
(IsometryEquiv.divRight c).toEquiv = Equiv.divRight c | null | true |
Matroid.isRkFinite_iff_exists_isBasis' | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.IsRkFinite X ↔ ∃ I, M.IsBasis' I X ∧ I.Finite | A set satisfies `IsRkFinite` iff it has a finite basis' | true |
HomotopicalAlgebra.Precylinder.op_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A),
P.op.p₁ = P.i₁.op | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref... | null | false |
Std.DHashMap.Internal.Raw₀.wfImp_insertMany | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w}
[inst_4 : ForIn Id ρ ((a : α) × β a)] {m : Std.DHashMap.Internal.Raw₀ α β} {l : ρ},
Std.DHashMap.Internal.Raw.WFImp ↑m → Std.DHashMap.Internal.Raw.WFImp ↑↑(m.insertMany l) | null | true |
Field.Emb.Cardinal.succEquiv._proof_7 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
(i : (Module.rank F E).ord.ToType),
IsScalarTower F
↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F ... | null | false |
RelHom.id_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop) (x : α), (RelHom.id r) x = x | null | true |
CategoryTheory.Dial.tensorObjImpl._proof_2 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
(X Y : CategoryTheory.Dial C), CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pair X.tgt Y.tgt) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.