name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.InfoTree.Util.0.Lean.Elab.InfoTree.deepestNodesM.match_1 | Lean.Elab.InfoTree.Util | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((r : α) → motive (some r)) → (Unit → motive none) → motive __do_lift | null | false |
Complex.UnitClosedDisc.normSq_lt_one | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitClosedDisc), Complex.normSq ↑z ≤ 1 | null | true |
Aesop.NormM.Context.rec | Aesop.Search.Expansion.Norm | {motive : Aesop.NormM.Context → Sort u} →
((options : Aesop.Options') →
(ruleSet : Aesop.LocalRuleSet) →
(normSimpContext : Aesop.NormSimpContext) →
motive { options := options, ruleSet := ruleSet, normSimpContext := normSimpContext }) →
(t : Aesop.NormM.Context) → motive t | null | false |
Continuous.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ}, Continuous f → Continuous fun y => Complex.exp (f y) | null | true |
HomologicalComplex.hasExactColimitsOfShape | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J]
[CategoryTheory.Limits.HasFiniteLimits C] [inst_4 : CategoryTheory.Limits.HasColimitsOfShape J C]
[CategoryTheory... | null | true |
Lean.Meta.DiscrTree.Key.arrow | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_two_mul_toInt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {x : BitVec 0}, (¬-2 ^ 0 ≤ 2 * if 2 * x.toNat < 2 ^ 0 then ↑x.toNat else ↑x.toNat - ↑(2 ^ 0)) → False | null | false |
IsRightUniformGroup.mk._flat_ctor | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_4} [inst : UniformSpace G] [inst_1 : Group G],
(Continuous fun p => p.1 * p.2) →
(Continuous fun a => a⁻¹) → uniformity G = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) → IsRightUniformGroup G | null | false |
Language.reverse_zero | Mathlib.Computability.Language | ∀ {α : Type u_1}, Language.reverse 0 = 0 | null | true |
Nat.add_choose | Mathlib.Data.Nat.Choose.Basic | ∀ (i j : ℕ), (i + j).choose j = (i + j).factorial / (i.factorial * j.factorial) | null | true |
CategoryTheory.Functor.FullyFaithful.preimage | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → F.FullyFaithful → {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y) | The inverse map `(F.obj X ⟶ F.obj Y) → (X ⟶ Y)` of `F.map`. | true |
AlgebraicGeometry.HasRingHomProperty.of_source_openCover | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q] {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.IsAffine Y]
(𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), Algebraic... | null | true |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.Ring.intCast_add._proof_1_6 | Init.Grind.Ring.Basic | ∀ (x y : ℕ), y ≥ x + 1 → ¬-↑(x + 1) + ↑y = ↑(y - (x + 1)) → False | null | false |
Lean.Elab.Tactic.Doc.TacticDoc._sizeOf_inst | Lean.Elab.Tactic.Doc | SizeOf Lean.Elab.Tactic.Doc.TacticDoc | null | false |
GaloisInsertion.choice_eq | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisInsertion l u) (a : α) (h : u (l a) ≤ a), self.choice a h = l a | Property of the choice function. | true |
PrimeSpectrum.zeroLocusEquivIrreducibleCloseds | Mathlib.RingTheory.Spectrum.Prime.Topology | {R : Type u} →
[inst : CommSemiring R] →
(I : Set R) → ↑(PrimeSpectrum.zeroLocus I) ≃o (TopologicalSpace.IrreducibleCloseds ↑(PrimeSpectrum.zeroLocus I))ᵒᵈ | Zero loci of prime ideals are closed irreducible sets in the Zariski topology and any closed
irreducible set is a zero locus of some prime ideal.
| true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.exists_finset_free_localization._simp_1_1 | Mathlib.RingTheory.PicardGroup | ∀ {α : Type u} [inst : Semiring α] (I : Ideal α), (I = ⊤) = (1 ∈ I) | null | false |
Units.instStarMul._proof_4 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : Rˣ),
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ }⁻¹ *
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } =
1 | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.fst._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p : ℤ), p + 2 = p + 2 | null | false |
Orthonormal.basisTensorProduct | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F] {ι₁ : Type u_6}
{ι₂ : Type u_7} {b₁ : Module.Basis ι₁ 𝕜 E} {b₂ : Module.Basis ι₂ 𝕜 F},
Orthonormal 𝕜 ⇑b₁ → Ortho... | The tensor product of two orthonormal bases is orthonormal. | true |
instCoeTCBiheytingHomOfBiheytingHomClass._proof_3 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_1} [inst : FunLike F α β] [inst_1 : BiheytingAlgebra α]
[inst_2 : BiheytingAlgebra β] [BiheytingHomClass F α β] (f : F) (a b : α), f (a ⇨ b) = f a ⇨ f b | null | false |
HomologicalComplex₂.total.map | Mathlib.Algebra.Homology.TotalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{I₁₂ : Type u_4} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} ... | The morphism `K.total c₁₂ ⟶ L.total c₁₂` of homological complexes induced
by a morphism of bicomplexes `K ⟶ L`. | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_6 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) {X_1 Y_1 Z : CategoryTheory.Over Y} (f : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
CategoryTheory.Over.homMk
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X
(CategoryTheory.Over.Hom.left... | null | false |
Height.logHeight_fun_mul_eq | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} {ι' : Type u_3} [Finite ι]
[Finite ι'] {x : ι → K},
x ≠ 0 → ∀ {y : ι' → K}, y ≠ 0 → (Height.logHeight fun a => x a.1 * y a.2) = Height.logHeight x + Height.logHeight y | The logarithmic height of the "multiplication table" `fun (i, j) ↦ x i * y j`
is the sum of the logarithmic heights of `x` and `y`. | true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision.match_1_3 | Mathlib.NumberTheory.Rayleigh | ∀ {s : ℝ} ⦃j : ℤ⦄ (motive : j ∈ {x | ∃ k, beattySeq' s k = x} → Prop) (h : j ∈ {x | ∃ k, beattySeq' s k = x}),
(∀ (m : ℤ) (h₂ : beattySeq' s m = j), motive ⋯) → motive h | null | false |
PUnit.normedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (a b : PUnit.{u_1 + 1}), a + b = b + a | null | false |
SSet.horn₂₂.isPushout | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | CategoryTheory.IsPushout (SSet.stdSimplex.δ 0) (SSet.stdSimplex.δ 0) SSet.horn₂₂.ι₀₂ SSet.horn₂₂.ι₁₂ | null | true |
MeasureTheory.ComplexMeasure.re | Mathlib.MeasureTheory.Measure.Complex | {α : Type u_1} → {m : MeasurableSpace α} → MeasureTheory.ComplexMeasure α →ₗ[ℝ] MeasureTheory.SignedMeasure α | The real part of a complex measure is a signed measure. | true |
MonCat.Colimits.coconeMorphism._proof_1 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (j : J),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) (MonCat.Colimits.Prequotient.of j 1) =
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one | null | false |
Qq.Impl.ExprBackSubstResult | Qq.Macro | Type | null | true |
Besicovitch.TauPackage.iUnionUpTo.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(i : Ordinal.{u}), p.iUnionUpTo i = ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j)) | null | true |
_private.Mathlib.LinearAlgebra.Semisimple.0.Module.End.IsSemisimple.of_mem_adjoin_pair._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {y : R} [inst : CommSemiring R], (Ideal.span {y}).IsRadical = IsRadical y | null | false |
ProbabilityTheory.Kernel.instIsFiniteKernelSectROfProd | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel (α × β) γ) (a : α) [ProbabilityTheory.IsFiniteKernel κ],
ProbabilityTheory.IsFiniteKernel (κ.sectR a) | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.withAlts | Lean.Meta.Match.Match | {α : Type} →
Lean.Expr →
Array Lean.Expr →
Array Lean.Meta.Match.DiscrInfo →
List Lean.Meta.Match.AltLHS →
Option Lean.Meta.Match.Overlaps →
(List Lean.Meta.Match.Alt → Array Lean.Expr → Array Lean.Meta.Match.AltParamInfo → Lean.MetaM α) →
Lean.MetaM α | Given a list of `AltLHS`, create a minor premise for each one, convert them into `Alt`, and then execute `k` | true |
Std.Rii.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_4 : Std.Rxi.IsAlwaysFinite α], List.Pairwise (fun a b => a ≠ b) r.toList | null | true |
CategoryTheory.PresheafOfGroups.OneCocycle.mk | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : CategoryTheory.Functor Cᵒᵖ GrpCat} →
{I : Type w'} →
{U : I → C} →
(toOneCochain : CategoryTheory.PresheafOfGroups.OneCochain G U) →
autoParam
(∀ (i j k : I) ⦃T : C⦄ (a : T ⟶ U i) (b : T ⟶ U j) (c :... | null | true |
CategoryTheory.MonoidalCategory.«term_◁ᵢ_» | Mathlib.CategoryTheory.Monoidal.Category | Lean.TrailingParserDescr | The left whiskering of an isomorphism is an isomorphism. | true |
hasFDerivAt_apply | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {ι : Type u_6} {F' : ι → Type u_7}
[inst_1 : (i : ι) → NormedAddCommGroup (F' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (F' i)] (i : ι) (f : (i : ι) → F' i),
HasFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f | null | true |
Filter.le_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α × β)} {g : Filter α} {g' : Filter β},
f ≤ g ×ˢ g' ↔ Filter.Tendsto Prod.fst f g ∧ Filter.Tendsto Prod.snd f g' | null | true |
Multiset.union_comm | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∪ t = t ∪ s | null | true |
skewAdjoint.instSMulSubtypeMemAddSubgroupOfStarModule | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
{A : Type u_2} →
[inst : Star R] →
[TrivialStar R] →
[inst_2 : AddCommGroup A] →
[inst_3 : StarAddMonoid A] →
[inst_4 : Monoid R] → [inst_5 : DistribMulAction R A] → [StarModule R A] → SMul R ↥(skewAdjoint A) | null | true |
Lean.Lsp.TextDocumentChangeRegistrationOptions.mk._flat_ctor | Lean.Data.Lsp.TextSync | Option Lean.Lsp.DocumentSelector → Lean.Lsp.TextDocumentSyncKind → Lean.Lsp.TextDocumentChangeRegistrationOptions | null | false |
_private.Qq.ForLean.Do.0.Lean.Elab.Term.extractBind.match_1 | Qq.ForLean.Do | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((m returnType : Lean.Expr) → motive (m.app returnType)) → ((x : Lean.Expr) → motive x) → motive type | null | false |
Rat.mul_eq_mkRat | Mathlib.Data.Rat.Defs | ∀ (q r : ℚ), q * r = mkRat (q.num * r.num) (q.den * r.den) | null | true |
CategoryTheory.Localization.SmallShiftedHom.equiv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(W : CategoryTheory.MorphismProperty C) →
{M : Type w'} →
[inst_2 : AddMonoid M] →
[inst_3 : CategoryTheory.HasShift C M] →
... | The bijection `SmallShiftedHom.{w} W X Y m ≃ ShiftedHom (L.obj X) (L.obj Y) m`
for all `m : M`, and `X` and `Y` in `C` when `L : C ⥤ D` is a localization functor for
`W : MorphismProperty C` such that the category `D` is equipped with a shift by `M`
and `L` commutes with the shifts. | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_ne_empty_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | null | false |
CategoryTheory.Limits.isColimitOfConeUnopOfCocone | Mathlib.CategoryTheory.Limits.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) →
{c : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneUnopOfCocone c) →... | Turn a limit for `F.unop : J ⥤ C` into a colimit for `F : Jᵒᵖ ⥤ Cᵒᵖ`. | true |
Lean.Lsp.Hover.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {contents : Lean.Lsp.MarkupContent} {range? : Option Lean.Lsp.Range} {contents_1 : Lean.Lsp.MarkupContent}
{range?_1 : Option Lean.Lsp.Range},
{ contents := contents, range? := range? } = { contents := contents_1, range? := range?_1 } →
contents = contents_1 ∧ range? = range?_1 | null | true |
Int.neg_neg | Init.Data.Int.Lemmas | ∀ (a : ℤ), - -a = a | null | true |
CategoryTheory.ShortComplex.leftRightHomologyComparison'_fac | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h₁ : S.LeftHomologyData) (h₂ : S.RightHomologyData) [inst_2 : S.HasHomology],
CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂ =
CategoryTheory.Category... | null | true |
AffineEquiv.mk.inj | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} {inst : Ring k}
{inst_1 : AddCommGroup V₁} {inst_2 : AddCommGroup V₂} {inst_3 : Module k V₁} {inst_4 : Module k V₂}
{inst_5 : AddTorsor V₁ P₁} {inst_6 : AddTorsor V₂ P₂} {toEquiv : P₁ ≃ P₂} {linear : V₁ ≃ₗ[k] V₂}
{map_vadd' : ∀ (p : ... | null | true |
RootPairing.Base.cartanMatrix_apply_eq_zero_iff_symm | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : 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 : P.IsCrystallographic] [CharZero R] [IsDomain R] {i j : ↥b.support},
b.cartanMatrix i j ... | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Result.mk.inj | Lean.Meta.LetToHave | ∀ {expr : Lean.Expr} {type? : Option Lean.Expr} {expr_1 : Lean.Expr} {type?_1 : Option Lean.Expr},
{ expr := expr, type? := type? } = { expr := expr_1, type? := type?_1 } → expr = expr_1 ∧ type? = type?_1 | null | true |
Mathlib.TacticAnalysis.Config.mk._flat_ctor | Mathlib.Tactic.TacticAnalysis | (Array Mathlib.TacticAnalysis.TacticNode → Lean.Elab.Command.CommandElabM Unit) → Mathlib.TacticAnalysis.Config | null | false |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions.0.CategoryTheory.Localization.exists_leftFraction₂.match_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] {X Y : C} (f : L.obj X ⟶ L.obj Y)
(motive : (∃ φ, f = φ.map L ⋯) → Prop) (x : ∃ φ, f ... | null | false |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_prod_of_discrete_right._simp_1_3 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)} {x : α × β},
ContinuousWithinAt f s x = ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1 | null | false |
Filter.commMonoid._proof_5 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : CommMonoid α] (a : Filter α), a * 1 = a | null | false |
SSet.homotopyEquivNormalizedChainComplex_hom | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X : SSet) (R : C),
(X.homotopyEquivNormalizedChainComplex R).hom = X.toNormalizedChainComplex R | null | true |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSym._proof_6 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (b : ℕ), ¬b = 0 → b / 2 < b | null | false |
Std.DTreeMap.Internal.RoiSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RoiSliceData α β) | null | false |
FractionalIdeal.spanFinset_coe | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ (R₁ : Type u_3) [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
[inst_3 : IsFractionRing R₁ K] {ι : Type u_5} (s : Finset ι) (f : ι → K),
↑(FractionalIdeal.spanFinset R₁ s f) = Submodule.span R₁ (f '' ↑s) | null | true |
SemiRingCat.limitπRingHom._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J SemiRingCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
Small.{u_1, max u_1 u_2}
↑((F.comp
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).comp
(... | null | false |
WithTop.lt_untop_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {b : α} [inst : LT α] {x : WithTop α} (hx : x ≠ ⊤), b < x.untop hx ↔ ↑b < x | null | true |
_private.Mathlib.Data.List.Forall2.0.List.rel_flatten.match_1_8 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
(funType_1 : (x : List (List α)) → (x_1 : List (List β)) → List.Forall₂ (List.Forall₂ R) x x_1 → Prop)
(motive :
(x : List (List α)) →
(x_1 : List (List β)) → (x_2 : List.Forall₂ (List.Forall₂ R) x x_1) → List.Forall₂.below x_2 → Prop)
(x : List (List α... | null | false |
_private.Lean.Meta.Sym.Arith.EvalNum.0.Lean.Meta.Sym.Arith.getOffset | Lean.Meta.Sym.Arith.EvalNum | Lean.Expr → Lean.Meta.Sym.SymM (Lean.Expr × ℕ) | Quick function for converting `e` into `s + k` s.t. `e` is definitionally equal to `Nat.add s k`.
This function always succeeds in finding such `s` and `k`
(as a last resort it returns `e` and `0`).
| true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Basic.0.Matrix.SpecialLinearGroup.toGL_mem_center_iff._simp_1_7 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Basic | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
AugmentedSimplexCategory.equivAugmentedSimplicialObject_inverse_obj_map | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject.Augmented C)
{X_1 Y : (CategoryTheory.WithInitial SimplexCategory)ᵒᵖ} (f : X_1 ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedSimplicialObject.inverse.obj X).map f =
match
match Opposite.unop X_1 with
... | null | true |
_private.Mathlib.Data.Finset.Update.0.Function.updateFinset_updateFinset._simp_1_3 | Mathlib.Data.Finset.Update | (¬False) = True | null | false |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast._proof_5 | Mathlib.Data.Rat.Cast.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (val : Q(PartialOrder «$α»)) (_oα : Q(LinearOrder «$α»)),
«$val» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | null | false |
Lean.Elab.Structural.IndGroupInst.recOn | Lean.Elab.PreDefinition.Structural.IndGroupInfo | {motive : Lean.Elab.Structural.IndGroupInst → Sort u} →
(t : Lean.Elab.Structural.IndGroupInst) →
((toIndGroupInfo : Lean.Elab.Structural.IndGroupInfo) →
(levels : List Lean.Level) →
(params : Array Lean.Expr) →
motive { toIndGroupInfo := toIndGroupInfo, levels := levels, params := p... | null | false |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalNestedTacticCore._regBuiltin.Lean.Elab.Tactic.Conv.evalNestedTacticCore_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N m : Submodule R M)
(motive : (∃ S, Nonempty (↥N ≃ₗ[R] ↥S)) → Prop) (x : ∃ S, Nonempty (↥N ≃ₗ[R] ↥S)),
(∀ (S : Submodule R ↥m) (e : ↥N ≃ₗ[R] ↥S), motive ⋯) → motive x | null | false |
Lean.Elab.Term.applyResult | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.Term.TermElabResult α → Lean.Elab.TermElabM α | Apply the result/exception and state captured with `observing`.
We use this method to implement overloaded notation and symbols. | true |
CategoryTheory.Adjunction.unit | Mathlib.CategoryTheory.Adjunction.Basic | {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 D C} → (F ⊣ G) → (CategoryTheory.Functor.id C ⟶ F.comp G) | The unit of an adjunction | true |
Lean.Meta.Sym.registerInstance | Lean.Meta.Sym.SynthInstance | Lean.Expr → Lean.Expr → Lean.Meta.Sym.SymM Unit | Registers `inst` as **the** instance for `type`. `synthInstance?` returns it without
running typeclass resolution, making `inst` the canonical representative for `type`.
Intended for satellite modules that construct instances for types they create themselves
(e.g., `grind linarith`'s envelope type `IntModule.OfNatModul... | true |
FreeGroup.of | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → α → FreeGroup α | `of` is the canonical injection from the type to the free group over that type by sending each
element to the equivalence class of the letter that is the element. | true |
_private.Mathlib.Algebra.Notation.Support.0.Pi.mulSupport_mulSingle_of_ne._proof_1_1 | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_2} [inst : DecidableEq ι] [inst_1 : One M] {i : ι} {a : M},
a ≠ 1 → Function.mulSupport (Pi.mulSingle i a) = {i} | null | false |
NumberField.ComplexEmbedding.conjugate_comp | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] (φ : K →+* ℂ) (σ : k →+* K),
(NumberField.ComplexEmbedding.conjugate φ).comp σ = NumberField.ComplexEmbedding.conjugate (φ.comp σ) | null | true |
normalizedGCDMonoidOfExistsLCM._proof_4 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
(h : ∀ (a b : α), ∃ c, ∀ (d : α), a ∣ d ∧ b ∣ d ↔ c ∣ d) (x x_1 : α),
normalize (normalize (Classical.choose ⋯)) = normalize (Classical.choose ⋯) | null | false |
UInt8.le_total | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a ≤ b ∨ b ≤ a | null | true |
CategoryTheory.MorphismProperty.toSet_max | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W₁ W₂ : CategoryTheory.MorphismProperty C),
(W₁ ⊔ W₂).toSet = W₁.toSet ∪ W₂.toSet | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux_eq_of._proof_1_2 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (len : ℕ) {len' : ℕ}, len + 1 = (len' + 1) / 2 → ¬0 < len' → False | null | false |
NonUnitalAlgHom.coe_comp | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {T : Type u_1} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : Monoid T] {φ : R →* S}
{A : Type v} {B : Type w} {C : Type w₁} [inst_3 : NonUnitalNonAssocSemiring A] [inst_4 : DistribMulAction R A]
[inst_5 : NonUnitalNonAssocSemiring B] [inst_6 : DistribMulAction S B] [inst_7 : NonUnital... | null | true |
Std.DTreeMap.Internal.Impl.getKey?_insertMany_empty_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → (↑(Std.DTreeMap.Internal.Impl.empty.insertMany l ⋯)).getKey? k' = some k | null | true |
nonempty_orderEmbedding_of_finite_infinite | Mathlib.Data.Finset.Sort | ∀ (α : Type u_1) [inst : LinearOrder α] [hα : Finite α] (β : Type u_2) [inst_1 : LinearOrder β] [hβ : Infinite β],
Nonempty (α ↪o β) | Any finite linear order order-embeds into any infinite linear order. | true |
Std.Time.WallTime.ofNanoseconds | Std.Time.DateTime.WallTime | Std.Time.Nanosecond.Offset → Std.Time.WallTime | Creates a `WallTime` from a `Nanosecond.Offset`. The epoch is 1970-01-01 00:00:00 in local
(civil) time, not UTC.
| true |
Filter.map_inr_inf_map_inl | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.map Sum.inr f ⊓ Filter.map Sum.inl g = ⊥ | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_9 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ),
r₀ ≤ r → (c r).Rel pq pq' → data.deg pq + 1 = data.deg pq' | null | false |
Module.Basis.mk_coord_apply_ne | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : ι → M} {hli : LinearIndependent R v} {hsp : ⊤ ≤ Submodule.span R (Set.range v)} {i j : ι},
j ≠ i → ((Module.Basis.mk hli hsp).coord i) (v j) = 0 | Given a basis, the `i`th element of the dual basis evaluates to 0 on the `j`th element of the
basis if `j ≠ i`. | true |
le_or_lt_of_mul_le_mul | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] [MulRightStrictMono α] {a₁ a₂ b₁ b₂ : α},
a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ | null | true |
CategoryTheory.PreGaloisCategory.instHasFiniteLimits | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C],
CategoryTheory.Limits.HasFiniteLimits C | null | true |
binomialSeries_eq_ordinaryHypergeometricSeries | Mathlib.Analysis.Analytic.Binomial | ∀ {𝕂 : Type u} [inst : Field 𝕂] [inst_1 : CharZero 𝕂] {𝔸 : Type v} [inst_2 : Ring 𝔸] [inst_3 : Algebra 𝕂 𝔸]
[inst_4 : TopologicalSpace 𝔸] [inst_5 : IsTopologicalRing 𝔸] {a b : 𝕂},
(∀ (k : ℕ), ↑k ≠ -b) →
binomialSeries 𝔸 a = (ordinaryHypergeometricSeries 𝔸 (-a) b b).compContinuousLinearMap (-Continuo... | null | true |
Lean.Elab.Term.ToDepElimPattern.TopSort.State._sizeOf_1 | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.TopSort.State → ℕ | null | false |
ODE.FunSpace.instMetricSpace | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} → {t₀ : ↑(Set.Icc tmin tmax)} → {x₀ : E} → {r L : NNReal} → MetricSpace (ODE.FunSpace t₀ x₀ r L) | The metric between two curves `α` and `β` is the supremum of the metric between `α t` and `β t`
over all `t` in the domain. This is finite when the domain is compact, such as a closed
interval in our case. | true |
_private.Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris.0.CategoryTheory.GrothendieckTopology.MayerVietorisSquare.fromBiprod_δ._proof_1_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris | ∀ (n₀ n₁ : ℕ), ¬1 + 2 ≤ 5 → False | null | false |
AEMeasurable.map_map_of_aemeasurable | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {g : β → γ} {f : α → β},
AEMeasurable g (MeasureTheory.Measure.map f μ) →
AEMeasurable f μ → MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) =... | null | true |
MaxTropical.untrop_lt_iff | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LT R] {x y : MaxTropical R}, MaxTropical.untrop y < MaxTropical.untrop x ↔ y < x | null | true |
CategoryTheory.FreeBicategory.Hom₂.associator_inv | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c d : CategoryTheory.FreeBicategory B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
CategoryTheory.FreeBicategory.Hom₂
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
(CategoryThe... | null | true |
Std.TreeMap.Raw.getElem?_eq_some_getD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α} {fallback : β}, t.contains a = true → t[a]? = some (t.getD a fallback) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.