name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Submonoid.center.smulCommClass_left | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Monoid M], SMulCommClass (↥(Submonoid.center M)) M M |
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 |
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 |
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 |
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 |
_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 |
_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 |
_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) |
Lean.IR.FnBody.sset | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → ℕ → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FnBody → Lean.IR.FnBody |
instDecidableEqInt64 | Init.Data.SInt.Basic | DecidableEq Int64 |
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₂ : CategoryTheory.Limits.CokernelCofork S₂.f) (hc₂ : CategoryTheory.Limits.IsColimit c₂) (f : c₁.pt ⟶ c₂.pt)
(comm :
CategoryTheory.CategoryStruct.comp φ.τ₂ (CategoryTheory.Limits.Cofork.π c₂) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π c₁) f),
(CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsColimitCokernelCofork φ hg₁ c₁ hc₁ hg₂ c₂ hc₂ f comm).φK = φ.τ₂ |
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 |
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 |
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.ι ⋯ |
_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 |
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₂ |
Lean.Lsp.instToJsonTypeDefinitionParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.TypeDefinitionParams |
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.OpenDecl} →
{ env := env, options := options, currNamespace := currNamespace, openDecls := openDecls } =
{ env := env', options := options', currNamespace := currNamespace', openDecls := openDecls' } →
(env = env' → options = options' → currNamespace = currNamespace' → openDecls = openDecls' → P) → P |
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 := change, willSave := willSave, willSaveWaitUntil := willSaveWaitUntil,
save? := save? } =
{ openClose := openClose_1, change := change_1, willSave := willSave_1, willSaveWaitUntil := willSaveWaitUntil_1,
save? := save?_1 }) =
(openClose = openClose_1 ∧
change = change_1 ∧ willSave = willSave_1 ∧ willSaveWaitUntil = willSaveWaitUntil_1 ∧ save? = save?_1) |
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 |
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.EqCnstr} →
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.normEq0 p d c =
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.normEq0 p' d' c' →
(p = p' → d = d' → c = c' → P) → P |
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 : CategoryTheory.StructuredArrow Y' L),
(CategoryTheory.Limits.Cone.whisker (CategoryTheory.StructuredArrow.mapIso e.symm).functor (E.coneAt Y)).π.app j =
CategoryTheory.CategoryStruct.comp (E.left.mapIso e).hom ((E.coneAt Y').π.app j) |
_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 |
Batteries.Tactic._aux_Batteries_Tactic_Unreachable___macroRules_Batteries_Tactic_unreachableConv_1 | Batteries.Tactic.Unreachable | Lean.Macro |
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)) → motive (Mathlib.Meta.Positivity.Strictness.nonzero pf)) → motive t |
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 |
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 |
List.length_eraseP_le | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.eraseP p l).length ≤ l.length |
_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 |
Filter.filter_eq | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {f g : Filter α}, f.sets = g.sets → f = g |
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) |
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 |
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 → α = β |
_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) |
lowerBounds_Icc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → lowerBounds (Set.Icc a b) = Set.Iic a |
HopfAlgCat.instMonoidalCategoryStruct._proof_2 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), SMulCommClass R R X.carrier |
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) |
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)) |
AlgebraicGeometry.instSubsingletonOverTerminalScheme | Mathlib.AlgebraicGeometry.Limits | ∀ {X : AlgebraicGeometry.Scheme}, Subsingleton (X.Over (⊤_ AlgebraicGeometry.Scheme)) |
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 (CategoryTheory.Limits.Pi.π (fun x => Opposite.op (Z x)) i) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι Z i).op h |
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 φ |
_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) |
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 |
_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) |
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 ω) (∑ i ∈ s, c i) μ |
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 |
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) |
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) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
(one_mul :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight one X)
mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom) →
(mul_one :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X one)
mul =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom) →
(mul_assoc :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight mul X)
mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X X X).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X mul) mul)) →
motive
{ one := one, mul := mul, one_mul := one_mul, mul_one := mul_one, mul_assoc := mul_assoc }) →
motive t |
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} {cmdSnaps_1 : IO.AsyncList IO.Error Lean.Server.Snapshots.Snapshot}
{diagnosticsRef_1 : IO.Ref (Array Lean.Widget.InteractiveDiagnostic)},
{ «meta» := «meta», initSnap := initSnap, cmdSnaps := cmdSnaps, diagnosticsRef := diagnosticsRef } =
{ «meta» := meta_1, initSnap := initSnap_1, cmdSnaps := cmdSnaps_1, diagnosticsRef := diagnosticsRef_1 } →
«meta» = meta_1 ∧ initSnap = initSnap_1 ∧ cmdSnaps = cmdSnaps_1 ∧ diagnosticsRef = diagnosticsRef_1 |
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 |
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 |
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.Normalize.MatchKind.enumWithDefault info' ctors' →
(info = info' → ctors = ctors' → P) → P |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer.0.SubMulAction.ofStabilizer._simp_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) |
_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 |
Vector.toList_ofFn | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → α}, (Vector.ofFn f).toList = List.ofFn f |
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)) |
Combinatorics.Line.coe_injective | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_2} {ι : Type u_3} [Nontrivial α], Function.Injective Combinatorics.Line.toFun |
Lean.Doc.Parser.document.formatter | Lean.DocString.Formatter | Lean.PrettyPrinter.Formatter |
ContinuousAt.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ} {x : α},
ContinuousAt f x → ContinuousAt (fun y => Complex.exp (f y)) x |
Lean.Elab.abortTermExceptionId | Lean.Elab.Exception | Lean.InternalExceptionId |
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 : ι) → Module R (G' i)] {f' : (i j : ι) → i ≤ j → G' i →ₗ[R] G' j} (e : (i : ι) → G i ≃ₗ[R] G' i)
(he : ∀ (i j : ι) (h : i ≤ j), ↑(e j) ∘ₗ f i j h = f' i j h ∘ₗ ↑(e i)) {i : ι} (g : G' i),
(Module.DirectLimit.congr e he).symm ((Module.DirectLimit.of R ι G' f' i) g) =
(Module.DirectLimit.of R ι G f i) ((e i).symm g) |
apply_le_nnnorm_cfc_nnreal._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax |
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.comp AddMonoid.Coprod.inl)
(AddMonoid.Coprod.map AddMonoid.Coprod.inr (AddMonoidHom.id P))) =
AddMonoidHom.id (AddMonoid.Coprod M (AddMonoid.Coprod N P)) |
_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) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 3552 t.ctorIdx → motive t) → motive t |
Lean.Core.mkSnapshot?._auto_1 | Lean.CoreM | Lean.Syntax |
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.rightUnitor.inv).coconeAt X)) |
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 |
IsClosed.isCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyPseudoMetrizableSpace X] {s : Set X},
IsClosed s → TopologicalSpace.IsCompletelyPseudoMetrizableSpace ↑s |
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.DHashMap.Internal.IsHashSelf self →
∀ (k : α),
(↑(Std.DHashMap.Internal.mkIdx self.size ⋯ (hash k))).toNat = i.toNat →
Std.Internal.List.containsKey k l = false |
PrimeMultiset.prod_sup | Mathlib.Data.PNat.Factors | ∀ (u v : PrimeMultiset), (u ⊔ v).prod = u.prod.lcm v.prod |
MeasureTheory.Measure.restrict_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (s : Set α), MeasureTheory.Measure.restrict 0 s = 0 |
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 |
Lean.Parser.Tactic.anyGoals | Init.Tactics | Lean.ParserDescr |
WittVector.polyOfInterest | Mathlib.RingTheory.WittVector.MulCoeff | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℕ → MvPolynomial (Fin 2 × ℕ) ℤ |
_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 |
_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) |
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 |
Lean.MetavarDecl | Lean.MetavarContext | Type |
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 |
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : Type u} → Std.Tactic.BVDecide.LRAT.Internal.ReduceResult α |
setOf_minimal_antichain | Mathlib.Order.Antichain | ∀ {α : Type u_1} [inst : PartialOrder α] (P : α → Prop), IsAntichain (fun x1 x2 => x1 ≤ x2) {x | Minimal P x} |
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' := ⋯ } |
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 |
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 |
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 |
Std.TreeMap.keyAtIdx? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → ℕ → Option α |
Matrix.conjTransposeRingEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (α : Type v) [inst : Semiring α] [inst_1 : StarRing α] [inst_2 : Fintype m] (M : (Matrix m m α)ᵐᵒᵖ),
(Matrix.conjTransposeRingEquiv m α).symm M = (MulOpposite.unop M).conjTranspose |
_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 |
_private.Lean.Environment.0.Lean.importModulesCore.match_3 | Lean.Environment | (motive : Option Lean.ImportedModule✝ → Sort u_1) →
(x : Option Lean.ImportedModule✝¹) →
((mod : Lean.ImportedModule✝²) → motive (some mod)) → ((x : Option Lean.ImportedModule✝³) → motive x) → motive x |
AddGroupNormClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : AddGroup α] →
[inst_1 : AddCommMonoid β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : AddGroupNormClass F α β → Sort u} →
(t : AddGroupNormClass F α β) →
([toAddGroupSeminormClass : AddGroupSeminormClass F α β] →
(eq_zero_of_map_eq_zero : ∀ (f : F) {a : α}, f a = 0 → a = 0) → motive ⋯) →
motive t |
_private.Lean.Expr.0.Lean.Expr.getForallBody._sparseCasesOn_1 | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t |
Ring.DirectLimit.instInhabited | Mathlib.Algebra.Colimit.Ring | {ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → CommRing (G i)] → (f : (i j : ι) → i ≤ j → G i → G j) → Inhabited (Ring.DirectLimit G f) |
CategoryTheory.evaluationLeftAdjoint_map_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {x d₂ : D} (f : x ⟶ d₂)
(x_1 : C),
((CategoryTheory.evaluationLeftAdjoint D c).map f).app x_1 =
CategoryTheory.Limits.Sigma.desc fun h =>
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Sigma.ι (fun x => d₂) h) |
Mathlib.Notation3.MatchState.getBinders | Mathlib.Util.Notation3 | Mathlib.Notation3.MatchState → Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinderParenthesized) |
Std.Internal.IO.Async.System.UserId.toNat | Std.Internal.Async.System | Std.Internal.IO.Async.System.UserId → ℕ |
Lean.Server.Reference.aliases._default | Lean.Server.References | Array Lean.Lsp.RefIdent |
BoxIntegral.unitPartition.box_upper | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] (ν : ι → ℤ),
(BoxIntegral.unitPartition.box n ν).upper = fun i => (↑(ν i) + 1) / ↑n |
CategoryTheory.cocones_map_app_app | Mathlib.CategoryTheory.Limits.Cones | ∀ (J : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{X Y : (CategoryTheory.Functor J C)ᵒᵖ} (f : X ⟶ Y) (X_1 : C)
(a : (CategoryTheory.coyoneda.obj (Opposite.op (Opposite.unop X))).obj ((CategoryTheory.Functor.const J).obj X_1))
(X_2 : J),
(((CategoryTheory.cocones J C).map f).app X_1 a).app X_2 =
CategoryTheory.CategoryStruct.comp (f.unop.app X_2) (a.app X_2) |
ContinuousLinearMap.toLinearMap₁₂ | Mathlib.Topology.Algebra.Module.StrongTopology | {R : Type u_1} →
{𝕜₂ : Type u_3} →
{𝕜₃ : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
{G : Type u_7} →
[inst : Semiring R] →
[inst_1 : NormedField 𝕜₂] →
[inst_2 : NormedField 𝕜₃] →
[inst_3 : AddCommMonoid E] →
[inst_4 : Module R E] →
[inst_5 : TopologicalSpace E] →
[inst_6 : AddCommGroup F] →
[inst_7 : Module 𝕜₂ F] →
[inst_8 : TopologicalSpace F] →
[inst_9 : AddCommGroup G] →
[inst_10 : Module 𝕜₃ G] →
[inst_11 : TopologicalSpace G] →
[inst_12 : IsTopologicalAddGroup G] →
[inst_13 : ContinuousConstSMul 𝕜₃ G] →
{σ₁₃ : R →+* 𝕜₃} →
{σ₂₃ : 𝕜₂ →+* 𝕜₃} → (E →SL[σ₁₃] F →SL[σ₂₃] G) → E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G |
_private.Mathlib.FieldTheory.KummerExtension.0.exists_root_adjoin_eq_top_of_isCyclic.match_1_5 | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_2) [inst : Field K] (L : Type u_1) [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : ↥(OrderDual.ofDual ⊥) → Prop) (h : ↥(OrderDual.ofDual ⊥)),
(∀ (σ' : Gal(L/K)) (hσ' : σ' ∈ OrderDual.ofDual ⊥), motive ⟨σ', hσ'⟩) → motive h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.