name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BddDistLat._sizeOf_inst | Mathlib.Order.Category.BddDistLat | SizeOf BddDistLat | null | false |
WithCStarModule.uniformEquiv._proof_1 | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_1} [inst : UniformSpace E], IsUniformInducing ⇑(WithCStarModule.equiv A E) | null | false |
CompactlySupportedContinuousMap.toRealLinearMap._proof_6 | Mathlib.Topology.ContinuousMap.CompactlySupported | ContinuousConstSMul ℝ ℝ | null | false |
Metric.infEDist_union | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α},
Metric.infEDist x (s ∪ t) = min (Metric.infEDist x s) (Metric.infEDist x t) | The edist to a union is the minimum of the edists | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.motive | Lean.Meta.IndPredBelow | Lean.LocalDecl → ℕ → Array Lean.FVarId → Lean.Meta.IndPredBelow.NewDecl✝ | A new declaration of type `∀ x y z, <nth motive> ... (h x y z)` for all `h ∈ vars` | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_associativity_assoc | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y Z T : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ T)
{Z_1 : CategoryTheory.Functor T.Modules X.Modules}
(h_1 :
AlgebraicGeometry.Scheme.Modules.pullback
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h) ⟶
Z_1),
CategoryTheory.CategoryStruct.com... | null | true |
_private.Lean.Compiler.LCNF.Renaming.0.Lean.Compiler.LCNF.Param.applyRenaming.match_1 | Lean.Compiler.LCNF.Renaming | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((binderName : Lean.Name) → motive (some binderName)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
ContinuousMultilinearMap.norm_ofSubsingleton_id_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (G : Type wG) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : Fintype ι] [inst_4 : Subsingleton ι] (i : ι),
‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ ≤ 1 | null | true |
Std.Time.TimeZone.Transition.localTimeType | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.Transition → Std.Time.TimeZone.LocalTimeType | The local time type associated with this transition.
| true |
CategoryTheory.categoryOfEnrichedCategoryType._proof_1 | Mathlib.CategoryTheory.Enriched.Basic | ∀ (C : Type u_2) [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {X Y : C} (f : X ⟶[Type u_1] Y),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.eComp (Type u_1) X X Y))
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.eId (Type u_1) X)) PUnit.unit, f) =
f | null | false |
Lean.IR.IRType._sizeOf_1 | Lean.Compiler.IR.Basic | Lean.IR.IRType → ℕ | null | false |
CategoryTheory.StructuredArrow.commaMapEquivalenceCounitIso._proof_4 | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_2, u_6} D] {T : Type u_8} [inst_2 : CategoryTheory.Category.{u_3, u_8} T]
{L : CategoryTheory.Functor C T} {R : CategoryTheory.Functor D T} {C' : Type u_10}
[inst_3 : CategoryTheory.Category.{u_5, u_... | null | false |
Lean.Meta.Sym.SymExtension.getStateCore | Lean.Meta.Sym.SymM | {σ : Type} → Lean.Meta.Sym.SymExtension σ → Array Lean.Meta.Sym.SymExtensionState → IO σ | null | true |
Homotopy.mkInductiveAux₁._sunfold | Mathlib.Algebra.Homology.Homotopy | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{P Q : ChainComplex V ℕ} →
(e : P ⟶ Q) →
(zero : P.X 0 ⟶ Q.X 1) →
(one : P.X 1 ⟶ Q.X 2) →
e.f 1 =
CategoryTheory.CategoryStruct.comp (P.d 1 0) ze... | null | false |
Matrix.nonsingular_submatrix_equiv_iff | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {m : Type u_2} {R : Type u_3} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
[inst_3 : DecidableEq n] [inst_4 : CommSemiring R] {A : Matrix n n R} {e₁ e₂ : m ≃ n},
(A.submatrix ⇑e₁ ⇑e₂).Nonsingular ↔ A.Nonsingular | null | true |
Cardinal.toNat_congr | Mathlib.SetTheory.Cardinal.ToNat | ∀ {α : Type u} {β : Type v} (e : α ≃ β), Cardinal.toNat (Cardinal.mk α) = Cardinal.toNat (Cardinal.mk β) | null | true |
AddZero.toZero | Mathlib.Algebra.Group.Monoid | {M : Type u_2} → [self : AddZero M] → Zero M | null | true |
_private.Lean.Meta.Tactic.FunIndInfo.0.Lean.Meta.getFunInduct?._sparseCasesOn_1 | Lean.Meta.Tactic.FunIndInfo | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.RepresentableBy.recOn | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type v)} →
{Y : C} →
{motive : F.RepresentableBy Y → Sort u} →
(t : F.RepresentableBy Y) →
((homEquiv : {X : C} → (X ⟶ Y) ≃ F.obj (Opposite.op X)) →
(homEquiv_comp :
... | null | false |
Aesop.Script.TacticState._sizeOf_inst | Aesop.Script.TacticState | SizeOf Aesop.Script.TacticState | null | false |
IsEvenlyCovered.homeomorph_comp | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {I : Type u_3}
[inst_2 : TopologicalSpace I] {x : X},
IsEvenlyCovered f x I → ∀ {Y : Type u_4} [inst_3 : TopologicalSpace Y] (g : X ≃ₜ Y), IsEvenlyCovered (⇑g ∘ f) (g x) I | null | true |
_private.Mathlib.MeasureTheory.Function.LpSpace.InfiniteSum.0.MeasureTheory.summable_norm_of_tsum_eLpNorm_ne_top._simp_1_3 | Mathlib.MeasureTheory.Function.LpSpace.InfiniteSum | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (0 ≤ a - b) = (b ≤ a) | null | false |
Unitary.mapEquiv_trans | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (f : R ≃⋆* S) (g : S ≃⋆* T),
Unitary.mapEquiv (f.trans g) = (Unitary.mapEquiv f).trans (Unitary.mapEquiv g) | null | true |
Lean.Widget.DiffTag.wasDeleted.sizeOf_spec | Lean.Widget.InteractiveCode | sizeOf Lean.Widget.DiffTag.wasDeleted = 1 | null | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Equiv.diff_right._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β},
m₁.Equiv m₂ = (Std.DHashMap.Internal.toListModel m₁.buckets).Perm (Std.DHashMap.Internal.toListModel m₂.buckets) | null | false |
SimpleGraph.Walk.boxProdRight.eq_1 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} (G : SimpleGraph α) {H : SimpleGraph β} {b₁ b₂ : β} (a : α),
SimpleGraph.Walk.boxProdRight G a = SimpleGraph.Walk.map (G.boxProdRight H a).toHom | null | true |
Equidecomp.trans_toPartialEquiv | Mathlib.Algebra.Group.Action.Equidecomp | ∀ {X : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : MulAction G X] (f g : Equidecomp X G),
(f.trans g).toPartialEquiv = f.trans g.toPartialEquiv | null | true |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.argsToMonoWithFnType.match_1 | Lean.Compiler.LCNF.ToMono | (motive : Option Lean.Expr → Sort u_1) →
(remainingType : Option Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (some (Lean.Expr.forallE binderName d b binderInfo))) →
((x : Option Lean.Expr) → motive x) → motive remainingType | null | false |
HasStrictDerivAt.hasStrictFDerivAt_equiv | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {f : 𝕜 → 𝕜} {f' x : 𝕜},
HasStrictDerivAt f f' x →
∀ (hf' : f' ≠ 0), HasStrictFDerivAt f (↑((ContinuousLinearEquiv.unitsEquivAut 𝕜) (Units.mk0 f' hf'))) x | null | true |
CategoryTheory.Limits.Multicofork.ofSigmaCofork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left}
{hc : CategoryTheory.Limits.IsColimit c} {d : CategoryTheory.Limits.Cofan I.right}
(a : CategoryTheory.Limits.Cofork (I.... | null | false |
Std.ExtTreeSet.contains_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k a : α},
(t.insert k).contains a = (cmp k a == Ordering.eq || t.contains a) | null | true |
List.splitOnP_nil | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} {p : α → Bool}, List.splitOnP p [] = [[]] | null | true |
Convexity.ConvexSpace.AffineMap.mk.sizeOf_spec | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R] {X : Type u_2}
{Y : Type u_3} [inst_3 : Convexity.ConvexSpace R X] [inst_4 : Convexity.ConvexSpace R Y] [inst_5 : SizeOf R]
[inst_6 : SizeOf X] [inst_7 : SizeOf Y] (toFun : X → Y)
(isAffineMap_toFun :
autoParam (Co... | null | true |
List.permutationsAux2._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} → {β : Type u_2} → α → List α → List β → List α → (List α → β) → List α × List β | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.basicOpen_eq_bot_iff._simp_1_6 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
Std.Iterators.HetT.property_liftInner | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type u_1} {m : Type w → Type w'} {n : Type w → Type w''} [inst : MonadLiftT m n] {x : Std.Iterators.HetT m α},
(Std.Iterators.HetT.liftInner n x).Property = x.Property | null | true |
BoundedContinuousFunction | Mathlib.Topology.ContinuousMap.Bounded.Basic | (α : Type u) → (β : Type v) → [TopologicalSpace α] → [PseudoMetricSpace β] → Type (max u v) | `α →ᵇ β` is the type of bounded continuous functions `α → β` from a topological space to a
metric space.
When possible, instead of parametrizing results over `(f : α →ᵇ β)`,
you should parametrize over `(F : Type*) [BoundedContinuousMapClass F α β] (f : F)`.
When you extend this structure, make sure to extend `Bounde... | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.smul_mem_smul_iff._simp_1_3 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : Monoid β] [inst_2 : MulAction α β] [SMulCommClass α β β]
[IsScalarTower α β β] (g : α) (m : β), IsUnit (g • m) = IsUnit m | null | false |
Std.DHashMap.Raw.WF.inter₀ | Std.Data.DHashMap.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
{h₁ : 0 < m₁.buckets.size} {h₂ : 0 < m₂.buckets.size},
m₁.WF → m₂.WF → (↑(Std.DHashMap.Internal.Raw₀.inter ⟨m₁, h₁⟩ ⟨m₂, h₂⟩)).WF | Internal implementation detail of the hash map | true |
CommAlgCat.instIsEquivalenceOppositeFiniteEtaleFintypeCatFiberOfIsSepClosed | Mathlib.RingTheory.Etale.Finite | ∀ (Ω : Type u) [inst : Field Ω] [IsSepClosed Ω], (CommAlgCat.FiniteEtale.fiber Ω Ω).IsEquivalence | null | true |
AddSubmonoid.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → AddZeroClass (M i)] [inst_1 : DecidableEq ι] {I : Set ι}
{S : (i : ι) → AddSubmonoid (M i)} (i : ι) (x : M i), (Pi.single i x ∈ AddSubmonoid.pi I S) = (i ∈ I → x ∈ S i) | null | false |
List.instLE | Init.Data.List.Basic | {α : Type u} → [LT α] → LE (List α) | null | true |
Asymptotics.isLittleOTVS_sup | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l₁ l₂ : Filter α} {f : α → E} {g : α → F},
f =o[𝕜; l₁ ⊔... | null | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.add_le_add_iff_right.match_1_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Lean.PrettyPrinter.OneLine.State.column._default | Lean.PrettyPrinter.Formatter | ℕ | null | false |
groupHomology.boundaries₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u, u, u} k G) → Submodule k (G →₀ ↑A) | The 1-boundaries `B₁(G, A)` of `A : Rep k G`, defined as the image of the map
`(G² →₀ A) → (G →₀ A)` defined by `a·(g₁, g₂) ↦ ρ_A(g₁⁻¹)(a)·g₂ - a·g₁g₂ + a·g₁`. | true |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.valuation_exists_uniformizer'._proof_1_2 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (π : R),
v.intValuation π = WithZero.exp (-1) →
(IsDedekindDomain.HeightOneSpectrum.valuation K v) ((algebraMap R K... | null | false |
CategoryTheory.MorphismProperty.limitsOfShape_le | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] [W.IsStableUnderLimitsOfShape J], W.limitsOfShape J ≤ W | null | true |
Complex.ofReal_inv._simp_1 | Mathlib.Basic.Complex.Basic | ∀ (r : ℝ), (↑r)⁻¹ = ↑r⁻¹ | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.isIso_map._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | 1 ≤ 3 | null | false |
SchwartzMap.toLpCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_3) {E : Type u_1} (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E]
[inst_5 : OpensMeasurableSpace E] [inst_6 : NormedField 𝕜] [inst_7 : NormedSpace 𝕜 F] [inst_8 : SMulCommClass ℝ 𝕜 F]
[... | null | false |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.eval_zero_comp_det._simp_1_7 | Mathlib.RingTheory.Norm.Transitivity | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
{x_2 : NonAssocSemiring γ} {δ : Type u_5} {x_3 : NonAssocSemiring δ} (f : α →+* β) (g : β →+* γ) (h : γ →+* δ),
h.comp (g.comp f) = (h.comp g).comp f | null | false |
CategoryTheory.IsEquivalenceRelation.mk._flat_ctor | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R X : C} {p₁ p₂ : R ⟶ X},
Nonempty (CategoryTheory.EquivalenceRelation p₁ p₂) → CategoryTheory.IsEquivalenceRelation p₁ p₂ | null | false |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_2 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
(M ∈ doublyStochastic R n) = ((∀ (i j : n), 0 ≤ M i j) ∧ (∀ (i : n), ∑ j, M i j = 1) ∧ ∀ (j : n), ∑ i, M i j = 1) | null | false |
String.Slice.sliceTo.eq_1 | Init.Data.String.Lemmas.Basic | ∀ (s : String.Slice) (pos : s.Pos),
s.sliceTo pos =
{ str := s.str, startInclusive := s.startInclusive, endExclusive := pos.str, startInclusive_le_endExclusive := ⋯ } | null | true |
Lean.Elab.Term.mkCalcStepViews | Lean.Elab.Calc | Lean.TSyntax `Lean.calcSteps → Lean.Elab.TermElabM (Array Lean.Elab.Term.CalcStepView) | null | true |
Lean.SourceInfo.fromRef | Init.Prelude | Lean.Syntax → optParam Bool false → Lean.SourceInfo | Constructs a synthetic `SourceInfo` using a `ref : Syntax` for the span. | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.all_cons._simp_1_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {a b : α} {s : Stream'.Seq α}, (a ∈ Stream'.Seq.cons b s) = (a = b ∨ a ∈ s) | null | false |
AnalyticAtWithin.compContinuousLinearMap | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {u : E →L[𝕜] F} {f : F → G} {s : Set... | null | true |
LinearMap.rTensor_comp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[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] (g : P →ₗ[R] Q)
(... | null | true |
Filter.Tendsto.val_inv_units | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {N : Type u_4} [inst : TopologicalSpace N] [inst_1 : Monoid N] [inst_2 : ContinuousMul N]
[inst_3 : T2Space N] {f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [inst_4 : l.NeBot]
(h₁ : Filter.Tendsto (fun x => ↑(f x)) l (nhds r₁)) (h₂ : Filter.Tendsto (fun x => ↑(f x)⁻¹) l (nhds r₂)),
↑(h₁.units h₂)⁻¹ = r... | null | true |
Std.Http.Protocol.H1.Config.maxChunkLineLength | Std.Http.Protocol.H1.Config | Std.Http.Protocol.H1.Config → ℕ | Maximum number of bytes consumed while parsing one chunk-size line with extensions (default: 8192 bytes).
| true |
pointedToBipointedSndBipointedToPointedSndAdjunction._proof_7 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Pointed) (Y : Bipointed) (f : X ⟶ bipointedToPointedSnd.obj Y),
f.toFun X.point = (bipointedToPointedSnd.obj Y).point | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.hole._regBuiltin.Lean.Parser.Term.hole.docString_3 | Lean.Parser.Term.Basic | IO Unit | null | false |
CategoryTheory.StrictPseudofunctorPreCore.ctorIdx | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} → {inst_1 : CategoryTheory.Bicategory C} → CategoryTheory.StrictPseudofunctorPreCore B C → ℕ | null | false |
SaturatedSubmonoid.instCompleteLattice._proof_3 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : MulOneClass M] (a b c : SaturatedSubmonoid M), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
Homeomorph.instGroup._proof_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X ≃ₜ X), x ^ 0 = 1 | null | false |
Lean.Widget.RpcEncodablePacket.strict.«_@».Lean.Widget.InteractiveDiagnostic.2157017296._hygCtx._hyg.1.noConfusion | Lean.Widget.InteractiveDiagnostic | {P : Sort u} →
{a a' : Lean.Json} →
Lean.Widget.RpcEncodablePacket.strict✝ a = Lean.Widget.RpcEncodablePacket.strict✝ a' → (a = a' → P) → P | null | false |
Lean.Meta.instReprSimpCongrTheorems.repr | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Lean.Meta.SimpCongrTheorems → ℕ → Std.Format | null | true |
ModuleCat.extendScalars_assoc' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R₁ R₂ R₃ R₄ : Type u₁} [inst : CommRing R₁] [inst_1 : CommRing R₂] [inst_2 : CommRing R₃] [inst_3 : CommRing R₄]
(f₁₂ : R₁ →+* R₂) (f₂₃ : R₂ →+* R₃) (f₃₄ : R₃ →+* R₄),
CategoryTheory.CategoryStruct.comp (ModuleCat.extendScalarsComp (f₂₃.comp f₁₂) f₃₄).hom
(CategoryTheory.CategoryStruct.comp
(Catego... | The associativity compatibility for the extension of scalars, in the exact form
that is needed in the definition `CommRingCat.moduleCatExtendScalarsPseudofunctor`
in the file `Mathlib/Algebra/Category/ModuleCat/Pseudofunctor.lean` | true |
measurableEmbedding_mulLeft₀ | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : MeasurableSpace G₀] [MeasurableMul G₀] {g : G₀},
g ≠ 0 → MeasurableEmbedding fun x => g * x | null | true |
_private.Mathlib.CategoryTheory.Equivalence.0.CategoryTheory.Functor.IsEquivalence.mk'._proof_1_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (G : CategoryTheory.Functor D C)
(η : CategoryTheory.Functor.id C ≅ F.comp G) (ε : G.comp F ≅ CategoryTheory.Functor.id D), F.IsEquivalence | null | false |
Qq.Impl.PatVarDecl.fvar | Qq.MatchImpl | (decl : Qq.Impl.PatVarDecl) →
have a := decl.fvarTy;
Q(«$a») | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.IsMatching.iSup._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {α : Type u} {s t : Set α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | null | false |
Lean.Elab.Tactic.Grind.ExtraTheorem.ctorIdx | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.ExtraTheorem → ℕ | null | false |
List.forIn'.loop._proof_1 | Init.Data.List.Control | ∀ {α : Type u_1} (as : List α) (a : α) (as' : List α), (∃ bs, bs ++ a :: as' = as) → ∃ bs, bs ++ as' = as | null | false |
CategoryTheory.IsCardinalAccessibleCategory.mono_iff | Mathlib.CategoryTheory.Presentable.CardinalPure | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (κ : Cardinal.{w}) [inst_1 : Fact κ.IsRegular]
[CategoryTheory.IsCardinalAccessibleCategory C κ] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono f ↔
∀ (T : C) [CategoryTheory.IsCardinalPresentable T κ] (g₁ g₂ : T ⟶ X),
CategoryTheory.CategoryStruct... | null | true |
groupHomology.isBoundary₁_of_mem_boundaries₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A],
∀ x ∈ groupHomology.boundaries₁ (Rep.ofDistribMulAction k G A), groupHomology.IsBoundary₁ x | null | true |
TopRep.hV2 | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} →
[inst : Ring k] → [inst_1 : TopologicalSpace k] → [inst_2 : Monoid G] → (self : TopRep k G) → Module k ↑self | null | true |
CategoryTheory.FreeBicategory.Hom₂.whisker_left.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] [inst_1 : SizeOf B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g h : b ⟶ c}
(η : CategoryTheory.FreeBicategory.Hom₂ g h),
sizeOf (CategoryTheory.FreeBicategory.Hom₂.whisker_left f η) =
1 + sizeOf a + sizeOf b + sizeOf c + sizeOf f + sizeOf g + sizeOf h + sizeOf η | null | true |
UInt32.toFin_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), (a * b).toFin = a.toFin * b.toFin | null | true |
AlgebraicGeometry.Scheme.Pullback.t_fst_snd | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j : 𝒰.I₀),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j)
(CategoryTheory.Categ... | null | true |
Mathlib.Tactic.mkHigherOrderType._unsafe_rec | Mathlib.Tactic.HigherOrder | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.State._sizeOf_1 | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.CollectDerivedValInfo.State✝ → ℕ | null | false |
Lean.Meta.Grind.CheckResult.closed.elim | Lean.Meta.Tactic.Grind.CheckResult | {motive : Lean.Meta.Grind.CheckResult → Sort u} →
(t : Lean.Meta.Grind.CheckResult) → t.ctorIdx = 3 → motive Lean.Meta.Grind.CheckResult.closed → motive t | null | false |
_private.Mathlib.Algebra.Category.Ring.Colimits.0.RingCat.Colimits.descFunLift.match_1.eq_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(motive : RingCat.Colimits.Prequotient F → Sort u_2) (x : RingCat.Colimits.Prequotient F)
(h_1 : (j : J) → (x : ↑(F.obj j)) → motive (RingCat.Colimits.Prequotient.of j x))
(h_2 : Unit → motive RingCat.Colimits.Prequoti... | null | true |
instReprUInt64 | Init.Data.Repr | Repr UInt64 | null | true |
CharP.orderOf_eq_two_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {R : Type u_6} [inst : Ring R] [Nontrivial R] [NoZeroDivisors R] (p : ℕ),
p ≠ 2 → ∀ [CharP R p] {x : R}, orderOf x = 2 ↔ x = -1 | null | true |
Polynomial.aeval_conj | Mathlib.Analysis.RCLike.Lemmas | ∀ {K : Type u_1} [inst : RCLike K] (p : Polynomial ℝ) (z : K),
(Polynomial.aeval ((starRingEnd K) z)) p = (starRingEnd K) ((Polynomial.aeval z) p) | null | true |
MulOpposite.instCommCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CommCStarAlgebra A] (a b c : Aᵐᵒᵖ), a * (b + c) = a * b + a * c | null | false |
CategoryTheory.GrothendieckTopology.Subcanonical.of_le | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J K : CategoryTheory.GrothendieckTopology C},
J ≤ K → ∀ [K.Subcanonical], J.Subcanonical | null | true |
ZNum.rec | Mathlib.Data.Num.Basic | {motive : ZNum → Sort u} →
motive ZNum.zero → ((a : PosNum) → motive (ZNum.pos a)) → ((a : PosNum) → motive (ZNum.neg a)) → (t : ZNum) → motive t | null | false |
Graph.isClosedSubgraph_bot_iff | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β}, G.IsClosedSubgraph ⊥ ↔ G = ⊥ | null | true |
Std.Time.Minute.instNegOffset._aux_1 | Std.Time.Time.Unit.Minute | Std.Time.Minute.Offset → Std.Time.Minute.Offset | null | false |
CategoryTheory.LocalizerMorphism.RightResolution.Hom.noConfusion | Mathlib.CategoryTheory.Localization.Resolution | {P : Sort u} →
{C₁ : Type u_1} →
{C₂ : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.Local... | null | false |
TopCat.Hom._mkInternal.injEq | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (hom' hom'_1 : C(↑X, ↑Y)), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | false |
Nat.le_sub_of_add_le' | Init.Data.Nat.Lemmas | ∀ {n k m : ℕ}, m + n ≤ k → n ≤ k - m | null | true |
Mathlib.Tactic.Translate.TranslateData.mk.noConfusion | Mathlib.Tactic.Translate.Expr | {P : Sort u} →
{dontTranslateAttr : Lean.NameMapExtension Unit} →
{unfoldBoundaries? : Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt} →
{translations : Lean.NameMapExtension Mathlib.Tactic.Translate.TranslationInfo} →
{attrName : Lean.Name} →
{changeNumeral isDual : Bool} →
... | null | false |
Action.instMonoidalForget._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] {X Y : Action V G} (f : X ⟶ Y) (X' : Action V G),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((Action.forget V G).map f) ((... | null | false |
_private.ProofWidgets.Component.MakeEditLink.0.ProofWidgets.Internal.utf16Size | ProofWidgets.Component.MakeEditLink | Char → UInt32 | Returns the number of bytes required to encode this `Char` in UTF-16. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.