name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicGeometry.SheafedSpace.mk.injEq | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (toPresheafedSpace : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf : toPresheafedSpace.presheaf.IsSheaf) (toPresheafedSpace_1 : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf_1 : toPresheafedSpace_1.presheaf.IsSheaf),
({ toPresheafedSpace := toPresheafedSpac... | true |
ContDiffMapSupportedIn.fderivLM._proof_10 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_3} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F], ContinuousConstSMul 𝕜 (E →L[ℝ] F) | false |
EStateM.Backtrackable.recOn | Init.Prelude | {δ σ : Type u} →
{motive : EStateM.Backtrackable δ σ → Sort u_1} →
(t : EStateM.Backtrackable δ σ) →
((save : σ → δ) → (restore : σ → δ → σ) → motive { save := save, restore := restore }) → motive t | false |
Mathlib.Tactic.Ring.ExBase.atom.injEq | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)} {sα : Q(CommSemiring «$α»)} {e : Q(«$α»)} (id id_1 : ℕ),
(Mathlib.Tactic.Ring.ExBase.atom id = Mathlib.Tactic.Ring.ExBase.atom id_1) = (id = id_1) | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_10 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {a : α} {b : β}, {a • b} = a • {b} | false |
CategoryTheory.Functor.OplaxMonoidal.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} {D : Type u_4} {E : 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} E]
[inst_3 : CategoryTheory.MonoidalCategory D] [inst_4 : CategoryTheory.MonoidalCategory E]
(L : CategoryTheory.Functor D E) [i... | false |
Std.Iter.allM_map | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[inst_3 : Std.IteratorLoop α Id m] [LawfulMonad m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → β'}
{p : β' → m Bool}, Std.Iter.allM p (Std.Iter.map f it) = Std.Iter.allM (fun x => p (f... | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.mem_erase._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, (a ∈ m) = (m.contains a = true) | false |
PiTensorProduct.map._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_2} {R : Type u_1} [inst : CommSemiring R] {t : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (t i)]
[inst_2 : (i : ι) → Module R (t i)], SMulCommClass R R (PiTensorProduct R fun i => t i) | false |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.isAtoms | Lean.Elab.DocString.Builtin.Keywords | List String → Lean.Syntax → Bool | true |
Finset.trop_inf | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} {S : Type u_2} [inst : LinearOrder R] [inst_1 : OrderTop R] (s : Finset S) (f : S → R),
Tropical.trop (s.inf f) = ∑ i ∈ s, Tropical.trop (f i) | true |
CategoryTheory.Limits.Bicone.IsBilimit.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {B : CategoryTheory.Limits.Bicone F}
[inst_2 : SizeOf J] [inst_3 : SizeOf C] (isLimit : CategoryTheory.Limits.IsLimit B.toCone)
(isColimit : CategoryTheory.Limits.IsColimit B.t... | true |
ProofWidgets.Html._sizeOf_inst | ProofWidgets.Data.Html | SizeOf ProofWidgets.Html | false |
CategoryTheory.EffectiveEpiStruct.noConfusionType | Mathlib.CategoryTheory.EffectiveEpi.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
CategoryTheory.EffectiveEpiStruct f →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{X' Y' : C'} → {f' : Y' ⟶ X'} → CategoryTh... | false |
QuadraticAlgebra.instFinite | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R], Module.Finite R (QuadraticAlgebra R a b) | true |
ULift.up_iSup | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] (f : ι → α), { down := ⨆ i, f i } = ⨆ i, { down := f i } | true |
Polygon.mk.sizeOf_spec | Mathlib.Geometry.Polygon.Basic | ∀ {P : Type u_1} {n : ℕ} [inst : SizeOf P] (vertices : Fin n → P), sizeOf { vertices := vertices } = 1 | true |
MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E],
(∀ x ∈ Set.Ioi a, HasDerivAt f (f' x) x) →
MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume →
Filter.Tendsto f Filter.atTop (nhds (Filter.atTop.limUnder f)) | true |
sigmaFinsuppEquivDFinsupp | Mathlib.Data.Finsupp.ToDFinsupp | {ι : Type u_1} → {η : ι → Type u_4} → {N : Type u_5} → [inst : Zero N] → ((i : ι) × η i →₀ N) ≃ Π₀ (i : ι), η i →₀ N | true |
LinearPMap.ctorIdx | Mathlib.LinearAlgebra.LinearPMap | {R : Type u} →
{inst : Ring R} →
{E : Type v} →
{inst_1 : AddCommGroup E} →
{inst_2 : Module R E} → {F : Type w} → {inst_3 : AddCommGroup F} → {inst_4 : Module R F} → (E →ₗ.[R] F) → ℕ | false |
Option.get_of_eq_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {a : α} {o : Option α} (h : o.isSome = true), o = some a → o.get h = a | true |
LinearEquiv.multilinearMapCongrLeft._proof_3 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_negOnePow_mul_cancel | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {α β : ℝ} {i : ℕ}, (-1) ^ i * α * ((-1) ^ i * β) = α * β | true |
ProofWidgets.Penrose.DiagramState._sizeOf_inst | ProofWidgets.Component.PenroseDiagram | SizeOf ProofWidgets.Penrose.DiagramState | false |
left_neg_eq_right_neg | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : AddMonoid M] {a b c : M}, b + a = 0 → a + c = 0 → b = c | true |
Mathlib.Tactic.Ring.of_eq | Mathlib.Tactic.Ring.Basic | ∀ {α : Sort u_1} {a b c : α}, a = c → b = c → a = b | true |
_private.Mathlib.NumberTheory.RamificationInertia.Ramification.0.Ideal._aux_Mathlib_NumberTheory_RamificationInertia_Ramification___unexpand_algebraMap_1 | Mathlib.NumberTheory.RamificationInertia.Ramification | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Tactic.SimpRw.0.Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1.match_1 | Mathlib.Tactic.SimpRw | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x | false |
Lean.CodeAction.insertBuiltin | Lean.Server.CodeActions.Attr | Array Lean.Name → Lean.CodeAction.CommandCodeAction → IO Unit | true |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_ennreal_mul._simp_1_3 | Mathlib.Data.EReal.Basic | ∀ (x y : NNReal), ↑x * ↑y = ↑(x * y) | false |
CategoryTheory.Functor.corepresentable_preservesLimit | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type v)) [F.IsCorepresentable]
{J : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} J] (G : CategoryTheory.Functor J C),
CategoryTheory.Limits.PreservesLimit G F | true |
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₂ ... | false |
CategoryTheory.sectionsFunctorNatIsoCoyoneda_inv_app_coe | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : Type (max u₁ u₂)) [inst_1 : Unique X]
(X_1 : CategoryTheory.Functor C (Type (max u₁ u₂)))
(a : (CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X))).obj X_1) (j : C),
↑((CategoryTheory.sectionsFunctorNatIsoCoyoneda X).... | true |
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 =
{ toNorm := (SeminormedGroup.induced E F f).toNorm, toGroup := (SeminormedGroup.induced E F f).... | 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 | 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) | 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 (... | 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) ... | 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} →
... | false |
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 | true |
instComplementInt16 | Init.Data.SInt.Basic | Complement Int16 | true |
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 | 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) | 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) | 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 :
HomologicalComplex.Ha... | true |
Lean.Lsp.DidChangeTextDocumentParams.mk | Lean.Data.Lsp.TextSync | Lean.Lsp.VersionedTextDocumentIdentifier →
Array Lean.Lsp.TextDocumentContentChangeEvent → Lean.Lsp.DidChangeTextDocumentParams | 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 | false |
_private.Lean.Meta.Tactic.Grind.Util.0._regBuiltin.Lean.Meta.Grind.reducePreMatchCond.declare_56._@.Lean.Meta.Tactic.Grind.Util.2249970803._hygCtx._hyg.10 | Lean.Meta.Tactic.Grind.Util | IO Unit | 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) | 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]? | true |
Lean.Lsp.instHashableResolvableCompletionItem | Lean.Data.Lsp.LanguageFeatures | Hashable Lean.Lsp.ResolvableCompletionItem | 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 | 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 | 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 | false |
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 | true |
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 | true |
AlgebraicGeometry.opensRestrict | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → (↑U).Opens ≃ { V // V ≤ U } | true |
_private.Lean.Widget.Diff.0.Lean.Widget.instAppendExprDiff | Lean.Widget.Diff | Append Lean.Widget.ExprDiff✝ | true |
_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 | false |
AlgebraicClosure.instCommRing._aux_34 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | (k : Type u_1) → [inst : Field k] → AlgebraicClosure k → AlgebraicClosure k → AlgebraicClosure k | false |
Lean.Meta.Grind.Arith.Cutsat.State.nonlinearOccs._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentHashMap Int.Linear.Var (List Int.Linear.Var) | false |
Std.Rxi.HasSize.mk._flat_ctor | Init.Data.Range.Polymorphic.Basic | {α : Type u} → (α → ℕ) → Std.Rxi.HasSize α | false |
_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) | 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) | false |
cfc_comp_zpow._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | 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 | false |
Mathlib.Meta.FunProp.FunctionData._sizeOf_inst | Mathlib.Tactic.FunProp.FunctionData | SizeOf Mathlib.Meta.FunProp.FunctionData | 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 | 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 | true |
MeasureTheory.empty_mem_measurableCylinders | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} (α : ι → Type u_1) [inst : (i : ι) → MeasurableSpace (α i)], ∅ ∈ MeasureTheory.measurableCylinders α | 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 | 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 | 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 := ⋯ } | 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) | false |
Lean.Meta.instDecidableEqProjReductionKind._proof_1 | Lean.Meta.Basic | ∀ (x y : Lean.Meta.ProjReductionKind), x.ctorIdx = y.ctorIdx → x = y | false |
WeaklyLawfulMonadAttach.casesOn | Init.Control.MonadAttach | {m : Type u → Type v} →
[inst : Monad m] →
[inst_1 : MonadAttach m] →
{motive : WeaklyLawfulMonadAttach m → Sort u_1} →
(t : WeaklyLawfulMonadAttach m) →
((map_attach : ∀ {α : Type u} {x : m α}, Subtype.val <$> MonadAttach.attach x = x) → motive ⋯) → motive t | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cpop_cons._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ (n : ℕ), (n < n + 1) = True | false |
Plausible.Gen.chooseNat | Plausible.Gen | Plausible.Gen ℕ | true |
Lean.Meta.Grind.Arith.Linear.pp? | Lean.Meta.Tactic.Grind.Arith.Linear.PP | Lean.Meta.Grind.Goal → Lean.MetaM (Option Lean.MessageData) | true |
CategoryTheory.ComposableArrows.Precomp.map.congr_simp | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f f_1 : X ⟶ F.left),
f = f_1 →
∀ (i j : Fin (n + 1 + 1)) (x : i ≤ j),
CategoryTheory.ComposableArrows.Precomp.map F f i j x = CategoryTheory.ComposableArrows.Precomp.map F f_1 i j x | true |
Set.empty_disjoint._simp_1 | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} (s : Set α), Disjoint ∅ s = True | false |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.evalGrindTraceCore.match_3 | Lean.Elab.Tactic.Grind.Main | (motive : Lean.Meta.Grind.ActionResult → Sort u_1) →
(__do_lift : Lean.Meta.Grind.ActionResult) →
((seq : List Lean.Meta.Grind.TGrind) → motive (Lean.Meta.Grind.ActionResult.closed seq)) →
((gs : List Lean.Meta.Grind.Goal) → motive (Lean.Meta.Grind.ActionResult.stuck gs)) → motive __do_lift | false |
ProofWidgets.Jsx.delabHtmlOfComponent' | ProofWidgets.Data.Html | Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax `proofWidgetsJsxElement) | true |
Group.rootableByNatOfRootableByInt.eq_1 | Mathlib.GroupTheory.Divisible | ∀ (A : Type u_1) [inst : Group A] [inst_1 : RootableBy A ℤ],
Group.rootableByNatOfRootableByInt A = { root := fun a n => RootableBy.root a ↑n, root_zero := ⋯, root_cancel := ⋯ } | true |
Rat.zero_add | Init.Data.Rat.Lemmas | ∀ (a : ℚ), 0 + a = a | true |
uniform_continuous_npow_on_bounded | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (B : α) {ε : α},
0 < ε → ∀ (n : ℕ), ∃ δ > 0, ∀ (q r : α), |r| ≤ B → |q - r| ≤ δ → |q ^ n - r ^ n| < ε | true |
EuclideanGeometry.image_inversion_sphere_dist_center | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c y : P} {R : ℝ},
R ≠ 0 →
y ≠ c →
EuclideanGeometry.inversion c R '' Metric.sphere y (dist y c) =
insert c ↑(AffineSubspace.perpBisector c (Euclid... | true |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.toSucc_surjectivity._simp_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W... | false |
UniformConcaveOn | Mathlib.Analysis.Convex.Strong | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → Set E → (ℝ → ℝ) → (E → ℝ) → Prop | true |
CategoryTheory.GrothendieckTopology.Point | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.GrothendieckTopology C → Type (max (max u v) (w + 1)) | true |
CategoryTheory.Limits.colimitHomIsoLimitYoneda._proof_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F]
(A : C), CategoryTheory.Limits.HasLimit (F.op.comp (CategoryTheory.yoneda.obj A)) | false |
Subalgebra.equivOfEq._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S T : Subalgebra R A), S = T → ∀ (x : ↥T), ↑x ∈ S | false |
Lean.Lsp.instToJsonInitializeResult | Lean.Data.Lsp.InitShutdown | Lean.ToJson Lean.Lsp.InitializeResult | true |
Std.ExtTreeMap.getElem!_eq_default | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, a ∉ t → t[a]! = default | true |
Lean.Grind.Linarith.Expr.collectVars | Lean.Meta.Tactic.Grind.Arith.Linear.VarRename | Lean.Grind.Linarith.Expr → Lean.Meta.Grind.VarCollector | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isPropQuickApp._unsafe_rec | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool | false |
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{t t' : RpcEncodablePacket✝} →
t = t' →
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusionType P t t' | false |
_private.Lean.Elab.Tactic.BVDecide.LRAT.Trim.0.Lean.Elab.Tactic.BVDecide.LRAT.trim.useAnalysis.go.match_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | (motive : Option Std.Tactic.BVDecide.LRAT.IntAction → Sort u_1) →
(step? : Option Std.Tactic.BVDecide.LRAT.IntAction) →
((step : Std.Tactic.BVDecide.LRAT.IntAction) → motive (some step)) → (Unit → motive none) → motive step? | false |
IntermediateField.adjoinRootEquivAdjoin._proof_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E},
IsIntegral F α →
Function.Bijective
⇑(AdjoinRoot.liftAlgHom (minpoly F α) (Algebra.ofId F ↥F⟮α⟯) (IntermediateField.AdjoinSimple.gen F α) ⋯) | false |
Aesop.Goal.instBEq | Aesop.Tree.Data | BEq Aesop.Goal | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.