name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
DoResultPRBC.recOn | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) →
((a : α) → (a_1 : σ) → motive (DoResultPRBC.pure a a_1)) →
((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) →
((a : σ) → motive (DoResultPRBC.break a)) → ((a : σ) → motive (DoResultPRBC.conti... | null | false |
IsMin.eq_of_ge | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b | null | true |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | (R : Type (u + 1)) →
[inst : Ring R] →
(F : CategoryTheory.Functor Profiniteᵒᵖ (ModuleCat R)) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
CategoryTheory.regularTopology.EqualizerCondition F → CondensedMod R | A `CondensedMod` version of `Condensed.ofSheafProfinite`. | true |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {s : Set E},
DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f... | null | true |
ENNReal.Lp_add_le | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) (f g : ι → ENNReal) {p : ℝ},
1 ≤ p → (∑ i ∈ s, (f i + g i) ^ p) ^ (1 / p) ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) + (∑ i ∈ s, g i ^ p) ^ (1 / p) | **Minkowski inequality**: the `L_p` seminorm of the sum of two vectors is less than or equal
to the sum of the `L_p`-seminorms of the summands. A version for `ℝ≥0∞`-valued nonnegative
functions. | true |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u →
{J : CategoryTheory.Limits.MultispanShape} →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
x.Hom x_1 →
{J' : CategoryTheory.Limits.MultispanShape} →
{x' x'_1 : CategoryTheory.Limits.WalkingMultispan J'} → x'.Hom x'_1 → Sort u | null | false |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.isStarNormal_of_mem._simp_1_2 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u} [inst : Mul R] [inst_1 : HasDistribNeg R] {a b : R}, Commute a b → Commute (-a) b = True | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.or_neg._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : CharZero R] (i : ι), b.height i ≠ 0 → 0 < b.height i ∨ 0 < -b.height i | null | false |
CochainComplex.homologyMap_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | null | false |
MeasureTheory.Integrable.bdd_mul' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_8} [inst : NormedRing 𝕜]
{f g : α → 𝕜} {c : ℝ},
MeasureTheory.Integrable g μ →
MeasureTheory.AEStronglyMeasurable f μ →
(∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c) → MeasureTheory.Integrable (fun x => f x * g x) μ | **Alias** of `MeasureTheory.Integrable.bdd_mul`. | true |
LinearMap.toMatrixₛₗ₂'_symm | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : AddCommMonoid N₂] [inst_2 : Module R N₂] [inst_3 : Semiring R₁]
[inst_4 : Semiring R₂] [inst_5 : Semiring S₁] [inst_6 : Semiring S₂] [inst_7 : Module S₁... | null | true |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} (f : Equiv.Perm α), Equivalence f.SameCycle | null | true |
CommHopfAlgCat.Hom.mk.inj | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u} {inst : CommRing R} {A B : CommHopfAlgCat R} {hom' hom'_1 : ↑A →ₐc[R] ↑B},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
lt_iff_le_and_ne' | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, b < a ↔ b ≤ a ∧ a ≠ b | null | true |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
[∀ (i : ι), WellFoundedLT (α i)], (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0) → WellFoundedLT (Π₀ (i : ι), α i) | null | true |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ) (h : n = 0)
(X : CochainComplex C ℤ) (i : ℤ),
((CochainComplex.shiftFunctorZero' C n h).inv.app X).f i = (HomologicalComplex.XIsoOfEq X ⋯).inv | null | true |
Lean.Widget.PanelWidgetInstance.mk.injEq | Lean.Widget.UserWidget | ∀ (toWidgetInstance : Lean.Widget.WidgetInstance) (range? : Option Lean.Lsp.Range) (name? : Option String)
(toWidgetInstance_1 : Lean.Widget.WidgetInstance) (range?_1 : Option Lean.Lsp.Range) (name?_1 : Option String),
({ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetIns... | null | true |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M} (h : S = T),
MulEquiv.submonoidCongr h = { toEquiv := Equiv.setCongr ⋯, map_mul' := ⋯ } | null | true |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (B : Rep.{u, u, u} k H),
Rep.coinvariantsTensorIndHom φ A B =
ModuleCat.ofHom
(Representation.Coinvariants.lift
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u, u, ... | null | true |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat}
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)]
[inst_2 : ∀ (X : C), CategoryTheory.HasSheafify (J.over X) AddCommGrpCat]
... | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findTactic?.merge._sparseCasesOn_3 | Lean.Server.CodeActions.Provider | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | Sort u →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
{L : CategoryTheory.Functor A T} →
{R : ... | null | false |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | null | false |
LinearEquiv.domMulActCongrRight._proof_6 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | null | false |
MulZeroClass.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{motive : MulZeroClass M₀ → Sort u_1} →
([toMul : Mul M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toMul := toMul, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero }) →
(t... | null | false |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | ∀ {a : Prop}, (¬¬a) = a | null | false |
CategoryTheory.toOverIsoToOverUnit_hom_app_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C),
(CategoryTheory.toOverIsoToOverUnit.hom.app X).left =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left
((CategoryTheory.equivToOverUnit C).unit.app
(... | null | true |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type w} →
{R : Type u} →
[inst : Semiring R] →
{M : Type v} → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {v : ι → M} → LinearIndependent R v → Prop | A linearly independent family is maximal if there is no strictly larger linearly independent family.
| true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_gt.match_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (x = 0 → motive 0) → (∀ (d : ℕ), x = d.succ → motive d.succ) → motive x | null | false |
CategoryTheory.Coverage.mem_toGrothendieck | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Coverage C} {X : C}
{S : CategoryTheory.Sieve X}, S ∈ K.toGrothendieck X ↔ K.Saturate X S | null | true |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.isMulCommutative_iSup._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ p) = (x ∈ ↑p) | null | false |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), ⊥ ≤ t | null | false |
Lean.Elab.Tactic.Do.Internal.VCGen.State.invariants._default | Lean.Elab.Tactic.Do.Internal.VCGen.Context | Array Lean.MVarId | null | false |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {β : Type u_2} (a b : α ↪ β), ⇑a = ⇑b ↔ a = b | null | false |
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | {n : ℕ} →
(α : Fin (n + 1) → Type u_2) →
[inst : (i : Fin (n + 1)) → LE (α i)] → α (Fin.last n) × ((i : Fin n) → α i.castSucc) ≃o ((i : Fin (n + 1)) → α i) | Order isomorphism between tuples of length `n + 1` and pairs of an element and a tuple of length
`n` given by separating out the last element of the tuple.
This is `Fin.snoc` as an `OrderIso`. | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
x ≈ x_1 →
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x =
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x_1 | null | false |
CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G :
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂)))
(CategoryTheory.Funct... | Given functors `F : C ⥤ D` and
`G : (Cᵒᵖ ⥤ Type max w v₁ v₂) ⥤ (Dᵒᵖ ⥤ Type max w v₁ v₂)`,
and a natural transformation `φ : F ⋙ uliftYoneda ⟶ uliftYoneda ⋙ G`, this is the
(natural) morphism `P ⟶ F.op ⋙ G.obj P` for all `P : Cᵒᵖ ⥤ Type max w v₁ v₂` that is
determined by `φ`. | true |
Lean.Meta.Sym.State.casesOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.State → Sort u} →
(t : Lean.Meta.Sym.State) →
((share : Lean.Meta.Sym.AlphaShareCommon.State) →
(maxFVar : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option Lean.FVarId)) →
(proofInstInfo : Lean.PHashMap Lean.Name (Option Lean.Meta.Sym.ProofInstInfo)) →
(inferType :... | null | false |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | Lean.TSyntax [`ident, `num] → Array Lean.Name → Array Lean.Expr → Lean.MessageData → Lean.MetaM ℕ | Elaborate syntax that refers to an argument of a declaration or hypothesis.
This is either a 1-indexed number, or a name from `argNames`.
- `fvars` is only used to add hover information to `stx`
- `head` is only used for the error message. | true |
HomotopicalAlgebra.Precylinder.symm_I | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A), P.symm.I = P.I | null | true |
CategoryTheory.AddMonObj.ofIso | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M X : C} → [CategoryTheory.AddMonObj M] → (M ≅ X) → CategoryTheory.AddMonObj X | Transfer `AddMonObj` along an isomorphism. | true |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | {α : Type u_1} →
{f : Filter α} →
{motive : f.Realizer → Sort u} →
((σ : Type u_5) → (F : CFilter (Set α) σ) → (eq : F.toFilter = f) → motive { σ := σ, F := F, eq := eq }) →
(t : f.Realizer) → motive t | null | false |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | Lean.Meta.ParamInfo → Bool | null | true |
instSemilatticeSupPrimeMultiset._proof_5 | Mathlib.Data.PNat.Factors | ∀ (a : PrimeMultiset), a ≤ a | null | false |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, Std.Commutative fun x y => x ||| y | null | true |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods.Commensurable 𝒢.periods | null | true |
SimpleGraph.FinsubgraphHom.restrict._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' G'' : G.Finsubgraph}, G'' ≤ G' → ∀ v ∈ (↑G'').verts, v ∈ (↑G').verts | null | false |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.emin = 1 - ↑FP.FloatCfg.emax | null | true |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} [inst : MulZeroOneClass α] {β : Type u_2} [inst_1 : CommMonoidWithZero β], MonoidHomClass (α →*₀ β) α β | null | false |
IsRelUpperSet.iInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {P : α → Prop} [inst : LE α] [Nonempty ι] {f : ι → Set α},
(∀ (i : ι), IsRelUpperSet (f i) P) → IsRelUpperSet (⋂ i, f i) P | null | true |
List.Sublist.below | Init.Data.List.Basic | {α : Type u_1} → {motive : (a a_1 : List α) → a.Sublist a_1 → Prop} → {a a_1 : List α} → a.Sublist a_1 → Prop | null | true |
_private.Plausible.Attr.0.initFn._@.Plausible.Attr.3035915354._hygCtx._hyg.2 | Plausible.Attr | IO Unit | null | false |
SSet.Subcomplex.Pairing.RankFunction.w_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι)
[inst_1 : P.IsProper] [inst_2 : SuccOrder ι] [inst_3 : NoMaxOrder ι] (j : ι) {Z : SSet}
(h : (f.filtration (Order.succ j)).toSSet ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.t j) (CategoryTheory.CategoryStru... | null | true |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X : C} (f : c.pt ⟶ X), (c.extend f).pt = X | null | true |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : α), Function.Embedding.coeWithTop a = ↑a | null | true |
AddMonoid.Coprod.swap_comp_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
(AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inl | null | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) = (p < n) | null | false |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : SetRel α α), (hausdorffEntourage U).inv = hausdorffEntourage U.inv | null | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type v} →
[inst_1 : CategoryTheory.SmallCategory I] →
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))) →
{J : Type v} →
[inst_2 : CategoryTheory.SmallCategory J] →
(G :
... | (implementation) Pulling out a colimit out of a hom functor is one half of the key lemma. Note
that all of the heavy lifting actually happens in `CostructuredArrow.toOverCompYonedaColimit`
and `yonedaYonedaColimit`. | true |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUnifor... | The set of compact operators from a normed space to a complete topological vector space is
closed. | true |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a * b = 1 → a⁻¹ = b | null | true |
Nat.lt_irrefl | Init.Prelude | ∀ (n : ℕ), ¬n < n | null | true |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (x y : Fin n), x - y = x + -y | null | true |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_5} {σ : Type u_6} [inst : CommRing R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → (-φ).IsHomogeneous n | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | Lean.Name → Array Lean.Name → Option Lean.Name | Find a name in `ns` that starts with prefix `p`. | true |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{X Y : C} →
(f : Y ⟶ X) →
(motive : (CategoryTheory.Sieve.generateSingleton f).arrows.category → Sort u_3) →
(x : (CategoryTheory.Sieve.generateSingleton f).arrows.category) →
((obj : CategoryTheory.Over X) →
... | null | false |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.wrapped._proof_1._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | @MeasureTheory.Filtration.definition✝ = @MeasureTheory.Filtration.definition✝ | null | false |
_private.Mathlib.NumberTheory.LSeries.Convergence.0.LSeriesSummable_of_abscissaOfAbsConv_lt_re._simp_1_2 | Mathlib.NumberTheory.LSeries.Convergence | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, (sInf s < b) = ∃ a ∈ s, a < b | null | false |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Semiring R] (h : IsField R), (if ha : 0 = 0 then 0 else Classical.choose ⋯) = 0 | null | false |
Lean.Elab.ConfigEval.instEvalExprOccurrences | Lean.Elab.ConfigEval.MetaInstances | Lean.Elab.ConfigEval.EvalExpr Lean.Meta.Occurrences | null | true |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
{D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
(t : CategoryTheory.Limits.IsLimit c) [inst_2 : CategoryTheory.... | null | false |
SimpleGraph.not_isUniform_iff | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {G : SimpleGraph α}
[inst_3 : DecidableRel G.Adj] {ε : 𝕜} {s t : Finset α},
¬G.IsUniform ε s t ↔
∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity ... | null | true |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap α β cmp → δ | Folds the given function over the mappings in the map in ascending order. | true |
CategoryTheory.RetractArrow.unop_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : Cᵒᵖ} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g),
h.unop.i =
CategoryTheory.Arrow.homMk (CategoryTheory.Arrow.Hom.right h.r).unop (CategoryTheory.Arrow.Hom.left h.r).unop ⋯ | null | true |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | Lean.FVarId → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit | Adds a new hypothesis. | true |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [MOD n] → b < n → a % n = b | null | true |
NonemptyInterval.mem_def | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : NonemptyInterval α} {a : α}, a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2 | null | true |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | ℕ → ℕ → ℕ | If `n < k * k`, then `minFacAux n k = n`, if `k | n`, then `minFacAux n k = k`.
Otherwise, `minFacAux n k = minFacAux n (k+2)` using well-founded recursion.
If `n` is odd and `1 < n`, then `minFacAux n 3` is the smallest prime factor of `n`.
This definition is by well-founded recursion, so `rfl` or `decide` cannot be ... | true |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive : CategoryTheory.Limits.WalkingParallelFamily J → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelFamily J) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelFamily.one → motive t | null | false |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | {V : Type u_1} →
{W : Type u_2} →
[inst : AddCommGroup V] →
[inst_1 : Module ℝ V] →
[inst_2 : TopologicalSpace V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module ℝ W] →
[inst_5 : TopologicalSpace W] →
{e : AddChar ℝ Circle} →
{L : ... | Algebra homomorphism mapping `w` to `fun v ↦ e (L v w)`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey!._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.Data.List.Sort.0.List.orderedInsert.match_1.eq_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} (motive : List α → Sort u_2) (b : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (b : α) → (l : List α) → motive (b :: l)),
(match b :: l with
| [] => h_1 ()
| b :: l => h_2 b l) =
h_2 b l | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) | null | true |
Ordnode.findLeAux._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} →
[inst : LE α] → [DecidableLE α] → α → (x : Ordnode α) → Ordnode.below (motive := fun x => α → α) x → α → α | null | false |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | Std.HashSet Lean.FVarId → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches | Erase matches containing any of the hypotheses `hs` from `ms`. | true |
List.IsSuffix.isInfix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ | null | true |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ofNat_dvd.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ} (motive : m ∣ n → Prop) (x : m ∣ n), (∀ (k : ℕ) (e : n = m * k), motive ⋯) → motive x | null | false |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) {M : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
IsScalarTower A A M | null | false |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | (prec emax : ℕ) → 0 < prec → prec ≤ emax → FP.FloatCfg | null | true |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C)
{X x : CategoryTheory.Cokleisli U} (f : X ⟶ x),
(CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).map f =
CategoryTheory.CategoryStruct.comp (U.δ.app X.of) (U.map f.of) | null | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.sub_mul_div_of_le.match_1_1 | Init.Data.Nat.Div.Basic | ∀ (n : ℕ) (motive : n = 0 ∨ n > 0 → Prop) (x : n = 0 ∨ n > 0),
(∀ (h₀ : n = 0), motive ⋯) → (∀ (h₀ : n > 0), motive ⋯) → motive x | null | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.uniq | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) {U X : C} {m : U ⟶ X} [inst_2 : CategoryTheory.Mono m] {χ' : X ⟶ Ω}
{π : U ⟶ CategoryTheory.Subobject.underlying.obj h.Ω₀}, CategoryTheory.IsPullback m π χ... | **Alias** of `CategoryTheory.SubobjectRepresentableBy.uniq`. | true |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {S : Submonoid Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ | null | true |
Std.ExtTreeMap.get!_eq_getElem! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, t.get! a = t[a]! | null | true |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → ℕ | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (X i)},
s.pi t = s.pi fun i => if i ∈ s then t i else Set.univ | null | false |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | ∀ {α : Type u_1} {r : α → α → Prop}, FaithfulSMul (r ≃r r) α | null | true |
ClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | A point `x` is a cluster point of a filter `F` if `𝓝 x ⊓ F ≠ ⊥`.
Also known as an accumulation point or a limit point, but beware that terminology varies.
This is *not* the same as asking `𝓝[≠] x ⊓ F ≠ ⊥`, which is called `AccPt` in Mathlib.
See `mem_closure_iff_clusterPt` in particular. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.