name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.range_finsuppTotal.match_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {ι : Type u_3} {M : Type u_1} [inst : AddCommGroup M] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Module R M]
(I : Ideal R) {v : ι → M} (x : M) (motive : x ∈ (Ideal.finsuppTotal ι M I v).range → Prop)
(x_1 : x ∈ (Ideal.finsuppTotal ι M I v).range),
(∀ (f : ι →₀ ↥I) (h : (Ideal.finsuppTotal ι M I v) f = x), motive ⋯) → motive x_1 | false |
MeasureTheory.Filtration.const | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
(ι : Type u_2) →
{m : MeasurableSpace Ω} → [inst : Preorder ι] → (m' : MeasurableSpace Ω) → m' ≤ m → MeasureTheory.Filtration ι m | true |
RingCat.Colimits.instRingColimitType._proof_18 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(a b : RingCat.Colimits.ColimitType F), a - b = a + -b | false |
Lean.RecursorRule.mk.inj | Lean.Declaration | ∀ {ctor : Lean.Name} {nfields : ℕ} {rhs : Lean.Expr} {ctor_1 : Lean.Name} {nfields_1 : ℕ} {rhs_1 : Lean.Expr},
{ ctor := ctor, nfields := nfields, rhs := rhs } = { ctor := ctor_1, nfields := nfields_1, rhs := rhs_1 } →
ctor = ctor_1 ∧ nfields = nfields_1 ∧ rhs = rhs_1 | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.mem_succ_iff._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT a (Std.PRange.succ b) = Std.PRange.UpwardEnumerable.LE a b | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.linearIndepOn_toRatVec | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)}, LinearIndepOn ℕ id s → LinearIndepOn ℚ (⇑toRatVec✝) s | true |
_private.Mathlib.Analysis.Complex.MeanValue.0.circleAverage_sub_sub_inv_smul_of_differentiable_on_off_countable._simp_1_16 | Mathlib.Analysis.Complex.MeanValue | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.grindTraceToGrind.match_1 | Lean.Elab.Tactic.Try | (motive : Option Lean.Syntax → Sort u_1) →
(only : Option Lean.Syntax) →
((only : Lean.Syntax) → motive (some only)) → ((x : Option Lean.Syntax) → motive x) → motive only | false |
CommGrpCat.Hom.noConfusionType | Mathlib.Algebra.Category.Grp.Basic | Sort u_1 → {A B : CommGrpCat} → A.Hom B → {A' B' : CommGrpCat} → A'.Hom B' → Sort u_1 | false |
Lean.Meta.Match.Example.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {t t' : Lean.Meta.Match.Example} → t = t' → Lean.Meta.Match.Example.noConfusionType P t t' | false |
PeriodPair.«term℘[_]» | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | Lean.ParserDescr | true |
CategoryTheory.MonoOver.instCoeOut | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X : C} → CoeOut (CategoryTheory.MonoOver X) C | true |
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 | 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 | false |
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 | true |
UpperSet._sizeOf_1 | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → {inst : LE α} → [SizeOf α] → UpperSet α → ℕ | 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 | 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) → motive x | false |
Lean.Meta.Tactic.TryThis.SuggestionText.ctorElimType | Lean.Meta.TryThis | {motive : Lean.Meta.Tactic.TryThis.SuggestionText → Sort u} → ℕ → Sort (max 1 u) | false |
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 → Action V G → Type (max 0 u_3) | 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 : α), a ≤ b ∨ b ≤ a) Std.Packages.LinearPreorderOfLEArgs.le_total._autoParam) →
autoParam
(let this := toPreorderOfLEArgs.le;
let this_1 := toPreorderOfLEArgs.decidableLE;
let this_2 := ord;
∀ (a b : α), (compare a b).isLE = true ↔ a ≤ b)
Std.Packages.LinearPreorderOfLEArgs.isLE_compare._autoParam →
autoParam
(let this := toPreorderOfLEArgs.le;
let this_1 := toPreorderOfLEArgs.decidableLE;
have this_2 := le_total;
let this_3 := ord;
∀ (a b : α), (compare a b).isGE = true ↔ b ≤ a)
Std.Packages.LinearPreorderOfLEArgs.isGE_compare._autoParam →
Std.Packages.LinearPreorderOfLEArgs α | true |
Int16.toUInt16_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec 16), (Int16.ofBitVec b).toUInt16 = { toBitVec := b } | 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.Abelian.coimage (α.app X) | 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 | 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) | 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} →
{G : Type u_8} →
[inst_5 : TopologicalSpace H] →
[inst_6 : TopologicalSpace G] →
{I : ModelWithCorners 𝕜 E₁ H} →
{J : ModelWithCorners 𝕜 E₃ G} →
{M : Type u_10} →
{N : Type u_12} →
[inst_7 : TopologicalSpace M] →
[inst_8 : ChartedSpace H M] →
[inst_9 : TopologicalSpace N] →
[inst_10 : ChartedSpace G N] →
{n : WithTop ℕ∞} →
{f : M → N} →
{motive : Manifold.IsSmoothEmbedding I J n f → Sort u} →
(t : Manifold.IsSmoothEmbedding I J n f) →
((isImmersion : Manifold.IsImmersion I J n f) →
(isEmbedding : Topology.IsEmbedding f) → motive ⋯) →
motive t | false |
Lean.Parser.Tactic.Conv.«conv_<;>_» | Init.Conv | Lean.TrailingParserDescr | 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 | 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 | true |
Std.ExtDHashMap.erase | Std.Data.ExtDHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} → {x_1 : Hashable α} → [EquivBEq α] → [LawfulHashable α] → Std.ExtDHashMap α β → α → Std.ExtDHashMap α β | 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 } | 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✝ | 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 | 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 | true |
Additive.addLeftCancelSemigroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [LeftCancelSemigroup α] → AddLeftCancelSemigroup (Additive α) | true |
RingEquiv.mapMatrix_symm | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {α : Type u_11} {β : Type u_12} [inst : Fintype m] [inst_1 : DecidableEq m]
[inst_2 : NonAssocSemiring α] [inst_3 : NonAssocSemiring β] (f : α ≃+* β), f.mapMatrix.symm = f.symm.mapMatrix | 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) | 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 =
(D.W ⊔ CategoryTheory.MorphismProperty.ofHoms fun x => CategoryTheory.CategoryStruct.id m₁) ⊔
CategoryTheory.MorphismProperty.ofHoms φ | 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 | false |
Std.instDecidableEqRoo.decEq | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → (x x_1 : Std.Roo α) → Decidable (x = x_1) | true |
WithBot.preimage_coe_Ioc | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, WithBot.some ⁻¹' Set.Ioc ↑a ↑b = Set.Ioc a b | true |
Char.eq_true_of_all_eq_true | Batteries.Data.Char.Basic | ∀ {p : Char → Bool}, Char.all p = true → ∀ (c : Char), p c = true | 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) | 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 | true |
MvPolynomial.vars_one | Mathlib.Algebra.MvPolynomial.Variables | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.vars 1 = ∅ | 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 | true |
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) | true |
nnnorm_le_mul_nnnorm_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (a b : E), ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ | true |
Lean.Parser.Term.throwNamedErrorAtMacro | Lean.Parser.Term | Lean.Parser.Parser | true |
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 | 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⟩) | true |
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 μ) →
AEMeasurable g μ → ∫ (y : Y) in s, f y ∂MeasureTheory.Measure.map g μ = ∫ (x : X) in g ⁻¹' s, f (g x) ∂μ | true |
Std.Time.Year.instLawfulEqOrdOffset | Std.Time.Date.Unit.Year | Std.LawfulEqOrd Std.Time.Year.Offset | true |
Vector.instIntModule._proof_4 | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Lean.Grind.IntModule α] (x : Vector α n), 0 • x = 0 | false |
_private.Mathlib.LinearAlgebra.ConvexSpace.0.convexComboPair_same._simp_1_3 | Mathlib.LinearAlgebra.ConvexSpace | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] (a : ι) (b₁ b₂ : M),
((fun₀ | a => b₁) + fun₀ | a => b₂) = fun₀ | a => b₁ + b₂ | false |
CanonicallyOrderedAdd.toLinearOrderedCommGroupWithZero._proof_2 | Mathlib.Algebra.Order.Field.Canonical | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : LinearOrder α] [CanonicallyOrderedAdd α] (a : α), 0 ≤ a | 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 | 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) | 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.IsTorsionFree A L₂ →
∀ (y : ↥(Algebra.algebraMapSubmonoid B (nonZeroDivisors A))), IsUnit (((algebraMap B₂ L₂).comp ↑σ) ↑y) | 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],
CategoryTheory.IsPushout (CommRingCat.ofHom (algebraMap R S)) (CommRingCat.ofHom (algebraMap R A))
(CommRingCat.ofHom (algebraMap S B)) (CommRingCat.ofHom (algebraMap A B)) | 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.comul
CoalgebraStruct.comul | 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 | 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 M]
(a b : DirectSum ιA fun i => A i) (c : DirectSum ιB fun i => M i), (a * b) • c = a • b • c | 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) →
(a : σ → Option (Γ k) → σ) → (a_1 : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.peek k a a_1)) →
((k : K) →
(a : σ → Option (Γ k) → σ) → (a_1 : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.pop k a a_1)) →
((a : σ → σ) → (a_1 : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.load a a_1)) →
((a : σ → Bool) → (a_1 a_2 : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.branch a a_1 a_2)) →
(Nat.hasNotBit 31 t.ctorIdx → motive t) → motive t | 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 : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n) →
(g' : I.cocomplex.X (n + 2) ⟶ J.cocomplex.X (n + 1)) →
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (I.cocomplex.d (n + 1) (n + 2)) g' +
CategoryTheory.CategoryStruct.comp g (J.cocomplex.d n (n + 1)) →
(I.cocomplex.X (n + 3) ⟶ J.cocomplex.X (n + 2)) | 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) | false |
Lean.Elab.Tactic.Omega.State.atoms._default | Lean.Elab.Tactic.Omega.OmegaM | Std.HashMap Lean.Expr ℕ | 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 | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_94 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
sSup_mem_of_not_isSuccPrelimit | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : CompleteLinearOrder α] {s : Set α}, ¬Order.IsSuccPrelimit (sSup s) → sSup s ∈ s | 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Ω] | true |
lt_mul_iff_one_lt_right | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Zero α] {a b : α} [inst_2 : Preorder α] [PosMulStrictMono α]
[PosMulReflectLT α], 0 < a → (a < a * b ↔ 1 < b) | 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) | 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) | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.inner_products_summable._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a : E), (0 ≤ ‖a‖) = True | false |
Cubic.b | Mathlib.Algebra.CubicDiscriminant | {R : Type u_1} → Cubic R → R | 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) | false |
Int8.toISize_div_of_ne_left | Init.Data.SInt.Lemmas | ∀ (a b : Int8), a ≠ Int8.minValue → (a / b).toISize = a.toISize / b.toISize | 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.Trivialization F₁ Bundle.TotalSpace.proj) (e₂ : Bundle.Trivialization F₂ Bundle.TotalSpace.proj),
IsOpen (e₁.baseSet ∩ e₂.baseSet) | false |
NoBotOrder.exists_not_ge | Mathlib.Order.Max | ∀ {α : Type u_3} {inst : LE α} [self : NoBotOrder α] (a : α), ∃ b, ¬a ≤ b | true |
_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) | false |
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) ↔ Topology.IsInducing F) | true |
NonUnitalSubsemiring.coe_toAddSubmonoid | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (s : NonUnitalSubsemiring R), ↑s.toAddSubmonoid = ↑s | 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 | false |
NNRat.preimage_cast_Ici | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] (p : ℚ≥0),
NNRat.cast ⁻¹' Set.Ici ↑p = Set.Ici p | 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 | 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) | false |
uniqueDiffOn_Icc | Mathlib.Analysis.Calculus.TangentCone.Real | ∀ {a b : ℝ}, a < b → UniqueDiffOn ℝ (Set.Icc a b) | true |
_private.Lean.Compiler.InlineAttrs.0.Lean.Compiler.InlineAttributeKind.toAttrString | Lean.Compiler.InlineAttrs | Lean.Compiler.InlineAttributeKind → String | 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 | 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.range ⇑(CategoryTheory.ConcreteCategory.hom f.base) | 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 | true |
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 | true |
Mathlib.Tactic.BicategoryLike.instInhabitedAtom.default | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Atom | 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)) | 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) | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric_eq_none_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | false |
_private.Mathlib.Data.Set.Card.0.Set.three_lt_ncard_iff._simp_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Finset α},
(3 < s.card) = ∃ a b c d, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ d ∈ s ∧ a ≠ b ∧ a ≠ c ∧ a ≠ d ∧ b ≠ c ∧ b ≠ d ∧ c ≠ d | false |
Std.DTreeMap.Internal.Impl.Const.minEntry | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) → t.isEmpty = false → α × β | true |
Batteries.Tactic.Lint.Linter.isFast | Batteries.Tactic.Lint.Basic | Batteries.Tactic.Lint.Linter → Bool | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.