name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UInt8.ofNatLT_mul | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (ha : a < 2 ^ 8) (hb : b < 2 ^ 8) (hab : a * b < 2 ^ 8),
UInt8.ofNatLT (a * b) hab = UInt8.ofNatLT a ha * UInt8.ofNatLT b hb | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.rpow_sqrt._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] (a : A), IsUnit a → 0 ≤ a → IsStrictlyPositive a | null | false |
Set.cardinalMk_uIcc | Mathlib.Order.Interval.Set.Card | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : LocallyFiniteOrder α] (a b : α),
Cardinal.mk ↑(Set.uIcc a b) = ↑(Finset.uIcc a b).card | null | true |
CategoryTheory.Under.createsColimitsOfShapeForgetOfIsConnected | Mathlib.CategoryTheory.Limits.Constructions.Over.Connected | {J : Type u'} →
[inst : CategoryTheory.Category.{v', u'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.IsConnected J] →
{B : C} → CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.Under.forget B) | The forgetful functor from the under category creates any connected limit. | true |
ContinuousMap.Homotopy.refl_apply | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : ↑unitInterval × X), (ContinuousMap.Homotopy.refl f) x = f x.2 | null | true |
UpperSet._sizeOf_1 | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → {inst : LE α} → [SizeOf α] → UpperSet α → ℕ | null | false |
StarSubalgebra.instIsSemitopologicalSemiringSubtypeMem | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[IsSemitopologicalSemiring A] (s : StarSubalgebra R A), IsSemitopologicalSemiring ↥s | null | true |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.Simprocs.add.match_1 | Lean.Meta.Tactic.Simp.Simproc | (motive : Option (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc) → Sort u_1) →
(x : Option (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc)) →
((proc : Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc) → motive (some proc)) →
((x : Option (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc)) → motive x) ... | null | false |
Lean.Meta.Tactic.TryThis.SuggestionText.ctorElimType | Lean.Meta.TryThis | {motive : Lean.Meta.Tactic.TryThis.SuggestionText → Sort u} → ℕ → Sort (max 1 u) | null | false |
PartOrdEmb.orderIsoOfIso._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {α β : PartOrdEmb} (e : α ≅ β) (x : CategoryTheory.ToType α),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp e.hom e.inv)) x =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id α)) x | null | false |
CartanMatrix.Realisation.matrix | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | {n : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
[inst_2 : CommRing R] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : AddCommGroup N] → [inst_6 : ... | The Cartan matrix. | true |
Action.HomSubtype | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
(G : Type u_2) →
[inst_1 : Monoid G] →
{FV : V → V → Type u_3} →
{CV : V → Type u_4} →
[inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] →
[CategoryTheory.ConcreteCategory V FV] → Action V G → Ac... | The type of `V`-morphisms that can be lifted back to morphisms in the category `Action`. | true |
Std.Packages.LinearPreorderOfLEArgs.mk | Init.Data.Order.PackageFactories | {α : Type u} →
(toPreorderOfLEArgs : Std.Packages.PreorderOfLEArgs α) →
(ord :
autoParam
(let this := toPreorderOfLEArgs.le;
let this := toPreorderOfLEArgs.decidableLE;
Ord α)
Std.Packages.LinearPreorderOfLEArgs.ord._autoParam) →
(le_total : autoParam (∀ (a b ... | null | true |
Int16.toUInt16_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec 16), (Int16.ofBitVec b).toUInt16 = { toBitVec := b } | null | true |
CategoryTheory.Abelian.FunctorCategory.coimageObjIso | Mathlib.CategoryTheory.Abelian.FunctorCategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type w} →
[inst_1 : CategoryTheory.Category.{z, w} D] →
[inst_2 : CategoryTheory.Abelian D] →
{F G : CategoryTheory.Functor C D} →
(α : F ⟶ G) → (X : C) → (CategoryTheory.Abelian.coimage α).obj X ≅ CategoryTheory.A... | The abelian coimage in a functor category can be calculated componentwise. | true |
RBTree.RBNode.modify_eq_alter | Batteries.Recycling.RBTree.Alter | ∀ {α : Type u_1} {cut : α → Ordering} {f : α → α} (t : RBTree.RBNode α),
RBTree.RBNode.modify cut f t = RBTree.RBNode.alter cut (Option.map f) t | null | true |
_private.Mathlib.Tactic.NormNum.NatFib.0.Mathlib.Meta.NormNum.proveNatFibAux.match_3 | Mathlib.Tactic.NormNum.NatFib | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n' : ℕ) → motive n') → motive x | null | false |
Mathlib.Meta.Multiset.ProveZeroOrConsResult.ctorElimType | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Multiset «$α»)} → {motive : Mathlib.Meta.Multiset.ProveZeroOrConsResult s → Sort u} → ℕ → Sort (max 1 u) | null | false |
Manifold.IsSmoothEmbedding.casesOn | Mathlib.Geometry.Manifold.SmoothEmbedding | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E₁ : Type u_2} →
{E₃ : Type u_4} →
[inst_1 : NormedAddCommGroup E₁] →
[inst_2 : NormedSpace 𝕜 E₁] →
[inst_3 : NormedAddCommGroup E₃] →
[inst_4 : NormedSpace 𝕜 E₃] →
{H : Type u_6} →
... | null | false |
Lean.Parser.Tactic.Conv.«conv_<;>_» | Init.Conv | Lean.TrailingParserDescr | `tac <;> tac'` runs `tac` on the main goal and `tac'` on each produced goal, concatenating all goals
produced by `tac'`.
| true |
Finpartition.bind | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
[IsModularLattice α] →
[DecidableEq α] → {a : α} → (P : Finpartition a) → ((i : α) → i ∈ P.parts → Finpartition i) → Finpartition a | Given a finpartition `P` of `a` and finpartitions of each part of `P`, this yields the
finpartition of `a` obtained by juxtaposing all the subpartitions. | true |
MeasurableDiv.measurable_div_const | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G₀ : Type u_2} {inst : MeasurableSpace G₀} {inst_1 : Div G₀} [self : MeasurableDiv G₀] (c : G₀),
Measurable fun x => x / c | null | true |
Std.ExtDHashMap.erase | Std.Data.ExtDHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} → {x_1 : Hashable α} → [EquivBEq α] → [LawfulHashable α] → Std.ExtDHashMap α β → α → Std.ExtDHashMap α β | Removes the mapping for the given key if it exists. | true |
IsLprojection.Subtype.one | Mathlib.Analysis.Normed.Module.MStructure | {X : Type u_1} →
[inst : NormedAddCommGroup X] →
{M : Type u_2} → [inst_1 : Ring M] → [inst_2 : Module M X] → One { P // IsLprojection X P } | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.LiveVars✝ → Lean.Compiler.LCNF.State✝ | null | false |
Sym2.attachWith_map_subtypeVal | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {s : Sym2 α} {P : α → Prop} (h : ∀ a ∈ s, P a), Sym2.map Subtype.val (s.attachWith h) = s | null | true |
IsDedekindDomain.HeightOneSpectrum.comap | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} →
[inst : CommRing R] →
{S : Type u_4} →
[inst_1 : CommRing S] →
(f : R →+* S) →
Function.Surjective ⇑f → IsDedekindDomain.HeightOneSpectrum S → IsDedekindDomain.HeightOneSpectrum R | A surjective ring homomorphism `f : R →+* S` induces a map from `HeightOneSpectrum S` to
`HeightOneSpectrum R` sending `v` to `v.asIdeal.comap f`. | true |
Additive.addLeftCancelSemigroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [LeftCancelSemigroup α] → AddLeftCancelSemigroup (Additive α) | null | true |
Mathlib.Tactic.Ring.Common.evalPowProd | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a : Q(«$α»)} →
{b : Q(ℕ... | There are several special cases when exponentiating monomials:
* `1 ^ n = 1`
* `x ^ y = (x ^ y)` when `x` is a constant (Note this may fail if e.g. `y` is not a constant)
* `(a * b) ^ e = a ^ e * b ^ e`
In all other cases we use `evalPowProdAtom`.
| true |
RingEquiv.mapMatrix_symm | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {α : Type u_8} {β : Type u_9} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NonAssocSemiring α]
[inst_3 : NonAssocSemiring β] (f : α ≃+* β), f.mapMatrix.symm = f.symm.mapMatrix | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_tendsto_of_tendsto_of_monotone._simp_1_4 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}, (a - b ≤ c) = (a ≤ c + b) | null | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₄_W | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
(D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ) {m₁ : J}
(φ : (x : Subtype D.P) → ↑x ⟶ m₁),
(CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₄ D φ).W =
... | null | true |
_private.Mathlib.Algebra.Order.BigOperators.Group.List.0.List.one_lt_prod_of_one_lt._proof_1_5 | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : Preorder M] (a b : M) (l : List M),
(1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a) → ∀ x ∈ b :: l, 1 < x | null | false |
Std.instDecidableEqRoo.decEq | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → (x x_1 : Std.Roo α) → Decidable (x = x_1) | null | true |
WithBot.preimage_coe_Ioc | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, WithBot.some ⁻¹' Set.Ioc ↑b ↑a = Set.Ioc b a | null | true |
Char.eq_true_of_all_eq_true | Batteries.Data.Char.Basic | ∀ {p : Char → Bool}, Char.all p = true → ∀ (c : Char), p c = true | null | true |
OrderIso.prodAssoc_apply | Mathlib.Order.Hom.Basic | ∀ (α : Type u_6) (β : Type u_7) (γ : Type u_8) [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (p : (α × β) × γ),
(OrderIso.prodAssoc α β γ) p = (p.1.1, p.1.2, p.2) | null | true |
continuousAt_toIcoDiv | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜]
[inst_3 : Archimedean 𝕜] [inst_4 : TopologicalSpace 𝕜] [OrderTopology 𝕜] {p : 𝕜} (hp : 0 < p) (a : 𝕜) {x : 𝕜},
¬x ≡ a [PMOD p] → ContinuousAt (toIcoDiv hp a) x | If `x` is not congruent to `a` modulo `p`, then `toIcoDiv` is continuous at `x`.
In fact, it is locally near `x`, see `eventuallyEq_toIcoDiv_nhds`. | true |
MvPolynomial.vars_one | Mathlib.Algebra.MvPolynomial.Variables | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.vars 1 = ∅ | null | true |
_private.Std.Sync.Broadcast.0.Std.Broadcast.Receiver.mk.sizeOf_spec | Std.Sync.Broadcast | ∀ {α : Type} [inst : SizeOf α] (inner : Std.Bounded.Receiver✝ α), sizeOf { inner := inner } = 1 + sizeOf inner | null | true |
CategoryTheory.Adjunction.rightExtensionPostCompose₂LeftAdjoint._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.AdjunctionPreserves | ∀ {C : Type u_5} {D : Type u_3} {H₁ : Type u_4} {H₂ : Type u_7} [inst : CategoryTheory.Category.{u_8, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] [inst_2 : CategoryTheory.Category.{u_2, u_4} H₁]
[inst_3 : CategoryTheory.Category.{u_6, u_7} H₂] {G₁ : CategoryTheory.Functor H₁ H₂} (L : CategoryTheory.Func... | null | false |
isStronglyTranscendental_mk_of_mem_minimalPrimes | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsReduced S] {x : S},
IsStronglyTranscendental R x → ∀ q ∈ minimalPrimes S, IsStronglyTranscendental R ((Ideal.Quotient.mk q) x) | [Stacks Tag 00Q0](https://stacks.math.columbia.edu/tag/00Q0) | true |
nnnorm_le_mul_nnnorm_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedGroup E] (a b : E), ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ | null | true |
Lean.Parser.Term.throwNamedErrorAtMacro | Lean.Parser.Term | Lean.Parser.Parser | Throws an error exception, tagging the associated message as a named error with the specified name
and validating that an associated error explanation exists. The error name must be followed by a
`Syntax` at which the error is to be thrown. The message is the final argument and may be passed as
an interpolated string o... | true |
RBTree.RBNode.toStream.match_1 | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(motive : RBTree.RBNode α → RBTree.RBNode.Stream α → Sort u_2) →
(x : RBTree.RBNode α) →
(x_1 : RBTree.RBNode.Stream α) →
((acc : RBTree.RBNode.Stream α) → motive RBTree.RBNode.nil acc) →
((c : RBTree.RBColor) →
(l : RBTree.RBNode α) →
(v : α)... | null | false |
StarRingEquiv.coe_mk | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} {B : Type u_2} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A] [inst_3 : Mul B] [inst_4 : Star A]
[inst_5 : Star B] (e : A ≃+* B) (h₁ : ∀ (a : A), e.toFun (star a) = star (e.toFun a)),
⇑{ toRingEquiv := e, map_star' := h₁ } = ⇑e | null | true |
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem.eq_1 | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : ↥X) (hxU : x ∈ U),
U.fromSpecStalkOfMem x hxU =
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Spec.map (CategoryTheory.inv (AlgebraicGeometry.Scheme.Hom.stalkMap U.ι ⟨x, hxU⟩)))
((↑U).fromSpecStalk ⟨x, hxU⟩) | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.processGCongrHypothesisAux.match_1 | Mathlib.Tactic.GRewrite.Core | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr)) →
((result proof : Lean.Expr) → motive (some (result, proof))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __do_lift | null | false |
MeasureTheory.setIntegral_map | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure X} {Y : Type u_5} [inst_2 : MeasurableSpace Y] {g : X → Y} {f : Y → E} {s : Set Y},
MeasurableSet s →
MeasureTheory.AEStronglyMeasurable f (MeasureTheory.Measure.map g μ) ... | null | true |
Std.Time.Year.instLawfulEqOrdOffset | Std.Time.Date.Unit.Year | Std.LawfulEqOrd Std.Time.Year.Offset | null | true |
CategoryTheory.essImage_yonedaAddGrp | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.yonedaAddGrp.essImage = fun F => (F.comp (CategoryTheory.forget AddGrpCat)).IsRepresentable | null | true |
Vector.instIntModule._proof_4 | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Lean.Grind.IntModule α] (x : Vector α n), 0 • x = 0 | null | false |
gciMapBicompl | Mathlib.Order.GaloisConnection.Basic | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{δ : Type u_4} →
{f : α → γ} →
{g : β → δ} →
Function.Injective f →
Function.Injective g → GaloisCoinsertion (fun x => Relation.Map x f g) fun x => Function.bicompl x f g | For injective functions `f` and `g`, `Relation.Map · f g` and `·.bicompl f g` form a Galois
coinsertion. | true |
Module.Dual.norm_extendRCLike_le_seminorm | Mathlib.Analysis.Normed.Module.RCLike.Extend | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Module ℝ E]
[inst_4 : IsScalarTower ℝ 𝕜 E] (fr : Module.Dual ℝ E) {p : Seminorm 𝕜 E},
(∀ (x : E), |fr x| ≤ p x) → ∀ (x : E), ‖fr.extendRCLike x‖ ≤ p x | If a real-linear functional is bounded by a `𝕜`-seminorm, then its `𝕜`-linear extension
is bounded by the same seminorm. | true |
CanonicallyOrderedAdd.toLinearOrderedCommGroupWithZero._proof_2 | Mathlib.Algebra.Order.Field.Canonical | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : LinearOrder α] [CanonicallyOrderedAdd α] (x : α), 0 ≤ x | null | false |
WeaklyLocallyCompactSpace.casesOn | Mathlib.Topology.Defs.Filter | {X : Type u_3} →
[inst : TopologicalSpace X] →
{motive : WeaklyLocallyCompactSpace X → Sort u} →
(t : WeaklyLocallyCompactSpace X) →
((exists_compact_mem_nhds : ∀ (x : X), ∃ s, IsCompact s ∧ s ∈ nhds x) → motive ⋯) → motive t | null | false |
galLift._proof_3 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_2} (L₂ : Type u_3) {B : Type u_1} {B₂ : Type u_4} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : CommRing B₂] [inst_3 : Algebra A B] [inst_4 : Algebra A B₂] [inst_5 : Field L₂] [inst_6 : Algebra A L₂]
[inst_7 : Algebra B₂ L₂] [IsScalarTower A B₂ L₂] (σ : B →ₐ[A] B₂),
IsDomain A →
Module.IsT... | null | false |
_private.Init.Data.Rat.Lemmas.0.Rat.neg_neg._simp_1_1 | Init.Data.Rat.Lemmas | ∀ (a b : ℚ), (a ≤ b) = (a.num * ↑b.den ≤ b.num * ↑a.den) | null | false |
CommRingCat.isPushout_of_isPushout | Mathlib.Algebra.Category.Ring.Constructions | ∀ (R S A B : Type u) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A] [inst_3 : CommRing B]
[inst_4 : Algebra R S] [inst_5 : Algebra S B] [inst_6 : Algebra R A] [inst_7 : Algebra A B] [inst_8 : Algebra R B]
[inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B] [Algebra.IsPushout R S A B],
... | null | true |
MonoidAlgebra.instBialgebra._proof_4 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ (R : Type u_3) (A : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
[inst_3 : Monoid M],
(LinearMap.mul R (MonoidAlgebra A M)).compr₂ CoalgebraStruct.comul =
(LinearMap.mul R (TensorProduct R (MonoidAlgebra A M) (MonoidAlgebra A M))).compl₁₂ CoalgebraStruct.comu... | null | false |
AlgebraicGeometry.Scheme.Hom.singleton_mem_qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Surjective f] [AlgebraicGeometry.QuasiCompact f],
CategoryTheory.Presieve.singleton f ∈ AlgebraicGeometry.Scheme.qcPrecoverage.coverings Y | null | true |
_private.Mathlib.Algebra.Module.GradedModule.0.DirectSum.Gmodule.mul_smul' | Mathlib.Algebra.Module.GradedModule | ∀ {ιA : Type u_1} {ιB : Type u_2} (A : ιA → Type u_3) (M : ιB → Type u_4) [inst : AddMonoid ιA] [inst_1 : VAdd ιA ιB]
[inst_2 : (i : ιA) → AddCommMonoid (A i)] [inst_3 : (i : ιB) → AddCommMonoid (M i)] [inst_4 : DecidableEq ιA]
[inst_5 : DecidableEq ιB] [inst_6 : DirectSum.GSemiring A] [inst_7 : DirectSum.Gmodule A... | null | true |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Turing.TM2to1.trStmts₁.match_1.splitter._sparseCasesOn_6 | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(t : Turing.TM2.Stmt Γ Λ σ) →
((k : K) → (a : σ → Γ k) → (a_1 : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.push k a a_1)) →
((k : K) →
... | null | false |
CategoryTheory.InjectiveResolution.descHomotopyZeroSucc | Mathlib.CategoryTheory.Abelian.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{Y Z : C} →
{I : CategoryTheory.InjectiveResolution Y} →
{J : CategoryTheory.InjectiveResolution Z} →
(f : I.cocomplex ⟶ J.cocomplex) →
(n : ℕ) →
(g : ... | An auxiliary definition for `descHomotopyZero`. | true |
_private.Init.Data.SInt.Bitwise.0.Int8.xor_not._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Elab.Tactic.Omega.State.atoms._default | Lean.Elab.Tactic.Omega.OmegaM | Std.HashMap Lean.Expr ℕ | null | false |
AlgebraicGeometry.PresheafedSpace.Γ | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.Functor (AlgebraicGeometry.PresheafedSpace C)ᵒᵖ C | The global sections, notated Gamma.
| true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_94 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
sSup_mem_of_not_isSuccPrelimit | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : CompleteLinearOrder α] {s : Set α}, ¬Order.IsSuccPrelimit (sSup s) → sSup s ∈ s | null | true |
MeasureTheory.condLExp_add_right | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {Ω : Type u_1} {mΩ₀ mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} (X : Ω → ENNReal) {Y : Ω → ENNReal},
AEMeasurable Y P → P⁻[X + Y | mΩ] =ᵐ[P] P⁻[X | mΩ] + P⁻[Y | mΩ] | null | true |
lt_mul_iff_one_lt_right | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Zero α] {a b : α} [inst_2 : Preorder α] [PosMulStrictMono α]
[PosMulReflectLT α], 0 < a → (a < a * b ↔ 1 < b) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.SimplicialObject.instCategoryAugmented | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.Category.{v, max u v} (CategoryTheory.SimplicialObject.Augmented C) | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.inner_products_summable._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (a : E), (0 ≤ ‖a‖) = True | null | false |
Cubic.b | Mathlib.Algebra.CubicDiscriminant | {R : Type u_1} → Cubic R → R | The degree-2 coefficient | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts.0.CategoryTheory.Functor.biprodComparison'_comp_biprodComparison._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Int8.toISize_div_of_ne_left | Init.Data.SInt.Lemmas | ∀ (a b : Int8), a ≠ Int8.minValue → (a / b).toISize = a.toISize / b.toISize | null | true |
Bundle.Pretrivialization.continuousLinearMap._proof_6 | Mathlib.Topology.VectorBundle.Hom | ∀ {B : Type u_1} {F₁ : Type u_2} [inst : NormedAddCommGroup F₁] {E₁ : B → Type u_3}
[inst_1 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_2 : NormedAddCommGroup F₂]
{E₂ : B → Type u_5} [inst_3 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] [inst_4 : TopologicalSpace B]
(e₁ : Bundle.Trivializa... | null | false |
_private.Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit.0.Profinite.NobelingProof.Products.limitOrdinal._simp_1_3 | Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, (a ∈ l.toFinset) = (a ∈ l) | null | false |
NoBotOrder.exists_not_ge | Mathlib.Order.Max | ∀ {α : Type u_3} {inst : LE α} [self : NoBotOrder α] (a : α), ∃ b, ¬a ≤ b | For each term `a`, there is some `b` which is either incomparable or strictly smaller. | true |
EquicontinuousOn.isInducing_uniformOnFun_iff_pi | Mathlib.Topology.UniformSpace.Ascoli | ∀ {ι : Type u_1} {X : Type u_2} {α : Type u_3} [inst : TopologicalSpace X] [inst_1 : UniformSpace α] {F : ι → X → α}
[inst_2 : TopologicalSpace ι] {𝔖 : Set (Set X)},
⋃₀ 𝔖 = Set.univ →
(∀ K ∈ 𝔖, IsCompact K) →
(∀ K ∈ 𝔖, EquicontinuousOn F K) → (Topology.IsInducing (⇑(UniformOnFun.ofFun 𝔖) ∘ F) ↔ Topol... | Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the topologies
of uniform convergence on `𝔖` and pointwise convergence induce the same topology on `ι`.
This is a specialization of `Equicontin... | true |
MeasureTheory.VectorMeasure.Integrable.finsetSum | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.VectorMeasure X F} {ι : Type u_7} (s : Finset ι) {f : ι → X → E},
(∀ i ∈ s, μ.Integrable (f i)) → μ.Integrable (∑ i ∈ s, f i) | null | true |
NonUnitalSubsemiring.coe_toAddSubmonoid | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (s : NonUnitalSubsemiring R), ↑s.toAddSubmonoid = ↑s | null | true |
Quiver.Path.decidableEqBddPathsOfDecidableEq._proof_8 | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (n : ℕ) (a x a_1 : V) (p' : Quiver.Path a a_1) (α : a_1 ⟶ x),
(p'.cons α).length ≤ n + 1 → p'.length ≤ n | null | false |
NNRat.preimage_cast_Ici | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_2} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] (p : ℚ≥0),
NNRat.cast ⁻¹' Set.Ici ↑p = Set.Ici p | null | true |
IsLocalization.primeSpectrumOrderIso._proof_3 | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (p : { p // Disjoint ↑M ↑p.asIdeal }),
(↑p).asIdeal.IsPrime ∧ Disjoint ↑M ↑(↑p).asIdeal | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey?_alter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
uniqueDiffOn_Icc | Mathlib.Analysis.Calculus.TangentCone.Real | ∀ {a b : ℝ}, a < b → UniqueDiffOn ℝ (Set.Icc a b) | null | true |
_private.Lean.Compiler.InlineAttrs.0.Lean.Compiler.InlineAttributeKind.toAttrString | Lean.Compiler.InlineAttrs | Lean.Compiler.InlineAttributeKind → String | null | true |
Std.DTreeMap.toArray_filterMap | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {γ : α → Type w}
{f : (a : α) → β a → Option (γ a)},
(Std.DTreeMap.filterMap f t).toArray =
Array.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toArray | null | true |
MeasureTheory.Measure.InnerRegular.instSum_1 | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] {ι : Type u_3}
{μ : ι → MeasureTheory.Measure α} [∀ (i : ι), (μ i).InnerRegular], (MeasureTheory.Measure.sum μ).InnerRegular | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isoOfRangeEq._proof_4 | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z),
Set.range ⇑(CategoryTheory.ConcreteCategory.hom f.base) = Set.range ⇑(CategoryTheory.ConcreteCategory.hom g.base) →
Set.range ⇑(CategoryTheory.ConcreteCategory.hom g.base) ⊆ Set.... | null | false |
Lean.Compiler.LCNF.Code.cases | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Cases pu → Lean.Compiler.LCNF.Code pu | null | true |
Mathlib.Tactic.BicategoryLike.MonadCoherenceHom.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MonadCoherenceHom m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MonadCoherenceHom m) →
((unfoldM : Mathlib.Tactic.BicategoryLike.CoherenceHom → m Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
motive { unfoldM := unfoldM }) →
motive ... | null | false |
Real.hasDerivAt_rpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {x p : ℝ}, x ≠ 0 ∨ 1 ≤ p → HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x | null | true |
Convexity.IsModuleConvexSpace.sConvexComb_eq_sum | Mathlib.Geometry.Convex.ConvexSpace.Module | ∀ {R : Type u_2} {M : Type u_3} {inst : Semiring R} {inst_1 : PartialOrder R} {inst_2 : IsStrictOrderedRing R}
{inst_3 : AddCommMonoid M} {inst_4 : Module R M} {inst_5 : Convexity.ConvexSpace R M}
[self : Convexity.IsModuleConvexSpace R M] (w : Convexity.StdSimplex R M),
Convexity.sConvexComb w = w.weights.sum fu... | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.startsWith_char_eq_head?._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
Mathlib.Tactic.BicategoryLike.instInhabitedAtom.default | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Atom | null | true |
continuousOn_open_iff | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s → (ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → IsOpen (s ∩ f ⁻¹' t)) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_erase_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.