name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int16.reduceGE._regBuiltin.Int16.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.780327193._hygCtx._hyg.236 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
DifferentiableWithinAt.continuousMultilinear_apply_const | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_5} {M : ι → Type u_6}
[inst_3 : (i : ι) → NormedAddCommGroup (M i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (M i)] {H : Type u_7}
[inst_5 : NormedAddCommGroup... | null | true |
Std.DTreeMap.wf | Std.Data.DTreeMap.Basic | ∀ {α : Type u} {β : α → Type v} {cmp : autoParam (α → α → Ordering) Std.DTreeMap._auto_1} (self : Std.DTreeMap α β cmp),
self.inner.WF | Internal implementation detail of the tree map. | true |
GrpCat.SurjectiveOfEpiAuxs.g_apply_fromCoset | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B) (x : ↑B) (y : ↑(Set.range fun x => x • ↑(GrpCat.Hom.hom f).range)),
((GrpCat.SurjectiveOfEpiAuxs.g f) x) (GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset y) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨x • ↑y, ⋯⟩ | null | true |
integral_log | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (s : ℝ) in a..b, Real.log s = b * Real.log b - a * Real.log a - b + a | null | true |
_private.Mathlib.Logic.Equiv.Set.0.Equiv.preimage_piEquivPiSubtypeProd_symm_pi._simp_1_3 | Mathlib.Logic.Equiv.Set | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
LinearEquiv.prodProdProdComm_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) (M₃ : Type y) (M₄ : Type z) [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : AddCommMonoid M₄] [inst_5 : Module R M]
[inst_6 : Module R M₂] [inst_7 : Module R M₃] [inst_8 : Module R M₄] (mnmn : (M × M₂) × M₃ × ... | null | true |
Lean.Parser.registerBuiltinDynamicParserAttribute | Lean.Parser.Extension | Lean.Name → Lean.Name → autoParam Lean.Name Lean.Parser.registerBuiltinDynamicParserAttribute._auto_1 → IO Unit | A builtin parser attribute that can be extended by users. | true |
RCLike.natCast._inherited_default | Mathlib.Analysis.RCLike.Basic | {K : semiOutParam (Type u_1)} → (K → K → K) → K → K → ℕ → K | null | false |
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor._sizeOf_inst | Mathlib.Tactic.Linarith.Datatypes | SizeOf Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor | null | false |
_private.Lean.Compiler.Old.0.Lean.Compiler.checkIsDefinition.match_4 | Lean.Compiler.Old | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((info : Lean.AsyncConstantInfo) → motive (some info)) → ((x : Option Lean.AsyncConstantInfo) → motive x) → motive x | null | false |
CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryCofan X Y}
(h : CategoryTheory.Limits.IsColimit s) {f g : s.pt ⟶ W},
CategoryTheory.CategoryStruct.comp s.inl f = CategoryTheory.CategoryStruct.comp s.inl g →
CategoryTheory.CategoryStruct.comp s.inr f = Catego... | null | true |
CategoryTheory.Functor.mapMonCompIso._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_4} [inst_4 : CategoryTheory.Category.{u_3, u_4} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
VectorBundleCore.vectorBundle | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι),
VectorBundle R F Z.Fiber | null | true |
CategoryTheory.FreeMonoidalCategory.Hom.ctorElim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
(ctorIdx : ℕ) →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
ctorIdx = t.ctorIdx → CategoryTheory.FreeMonoidalCategory.Hom.ctorElimType ctorIdx → motive a a_1 t | null | false |
Aesop.PremiseIndex._sizeOf_inst | Aesop.Forward.PremiseIndex | SizeOf Aesop.PremiseIndex | null | false |
IsLocalization.algEquivOfAlgEquiv | Mathlib.RingTheory.Localization.Basic | {A : Type u_4} →
[inst : CommSemiring A] →
{R : Type u_5} →
[inst_1 : CommSemiring R] →
[inst_2 : Algebra A R] →
{M : Submonoid R} →
(S : Type u_6) →
[inst_3 : CommSemiring S] →
[inst_4 : Algebra A S] →
[inst_5 : Algebra R S] →
... | If `S`, `Q` are localizations of `R` and `P` at submonoids `M`, `T` respectively,
an isomorphism `h : R ≃ₐ[A] P` such that `h(M) = T` induces an isomorphism of localizations
`S ≃ₐ[A] Q`. | true |
ModuleCat.exteriorPower.functor | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | (R : Type u) → [inst : CommRing R] → ℕ → CategoryTheory.Functor (ModuleCat R) (ModuleCat R) | The functor `ModuleCat R ⥤ ModuleCat R` which sends a module to its
`n`th exterior power. | true |
CategoryTheory.PreGaloisCategory.PreservesIsConnected | Mathlib.CategoryTheory.Galois.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{D : Type v₁} → [inst_1 : CategoryTheory.Category.{v₂, v₁} D] → CategoryTheory.Functor C D → Prop | A functor is said to preserve connectedness if whenever `X : C` is connected,
also `F.obj X` is connected. | true |
sSupIndep_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_5} [inst : CompleteLattice α] (s : Set α), sSupIndep s ↔ iSupIndep Subtype.val | null | true |
Aesop.GoalState.ctorIdx | Aesop.Tree.Data | Aesop.GoalState → ℕ | null | false |
_private.Lean.Parser.Extension.0.Lean.Parser.resolveParserNameCore.isParser.match_1 | Lean.Parser.Extension | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Parser.Parser us)) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Parser.TrailingParser us)) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.ParserDescr us)) →
(... | null | false |
unexpandMkArray0 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
Monotone.partSeq | Mathlib.Order.Part | ∀ {α : Type u_1} [inst : Preorder α] {β γ : Type u_4} {f : α → Part (β → γ)} {g : α → Part β},
Monotone f → Monotone g → Monotone fun x => f x <*> g x | null | true |
Lean.Elab.Tactic.evalWithReducible | Lean.Elab.Tactic.ElabTerm | Lean.Elab.Tactic.Tactic | null | true |
Submonoid.mem_closure_pair | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_4} [inst : CommMonoid A] (a b c : A), c ∈ Submonoid.closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c | An element is in the closure of a two-element set if it is a linear combination of those two
elements. | true |
BooleanRing.sup_comm | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : α), a ⊔ b = b ⊔ a | null | true |
instNonUnitalCommCStarAlgebraSubtypeMemNonUnitalStarSubalgebraComplexElementalOfIsStarNormal._proof_7 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (x : A),
SMulCommClass ℂ ↥(NonUnitalStarAlgebra.elemental ℂ x) ↥(NonUnitalStarAlgebra.elemental ℂ x) | null | false |
Set.Ioi_pred_eq_Ici | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α),
Set.Ioi (Order.pred a) = Set.Ici a | null | true |
CategoryTheory.SmallObject.functorMapTgt.eq_1 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObj... | null | true |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv._proof_2 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H₁ : Type u_4}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | null | false |
Lean.Meta.UnificationConstraint.rec | Lean.Meta.UnificationHint | {motive : Lean.Meta.UnificationConstraint → Sort u} →
((lhs rhs : Lean.Expr) → motive { lhs := lhs, rhs := rhs }) → (t : Lean.Meta.UnificationConstraint) → motive t | null | false |
CategoryTheory.Functor.flipping | Mathlib.CategoryTheory.Functor.Currying | {C : Type u₂} →
[inst : CategoryTheory.Category.{v₂, u₂} C] →
{D : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} D] →
{E : Type u₄} →
[inst_2 : CategoryTheory.Category.{v₄, u₄} E] →
CategoryTheory.Functor C (CategoryTheory.Functor D E) ≌
CategoryTheory.Fun... | The equivalence of functor categories given by flipping. | true |
Action.Functor.mapActionPreservesLimitsOfShapeOfPreserves | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_3}
[inst_1 : CategoryTheory.Category.{v_2, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [inst_2 : Monoid G]
{J : Type u_5} [inst_3 : CategoryTheory.Category.{v_3, u_5} J] [CategoryTheory.Limits.PreservesLimitsOfShape J F]
[Categ... | `F.mapAction : Action V G ⥤ Action W G` preserves limits of some shape `J` if
`V` has limits of shape `J` and `F` preserves limits of shape `J`. | true |
CategoryTheory.GradedObject.mapTrifunctorMapObj | Mathlib.CategoryTheory.GradedObject.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u... | Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₃`, graded objects `X₁ : GradedObject I₁ C₁`,
`X₂ : GradedObject I₂ C₂`, `X₃ : GradedObject I₃ C₃`, and a map `p : I₁ × I₂ × I₃ → J`,
this is the `J`-graded object sending `j` to the coproduct of
`((F.obj (X₁ i₁)).obj (X₂ i₂)).obj (X₃ i₃)` for `p ⟨i₁, i₂, i₃⟩ = k`. | true |
Lean.Compiler.InlineAttributeKind.alwaysInline.sizeOf_spec | Lean.Compiler.InlineAttrs | sizeOf Lean.Compiler.InlineAttributeKind.alwaysInline = 1 | null | true |
Lean.ConstantInfo.recInfo.sizeOf_spec | Lean.Declaration | ∀ (val : Lean.RecursorVal), sizeOf (Lean.ConstantInfo.recInfo val) = 1 + sizeOf val | null | true |
AddSubgroup.normalizer_addCommutator_ge_right | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H₁ H₂ : AddSubgroup G), H₂ ≤ AddSubgroup.normalizer ↑⁅H₁, H₂⁆ | null | true |
Topology.IsCoinducing.continuous | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Topology.IsCoinducing f → Continuous f | null | true |
continuous_if_const | Mathlib.Topology.Piecewise | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} (p : Prop)
[inst_2 : Decidable p], (p → Continuous f) → (¬p → Continuous g) → Continuous fun a => if p then f a else g a | null | true |
Finmap.liftOn₂_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} {γ : Type u_1} (s₁ s₂ : AList β) (f : AList β → AList β → γ)
(H : ∀ (a₁ b₁ a₂ b₂ : AList β), a₁.entries.Perm a₂.entries → b₁.entries.Perm b₂.entries → f a₁ b₁ = f a₂ b₂),
s₁.toFinmap.liftOn₂ s₂.toFinmap f H = f s₁ s₂ | null | true |
Std.TreeMap.getElem_insertMany_list_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [inst_2 : Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α}
(contains : (List.map Prod.fst l).contains k = false) {h' : k ∈ t.insertMany l}, (t.insertMany l)[k] = t[k] | null | true |
partialFunToPointed._proof_4 | Mathlib.CategoryTheory.Category.PartialFun | ∀ (X : PartialFun),
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point =
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point | null | false |
NatPow.casesOn | Init.Prelude | {α : Type u} → {motive : NatPow α → Sort u_1} → (t : NatPow α) → ((pow : α → ℕ → α) → motive { pow := pow }) → motive t | null | false |
Std.DHashMap.Const.mem_unitOfList._simp_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k : α},
(k ∈ Std.DHashMap.Const.unitOfList l) = (l.contains k = true) | null | false |
CategoryTheory.Bicategory.eqToHom_whiskerRight | Mathlib.CategoryTheory.Bicategory.Strict.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (η : f = g) (h : b ⟶ c),
CategoryTheory.Bicategory.whiskerRight (CategoryTheory.eqToHom η) h = CategoryTheory.eqToHom ⋯ | null | true |
Localization.AtPrime.mapPiEvalRingHom | Mathlib.RingTheory.Localization.AtPrime.Basic | {ι : Type u_4} →
{R : ι → Type u_5} →
[inst : (i : ι) → CommSemiring (R i)] →
{i : ι} →
(I : Ideal (R i)) →
[inst_1 : I.IsPrime] → Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I) →+* Localization.AtPrime I | `Localization.localRingHom` specialized to a projection homomorphism from a product ring. | true |
Filter.Germ.instLinearOrder | Mathlib.Order.Filter.FilterProduct | {α : Type u} → {β : Type v} → {φ : Ultrafilter α} → [LinearOrder β] → LinearOrder ((↑φ).Germ β) | If `φ` is an ultrafilter then the ultraproduct is a linear order. | true |
_private.Mathlib.Data.Set.Pairwise.Lattice.0.Set.pairwise_iUnion₂._simp_1_3 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
AsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | Type u_4 → Type u_4 | Type synonym to view a Boolean ring as a Boolean algebra. | true |
_private.Mathlib.Topology.Sheaves.Flasque.0.TopCat.Sheaf.IsFlasque.epi_of_shortExact.match_1_7.eq_2 | Mathlib.Topology.Sheaves.Flasque | ∀ (motive : Fin 2 → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()) =
h_2 () | null | true |
Graph.IsSpanningSubgraph.mono_left | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G H K : Graph α β}, H ≤ K → K ≤ G → H ≤s G → K ≤s G | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.instHashablePurity.hash.match_1 | Lean.Compiler.LCNF.Basic | (motive : Lean.Compiler.LCNF.Purity → Sort u_1) →
(x : Lean.Compiler.LCNF.Purity) →
(Unit → motive Lean.Compiler.LCNF.Purity.pure) → (Unit → motive Lean.Compiler.LCNF.Purity.impure) → motive x | null | false |
isClopen_range_inr | Mathlib.Topology.Clopen | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsClopen (Set.range Sum.inr) | null | true |
Convex.smul_vadd_mem_of_mem_nhds_of_mem_asymptoticCone | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [IsStrictOrderedRing k]
[inst_3 : TopologicalSpace k] [OrderTopology k] [inst_5 : AddCommGroup V] [inst_6 : Module k V]
[inst_7 : TopologicalSpace V] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : Set V} {c : k} {v p : V},
Convex k s →... | If `v` is in the asymptotic cone of a convex set `s`, then for every interior point `p`, the ray
of direction `v` starting from `p` is contained in `s`. | true |
Std.Do.SPred.forall_cons | Std.Do.SPred.SPred | ∀ {σs : List (Type u)} {σ : Type u} {s : σ} {α : Sort u_1} {P : α → Std.Do.SPred (σ :: σs)},
Std.Do.SPred.forall P s = spred(∀ a, P a s) | null | true |
Set.Nontrivial.not_subsingleton | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {s : Set α}, s.Nontrivial → ¬s.Subsingleton | **Alias** of the reverse direction of `Set.not_subsingleton_iff`. | true |
Algebra.TensorProduct.piScalarRight | Mathlib.RingTheory.TensorProduct.Pi | (R : Type u_1) →
(S : Type u_2) →
(A : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
[inst_3 : Semiring A] →
[inst_4 : Algebra R A] →
[inst_5 : Algebra S A] →
[inst_6 : IsScalarTower R ... | Variant of `Algebra.TensorProduct.piRight` with constant factors. | true |
Computation.Results.terminates | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → s.Terminates | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_diff!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun._unsafe_rec | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | (𝕜 : Type u_2) →
{α : Type u_5} →
[AddCommGroup 𝕜] → [One 𝕜] → [inst : Preorder α] → [LocallyFiniteOrder α] → [DecidableEq α] → α → α → 𝕜 | null | false |
CategoryTheory.MorphismProperty.Over.mapPullbackAdj._proof_10 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition] [inst_3 : Q.IsStableUnderBaseChange]
(f : X ⟶ Y) [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.IsStableUnderBaseChangeAlong f]
[inst... | null | false |
IncidenceAlgebra.sum_Icc_mu_left | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : Ring 𝕜] [inst_1 : PartialOrder α] [inst_2 : LocallyFiniteOrder α]
[inst_3 : DecidableEq α] (a b : α), ∑ x ∈ Finset.Icc a b, (IncidenceAlgebra.mu 𝕜) x b = if a = b then 1 else 0 | null | true |
Finset.union_val_nd | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).val = s.val.ndunion t.val | null | true |
div_le_inv_mul_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LinearOrder α] [MulLeftMono α] {a b : α} [MulRightMono α],
a / b ≤ a⁻¹ * b ↔ a ≤ b | null | true |
CategoryTheory.Functor.rightDerivedDesc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_5, u_3} H] →
(RF : CategoryTheory.Functor D H) →
{F : CategoryTheory.Functor C... | Constructor for natural transformations from a right derived functor. | true |
AddCommute.zsmul_add | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, AddCommute a b → ∀ (n : ℤ), n • (a + b) = n • a + n • b | null | true |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.Trie.format.match_1 | Lean.Meta.DiscrTree.Basic | {α : Type} →
(motive : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
((k : Lean.Meta.DiscrTree.Key) → (c : Lean.Meta.DiscrTree.Trie α) → motive (k, c)) → motive x | null | false |
LinearMap.rTensor_comp_lTensor | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} {Q : Type u_10}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (f : M →ₗ[R] P)
... | null | true |
Std.DTreeMap.Internal.Impl.getKey!_diff_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α] (h₁ : m₁.WF),
m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.diff m₂ ⋯).getKey! k = default | null | true |
MeasureTheory.FinStronglyMeasurable.sub | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → β}
[inst : TopologicalSpace β] [inst_1 : SubtractionMonoid β] [ContinuousSub β],
MeasureTheory.FinStronglyMeasurable f μ →
MeasureTheory.FinStronglyMeasurable g μ → MeasureTheory.FinStronglyMeasurable (f - g) μ | null | true |
_private.Lean.Parser.Extra.0.Lean.Parser.ppAllowUngrouped._regBuiltin.Lean.Parser.ppAllowUngrouped.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
HasStrictFDerivAt.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f g : E → ℂ} {f' g' : StrongDual ℂ E}
{x : E},
HasStrictFDerivAt f f' x →
HasStrictFDerivAt g g' x →
f x ∈ Complex.slitPlane →
HasStrictFDerivAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log ... | null | true |
TopCat.Presheaf.pushforwardEq_hom_app._proof_2 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} {f g : X ⟶ Y},
f = g →
∀ (U : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
(TopologicalSpace.Opens.map f).op.obj U = (TopologicalSpace.Opens.map g).op.obj U | null | false |
PreconnectedSpace.rec | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : PreconnectedSpace α → Sort u_1} →
((isPreconnected_univ : IsPreconnected Set.univ) → motive ⋯) → (t : PreconnectedSpace α) → motive t | null | false |
Mathlib.Tactic.Sat.Clause.mk.injEq | Mathlib.Tactic.Sat.FromLRAT | ∀ (lits : Array ℤ) (expr proof : Lean.Expr) (lits_1 : Array ℤ) (expr_1 proof_1 : Lean.Expr),
({ lits := lits, expr := expr, proof := proof } = { lits := lits_1, expr := expr_1, proof := proof_1 }) =
(lits = lits_1 ∧ expr = expr_1 ∧ proof = proof_1) | null | true |
Function.Injective.isMulTorsionFree | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] [IsMulTorsionFree N] (f : M →* N),
Function.Injective ⇑f → IsMulTorsionFree M | If the codomain of an injective monoid homomorphism is torsion free,
then so is the domain. | true |
_private.Init.Data.List.Basic.0.List.reverseAux.match_1.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (a : α) (l r : List α) (h_1 : (r : List α) → motive [] r)
(h_2 : (a : α) → (l r : List α) → motive (a :: l) r),
(match a :: l, r with
| [], r => h_1 r
| a :: l, r => h_2 a l r) =
h_2 a l r | null | true |
HomogeneousLocalization.NumDenSameDeg.instNeg._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [NegMemClass σ A] {𝒜 : ι → σ}
(x : Submonoid A) (c : HomogeneousLocalization.NumDenSameDeg 𝒜 x), -↑c.num ∈ 𝒜 c.deg | null | false |
imageToKernel_op | Mathlib.Algebra.Homology.Opposite | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] [inst_1 : CategoryTheory.Abelian V] {X Y Z : V}
(f : X ⟶ Y) (g : Y ⟶ Z) (w : CategoryTheory.CategoryStruct.comp f g = 0),
imageToKernel g.op f.op ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.imageSubobjectIso g.op ≪≫ (Category... | null | true |
CategoryTheory.Adjunction.coconesIsoComponentInv._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J C} (Y : D)
(t :... | null | false |
CategoryTheory.Limits.reflectsColimitsOfShape_of_natIso | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] {F G : CategoryTheory.Functor C D} (h : F ≅ G)
[CategoryTheory.Limits.ReflectsColimitsOfShape J F], CategoryTheory.Limits.ReflectsColimits... | Transfer reflection of colimits of shape along a natural isomorphism in the functor. | true |
Function.RightInverse.filter_map | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
Function.RightInverse g f → Function.RightInverse (Filter.map g) (Filter.map f) | null | true |
GradedRingHom.coe_mul | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_6} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} (f g : 𝒜 →+*ᵍ 𝒜),
⇑(f * g) = ⇑f ∘ ⇑g | null | true |
MeasureTheory.AEEqFun.instSub._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : AddGroup γ] [IsTopologicalAddGroup γ],
Continuous fun p => p.1 - p.2 | null | false |
Lean.Meta.Grind.SolverExtension.ctorIdx | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → ℕ | null | false |
Submodule.toAddSubmonoid_injective | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Function.Injective Submodule.toAddSubmonoid | null | true |
IsIntegralClosure.mk'_add | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} (A : Type u_2) {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (x y : B) (hx : IsIntegral R x)
(hy : IsIntegral R y), IsIntegralClosure.mk' A (x + y) ⋯ = IsIntegralClosure.mk' A x hx + Is... | null | true |
CochainComplex.πTruncGE_naturality_assoc | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : ∀ (i : ℤ), HomologicalComplex.HasHomology K i] [inst_4 : ∀ (i : ℤ), HomologicalComplex.HasHomology L i]... | null | true |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.iSupIndep_iff_supIndep_of_injOn._simp_1_6 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α},
(x ∈ s.preimage f hf) = (f x ∈ s) | null | false |
Ideal.rootsOfUnityMapQuot | Mathlib.NumberTheory.NumberField.Ideal.Basic | {K : Type u_1} →
[inst : Field K] →
(I : Ideal (NumberField.RingOfIntegers K)) →
(n : ℕ) → ↥(rootsOfUnity n (NumberField.RingOfIntegers K)) →* (NumberField.RingOfIntegers K ⧸ I)ˣ | For `I` an integral ideal of `K`, the group morphism from the group of roots of unity of `K`
of order `n` to `(𝓞 K ⧸ I)ˣ`.
| true |
List.sublists'.eq_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} (l : List α),
l.sublists' = (List.foldr (fun a arr => Array.foldl (fun r l => r.push (a :: l)) arr arr) #[[]] l).toList | null | true |
Measurable.sinh | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => Real.sinh (f x) | null | true |
Nat.card_eq_fintype_card | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} [inst : Fintype α], Nat.card α = Fintype.card α | null | true |
WithCStarModule.equiv_symm_snd | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} (x : E × F), ((WithCStarModule.equiv A (E × F)).symm x).2 = x.2 | null | true |
fst_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).1 = a.1 ⇨ b.1 | null | true |
NonemptyInterval.instPreorder._proof_3 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α],
autoParam (∀ (a b : NonemptyInterval α), a < b ↔ a ≤ b ∧ ¬b ≤ a) Preorder.lt_iff_le_not_ge._autoParam | null | false |
StarAlgHom.ofId.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ (R : Type u_7) (A : Type u_8) [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A] [inst_3 : StarMul A]
[inst_4 : Algebra R A] [inst_5 : StarModule R A], StarAlgHom.ofId R A = StarAlgHom.ofId R A | null | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instOrdRefIdent.ord.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 : String) → (x : Lean.Lsp.RefIdent) → motive (Lean.Lsp.RefIdent.const a a_1) x) →
((x : Lean.Lsp.Ref... | null | false |
Nat.mod_four_ne_three_of_mem_primeFactors_of_isSquare_neg_one | Mathlib.NumberTheory.SumTwoSquares | ∀ {p n : ℕ}, p ∈ n.primeFactors → IsSquare (-1) → p % 4 ≠ 3 | If `p` is a prime factor of `n` such that `-1` is a square modulo `n`, then `p % 4 ≠ 3`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.