name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} [h : Decidable p], (false = decide p) = ¬p |
Lean.Server.Snapshots.Snapshot.recOn | Lean.Server.Snapshots | {motive : Lean.Server.Snapshots.Snapshot → Sort u} →
(t : Lean.Server.Snapshots.Snapshot) →
((stx : Lean.Syntax) →
(mpState : Lean.Parser.ModuleParserState) →
(cmdState : Lean.Elab.Command.State) → motive { stx := stx, mpState := mpState, cmdState := cmdState }) →
motive t |
AddLocalization.liftOn₂_mk | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p)
(H :
∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
(AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d')
(a c : M) (b d : ↥S), (AddLocalization.mk a b).liftOn₂ (AddLocalization.mk c d) f H = f a b c d |
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ : CategoryTheory.Functor J C) {F₂ F₂' : CategoryTheory.Functor J C} (g : F₂ ⟶ F₂') (j : J),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.whiskerLeft F₁ g).app j)
(CategoryTheory.SemiCartesianMonoidalCategory.snd (F₁.obj j) (F₂'.obj j)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.snd (F₁.obj j) (F₂.obj j))
(g.app j) |
Polynomial.map_evalRingHom_eval | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p |
MulArchimedeanClass.mk_right_le_mk_mul_iff._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk (a * b)) = (MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk a) |
Units.isOpenMap_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val |
IsSemisimpleModule.recOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive t |
Pi.instSub | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {G : ι → Type u_4} → [(i : ι) → Sub (G i)] → Sub ((i : ι) → G i) |
Set.Definable.compl | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ |
PresheafOfModules.instIsLocalizationSheafOfModulesSheafificationInverseImageFunctorOppositeAbWToPresheaf | Mathlib.Algebra.Category.ModuleCat.Sheaf.Localization | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.val)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]
[inst_3 : J.WEqualsLocallyBijective AddCommGrpCat] [inst_4 : CategoryTheory.HasWeakSheafify J AddCommGrpCat],
(PresheafOfModules.sheafification α).IsLocalization (J.W.inverseImage (PresheafOfModules.toPresheaf R₀)) |
left_subset_compRel | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {s t : SetRel α α}, idRel ⊆ t → s ⊆ s.comp t |
Std.DHashMap.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∈ m → m.get? a = some (m.getD a fallback) |
Finset.sup_eq_sSup_image | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β), s.sup f = sSup (f '' ↑s) |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier | Mathlib.Algebra.Category.MonCat.Basic | CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => ↑x1 →+ ↑x2 |
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_3 | Mathlib.Probability.Distributions.Exponential | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) |
CategoryTheory.Functor.OplaxMonoidal.instIsIsoη | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] [CategoryTheory.Limits.PreservesFiniteProducts F],
CategoryTheory.IsIso (CategoryTheory.Functor.OplaxMonoidal.η F) |
WCovBy.eq_or_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ⩿ a → a = b ∨ b ⋖ a |
CompactExhaustion.mk.inj | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} {inst : TopologicalSpace X} {toFun : ℕ → Set X} {isCompact' : ∀ (n : ℕ), IsCompact (toFun n)}
{subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))} {iUnion_eq' : ⋃ n, toFun n = Set.univ}
{toFun_1 : ℕ → Set X} {isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n)}
{subset_interior_succ'_1 : ∀ (n : ℕ), toFun_1 n ⊆ interior (toFun_1 (n + 1))}
{iUnion_eq'_1 : ⋃ n, toFun_1 n = Set.univ},
{ toFun := toFun, isCompact' := isCompact', subset_interior_succ' := subset_interior_succ',
iUnion_eq' := iUnion_eq' } =
{ toFun := toFun_1, isCompact' := isCompact'_1, subset_interior_succ' := subset_interior_succ'_1,
iUnion_eq' := iUnion_eq'_1 } →
toFun = toFun_1 |
Fin.shiftLeft | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n |
Matrix.uniqueEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : Unique m] [inst_1 : Unique n] (a : A),
Matrix.uniqueEquiv.symm a = Matrix.of fun x x_1 => a |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro |
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1 | Mathlib.Tactic.Abel | Lean.Macro |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : F.obj a ⟶ F.obj b}
(h : CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.CategoryStruct.id b)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).inv) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (F.map f)).hom
(CategoryTheory.CategoryStruct.comp (F.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv)
(CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct.id b)).hom h)) |
IntermediateField.exists_algHom_of_splits_of_aeval | Mathlib.FieldTheory.Extension | ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K],
(∀ (s : E), IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
∀ {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 → ∃ φ, φ x = y |
Finset.nontrivial_iff_ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → (s.Nontrivial ↔ s ≠ {a}) |
PartOrdEmb.dual._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ (X : PartOrdEmb),
PartOrdEmb.ofHom (PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X)).dual =
CategoryTheory.CategoryStruct.id { carrier := (↑X)ᵒᵈ, str := OrderDual.instPartialOrder ↑X } |
Plausible.InjectiveFunction.sliceSizes.eq_def | Mathlib.Testing.Plausible.Functions | ∀ (x : ℕ),
Plausible.InjectiveFunction.sliceSizes x =
let n := x;
if h : 0 < n then
have this := ⋯;
MLList.cons ⟨n, h⟩ (Plausible.InjectiveFunction.sliceSizes (n / 2))
else MLList.nil |
pure_le_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._simp_1_5 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) |
Lean.Elab.Term.MutualClosure.FixPoint.run | Lean.Elab.MutualDef | Array Lean.FVarId → Lean.Elab.Term.MutualClosure.UsedFVarsMap → Lean.Elab.Term.MutualClosure.UsedFVarsMap |
NonemptyFinLinOrd.ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | {X Y : Type u} →
[inst : Nonempty X] →
[inst_1 : LinearOrder X] →
[inst_2 : Fintype X] →
[inst_3 : Nonempty Y] →
[inst_4 : LinearOrder Y] → [inst_5 : Fintype Y] → (X →o Y) → (NonemptyFinLinOrd.of X ⟶ NonemptyFinLinOrd.of Y) |
Ideal.under_under | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (𝔓 : Ideal C),
Ideal.under A (Ideal.under B 𝔓) = Ideal.under A 𝔓 |
_private.Init.Data.Int.LemmasAux.0.Int.min_assoc._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬min (min a b) c = min a (min b c) → False |
List.infix_filter_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α}, l₂ <:+: List.filter p l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = List.filter p l |
Std.Do.SPred.true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, P ⊢ₛ ⌜True⌝ |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.addG.match_1 | Mathlib.Tactic.Abel | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((n : Lean.Name) → motive n) → motive x |
BoxIntegral.Box.Ioo_subset_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Box.Ioo I ⊆ ↑I |
FormalMultilinearSeries.coeff_eq_zero | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {n : ℕ}, p.coeff n = 0 ↔ p n = 0 |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_5.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(rs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l_1.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3) →
(l_1 : Std.DTreeMap.Internal.Impl α β) →
(hlb : l_1.Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l_1.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
((hlb : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond Std.DTreeMap.Internal.Impl.leaf.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive Std.DTreeMap.Internal.Impl.leaf hlb hlr) →
((ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr) hlb hlr) →
motive l_1 hlb hlr |
Subsemigroup.range_subtype | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s |
String.Pos.Raw.isValidForSlice_stringSliceTo | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos} {q : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice (s.sliceTo p) q ↔ q ≤ p.offset ∧ String.Pos.Raw.IsValid s q |
Lean.Meta.instInhabitedUnificationHints.default | Lean.Meta.UnificationHint | Lean.Meta.UnificationHints |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι) (n : ℕ), n + 2 ≤ (a :: l).length → n + 1 < (a :: l).length |
Lean.Omega.LinearCombo.coordinate_eval_0 | Init.Omega.LinearCombo | ∀ {a0 : ℤ} {t : List ℤ}, (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0 |
Bundle.Pretrivialization.linearMapAt_def_of_notMem | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : AddCommMonoid F] [inst_4 : Module R F]
[inst_5 : (x : B) → AddCommMonoid (E x)] [inst_6 : (x : B) → Module R (E x)]
(e : Bundle.Pretrivialization F Bundle.TotalSpace.proj) [inst_7 : Bundle.Pretrivialization.IsLinear R e] {b : B},
b ∉ e.baseSet → Bundle.Pretrivialization.linearMapAt R e b = 0 |
AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.isLocallyFraction | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
TopCat.LocalPredicate fun x => HomogeneousLocalization.AtPrime 𝒜 x.asHomogeneousIdeal.toIdeal |
List.eq_nil_of_map_eq_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l = [] → l = [] |
Lean.Elab.ContextInfo.parentDecl?._default | Lean.Elab.InfoTree.Types | Option Lean.Name |
CategoryTheory.OplaxFunctor.comp | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Bicategory D] →
CategoryTheory.OplaxFunctor B C → CategoryTheory.OplaxFunctor C D → CategoryTheory.OplaxFunctor B D |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractive.match_3 | Lean.Widget.InteractiveDiagnostic | (motive : Lean.Widget.EmbedFmt✝ → Sort u_1) →
(x : Lean.Widget.EmbedFmt✝¹) →
((ctx : Lean.Elab.ContextInfo) →
(infos : Std.TreeMap ℕ Lean.Elab.Info compare) → motive (Lean.Widget.EmbedFmt.code✝ ctx infos)) →
((ctx : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) → (g : Lean.MVarId) → motive (Lean.Widget.EmbedFmt.goal✝ ctx lctx g)) →
((wi : Lean.Widget.WidgetInstance) → (alt : Std.Format) → motive (Lean.Widget.EmbedFmt.widget✝ wi alt)) →
((cls : Lean.Name) →
(msg : Std.Format) →
(collapsed : Bool) →
(children : Lean.Widget.StrictOrLazy (Array Std.Format) (Array Lean.MessageData)) →
motive (Lean.Widget.EmbedFmt.trace✝ cls msg collapsed children)) →
(Unit → motive Lean.Widget.EmbedFmt.ignoreTags✝) → motive x |
Associates.FactorSet.prod | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {α : Type u_1} → [inst : CommMonoidWithZero α] → Associates.FactorSet α → Associates α |
List.length_product | Mathlib.Data.List.ProdSigma | ∀ {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β), (l₁ ×ˢ l₂).length = l₁.length * l₂.length |
FirstOrder.Language.IsRelational | Mathlib.ModelTheory.Basic | FirstOrder.Language → Prop |
Submodule.map.congr_simp | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] (f f_1 : M →ₛₗ[σ₁₂] M₂),
f = f_1 → ∀ (p p_1 : Submodule R M), p = p_1 → Submodule.map f p = Submodule.map f_1 p_1 |
CategoryTheory.ShortComplex.moduleCat_exact_iff | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact ↔
∀ (x₂ : ↑S.X₂),
(CategoryTheory.ConcreteCategory.hom S.g) x₂ = 0 → ∃ x₁, (CategoryTheory.ConcreteCategory.hom S.f) x₁ = x₂ |
CategoryTheory.IsCofiltered.nonempty | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C], Nonempty C |
Lean.Widget.inst._@.Lean.Widget.Basic.2038268869._hygCtx._hyg.3 | Lean.Widget.Basic | TypeName Lean.Elab.InfoWithCtx |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.noConfusionType | Lean.Meta.Tactic.Grind.Split | Sort u → Lean.Meta.Grind.SplitCandidate✝ → Lean.Meta.Grind.SplitCandidate✝ → Sort u |
CategoryTheory.Retract.op_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y), h.op.i = h.r.op |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.isHashSelf_filterMapₘ._simp_1_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b |
Std.DHashMap.isEmpty_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty) |
CategoryTheory.Limits.spanExt_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Y} {g : X ⟶ Z} {f' : X' ⟶ Y'} {g' : X' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iY.hom)
(wg : CategoryTheory.CategoryStruct.comp iX.hom g' = CategoryTheory.CategoryStruct.comp g iZ.hom),
(CategoryTheory.Limits.spanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingSpan.left = iY.inv |
CategoryTheory.IsAccessibleCategory.rec | Mathlib.CategoryTheory.Presentable.LocallyPresentable | {C : Type u} →
[hC : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsAccessibleCategory.{w, v, u} C → Sort u_1} →
((exists_cardinal : ∃ κ, ∃ (x : Fact κ.IsRegular), CategoryTheory.IsCardinalAccessibleCategory C κ) → motive ⋯) →
(t : CategoryTheory.IsAccessibleCategory.{w, v, u} C) → motive t |
IntermediateField.isIntegral_iff | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {S : IntermediateField K L}
{x : ↥S}, IsIntegral K x ↔ IsIntegral K ↑x |
Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer_1 | Lean.Parser | IO Unit |
AlgebraicGeometry.Scheme.IdealSheafData.support_antitone | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Antitone AlgebraicGeometry.Scheme.IdealSheafData.support |
CategoryTheory.CatCenter.localizationRingHom | Mathlib.CategoryTheory.Center.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : CategoryTheory.Preadditive D] →
[L.Additive] → CategoryTheory.CatCenter C →+* CategoryTheory.CatCenter D |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_3 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) |
Std.DHashMap.Internal.Raw₀.insertIfNew_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α} {v : β k}, (↑(m₁.insertIfNew k v)).Equiv ↑(m₂.insertIfNew k v) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
IsCompact.locallyCompactSpace_of_mem_nhds_of_group | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {K : Set G},
IsCompact K → ∀ {x : G}, K ∈ nhds x → LocallyCompactSpace G |
ringChar.of_eq | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ}, ringChar R = p → CharP R p |
WittVector.poly_eq_of_wittPolynomial_bind_eq | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ) [Fact (Nat.Prime p)] (f g : ℕ → MvPolynomial ℕ ℤ),
(∀ (n : ℕ), (MvPolynomial.bind₁ f) (wittPolynomial p ℤ n) = (MvPolynomial.bind₁ g) (wittPolynomial p ℤ n)) → f = g |
TwoSidedIdeal.orderIsoIsTwoSided_symm_apply | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : { I // I.IsTwoSided }),
(RelIso.symm TwoSidedIdeal.orderIsoIsTwoSided) I =
have this := ⋯;
(↑I).toTwoSided |
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Ring 𝕜] [NoZeroDivisors 𝕜],
IsPreconnected S → ContinuousOn f S → Set.EqOn (f ^ 2) 1 S → Set.EqOn f 1 S ∨ Set.EqOn f (-1) S |
Fin.preimage_natAdd_uIoc_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), Fin.natAdd m ⁻¹' Set.uIoc (Fin.natAdd m i) (Fin.natAdd m j) = Set.uIoc i j |
FirstOrder.Language.Substructure.closure_induction | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : Set M} {p : M → Prop} {x : M},
x ∈ (FirstOrder.Language.Substructure.closure L).toFun s →
(∀ x ∈ s, p x) → (∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f (setOf p)) → p x |
String.utf8ByteSize_sliceFrom | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos}, (s.sliceFrom p).utf8ByteSize = s.utf8ByteSize - p.offset.byteIdx |
CategoryTheory.CartesianClosed.uncurry | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A X Y : C} →
[inst_2 : CategoryTheory.Closed A] → (Y ⟶ A ⟹ X) → (CategoryTheory.MonoidalCategoryStruct.tensorObj A Y ⟶ X) |
Set.preimage_const | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (b : β) (s : Set β) [inst : Decidable (b ∈ s)],
(fun x => b) ⁻¹' s = if b ∈ s then Set.univ else ∅ |
Multiset.union_le_iff | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ∪ t ≤ u ↔ s ≤ u ∧ t ≤ u |
genericPoint_specializes | Mathlib.Topology.Sober | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSober α] [inst_2 : IrreducibleSpace α] (x : α),
genericPoint α ⤳ x |
Mathlib.Meta.NormNum.Result.toSimpResult.match_1 | Mathlib.Tactic.NormNum.Result | {u : Lean.Level} →
{α : Q(Type u)} →
{e : Q(«$α»)} →
(motive : (e' : Q(«$α»)) × Q(«$e» = «$e'») → Sort u_1) →
(x : (e' : Q(«$α»)) × Q(«$e» = «$e'»)) →
((expr : Q(«$α»)) → (proof? : Q(«$e» = «$expr»)) → motive ⟨expr, proof?⟩) → motive x |
PositiveLinearMap.gnsStarAlgHom._proof_13 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] (f : A →ₚ[ℂ] ℂ),
SMulCommClass ℂ ℂ (UniformSpace.Completion f.PreGNS) |
Filter.HasBasis.inf_neBot_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ((l ⊓ l').NeBot ↔ ∀ ⦃i : ι⦄, p i → ∀ ⦃s' : Set α⦄, s' ∈ l' → (s i ∩ s').Nonempty) |
BialgEquiv.ofAlgEquiv._proof_7 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R B] (f : A ≃ₐ[R] B),
(Algebra.TensorProduct.map ↑f ↑f).comp (Bialgebra.comulAlgHom R A) = (Bialgebra.comulAlgHom R B).comp ↑f →
TensorProduct.map { toFun := f.toFun, map_add' := ⋯, map_smul' := ⋯ }
{ toFun := f.toFun, map_add' := ⋯, map_smul' := ⋯ } ∘ₗ
CoalgebraStruct.comul =
CoalgebraStruct.comul ∘ₗ { toFun := f.toFun, map_add' := ⋯, map_smul' := ⋯ } |
CategoryTheory.Functor.PreservesRightHomologyOf.mk._flat_ctor | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {F : CategoryTheory.Functor C D}
[inst_4 : F.PreservesZeroMorphisms] {S : CategoryTheory.ShortComplex C},
(∀ (h : S.RightHomologyData), h.IsPreservedBy F) → F.PreservesRightHomologyOf S |
_private.Aesop.Forward.State.0.Aesop.VariableMap.modifyM.match_3 | Aesop.Forward.State | (motive : Option Aesop.InstMap → Sort u_1) →
(x : Option Aesop.InstMap) → (Unit → motive none) → ((m : Aesop.InstMap) → motive (some m)) → motive x |
Matroid.mapSetEmbedding_indep_iff' | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {f : ↑M.E ↪ β} {I : Set β},
(M.mapSetEmbedding f).Indep I ↔ ∃ I₀, M.Indep (Subtype.val '' I₀) ∧ I = ⇑f '' I₀ |
Topology.IsEmbedding.comapUniformSpace | Mathlib.Topology.UniformSpace.UniformEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] → [u : UniformSpace β] → (f : α → β) → Topology.IsEmbedding f → UniformSpace α |
_private.Mathlib.NumberTheory.DirichletCharacter.Orthogonality.0.DirichletCharacter.sum_char_inv_mul_char_eq._simp_1_1 | Mathlib.NumberTheory.DirichletCharacter.Orthogonality | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) |
Nat.add_mod_add_ite | Mathlib.Data.Nat.ModEq | ∀ (a b c : ℕ), ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c |
Algebra.idealMap._proof_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : Semiring S] [inst_2 : Algebra R S] (I : Ideal R),
∀ x ∈ I, (algebraMap R S) x ∈ Ideal.map (algebraMap R S) I |
_private.Mathlib.RingTheory.WittVector.TeichmullerSeries.0.WittVector._aux_Mathlib_RingTheory_WittVector_TeichmullerSeries___unexpand_WittVector_1 | Mathlib.RingTheory.WittVector.TeichmullerSeries | Lean.PrettyPrinter.Unexpander |
Finset.toRight_union | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u v : Finset (α ⊕ β)} [inst : DecidableEq α] [inst_1 : DecidableEq β],
(u ∪ v).toRight = u.toRight ∪ v.toRight |
HasSum.mul_of_nonarchimedean | Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean | ∀ {α : Type u_1} {β : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : UniformSpace R] [IsUniformAddGroup R]
[NonarchimedeanRing R] {f : α → R} {g : β → R} {a b : R},
HasSum f a → HasSum g b → HasSum (fun i => f i.1 * g i.2) (a * b) |
Asymptotics.isEquivalent_of_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
Filter.Tendsto (u / v) l (nhds 1) → Asymptotics.IsEquivalent l u v |
Lean.Compiler.LCNF.CSE.State.noConfusion | Lean.Compiler.LCNF.CSE | {P : Sort u} → {t t' : Lean.Compiler.LCNF.CSE.State} → t = t' → Lean.Compiler.LCNF.CSE.State.noConfusionType P t t' |
Aesop.Queue.mk._flat_ctor | Aesop.Search.Queue.Class | {Q : Type} → BaseIO Q → (Q → Array Aesop.GoalRef → BaseIO Q) → (Q → BaseIO (Option Aesop.GoalRef × Q)) → Aesop.Queue Q |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.