name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Option.map_id_apply | Init.Data.Option.Lemmas | ∀ {α : Type u} {x : Option α}, Option.map id x = x | null | true |
HopfAlgebra.mk.noConfusion | Mathlib.RingTheory.HopfAlgebra.Basic | {R : Type u} →
{A : Type v} →
{inst : CommSemiring R} →
{inst_1 : Semiring A} →
{P : Sort u_1} →
{toHopfAlgebraStruct : HopfAlgebraStruct R A} →
{mul_antipode_rTensor_comul :
LinearMap.mul' R A ∘ₗ LinearMap.rTensor A (HopfAlgebraStruct.antipode R) ∘ₗ CoalgebraSt... | null | false |
Std.Http.URI.Port.omitted.elim | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Port → Sort u} →
(t : Std.Http.URI.Port) → t.ctorIdx = 0 → motive Std.Http.URI.Port.omitted → motive t | null | false |
Subsemiring.centralizer._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] (s : Set R) {a b : R},
a ∈ (Submonoid.centralizer s).carrier →
b ∈ (Submonoid.centralizer s).carrier → a * b ∈ (Submonoid.centralizer s).carrier | null | false |
Lean.FuzzyMatching.fuzzyMatchScoreWithThreshold? | Lean.Data.FuzzyMatching | String → String → optParam Float 0.1 → Option Float | null | true |
Part.eq_none_iff' | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α}, o = Part.none ↔ ¬o.Dom | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1352222462._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
WithOne.instMonad._aux_5 | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u_1} → α → WithOne α | null | false |
Vector.getElem_extract | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {as : Vector α n} {start stop : ℕ} (h : i < min stop n - start),
(as.extract start stop)[i] = as[start + i] | null | true |
CategoryTheory.PreOneHypercover.Hom.ext'._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F}, f.s₀ = g.s₀ → ∀ (i : E.I₀), g.s₀ i = f.s₀ i | null | false |
groupHomology.mapShortComplexH1_id_comp | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep.{u, u, u} k G} (φ : A ⟶ B) (ψ : B ⟶ C),
groupHomology.mapShortComplexH1 (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp φ ψ) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapShortComplexH1 (MonoidHom.id G) φ)
(groupHomology.mapS... | null | true |
CoeTC.mk._flat_ctor | Init.Coe | {α : Sort u} → {β : Sort v} → (α → β) → CoeTC α β | null | false |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.Affine.Simplex.sum_pointsWithCircumcenter._simp_1_1 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | null | false |
Nat.sub | Init.Prelude | ℕ → ℕ → ℕ | Subtraction of natural numbers, truncated at `0`. Usually used via the `-` operator.
If a result would be less than zero, then the result is zero.
This definition is overridden in both the kernel and the compiler to efficiently evaluate using the
arbitrary-precision arithmetic library. The definition provided here is... | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getBoolLit._sparseCasesOn_2 | Lean.Compiler.LCNF.Simp.ConstantFold | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Differentiable.div_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'}, Differentiable 𝕜 c → ∀ (d : 𝕜'), Differentiable 𝕜 fun x => c x / d | null | true |
AlgHom.IsArithFrobAt.restrict | Mathlib.RingTheory.Frobenius | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{φ : S →ₐ[R] S} → {Q : Ideal S} → φ.IsArithFrobAt Q → S ⧸ Q →ₐ[R ⧸ Ideal.under R Q] S ⧸ Q | A Frobenius element at `Q` restricts to the Frobenius map on `S ⧸ Q`. | true |
MeasureTheory.FiniteMeasure.instMeasurableSpace._proof_3 | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω], MeasureTheory.FiniteMeasure.instMeasurableSpace._aux_1 ∅ | null | false |
Std.Iterators.Types.DropWhile.instIterator.match_3 | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} →
(it : Std.IterM m β) →
(motive : it.internalState.inner.Step → Sort u_3) →
(x : it.internalState.inner.Step... | null | false |
DistribMulAction.toAddAut._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Basic | ∀ (G : Type u_2) (A : Type u_1) [inst : Group G] [inst_1 : AddMonoid A] [inst_2 : DistribMulAction G A] (x x_1 : G),
DistribMulAction.toAddEquiv A (x * x_1) = DistribMulAction.toAddEquiv A x * DistribMulAction.toAddEquiv A x_1 | null | false |
ProperVAdd.isProperMap_vadd_pair_set | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X] [ProperVAdd G X] {t : Set X}, IsProperMap fun gx => (gx.1 +ᵥ ↑gx.2, gx.2) | If `G` acts on `X` properly, then the map `G × T → X × T, (g, t) ↦ (g +ᵥ t, t)` is still
proper for *any* subset `T` of `X`. | true |
Cardinal.IsRegular.casesOn | Mathlib.SetTheory.Cardinal.Regular | {c : Cardinal.{u_1}} →
{motive : c.IsRegular → Sort u} →
(t : c.IsRegular) → ((aleph0_le : Cardinal.aleph0 ≤ c) → (le_cof_ord : c ≤ c.ord.cof) → motive ⋯) → motive t | null | false |
AlgebraicGeometry.Scheme.instIsPreimmersionMapResidue | Mathlib.AlgebraicGeometry.ResidueField | ∀ {X : AlgebraicGeometry.Scheme} (x : ↥X), AlgebraicGeometry.IsPreimmersion (AlgebraicGeometry.Spec.map (X.residue x)) | See `AlgebraicGeometry.IsClosedImmersion.SpecMap_residue` for the stronger result that
`Spec.map (X.residue x)` is a closed immersion. | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.angleDiff_nonneg._proof_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ (x y : Circle), 0 ≤ x.angleDiff y | null | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofStr._simp_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
String.Pos.sliceTo | Init.Data.String.Basic | {s : String} → (p₀ pos : s.Pos) → pos ≤ p₀ → (s.sliceTo p₀).Pos | Given a position in `s` that is at most `p₀`, obtain the corresponding position in `s.sliceTo p₀`. | true |
_private.Mathlib.Topology.Compactification.StoneCech.0.Ultrafilter.tendsto_pure_self._simp_1_1 | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} {β : Type v} {m : α → β} {f : Ultrafilter α} {s : Set β}, (s ∈ Ultrafilter.map m f) = (m ⁻¹' s ∈ f) | null | false |
NonUnitalStarAlgHom.nnnorm_apply_le | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : NonUnitalCStarAlgebra B]
[inst_2 : FunLike F A B] [NonUnitalAlgHomClass F ℂ A B] [StarHomClass F A B] (φ : F) (a : A), ‖φ a‖₊ ≤ ‖a‖₊ | A non-unital star algebra homomorphism of complex C⋆-algebras is norm contractive. | true |
Lean.Meta.Sym.ProofInstInfo | Lean.Meta.Sym.SymM | Type | Information about a function symbol. It stores which argument positions are proofs or instances,
enabling optimizations during pattern matching and structural definitional equality tests
such as skipping proof arguments or deferring instance synthesis.
| true |
CategoryTheory.Pairwise.coconeIsColimit._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} {α : Type u_2} (U : ι → α) [inst : CompleteLattice α]
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Pairwise.diagram U)) (j : CategoryTheory.Pairwise ι),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pairwise.cocone U).ι.app j) (CategoryTheory.homOfLE ⋯) = s.ι.app j | null | false |
TopHom.instLattice._proof_2 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Top α] [inst_1 : Lattice β] [inst_2 : OrderTop β] {x y : TopHom α β},
⇑x ≤ ⇑y ↔ ⇑x ≤ ⇑y | null | false |
_private.Mathlib.Topology.CWComplex.Classical.Finite.0.Topology.RelCWComplex.finite_cells_of_finite.match_1_1 | Mathlib.Topology.CWComplex.Classical.Finite | {X : Type u_1} →
[inst : TopologicalSpace X] →
{C D : Set X} →
[inst_1 : Topology.RelCWComplex C D] →
(n : ℕ) →
(motive : (m : { m // m < n }) × Topology.RelCWComplex.cell C ↑m → Sort u_2) →
(x : (m : { m // m < n }) × Topology.RelCWComplex.cell C ↑m) →
((m : { m ... | null | false |
Zsqrtd.decidableNonnegg | Mathlib.NumberTheory.Zsqrtd.Basic | (c d : ℕ) → DecidableRel (Zsqrtd.Nonnegg c d) | null | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_3 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x l : ℕ)
(R : L.Relations l) (ts : Fin l → L.Term (α ⊕ Fin x))
(h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.Bounded... | null | true |
UpperSet.iciSupHom | Mathlib.Order.UpperLower.Hom | {α : Type u_1} → [inst : SemilatticeSup α] → SupHom α (UpperSet α) | `UpperSet.Ici` as a `SupHom`. | true |
MeasureTheory.AECover.biInter_Ici_aecover | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [Countable ι] [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : Preorder ι] {φ : ι → Set α},
MeasureTheory.AECover μ Filter.atTop φ → MeasureTheory.AECover μ Filter.atTop fun n => ⋂ k ∈ Set.Ici n, φ k | null | true |
WeierstrassCurve.Jacobian.negAddY_of_X_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q →
P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 → W'.negAddY P Q * (P 2 * Q 2) ^ 3 = (P 1 * Q 2 ^ 3 - Q 1 * P 2 ^ 3) ^ 3 | null | true |
Lean.Parser.ParserContext.setEndPos | Lean.Parser.Types | (c : Lean.Parser.ParserContext) →
(endPos : String.Pos.Raw) → endPos ≤ c.inputString.rawEndPos → Lean.Parser.ParserContext | Modifies the ending position of a parser context.
| true |
UniqueProds.of_injective_mulHom | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} {H : Type v} [inst : Mul G] [inst_1 : Mul H] (f : H →ₙ* G),
Function.Injective ⇑f → UniqueProds G → UniqueProds H | null | true |
CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₂ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₂ = ... | null | true |
PowerSeries.rescale_zero_apply | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (f : PowerSeries R),
(PowerSeries.rescale 0) f = PowerSeries.C (PowerSeries.constantCoeff f) | null | true |
ContinuousLinearMap.isIdempotentElem_iff_eq_projectionL_range_ker | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {f : M →L[R] M},
IsIdempotentElem f ↔ ∃ (h : Submodule.IsTopCompl (↑f).range (↑f).ker), f = (↑f).range.projectionL (↑f).ker h | null | true |
AffineIsometryEquiv.linearIsometryEquiv | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_4} →
{P : Type u_7} →
{P₂ : Type u_8} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Norme... | The underlying linear equiv of an affine isometry equiv is in fact a linear isometry equiv. | true |
Polynomial.scaleRoots | Mathlib.RingTheory.Polynomial.ScaleRoots | {R : Type u_1} → [inst : Semiring R] → Polynomial R → R → Polynomial R | `scaleRoots p s` is a polynomial with root `r * s` for each root `r` of `p`. | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry._unary.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : Type v} (_x : (x : Std.DTreeMap.Internal.Impl α fun x => β) ×' x.isEmpty = false),
Std.DTreeMap.Internal.Impl.Const.maxEntry._unary _x =
PSigma.casesOn _x fun t h =>
match t, h with
| Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf, x => (k, v)
| S... | null | false |
Finset.sum_ite_eq' | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (a : ι) (b : ι → M),
(∑ x ∈ s, if x = a then b x else 0) = if a ∈ s then b a else 0 | A sum taken over a conditional whose condition is an equality
test on the index and whose alternative is `0` has value either the term at that index or `0`.
The difference with `Finset.sum_ite_eq` is that the arguments to `Eq` are swapped. | true |
Set.Unbounded.eq_1 | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) (s : Set α), Set.Unbounded r s = ∀ (a : α), ∃ b ∈ s, ¬r b a | null | true |
RingQuot.Rel.brecOn | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {r : R → R → Prop} {motive : (a a_1 : R) → RingQuot.Rel r a a_1 → Prop} {a a_1 : R}
(t : RingQuot.Rel r a a_1),
(∀ (a a_2 : R) (t : RingQuot.Rel r a a_2), RingQuot.Rel.below t → motive a a_2 t) → motive a a_1 t | null | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcycles_exact._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | Lean.Syntax | null | false |
CategoryTheory.yonedaAddGrpObj._proof_4 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(G : C) [inst_2 : CategoryTheory.AddGrpObj G] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
AddGrpCat.ofHom
(AddMonCat.Hom.hom ((CategoryTheory.yonedaAddMonObj G).map (CategoryTheory.CategoryStruct.co... | null | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun'._proof_1 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (b a : α) (x : ↥(Finset.Ioc a b)), a < ↑x ∧ ↑x ≤ b | null | false |
DivisionRing.toNNRatCast | Mathlib.Algebra.Field.Defs | {K : Type u_2} → [self : DivisionRing K] → NNRatCast K | null | true |
Set.eq_domRestrict_iff | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {π : α → Type u_5} {s : Set α} {f : (a : ↑s) → π ↑a} {g : (a : α) → π a},
f = s.domRestrict g ↔ ∀ (a : α) (ha : a ∈ s), f ⟨a, ha⟩ = g a | null | true |
_private.Init.Data.Option.Lemmas.0.Option.choice.eq_1 | Init.Data.Option.Lemmas | ∀ (α : Type u_1), Option.choice α = if h : Nonempty α then some (Classical.choice h) else none | null | true |
CategoryTheory.Limits.zeroProdIso_inv_snd | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.zeroProdIso X).inv CategoryTheory.Limits.prod.snd =
CategoryTheory.CategoryStruct... | null | true |
SheafOfModules.relationsOfIsCokernelFree_s | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {ι σ : Type u} {M : SheafOfModules R}
(f : SheafOfModules.free ι ⟶ S... | null | true |
AddCon.instInfSet._proof_2 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (S : Set (AddCon M)) {w x y z : M},
(∀ c ∈ S, c w x) → (∀ c ∈ S, c y z) → ∀ c ∈ S, c (w + y) (x + z) | null | false |
OnePoint.instFintype._proof_3 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : Fintype X] (x : OnePoint X), x ∈ OnePoint.instFintype._aux_1 | null | false |
Int.fract_div_mul_self_add_zsmul_eq | Mathlib.Algebra.Order.Floor.Ring | ∀ {k : Type u_4} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : FloorRing k] (a b : k),
a ≠ 0 → Int.fract (b / a) * a + ⌊b / a⌋ • a = b | null | true |
Lean.Parser.Command.openHiding.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Lean.Widget.TaggedText.rec_1 | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
{motive_2 : Array (Lean.Widget.TaggedText α) → Sort u_1} →
{motive_3 : List (Lean.Widget.TaggedText α) → Sort u_1} →
((a : String) → motive_1 (Lean.Widget.TaggedText.text a)) →
((a : Array (Lean.Widget.TaggedText α)) → motiv... | null | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt'._proof_1_13 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {a b : ℝ} {φ φ' : ℝ → ℝ},
(∀ x ∈ Set.Icc a b, HasDerivWithinAt φ (φ' x) (Set.Icc a b) x) →
∀ x ∈ Set.Ico a b, HasDerivWithinAt φ (φ' x) (Set.Ici x) x | null | false |
CyclotomicField.instField._proof_54 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K],
autoParam (∀ (n_1 : ℕ) (a : CyclotomicField n K), a ^ ↑n_1.succ = a ^ ↑n_1 * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
MonoidWithZero.mk | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
[toMonoid : Monoid M₀] → [toZero : Zero M₀] → (∀ (a : M₀), 0 * a = 0) → (∀ (a : M₀), a * 0 = 0) → MonoidWithZero M₀ | null | true |
Std.DTreeMap.Raw.get_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h₁ : t₁.WF) (h₂ : t₂.WF) {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂},
(t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
FirstOrder.Language.Formula.realize_iSup | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{f : β → L.Formula α} {v : α → M}, (FirstOrder.Language.Formula.iSup f).Realize v ↔ ∃ b, (f b).Realize v | null | true |
CategoryTheory.Sigma.SigmaHom.ctorIdx | Mathlib.CategoryTheory.Sigma.Basic | {I : Type w₁} →
{C : I → Type u₁} →
{inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)} →
{a a_1 : (i : I) × C i} → CategoryTheory.Sigma.SigmaHom a a_1 → ℕ | null | false |
Std.Async.IO.AsyncWrite.noConfusion | Std.Async.IO | {P : Sort u} →
{α β : Type} →
{t : Std.Async.IO.AsyncWrite α β} →
{α' β' : Type} →
{t' : Std.Async.IO.AsyncWrite α' β'} → α = α' → β = β' → t ≍ t' → Std.Async.IO.AsyncWrite.noConfusionType P t t' | null | false |
_private.Mathlib.Algebra.Ring.Idempotent.0.IsIdempotentElem.sub_iff._simp_1_3 | Mathlib.Algebra.Ring.Idempotent | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - b - c = a - (b + c) | null | false |
CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hf : CategoryTheory.IsIso S.f),
CategoryTheory.CategoryStruct.comp S.f (CategoryTheory.inv S.f) = CategoryTheory.CategoryStruct.id S.X₁ | null | false |
CategoryTheory.Comma.id_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T}
{R : CategoryTheory.Functor B T} {X : CategoryTheory.Comma L R},
(CategoryTheory.CategoryStruct.id X)... | null | true |
CategoryTheory.Abelian.AbelianStruct.mk._flat_ctor | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
{f : X ⟶ Y} →
(kernelFork : CategoryTheory.Limits.KernelFork f) →
CategoryTheory.Limits.IsLimit kernelFork →
(cokernelCofork : CategoryTheory.Lim... | null | false |
zpow_right_strictAnti₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀}
[ZeroLEOneClass G₀], 0 < a → a < 1 → StrictAnti fun n => a ^ n | null | true |
CategoryTheory.Functor.comp_mapCommGrp_mul | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] ... | null | true |
AddCommGroup.freeRank.eq_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : AddGroup.FG G],
AddCommGroup.freeRank G = AddGroup.rank (G ⧸ AddCommGroup.torsion G) | null | true |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve | Mathlib.CategoryTheory.Sites.Descent.Precoverage | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type t} →
{S : C} →
{X : ι → C} →
((i : ι) → X i ⟶ S) →
{ι' : Type t'} →
{X' : ι' → C} →
((j : ι') → X' j ⟶ S) →
(i : ι) → CategoryTheory.Sieve (CategoryTheory.Over.m... | Given two families of morphisms `f i : X i ⟶ S` and `f' j : X' j ⟶ S`,
this is the sieve on `Over.mk (𝟙 (X i)) : Over (X i)` which corresponds
to the sieve of `X i` that is obtained by pulling back by `f i` the sieve
generated by `f'`. | true |
_private.Lean.DocString.Extension.0.Lean.initFn._@.Lean.DocString.Extension.797151674._hygCtx._hyg.2 | Lean.DocString.Extension | IO (IO.Ref (Lean.NameMap Lean.VersoDocString)) | null | false |
CategoryTheory.Limits.prod.fst.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.fst =
CategoryTheory.Limits.limit.π (CategoryTheory.Limits.pair X Y) { as := CategoryTheory.Limits.WalkingPair.left } | null | true |
_private.Mathlib.Data.Sigma.Basic.0.Sigma.curry_update._proof_1_4 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_3} {β : α → Type u_2} {γ : (a : α) → β a → Type u_1} [inst : DecidableEq α]
[inst_1 : (a : α) → DecidableEq (β a)] (f : (i : (a : α) × β a) → γ i.fst i.snd) (ia : α) (ib : β ia)
(x : γ ⟨ia, ib⟩.fst ⟨ia, ib⟩.snd) (jb : β ia),
Function.update f ⟨ia, ib⟩ x ⟨ia, jb⟩ = Function.update (fun y => f ⟨ia, y⟩... | null | false |
intervalIntegral.integral_deriv_smul_comp_of_deriv_nonpos | Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts | ∀ {a b : ℝ} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f f' : ℝ → ℝ} {g : ℝ → E},
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt f (f' x) x) →
(∀ x ∈ Set.Ioo (min a b) (max a b), f' x ≤ 0) → ∫ (x : ℝ) in a..b, f' x • (g ∘ f) x = ∫ (u : ℝ) in f a.... | Change of variables for antitone functions.
If `f` is continuous on `[a, b]` and has a nonpositive derivative `f'` in `(a, b)`,
then we can substitute `u = f x` to get `∫ x in a..b, f' x • (g ∘ f) x = ∫ u in f a..f b, g u`. | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.NNReal.tsum_indicator_ne_zero.match_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → NNReal} {s : Set α} (motive : (∃ a ∈ s, f a ≠ 0) → Prop) (h : ∃ a ∈ s, f a ≠ 0),
(∀ (a : α) (ha : a ∈ s) (hap : f a ≠ 0), motive ⋯) → motive h | null | false |
CochainComplex.ConnectData.d.eq_1 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.ofNat n) (Int.ofNat m) = L.d n m | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (self self_1 : D.IsTerminal e),
self = self_1 → ∀ {j : J} (hj : D.P j), self.lift hj = self_1.lift hj | null | true |
Std.Roc.mk.sizeOf_spec | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : SizeOf α] (lower upper : α), sizeOf (lower<...=upper) = 1 + sizeOf lower + sizeOf upper | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftLeftZeroExtend._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (n : ℕ), ¬w < w + (n + 1) → False | null | false |
FirstOrder.Language.LHom.ofIsEmpty_onRelation | Mathlib.ModelTheory.LanguageMap | ∀ (L : FirstOrder.Language) (L' : FirstOrder.Language) [inst : L.IsAlgebraic] [inst_1 : L.IsRelational] {n : ℕ}
(a : L.Relations n), (FirstOrder.Language.LHom.ofIsEmpty L L').onRelation a = isEmptyElim a | null | true |
ConvexBody.carrier | Mathlib.Analysis.Convex.Body | {V : Type u_2} → [inst : TopologicalSpace V] → [inst_1 : AddCommMonoid V] → [inst_2 : SMul ℝ V] → ConvexBody V → Set V | The **carrier set** underlying a convex body: the set of points contained in it | true |
Lean.IR.Param.mk | Lean.Compiler.IR.Basic | Lean.IR.VarId → Bool → Lean.IR.IRType → Lean.IR.Param | null | true |
BitVec.cpopLayer.congr_simp | Init.Data.BitVec.Bitblast | ∀ {len w iterNum : ℕ} (oldLayer oldLayer_1 : BitVec (len * w)),
oldLayer = oldLayer_1 →
∀ (newLayer newLayer_1 : BitVec (iterNum * w)),
newLayer = newLayer_1 →
∀ (hold : 2 * (iterNum - 1) < len), oldLayer.cpopLayer newLayer hold = oldLayer_1.cpopLayer newLayer_1 hold | null | true |
instSemiringCorner | Mathlib.RingTheory.Idempotents | {R : Type u_1} → (e : R) → [inst : NonUnitalSemiring R] → (idem : IsIdempotentElem e) → Semiring idem.Corner | null | true |
IntermediateField.inf_relrank_left | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A B : IntermediateField F E),
(A ⊓ B).relrank A = B.relrank A | null | true |
CategoryTheory.ShrinkHoms.hasLimitsOfShape | Mathlib.CategoryTheory.Abelian.Transfer | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{w, v_1, u_1} C]
(J : Type u_2) [inst_2 : CategoryTheory.Category.{v_2, u_2} J] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.ShrinkHoms.{u_1} C) | null | true |
MeasureTheory.AEDisjoint | Mathlib.MeasureTheory.Measure.AEDisjoint | {α : Type u_2} → {m : MeasurableSpace α} → MeasureTheory.Measure α → Set α → Set α → Prop | Two sets are said to be `μ`-a.e. disjoint if their intersection has measure zero. | true |
RingTheory.Sequence.IsRegular.recIterModByRegular.match_1 | Mathlib.RingTheory.Regular.RegularSequence | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(r : R) →
(rs' : List R) →
(motive : IsSMulRegular M r ∧ RingTheory.Sequence.IsRegular (QuotSMulTop r M) rs' → Sort u_3) →
(x : IsSMulRegula... | null | false |
CategoryTheory.Limits.limitBiconeOfUnique_bicone_π | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : Unique J] (f : J → C) (j : J),
(CategoryTheory.Limits.limitBiconeOfUnique f).bicone.π j = CategoryTheory.eqToHom ⋯ | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr.0.Lean.Meta.Grind.Arith.CommRing.denoteExprCore.go | Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr | {M : Type → Type} →
[Monad M] →
[Lean.MonadError M] →
[MonadLiftT Lean.MetaM M] →
[Lean.Meta.Sym.Arith.MonadCanon M] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing M] →
(ℕ → Lean.Expr) → Lean.Meta.Grind.Arith.CommRing.RingExpr → M Lean.Expr | null | true |
CategoryTheory.StrictlyUnitaryPseudofunctorCore._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
(obj : B → C) (map : {X Y : B} → (X ⟶ Y) → (obj X ⟶ obj Y)),
(∀ (X : B), map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (obj X)) →
∀ {a b : B} (f : a ⟶ b),
CategoryTheor... | null | false |
String.Pos.get?_toSlice | Init.Data.String.Lemmas.Slice | ∀ {s : String} {p : s.Pos}, p.toSlice.get? = p.get? | null | true |
LeftInvariantDerivation.instAdd | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{G : Type u_4} →
... | null | true |
instAddCommMonoidEReal | Mathlib.Data.EReal.Basic | AddCommMonoid EReal | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.