name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv._proof_2 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} J] {K : Type u_4}
[inst_1 : CategoryTheory.Category.{u_6, u_4} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_3, u_2} C]
{F : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cocone F} (e : K ≌ J),
Function.LeftInverse (CategoryTheory.Limit... | null | false |
LinearPMap.apply_comp_inclusion | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {T S_1 : E →ₛₗ.[σ] F}
(h : T ≤ S_1) (x : ↥T.domain), ↑T x = ↑S_1 ((Submodule.inclusion ⋯) x) | null | true |
AlgebraicGeometry.RingedSpace.zeroLocus_singleton | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
(f : ↑(X.presheaf.obj (Opposite.op U))), X.zeroLocus {f} = (X.basicOpen f).carrierᶜ | null | true |
CategoryTheory.InjectiveResolution.descFSucc._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
(J : CategoryTheory.InjectiveResolution Z) (n : ℕ),
CategoryTheory.CategoryStruct.comp (J.cocomplex.d n (n + 1)) (J.cocomplex.d (n + 1) (n + 2)) = 0 | null | false |
Lean.Parser.Syntax.nonReserved.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_160 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
ValueDistribution.proximity_pow_zero | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {f : ℂ → ℂ} {n : ℕ}, ValueDistribution.proximity (f ^ n) 0 = n • ValueDistribution.proximity f 0 | For natural numbers `n`, the proximity function of `f ^ n` at `0` equals `n` times the proximity
function of `f` at `0`.
| true |
Mathlib.Meta.Positivity.nonneg_of_isNat' | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℕ} [inst : AddMonoidWithOne A] [inst_1 : PartialOrder A] [AddLeftMono A]
[ZeroLEOneClass A], Mathlib.Meta.NormNum.IsNat e n → 0 ≤ e | null | true |
Lean.Meta.ExprParamInfo.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{name : Lean.Name} →
{type : Lean.Expr} →
{binderInfo : Lean.BinderInfo} →
{name' : Lean.Name} →
{type' : Lean.Expr} →
{binderInfo' : Lean.BinderInfo} →
{ name := name, type := type, binderInfo := binderInfo } =
{ name := name', ty... | null | false |
Lean.Linter.MissingDocs.Handler | Lean.Linter.MissingDocs | Type | null | true |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_lt_coe_iff._simp_1_2 | Mathlib.Order.KrullDimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.cmdCodeActionProvider._sparseCasesOn_2 | Lean.Server.CodeActions.Provider | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CommandInfo) → motive (Lean.Elab.Info.ofCommandInfo i)) →
(Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
ProbabilityTheory.uncenteredCovarianceBilinDual._proof_7 | Mathlib.Probability.Moments.CovarianceBilinDual | ContinuousAdd ℝ | null | false |
Lean.Meta.Simp.ConfigCtx.arith._inherited_default | Init.MetaTypes | Bool | null | false |
Int64.ofIntClamp_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 64), Int64.ofIntClamp n.toInt = Int64.ofBitVec n | null | true |
IsLocalDiffeomorphAt.localInverse_eqOn_left | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H₁ : Type u_5}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | null | true |
PseudoMetricSpace.replaceUniformity_eq | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_3} [U : UniformSpace α] (m : PseudoMetricSpace α) (H : uniformity α = uniformity α),
m.replaceUniformity H = m | null | true |
Bool.ite_true_left_eq_true._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Bool}, ((if p then true else x) = true) = (p ∨ x = true) | null | false |
Lean.Elab.Term.GeneralizeResult.altViews | Lean.Elab.Match | Lean.Elab.Term.GeneralizeResult → Array Lean.Elab.Term.TermMatchAltView | null | true |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.IsSelfAdjoint.sub._simp_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | null | false |
instCompactSpaceMultiplicative | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactSpace X], CompactSpace (Multiplicative X) | null | true |
CategoryTheory.EnrichedCat.comp_whiskerRight | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₁} [inst_3 : CategoryTheory.EnrichedCategory V D]
{E : Type u₂} [inst_4 : CategoryTheory.EnrichedCategory V E] {F G H : CategoryTheory.Enriched... | null | true |
BoxIntegral.BoxAdditiveMap.ext | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {I₀ : WithTop (BoxIntegral.Box ι)}
{f g : BoxIntegral.BoxAdditiveMap ι M I₀}, (∀ (J : BoxIntegral.Box ι), f J = g J) → f = g | null | true |
AddMonoidHom.eqLocusM | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{N : Type u_2} → [inst : AddZeroClass M] → [inst_1 : AddZeroClass N] → (M →+ N) → (M →+ N) → AddSubmonoid M | The additive submonoid of elements `x : M` such that `f x = g x` | true |
CochainComplex.injective_opcycles | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n₀ n₁ : ℤ) [CategoryTheory.Injective (K.X n₀)] [CategoryTheory.Injective (K.X n₁)]
[K.IsStrictlyGE n₀],
HomologicalComplex.ExactAt K n₀ →
autoParam (n₀ + 1 = n₁) CochainComplex.injectiv... | null | true |
Set.inter_sub_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ∩ s₂ - (t₁ ∪ t₂) ⊆ s₁ - t₁ ∪ (s₂ - t₂) | null | true |
Path.Homotopic.Quotient.trans_assoc | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} (γ₀ : Path.Homotopic.Quotient x₀ x₁)
(γ₁ : Path.Homotopic.Quotient x₁ x₂) (γ₂ : Path.Homotopic.Quotient x₂ x₃),
(γ₀.trans γ₁).trans γ₂ = γ₀.trans (γ₁.trans γ₂) | null | true |
RelIso.toRelEmbedding | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → r ≃r s → r ↪r s | Convert a `RelIso` to a `RelEmbedding`. This function is also available as a coercion
but often it is easier to write `f.toRelEmbedding` than to write explicitly `r` and `s`
in the target type. | true |
LawfulBitraversable.bitraverse_eq_bimap_id' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {α α' β β' : Type u}
(f : α → β) (f' : α' → β'), bitraverse (pure ∘ f) (pure ∘ f') = pure ∘ bimap f f' | null | true |
Array.size_filterMap_lt_size_iff_exists | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β},
(Array.filterMap f xs).size < xs.size ↔ ∃ x, ∃ (_ : x ∈ xs), f x = none | null | true |
Equiv.prodPEmpty | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → α × PEmpty.{u_10 + 1} ≃ PEmpty.{u_11} | `PEmpty` type is a right absorbing element for type product up to an equivalence. | true |
Array.lt_size_left_of_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {i : ℕ} {as : Array α} {bs : Array β},
i < (Array.zipWith f as bs).size → i < as.size | null | true |
_private.Init.Data.Vector.OfFn.0.Vector.map_ofFn._simp_1_1 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, (xs = ys) = (xs.toArray = ys.toArray) | null | false |
Std.DTreeMap.Internal.Impl.get?_erase_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α}, (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.get? k = none | null | true |
_private.Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas.0.Int.closure_eq_zmultiples_finsetGcd._proof_1_1 | Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas | ∀ (s : Finset ℤ), AddSubgroup.closure ↑s ≤ AddSubgroup.zmultiples (s.gcd id) | null | false |
IsPicardLindelof.exists_forall_mem_closedBall_eq_hasDerivWithinAt_lipschitzOnWith | Mathlib.Analysis.ODE.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E → E}
{tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {a r L K : NNReal},
IsPicardLindelof f t₀ x₀ a r L K →
∃ α,
(∀ x ∈ Metric.closedBall x₀ ↑r,
α x ↑t₀ = x ∧ ∀ t ∈ Set.Icc tmin tmax, HasD... | **Picard-Lindelöf (Cauchy-Lipschitz) theorem**, differential form. This version shows the
existence of a local flow and that it is Lipschitz continuous in the initial point. | true |
Ordnode.rec.eq._@.Mathlib.Data.Ordmap.Ordnode.1389437611._hygCtx._hyg.4 | Mathlib.Data.Ordmap.Ordnode | @Ordnode.rec = @Ordnode.rec✝ | null | false |
_private.Mathlib.LinearAlgebra.Complex.Module.0.mem_unitary_iff_isStarNormal_and_realPart_sq_add_imaginaryPart_sq_eq_one._simp_1_5 | Mathlib.LinearAlgebra.Complex.Module | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
Array.reverse_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α} (H : ∀ a ∈ xs, P a),
(Array.pmap f xs H).reverse = Array.pmap f xs.reverse ⋯ | null | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.coe_auxContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {𝕜 : Type u_1} {V : Type u_2} {W : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] [inst_4 : NormedAddCommGroup W]
[inst_5 : InnerProductSpace 𝕜 W] [inst_6 : CompleteSpace W] (e : V ≃L[𝕜] W) {α α' : 𝕜} (hα : α ≠ 0)
(hα2 : α' * α' = α⁻... | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonNatTrans | 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) →
... | The product comparison morphism from `F(A ⊗ -)` to `FA ⊗ F-`, whose components are given by
`prodComparison`. | true |
AddCommGroup.toAddGroup | Mathlib.Algebra.Group.Defs | {G : Type u_2} → [self : AddCommGroup G] → AddGroup G | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.Bicone.IsBilimit.ext.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {B : CategoryTheory.Limits.Bicone F}
(motive : B.IsBilimit → Prop) (h : B.IsBilimit),
(∀ (isLimit : CategoryTheory.Limits.IsLimit B.toCone) (isColimit : CategoryTheory.Limi... | null | false |
Lean.JsonRpc.MessageKind._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.MessageKind → ℕ | null | false |
Matrix.SpecialLinearGroup.diag2_coe' | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {F : Type u_1} [inst : Field F] {a : F} (ha : a ≠ 0), ↑(Matrix.SpecialLinearGroup.diag2 a ha) = !![a, 0; 0, a⁻¹] | null | true |
FiberBundle.extChartAt_target | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_6} [inst_5 : NormedAddCommGroup EB]
[inst_... | null | true |
CategoryTheory.Limits.parallelPair.ext._to_dual_3 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} →
(one :
F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one) →
(zero :
F.obj CategoryTheo... | null | false |
Lean.Lsp.WaitForILeans | Lean.Data.Lsp.Extra | Type | null | true |
WithAbs.instField._proof_8 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R]
(v : AbsoluteValue R S), autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den) DivisionRing.nnratCast_def._autoParam | null | false |
Real.commRing._proof_11 | Mathlib.Basic.Real.Basic | ∀ (n : ℕ) (x : ℝ), x ^ (n + 1) = x ^ n * x | null | false |
Filter.Eventually.prodMk_nhds | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {px : X → Prop} {x : X},
(∀ᶠ (x : X) in nhds x, px x) →
∀ {py : Y → Prop} {y : Y}, (∀ᶠ (y : Y) in nhds y, py y) → ∀ᶠ (p : X × Y) in nhds (x, y), px p.1 ∧ py p.2 | null | true |
_private.Lean.Compiler.LCNF.CoalesceRC.0.Lean.Compiler.LCNF.State._sizeOf_inst | Lean.Compiler.LCNF.CoalesceRC | SizeOf Lean.Compiler.LCNF.State✝ | null | false |
Vector3.eq_nil | Mathlib.Data.Vector3 | ∀ {α : Type u_1} (v : Vector3 α 0), v = [] | null | true |
CategoryTheory.Limits.CreatesFiniteLimits.noConfusion | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{t : CategoryTheory.Limits.CreatesFiniteLimits F} →
{C' : Type u₁} →
{in... | null | false |
AlgebraicGeometry.Scheme.Cover.gluedCover_V | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x : 𝒰.I₀ × 𝒰.I₀),
(AlgebraicGeometry.Scheme.Cover.gluedCover 𝒰).V x =
match x with
| (x, y) => CategoryTheory.Limits.pullback (𝒰.f x) (𝒰.f y) | null | true |
Std.ExtDTreeMap.contains_alter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).contains k' = if cmp k k' = Ordering.eq then (f (t.get? k)).isSome else t.contains k' | null | true |
IsPrimitiveRoot.disjoint | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {k l : ℕ},
k ≠ l → Disjoint (primitiveRoots k R) (primitiveRoots l R) | The sets `primitiveRoots k R` are pairwise disjoint. | true |
Subring.comap_iInf | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {ι : Sort u_1} (f : R →+* S)
(s : ι → Subring S), Subring.comap f (iInf s) = ⨅ i, Subring.comap f (s i) | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateContImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.Code.let decl k)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
... | null | false |
ContDiffMapSupportedIn.bounded_iteratedFDeriv | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K) {i : ℕ},
↑i ≤ n → ∃ C, ∀ (x : E), ‖iteratedFDeriv ℝ i (⇑f) x‖ ≤ C | null | true |
selfZPow_mul_neg | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (x : R) (B : Type u_2) [inst_1 : CommSemiring B] [inst_2 : Algebra R B]
[inst_3 : IsLocalization.Away x B] (d : ℤ), selfZPow x B d * selfZPow x B (-d) = 1 | null | true |
CochainComplex.mappingConeCompTriangle_mor₁ | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
(CochainComplex.mappingConeCompTriangle f g).mor₁ =
CochainComplex.mappingCone.map f (CategoryT... | null | true |
Cardinal.lift_le_beth_natCast | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}} {n : ℕ}, Cardinal.lift.{v, u} c ≤ Cardinal.beth ↑n ↔ c ≤ Cardinal.beth ↑n | null | true |
_private.Mathlib.Order.Filter.AtTopBot.CountablyGenerated.0.Filter.tendsto_iff_seq_tendsto._simp_1_2 | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u} {f : Filter α} {s : Set α}, (f ⊓ Filter.principal s = ⊥) = (sᶜ ∈ f) | null | false |
Std.TreeMap.toArray_map | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {f : α → β → γ},
(Std.TreeMap.map f t).toArray = Array.map (fun p => (p.1, f p.1 p.2)) t.toArray | null | true |
groupCohomology.linearYonedaObjResProjectiveResolutionIso._proof_9 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}, (Rep.resFunctor S.subtype).PreservesHomology | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁._sparseCasesOn_1 | Lean.Elab.Tactic.RCases | {motive_1 : Lean.Elab.Tactic.RCases.RCasesPatt → Sort u} →
(t : Lean.Elab.Tactic.RCases.RCasesPatt) →
((ref : Lean.Syntax) → (a : Lean.Name) → motive_1 (Lean.Elab.Tactic.RCases.RCasesPatt.one ref a)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.docBlame._sparseCasesOn_7 | Batteries.Tactic.Lint.Misc | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Array.toListLitAux.eq_2 | Init.Data.Array.GetLit | ∀ {α : Type u_1} (xs : Array α) (n : ℕ) (hsz : xs.size = n) (x : List α) (i : ℕ) (hi : i + 1 ≤ xs.size),
xs.toListLitAux n hsz i.succ hi x = xs.toListLitAux n hsz i ⋯ (xs.getLit i hsz ⋯ :: x) | null | true |
CategoryTheory.MorphismProperty.LeftFraction₃.hs | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(self : W.LeftFraction₃ X Y), W self.s | the condition that the denominator belongs to the given morphism property | true |
_private.Mathlib.CategoryTheory.Sites.MorphismProperty.0.CategoryTheory.MorphismProperty.instIsStableUnderCompositionPrecoverageOfIsStableUnderComposition.match_1 | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type (max u_2 u_1)} (S : C) (X : ι → C)
(f : (i : ι) → X i ⟶ S) (σ : ι → Type (max u_2 u_1)) (Y : (i : ι) → σ i → C) (g : (i : ι) → (j : σ i) → Y i j ⟶ X i)
(motive :
(Z : C) →
(p : Z ⟶ S) →
CategoryTheory.Presieve.ofArrows (fun p... | null | false |
ContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.Defs | Sort u →
{X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
C(X, Y) →
{X' : Type u_1} →
{Y' : Type u_2} → [inst' : TopologicalSpace X'] → [inst'_1 : TopologicalSpace Y'] → C(X', Y') → Sort u | null | false |
IsStarNormal.one_sub | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : StarRing R] {a : R} [ha : IsStarNormal a], IsStarNormal (1 - a) | null | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X},
E.sieve₀ ≤ S → ∀ (x : E.multicospanShape.R), S.arrows (E.f (E.multicospanShape.snd x)) | null | false |
Std.TreeMap.Raw.not_mem_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → k ∉ t₁ \ t₂ | null | true |
_private.Mathlib.Analysis.RCLike.Sqrt.0.RCLike.sqrt_eq_ite._proof_1_2 | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ¬RCLike.im RCLike.I = 1 → RCLike.I = 0 | null | false |
nnnorm_add_eq_nnnorm_right | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] {x : E} (y : E), ‖x‖₊ = 0 → ‖x + y‖₊ = ‖y‖₊ | null | true |
PresheafOfModules.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Presheaf | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
PresheafOfModules R →
{C' : Type u₁} →
[inst' : CategoryTheory.Category.{v₁, u₁} C'] →
{R' : CategoryTheory.Functor C'ᵒᵖ RingCat} → PresheafOfModule... | null | false |
Batteries.AssocList.findEntryP?.eq_1 | Batteries.Data.AssocList.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (p : α → β → Bool), Batteries.AssocList.findEntryP? p Batteries.AssocList.nil = none | null | true |
instOneNonemptyInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : Preorder α] → [One α] → One (NonemptyInterval α) | null | true |
MeasureTheory.integral_comp_mul_right_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : ℝ → E) (a : ℝ) {b : ℝ},
0 < b → ∫ (x : ℝ) in Set.Ioi a, g (x * b) = b⁻¹ • ∫ (x : ℝ) in Set.Ioi (a * b), g x | null | true |
Units.chartAt_source | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {a : Rˣ}, (chartAt R a).source = Set.univ | null | true |
Module.DualBases.basis | Mathlib.LinearAlgebra.Dual.Basis | {R : Type u_1} →
{M : Type u_2} →
{ι : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {e : ι → M} → {ε : ι → Module.Dual R M} → Module.DualBases e ε → Module.Basis ι R M | `(h : DualBases e ε).basis` shows the family of vectors `e` forms a basis. | true |
CategoryTheory.Limits.cokernel.mapIso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_2 : CategoryTheory.Limits.HasCokernel f] →
{X' Y' : C} →
(f' : X' ⟶ Y') →
[inst_3 : CategoryTheory.Limi... | A commuting square of isomorphisms induces an isomorphism of cokernels. | true |
AlgebraicGeometry.Scheme.Hom.asFiberHom_fiberι_assoc | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.asFiberHom f x)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.fiberι f (f x)) h) =
CategoryTheory.CategoryStruct.comp (X.fr... | null | true |
CategoryTheory.Limits.Cocone.extendComp | 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} →
(s : CategoryTheory.Limits.Cocone F) →
{X Y : C} →
(g : s.pt ⟶ Y) → (f : Y ⟶ X) → s.extend (CategoryThe... | Extending a cocone by a composition is the same as extending the cone twice. | true |
Topology.CWComplex.noConfusion | Mathlib.Topology.CWComplex.Classical.Basic | {P : Sort u_1} →
{X : Type u} →
{inst : TopologicalSpace X} →
{C : Set X} →
{t : Topology.CWComplex C} →
{X' : Type u} →
{inst' : TopologicalSpace X'} →
{C' : Set X'} →
{t' : Topology.CWComplex C'} →
X = X' → inst ≍ inst' → C ≍ C'... | null | false |
AddCon.eq | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {a b : M}, ↑a = ↑b ↔ c a b | Two elements are related by an additive congruence relation `c` iff
they are represented by the same element of the quotient by `c`. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertListIfNew.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l : List ((a : α) × β a)) (k : α) (v : β k)
(l_1 : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l (⟨k, v⟩ :: l_1) =
Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) l_1 | null | true |
HomologicalComplex.isoHomologyι_hom_inv_id_assoc | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι) (hj : c.next i = j) (h : K.d i j = 0)
[inst_2 : K.HasHomology i] {Z : C} (h_1 : K.homology i ⟶ Z),
CategoryTheory.CategorySt... | null | true |
Units.liftRight.congr_simp | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u} {N : Type v} [inst : Monoid M] [inst_1 : Monoid N] (f f_1 : M →* N) (e_f : f = f_1) (g g_1 : M → Nˣ)
(e_g : g = g_1) (h : ∀ (x : M), ↑(g x) = f x), Units.liftRight f g h = Units.liftRight f_1 g_1 ⋯ | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteLimits.instIsClosedUnderFiniteProducts | Mathlib.CategoryTheory.ObjectProperty.FiniteLimits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteLimits], P.IsClosedUnderFiniteProducts | null | true |
AddAction.mem_orbit_symm | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a₁ a₂ : α},
a₁ ∈ AddAction.orbit G a₂ ↔ a₂ ∈ AddAction.orbit G a₁ | null | true |
Std.DTreeMap.Internal.Impl.keysArray_filter_key | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {f : α → Bool} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t ⋯).impl.keysArray = Array.filter f t.keysArray | null | true |
coe_convexAddSubmonoid | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], ↑(convexAddSubmonoid 𝕜 E) = {s | Convex 𝕜 s} | null | true |
_private.Mathlib.Data.Set.Restrict.0.Set.injective_codRestrict._simp_1_1 | Mathlib.Data.Set.Restrict | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
RBTree.RBNode.cmpEq_iff | Batteries.Recycling.RBTree.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x y : α} [Std.TransCmp cmp],
RBTree.RBNode.cmpEq cmp x y ↔ cmp x y = Ordering.eq | null | true |
ULift.seminormedCommRing._proof_6 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (n : ℕ) (x : ULift.{u_1, u_2} α), x ^ (n + 1) = x ^ n * x | null | false |
Std.Async.UDP.Socket.bind | Std.Async.UDP | Std.Async.UDP.Socket → Std.Net.SocketAddress → IO Unit | Binds the UDP socket to the given address. Address reuse is enabled to allow rebinding the
same address.
| true |
CategoryTheory.Abelian.SpectralObject.Hom.casesOn | Mathlib.Algebra.Homology.SpectralObject.Basic | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
{X X' : CategoryTheory.Abelian.SpectralObject C ι} →
{motive : X.Hom X' → Sort u} →
(t : X.Hom... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.