name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Subsemigroup.coe_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup N) (f : M →ₙ* N),
↑(Subsemigroup.comap f S) = ⇑f ⁻¹' ↑S | true |
MvPolynomial.coeffs_C | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq R] (r : R),
(MvPolynomial.C r).coeffs = if r = 0 then ∅ else {r} | true |
Nat.sqrt.lt_iter_succ_sq | Mathlib.Data.Nat.Sqrt | ∀ (n guess : ℕ), n < (guess + 1) * (guess + 1) → n < (Nat.sqrt.iter n guess + 1) * (Nat.sqrt.iter n guess + 1) | true |
_private.Init.Data.Range.Polymorphic.Int.0.Std.PRange.instLawfulUpwardEnumerableInt._proof_3 | Init.Data.Range.Polymorphic.Int | ∀ (n : ℕ) (a : ℤ), ¬a + ↑(n + 1) = a + ↑n + 1 → False | false |
ExteriorAlgebra.map._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M), 0 (f.toFun x) = 0 (f.toFun x) | false |
WithOne.coe_inv._simp_2 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} [inst : Inv α] (a : α), (↑a)⁻¹ = ↑a⁻¹ | false |
hasSum_of_isLUB_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), 0 ≤ f i) → IsLUB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | true |
IsLocalization.bot_lt_comap_prime | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[IsLocalization M S] [IsDomain R],
M ≤ nonZeroDivisors R → ∀ (p : Ideal S) [hpp : p.IsPrime], p ≠ ⊥ → ⊥ < Ideal.comap (algebraMap R S) p | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence.0.EisensteinSeries.eisensteinSeries_tendstoLocallyUniformly._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {p : Filter ι} [LocallyCompactSpace α],
TendstoLocallyUniformly F f p = ∀ (K : Set α), IsCompact K → TendstoUniformlyOn F f p K | false |
Submonoid.center.smulCommClass_left | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Monoid M], SMulCommClass (↥(Submonoid.center M)) M M | true |
Submonoid.rec | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : MulOneClass M] →
{motive : Submonoid M → Sort u} →
((toSubsemigroup : Subsemigroup M) →
(one_mem' : 1 ∈ toSubsemigroup.carrier) → motive { toSubsemigroup := toSubsemigroup, one_mem' := one_mem' }) →
(t : Submonoid M) → motive t | false |
Submodule.subtype_injective | Mathlib.Algebra.Module.Submodule.LinearMap | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M),
Function.Injective ⇑p.subtype | true |
Finset.tendsto_Ioc_atBot_prod_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [NoBotOrder α],
Filter.Tendsto (fun p => Finset.Ioc p.1 p.2) (Filter.atBot ×ˢ Filter.atTop) Filter.atTop | true |
_private.Mathlib.Logic.Basic.0.apply_ite_left._proof_1_1 | Mathlib.Logic.Basic | ∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : α → β → γ) (P : Prop) [inst : Decidable P] (x y : α) (z : β),
f (if P then x else y) z = if P then f x z else f y z | false |
UInt64.reduceBNe._regBuiltin.UInt64.reduceBNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_conj_iff._simp_1_2 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.leadingTerm_eq_zero_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {s : σ →₀ ℕ} {b : R}, ((MvPolynomial.monomial s) b = 0) = (b = 0) | false |
Lean.IR.FnBody.sset | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → ℕ → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FnBody → Lean.IR.FnBody | true |
instDecidableEqInt64 | Init.Data.SInt.Basic | DecidableEq Int64 | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsColimitCokernelCofork_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hg₁ : S₁.g = 0)
(c₁ : CategoryTheory.Limits.CokernelCofork S₁.f) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hg₂ : S₂.g = 0)
(c₂ : CategoryTheor... | true |
finSigmaFinEquiv.match_1 | Mathlib.Algebra.BigOperators.Fin | (motive : (m : ℕ) → {n : Fin m → ℕ} → Sort u_1) →
(m : ℕ) → {n : Fin m → ℕ} → ((n : Fin 0 → ℕ) → motive 0) → ((m : ℕ) → (n : Fin m.succ → ℕ) → motive m.succ) → motive m | false |
IsAlgebraic.of_aeval_of_transcendental | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : A} {f : Polynomial R},
IsAlgebraic R ((Polynomial.aeval r) f) → Transcendental R f → IsAlgebraic R r | true |
CategoryTheory.Limits.Multifork.isoOfι | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
{I : CategoryTheory.Limits.MulticospanIndex J C} →
(t : CategoryTheory.Limits.Multifork I) → t ≅ CategoryTheory.Limits.Multifork.ofι I t.pt t.ι ⋯ | true |
_private.Mathlib.Combinatorics.Digraph.Orientation.0.Digraph.toSimpleGraphStrict_bot.match_1_1 | Mathlib.Combinatorics.Digraph.Orientation | ∀ {V : Type u_1} (x x_1 : V) (motive : ⊥.toSimpleGraphStrict.Adj x x_1 → Prop) (x_2 : ⊥.toSimpleGraphStrict.Adj x x_1),
(∀ (left : x ≠ x_1) (h : ⊥.Adj x x_1 ∧ ⊥.Adj x_1 x), motive ⋯) → motive x_2 | false |
Std.ExtDHashMap.not_mem_diff_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₁ → k ∉ m₁ \ m₂ | true |
Lean.Lsp.instToJsonTypeDefinitionParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.TypeDefinitionParams | true |
Lean.Parser.ParserModuleContext.mk.noConfusion | Lean.Parser.Types | {P : Sort u} →
{env : Lean.Environment} →
{options : Lean.Options} →
{currNamespace : Lean.Name} →
{openDecls : List Lean.OpenDecl} →
{env' : Lean.Environment} →
{options' : Lean.Options} →
{currNamespace' : Lean.Name} →
{openDecls' : List Lean.Ope... | false |
Lean.Lsp.TextDocumentSyncOptions.mk.injEq | Lean.Data.Lsp.TextSync | ∀ (openClose : Bool) (change : Lean.Lsp.TextDocumentSyncKind) (willSave willSaveWaitUntil : Bool)
(save? : Option Lean.Lsp.SaveOptions) (openClose_1 : Bool) (change_1 : Lean.Lsp.TextDocumentSyncKind)
(willSave_1 willSaveWaitUntil_1 : Bool) (save?_1 : Option Lean.Lsp.SaveOptions),
({ openClose := openClose, change... | true |
ZeroHom.toFun_eq_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] (f : ZeroHom M N), f.toFun = ⇑f | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.normEq0.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{p : Lean.Grind.CommRing.Poly} →
{d : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c : Lean.Meta.Grind.Arith.CommRing.EqCnstr} →
{p' : Lean.Grind.CommRing.Poly} →
{d' : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c' : Lean.Meta.Grind.Arith.CommRing.EqC... | false |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtOfIso'._proof_2 | 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} (E : L.RightExtension F) {Y Y' : D} (e : Y ≅ Y')
(j : Categ... | false |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.IsUniformInducing.mk'._simp_1_2 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {f g : Filter α}, (f = g) = ∀ (s : Set α), s ∈ f ↔ s ∈ g | false |
Batteries.Tactic._aux_Batteries_Tactic_Unreachable___macroRules_Batteries_Tactic_unreachableConv_1 | Batteries.Tactic.Unreachable | Lean.Macro | false |
Mathlib.Meta.Positivity.Strictness.nonzero.elim | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
t.ctorIdx = 2 → ((pf : Q(«$e» ≠ 0)) → motiv... | false |
MonomialOrder.lex_le_iff | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {c d : σ →₀ ℕ},
MonomialOrder.lex.toSyn c ≤ MonomialOrder.lex.toSyn d ↔ toLex c ≤ toLex d | true |
AlgHom.snd_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), (AlgHom.snd R B C).comp (f.prod g) = g | true |
List.length_eraseP_le | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.eraseP p l).length ≤ l.length | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_one_two_three_iff._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | false |
Filter.filter_eq | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {f g : Filter α}, f.sets = g.sets → f = g | true |
_private.Mathlib.Data.Finset.Defs.0.Finset.instAsymmSSubset._proof_1 | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1}, Std.Asymm fun x1 x2 => x1 ⊂ x2 | false |
Finset.gcd_eq_of_dvd_sub | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommRing α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β} {f g : β → α}
{a : α}, (∀ x ∈ s, a ∣ f x - g x) → gcd a (s.gcd f) = gcd a (s.gcd g) | true |
Turing.PartrecToTM2.Γ'.consₗ.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Γ' → Sort u} →
(t : Turing.PartrecToTM2.Γ') → t.ctorIdx = 0 → motive Turing.PartrecToTM2.Γ'.consₗ → motive t | false |
CategoryTheory.MorphismProperty.FunctorsInverting.hom_ext | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{W : CategoryTheory.MorphismProperty C} {F₁ F₂ : W.FunctorsInverting D} {α β : F₁ ⟶ F₂}, α.hom.app = β.hom.app → α = β | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.expOpenPartialHomeomorph._simp_1 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {z : ℂ}, (Complex.exp z ∈ Complex.slitPlane) = (toIocMod Real.two_pi_pos (-Real.pi) z.im ≠ Real.pi) | false |
lowerBounds_Icc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → lowerBounds (Set.Icc a b) = Set.Iic a | true |
HopfAlgCat.instMonoidalCategoryStruct._proof_2 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), SMulCommClass R R X.carrier | false |
spectrum.map_star | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] [inst_3 : InvolutiveStar R]
[inst_4 : StarRing A] [StarModule R A] (a : A), spectrum R (star a) = star (spectrum R a) | true |
LightCondensed.lanPresheafIso | Mathlib.Condensed.Discrete.Colimit | {S : LightProfinite} →
{F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)} →
CategoryTheory.Limits.IsColimit (F.mapCocone (CategoryTheory.Limits.coconeRightOpOfCone S.asLimitCone)) →
((LightCondensed.lanPresheaf F).obj (Opposite.op S) ≅ F.obj (Opposite.op S)) | true |
AlgebraicGeometry.instSubsingletonOverTerminalScheme | Mathlib.AlgebraicGeometry.Limits | ∀ {X : AlgebraicGeometry.Scheme}, Subsingleton (X.Over (⊤_ AlgebraicGeometry.Scheme)) | true |
CategoryTheory.Limits.opCoproductIsoProduct_hom_comp_π_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct Z] (i : α) {Z_1 : Cᵒᵖ} (h : Opposite.op (Z i) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opCoproductIsoProduct Z).hom
(CategoryTheory.CategoryStruct.comp (... | true |
CategoryTheory.BasedFunctor.isHomLift_iff | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴) {R S : 𝒮} {a b : 𝒳.obj} (f : R ⟶ S)
(φ : a ⟶ b), 𝒴.p.IsHomLift f (F.map φ) ↔ 𝒳.p.IsHomLift f φ | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_4 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Polynomial.eval₂AlgHom | Mathlib.Algebra.Polynomial.AlgebraMap | {R : Type u} →
{A : Type z} →
{B : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] → (f : A →ₐ[R] B) → (b : B) → (∀ (a : A), Commute (f a) b) → Polynomial A →ₐ[R] B | true |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.surjective_quotientMap_of_maximal_of_localization._simp_1_2 | Mathlib.RingTheory.Localization.Ideal | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | false |
ProbabilityTheory.HasSubgaussianMGF.sum_of_iIndepFun | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_2} {X : ι → Ω → ℝ},
ProbabilityTheory.iIndepFun X μ →
∀ {c : ι → NNReal} {s : Finset ι},
(∀ i ∈ s, ProbabilityTheory.HasSubgaussianMGF (X i) (c i) μ) →
ProbabilityTheory.HasSubgaussianMGF (fun ω => ∑ i ∈ s, X i ω) (∑... | true |
CategoryTheory.Abelian.Ext.mk₀_addEquiv₀_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (f : CategoryTheory.Abelian.Ext X Y 0),
CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.Abelian.Ext.addEquiv₀ f) = f | true |
MonomialOrder.leadingCoeff_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι},
(∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.leadingCoeff (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingCoeff (P i) | true |
CategoryTheory.MonObj.casesOn | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.MonObj X → Sort u} →
(t : CategoryTheory.MonObj X) →
((one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
... | false |
Lean.Server.FileWorker.EditableDocumentCore.mk.inj | Lean.Server.FileWorker.Utils | ∀ {«meta» : Lean.Server.DocumentMeta} {initSnap : Lean.Language.Lean.InitialSnapshot}
{cmdSnaps : IO.AsyncList IO.Error Lean.Server.Snapshots.Snapshot}
{diagnosticsRef : IO.Ref (Array Lean.Widget.InteractiveDiagnostic)} {meta_1 : Lean.Server.DocumentMeta}
{initSnap_1 : Lean.Language.Lean.InitialSnapshot} {cmdSnap... | true |
nonpos_of_add_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α] [AddLeftReflectLE α] {a b : α}, a + b ≤ a → b ≤ 0 | true |
Std.HashMap.getKey!_diff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, (m₁ \ m₂).getKey! k = if k ∈ m₂ then default else m₁.getKey! k | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault.noConfusion | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {P : Sort u} →
{info : Lean.InductiveVal} →
{ctors : Array Lean.ConstructorVal} →
{info' : Lean.InductiveVal} →
{ctors' : Array Lean.ConstructorVal} →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault info ctors =
Lean.Elab.Tactic.BVDecide.Frontend.Normal... | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer.0.SubMulAction.ofStabilizer._simp_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.substRHS.match_1 | Lean.Meta.Match.SimpH | (motive : Lean.Meta.FVarSubst × Lean.MVarId → Sort u_1) →
(__discr : Lean.Meta.FVarSubst × Lean.MVarId) →
((subst : Lean.Meta.FVarSubst) → (mvarId : Lean.MVarId) → motive (subst, mvarId)) → motive __discr | false |
Vector.toList_ofFn | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → α}, (Vector.ofFn f).toList = List.ofFn f | true |
OpenPartialHomeomorph.continuousAt_iff_continuousAt_comp_right | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) {f : Y → Z} {x : Y},
x ∈ e.target → (ContinuousAt f x ↔ ContinuousAt (f ∘ ↑e) (↑e.symm x)) | true |
Combinatorics.Line.coe_injective | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_2} {ι : Type u_3} [Nontrivial α], Function.Injective Combinatorics.Line.toFun | true |
Lean.Doc.Parser.document.formatter | Lean.DocString.Formatter | Lean.PrettyPrinter.Formatter | true |
ContinuousAt.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ} {x : α},
ContinuousAt f x → ContinuousAt (fun y => Complex.exp (f y)) x | true |
Lean.Elab.abortTermExceptionId | Lean.Elab.Exception | Lean.InternalExceptionId | true |
Module.DirectLimit.congr_symm_apply_of | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] {G' : ι → Type u_5} [inst_5 : (i : ι) → AddCommMonoid (G' i)]
[inst_6 : (i : ι)... | true |
apply_le_nnnorm_cfc_nnreal._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | false |
AddEquiv.coprodAssoc._proof_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ (M : Type u_1) (N : Type u_2) (P : Type u_3) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddMonoid P],
(AddMonoid.Coprod.lift (AddMonoid.Coprod.map (AddMonoidHom.id M) AddMonoid.Coprod.inl)
(AddMonoid.Coprod.inr.comp AddMonoid.Coprod.inr)).comp
(AddMonoid.Coprod.lift (AddMonoid.Coprod.inl.... | false |
FGModuleRepr.instCategory._aux_5 | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | (R : Type u_1) → [inst : CommRing R] → {X Y Z : FGModuleRepr R} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
_private.Lean.Elab.PreDefinition.Structural.SmartUnfolding.0.Lean.Elab.Structural.addSmartUnfoldingDefAux.visit._sparseCasesOn_8 | Lean.Elab.PreDefinition.Structural.SmartUnfolding | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(... | false |
Lean.Core.mkSnapshot?._auto_1 | Lean.CoreM | Lean.Syntax | false |
CategoryTheory.Functor.isDenseAt_iff | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : D},
F.isDenseAt X ↔
Nonempty
(CategoryTheory.Limits.IsColimit
((CategoryTheory.Functor.LeftExtension.mk (CategoryTheory.Functor.id D) F.righ... | true |
LipschitzWith.min_const | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ} {Kf : NNReal},
LipschitzWith Kf f → ∀ (a : ℝ), LipschitzWith Kf fun x => min (f x) a | true |
IsClosed.isCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyPseudoMetrizableSpace X] {s : Set X},
IsClosed s → TopologicalSpace.IsCompletelyPseudoMetrizableSpace ↑s | true |
Std.DHashMap.Internal.exists_bucket' | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α]
(self : Array (Std.DHashMap.Internal.AssocList α β)) (i : USize) (hi : i.toNat < self.size),
∃ l,
(List.flatMap Std.DHashMap.Internal.AssocList.toList self.toList).Perm (self[i.toNat].toList ++ l) ∧
∀ [LawfulHashable α],
Std.DHas... | true |
PrimeMultiset.prod_sup | Mathlib.Data.PNat.Factors | ∀ (u v : PrimeMultiset), (u ⊔ v).prod = u.prod.lcm v.prod | true |
MeasureTheory.Measure.restrict_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (s : Set α), MeasureTheory.Measure.restrict 0 s = 0 | true |
ModelWithCorners.t1Space | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst : TopologicalSpace M] [ChartedSpace H M], T1Space M | true |
Lean.Parser.Tactic.anyGoals | Init.Tactics | Lean.ParserDescr | true |
WittVector.polyOfInterest | Mathlib.RingTheory.WittVector.MulCoeff | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℕ → MvPolynomial (Fin 2 × ℕ) ℤ | true |
_private.Lean.Level.0.Lean.Level.addOffsetAux.match_1 | Lean.Level | (motive : ℕ → Lean.Level → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Level) → ((u : Lean.Level) → motive 0 u) → ((n : ℕ) → (u : Lean.Level) → motive n.succ u) → motive x x_1 | false |
_private.Init.Data.Array.Range.0.Array.mk_add_mem_zipIdx_iff_getElem?._simp_1_2 | Init.Data.Array.Range | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | false |
TwoSidedIdeal.mem_mk | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {x : R} {c : RingCon R}, x ∈ { ringCon := c } ↔ c x 0 | true |
Lean.MetavarDecl | Lean.MetavarContext | Type | true |
Std.Internal.List.containsKey_maxKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false → ∀ {fallback : α}, Std.Internal.List.containsKey (Std.Internal.List.maxKeyD l fallback) l = true | true |
NonemptyFinLinOrd.instLargeCategory._proof_9 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(∀ {W X Y Z : NonemptyFinLinOrd} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | false |
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : Type u} → Std.Tactic.BVDecide.LRAT.Internal.ReduceResult α | true |
setOf_minimal_antichain | Mathlib.Order.Antichain | ∀ {α : Type u_1} [inst : PartialOrder α] (P : α → Prop), IsAntichain (fun x1 x2 => x1 ≤ x2) {x | Minimal P x} | true |
AddSubgroup.centralizer.eq_1 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.centralizer s = { carrier := s.addCentralizer, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ } | true |
IntermediateField.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B C : IntermediateField F E},
A ⊓ C = B ⊓ C → A.relrank C = B.relrank C | true |
AddMonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : M →+ N) (g : M →+ P), ⇑(f.prod g) = Pi.prod ⇑f ⇑g | true |
CategoryTheory.ObjectProperty.limitsClosure.of_isoClosure | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] {X Y : C} (e : X ≅ Y),
P.limitsClosure J X → P.limitsClosure J Y | true |
Std.TreeMap.keyAtIdx? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → ℕ → Option α | true |
Matrix.conjTransposeRingEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (α : Type v) [inst : NonUnitalNonAssocSemiring α] [inst_1 : StarRing α] [inst_2 : Fintype m]
(a : (Matrix m m α)ᵐᵒᵖ), (Matrix.conjTransposeRingEquiv m α).symm a = (MulOpposite.unop a).conjTranspose | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.