name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousMultilinearMap.toMultilinearMap_add | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂... | null | true |
instCommRingBDeRhamPlus._proof_18 | Mathlib.RingTheory.Perfectoid.BDeRham | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) R] (a : BDeRhamPlus R p), 1 * a = a | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.noConfusion | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {P : Sort u_1} →
{C₀ : Type u₀} →
{C : Type u} →
{inst : CategoryTheory.Category.{v₀, u₀} C₀} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C₀ C} →
{S : C} →
{t : F.PreOneHypercoverDenseData S} →
{C₀' : Type u₀} →
... | null | false |
UInt32.toUInt64._proof_1 | Init.Data.UInt.BasicAux | 2 ^ 32 < 2 ^ 64 | null | false |
Dynamics.coverEntropyInf_eq_iSup_netEntropyInfEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} [inst : UniformSpace X] (T : X → X) (F : Set X),
Dynamics.coverEntropyInf T F = ⨆ U ∈ uniformity X, Dynamics.netEntropyInfEntourage T F U | Bowen-Dinaburg's definition of topological entropy using nets is
`⨆ U ∈ 𝓤 X, netEntropyEntourage T F U`. This quantity is the same as the topological entropy using
covers, so there is no need to define a new notion of topological entropy. This version of the
theorem relates the `liminf` versions of topological entropy... | true |
instContinuousSqrtNNReal._proof_1 | Mathlib.Topology.ContinuousMap.ContinuousSqrt | ContinuousOn (⇑NNReal.sqrt ∘ fun x => x.2 - x.1) {x | x.1 ≤ x.2} | null | false |
aemeasurable_to_prop | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → Prop},
MeasureTheory.NullMeasurableSet (f ⁻¹' {True}) μ → AEMeasurable f μ | null | true |
Nonneg.coeAddMonoidHom | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} → [inst : AddMonoid α] → [inst_1 : Preorder α] → [inst_2 : AddLeftMono α] → Nonneg α →+ α | Coercion `Nonneg α → α` as an `AddMonoidHom`. | true |
RootPairing.coroot_mem_or_neg_mem_closure_of_root | Mathlib.LinearAlgebra.RootSystem.BaseExists | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [inst : AddCommGroup M]
[inst_1 : AddCommGroup N] [inst_2 : Field R] [CharZero R] [inst_4 : Module R M] [inst_5 : Module R N]
(P : RootPairing ι R M N) [P.IsRootSystem] [P.IsCrystallographic] [P.IsReduced] (s : Set ι),
LinearIndepOn R (⇑P.ro... | This is really just an auxiliary result en route to `RootPairing.Base.mk'`. | true |
MeasureTheory.VectorMeasure.etvDist_zero_left | Mathlib.MeasureTheory.VectorMeasure.TotalVariation | ∀ {𝓧 : Type u_1} {M : Type u_2} {m𝓧 : MeasurableSpace 𝓧} [inst : NormedAddCommGroup M]
(ν : MeasureTheory.VectorMeasure 𝓧 M), MeasureTheory.VectorMeasure.etvDist 0 ν = ν.variation Set.univ | null | true |
CategoryTheory.Arrow.arrow_mk_comp_eqToHom | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Y' : T} (f : X ⟶ Y) (h : Y = Y'),
CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom h)) = CategoryTheory.Arrow.mk f | null | true |
egauge_empty | Mathlib.Analysis.Convex.EGauge | ∀ (𝕜 : Type u_1) [inst : NNNorm 𝕜] {E : Type u_2} [inst_1 : SMul 𝕜 E] (x : E), egauge 𝕜 ∅ x = ⊤ | null | true |
_private.Mathlib.Logic.Relation.0.Relation.EqvGen.eqvGen_mono.match_1_7 | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r r' : α → α → Prop},
let funType_1 := fun x x_1 x_2 => Relation.EqvGen r' x x_1;
∀ (motive : (x x_1 : α) → (x_2 : Relation.EqvGen r x x_1) → Relation.EqvGen.below x_2 → Prop) (x x_1 : α)
(x_2 : Relation.EqvGen r x x_1) (below : Relation.EqvGen.below x_2),
(∀ (x : α), motive x x ⋯ ⋯) →
... | null | false |
_private.Mathlib.Topology.Connected.Clopen.0.IsClopen.isPreconnected_iff._proof_1_6 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u_1} {s : Set α} (a b : Set α), s ⊆ a ∪ b → s = s ∩ a ∪ s ∩ b | null | false |
instIsScalarTowerTensorProductKaehlerDifferential._proof_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower S (TensorProduct R S S) Ω[S⁄R] | null | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.isAtomic_of_complementedLattice._simp_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastExtractAndExtendBit._proof_1_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {w : ℕ} (start idx : ℕ), idx = 0 → ¬start + idx < w → ¬w ≤ start → False | null | false |
List.getElem_set | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α} (h : j < (l.set i a).length), (l.set i a)[j] = if i = j then a else l[j] | null | true |
_private.Lean.Meta.Sym.Canon.0.Lean.Meta.Sym.Canon.canon.canonCond._unsafe_rec | Lean.Meta.Sym.Canon | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Sym.Canon.CanonM✝ Lean.Expr | null | false |
Lean.Meta.RefinedDiscrTree.LazyEntry.stack | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Lean.Meta.RefinedDiscrTree.LazyEntry → List Lean.Meta.RefinedDiscrTree.StackEntry | The stack, used to emulate recursion. It contains the list of all expressions for which the
keys still need to be computed, in that order.
For example in `10.add (20.add 30)`, after computing the keys `⟨Nat.add, 2⟩` and `10`, the stack
will be a list of length 1 containing the expression `20.add 30`.
| true |
Aesop.elabGlobalRuleIdent? | Aesop.RuleTac.ElabRuleTerm | Lean.Term → Lean.Elab.TermElabM (Option Lean.Name) | null | true |
Lean.Doc.Parser.header | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → Lean.Parser.ParserFn | Parses a header. | true |
Int.neg_one_pow_ne_zero | Mathlib.Data.Int.Order.Units | ∀ {n : ℕ}, (-1) ^ n ≠ 0 | null | true |
List.nodup_append | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ ++ l₂).Nodup ↔ l₁.Nodup ∧ l₂.Nodup ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, a ≠ b | null | true |
leOfOrd | Init.Data.Ord.Basic | {α : Type u_1} → [Ord α] → LE α | Constructs an `LE` instance from an `Ord` instance that asserts that the result of `compare`
satisfies `Ordering.isLE`.
| true |
Lean.Expr.lt | Lean.Expr | Lean.Expr → Lean.Expr → Bool | A total order for expressions that takes the structure into account (e.g., variable names). | true |
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldDeclsFrom.match_1 | Lean.Meta.Transform | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.ConstantInfo) → motive (some info)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
DFinsupp.sigmaCurryLEquiv_symm_apply | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} [inst : Semiring R] [inst_1 : DecidableEq ι] {α : ι → Type u_7}
{M : (i : ι) → α i → Type u_8} [inst_2 : (i : ι) → (j : α i) → AddCommMonoid (M i j)]
[inst_3 : (i : ι) → (j : α i) → Module R (M i j)] (a : Π₀ (i : ι) (j : α i), M i j),
DFinsupp.sigmaCurryLEquiv.symm a = DFinsupp.sig... | null | true |
Lean.ScopedEnvExtension.mk._flat_ctor | Lean.ScopedEnvExtension | {α β σ : Type} →
Lean.ScopedEnvExtension.Descr α β σ →
Lean.PersistentEnvExtension (Lean.ScopedEnvExtension.Entry α) (Lean.ScopedEnvExtension.Entry β)
(Lean.ScopedEnvExtension.StateStack α β σ) →
Lean.ScopedEnvExtension α β σ | null | false |
WeierstrassCurve.b₂_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [CharP R 2], W.b₂ = W.a₁ ^ 2 | null | true |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.disjoint_nhdsSet_right._simp_1_1 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = Disjoint b a | null | false |
_private.Mathlib.Order.Monotone.Defs.0.AntitoneOn._proof_2 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
(∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a) = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → b ≤ a → f a ≤ f b | null | false |
Matrix.zero | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [Zero α] → Zero (Matrix m n α) | null | true |
_private.Init.Data.Vector.Extract.0.Vector.extract_sub_one._proof_1 | Init.Data.Vector.Extract | ∀ {n i j : ℕ}, j < n → ¬min j n - i - 1 = min (j - 1) n - i → False | null | false |
MeasurableEquiv.prodSumDistrib | Mathlib.MeasureTheory.MeasurableSpace.Embedding | (α : Type u_6) →
(β : Type u_7) →
(γ : Type u_8) →
[inst : MeasurableSpace α] →
[inst_1 : MeasurableSpace β] → [inst_2 : MeasurableSpace γ] → α × (β ⊕ γ) ≃ᵐ α × β ⊕ α × γ | Products distribute over sums (on the left) as measurable spaces. | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Moebius.0.ArithmeticFunction.moebius_ne_zero_iff_eq_or._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {n : ℕ},
ArithmeticFunction.moebius n = 0 ∨ ArithmeticFunction.moebius n = 1 ∨ ArithmeticFunction.moebius n = -1 →
(¬ArithmeticFunction.moebius n = 0 ↔ ArithmeticFunction.moebius n = 1 ∨ ArithmeticFunction.moebius n = -1) | null | false |
CategoryTheory.Comonad.beckCoalgebraEqualizer._proof_1 | Mathlib.CategoryTheory.Monad.Equalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Comonad C} (X : T.Coalgebra)
(s :
CategoryTheory.Limits.Fork (CategoryTheory.Comonad.CofreeEqualizer.topMap X)
(CategoryTheory.Comonad.CofreeEqualizer.bottomMap X)),
CategoryTheory.CategoryStruct.comp s.ι.f (T.map X.a) = Ca... | null | false |
TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] {s : Set R} {z : R},
z ∈ TwoSidedIdeal.span s ↔ z ∈ AddSubgroup.closure (Set.univ * s * Set.univ) | null | true |
Polynomial.quotientSpanCXSubCAlgEquiv._proof_3 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (x y : R), (Ideal.span {Polynomial.C x, Polynomial.X - Polynomial.C y}).IsTwoSided | null | false |
StructureGroupoid.maximalAtlas.eq_1 | Mathlib.Geometry.Manifold.ContMDiff.Atlas | ∀ {H : Type u} (M : Type u_2) [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(G : StructureGroupoid H),
StructureGroupoid.maximalAtlas M G = {e | ∀ e' ∈ atlas H M, e.symm.trans e' ∈ G ∧ e'.symm.trans e ∈ G} | null | true |
AddAction.selfEquivSigmaOrbits | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) →
(α : Type u_2) →
[inst : AddGroup G] →
[inst_1 : AddAction G α] → α ≃ (ω : AddAction.orbitRel.Quotient G α) × ↑(AddAction.orbit G (Quotient.out ω)) | Decomposition of a type `X` as a disjoint union of its orbits under an additive
group action. | true |
BoolRing.Iso.mk._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {α β : BoolRing} (e : ↑α ≃+* ↑β),
CategoryTheory.CategoryStruct.comp { hom' := ↑e.symm } { hom' := ↑e } = CategoryTheory.CategoryStruct.id β | null | false |
NNRat.coe_zpow._simp_1 | Mathlib.Algebra.Field.Rat | ∀ (p : ℚ≥0) (n : ℤ), ↑p ^ n = ↑(p ^ n) | null | false |
CategoryTheory.Lax.StrongTrans.app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.StrongTrans F G → (a : B) → F.obj a ⟶ G.obj a | null | true |
PNat.Coprime.gcd_mul_right_cancel_right | Mathlib.Data.PNat.Prime | ∀ (m : ℕ+) {n k : ℕ+}, k.Coprime m → m.gcd (n * k) = m.gcd n | null | true |
Lean.Server.FileWorker.SignatureHelp.SearchControl.ctorElimType | Lean.Server.FileWorker.SignatureHelp | {motive : Lean.Server.FileWorker.SignatureHelp.SearchControl → Sort u} → ℕ → Sort (max 1 u) | null | false |
Topology.RelCWComplex.Subcomplex._sizeOf_1 | Mathlib.Topology.CWComplex.Classical.Basic | {X : Type u_1} →
{t : TopologicalSpace X} →
{C D : Set X} →
{inst : Topology.RelCWComplex C D} →
[SizeOf X] → [(a : X) → SizeOf (C a)] → [(a : X) → SizeOf (D a)] → Topology.RelCWComplex.Subcomplex C → ℕ | null | false |
ENNReal.eq_of_forall_le_nnreal_iff | Mathlib.Basic.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), x ≤ ↑r ↔ y ≤ ↑r) → x = y | null | true |
Set.preimage_mul_const_Ici_of_neg | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (a : α) {c : α},
c < 0 → (fun x => x * c) ⁻¹' Set.Ici a = Set.Iic (a / c) | null | true |
TrivSqZeroExt.nonAssocSemiring._proof_8 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] (x : TrivSqZeroExt R M), 0 * x = 0 | null | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.State._sizeOf_inst | Lean.Meta.Tactic.Grind.ProveEq | SizeOf Lean.Meta.Grind.AbstractM.State✝ | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.rightActionOfMonoidalOppositeLeftAction | Mathlib.CategoryTheory.Monoidal.Action.Opposites | (C : Type u_1) →
(D : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.MonoidalCategory.MonoidalLeftAction Cᴹᵒᵖ D] →
CategoryTheory.MonoidalCategory.Monoi... | Define a right action of `C` on `D` from a left action of `Cᴹᵒᵖ` on `D` via
the formula `d ⊙ᵣ c := (mop c) ⊙ₗ d`. | true |
Plausible.retry._f | Plausible.Testable | {p : Prop} → Plausible.Gen (Plausible.TestResult p) → (x : ℕ) → Nat.below x → Plausible.Gen (Plausible.TestResult p) | null | false |
Mathlib.Tactic.runUse | Mathlib.Tactic.Use | Bool → Lean.Elab.Tactic.TacticM Unit → List Lean.Term → Lean.Elab.Tactic.TacticM Unit | Run the `useLoop` on the main goal then discharge remaining explicit `Prop` arguments. | true |
Algebra.IsPushout.cancelBaseChangeAux._proof_6 | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_2) (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_1)
[inst_3 : CommRing A] [inst_4 : Algebra R A], SMulCommClass A R (TensorProduct R A S) | null | false |
Mathlib.Tactic.BicategoryLike.MonadMor₂.mk | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.AtomIso → m Mathlib.Tactic.BicategoryLike.Atom) →
(Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂) →
(Mathlib.Tactic.BicategoryLike.AtomIs... | null | true |
StateT.run_seqRight | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {σ α β : Type u_1} [inst : Monad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ),
(x *> y).run s = do
let p ← x.run s
y.run p.2 | null | true |
UniqueFactorizationMonoid.radical | Mathlib.RingTheory.Radical.Basic | {M : Type u_1} → [inst : CommMonoidWithZero M] → [NormalizationMonoid M] → [UniqueFactorizationMonoid M] → M → M | The radical of an element `a` in a unique factorization monoid is the product of
the prime factors of `a`. | true |
Mathlib.Tactic.Order.AtomicFact.ne.inj | Mathlib.Tactic.Order.CollectFacts | ∀ {lhs rhs : ℕ} {proof : Lean.Expr} {lhs_1 rhs_1 : ℕ} {proof_1 : Lean.Expr},
Mathlib.Tactic.Order.AtomicFact.ne lhs rhs proof = Mathlib.Tactic.Order.AtomicFact.ne lhs_1 rhs_1 proof_1 →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ proof = proof_1 | null | true |
Filter.map_map₂_antidistrib_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α}
{g : Filter β} {n : γ → δ} {m' : β' → α → δ} {n' : β → β'},
(∀ (a : α) (b : β), n (m a b) = m' (n' b) a) → Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' g) f | Symmetric statement to `Filter.map₂_map_left_anticomm`. | true |
Fin.insertNth_monotone | Mathlib.Order.Fin.InsertNth | ∀ {n : ℕ} {α : Type u_1} [inst : Preorder α] {f : Fin (n + 1) → α},
Monotone f → ∀ (i : Fin n) (x : α), f i.castSucc ≤ x → x ≤ f i.succ → Monotone (i.castSucc.succ.insertNth x f) | null | true |
Filter.lift'_neBot_iff | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β},
Monotone h → ((f.lift' h).NeBot ↔ ∀ s ∈ f, (h s).Nonempty) | null | true |
Pi.instMul | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {M : ι → Type u_5} → [(i : ι) → Mul (M i)] → Mul ((i : ι) → M i) | null | true |
List.prefix_rfl | Init.Data.List.Sublist | ∀ {α : Type u_1} {l : List α}, l <+: l | null | true |
Aesop.Frontend.Priority.noConfusion | Aesop.Frontend.RuleExpr | {P : Sort u} → {t t' : Aesop.Frontend.Priority} → t = t' → Aesop.Frontend.Priority.noConfusionType P t t' | null | false |
WithIdealFilter.mem_nhds_iff | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] {F : IdealFilter A} {a : WithIdealFilter F} {s : Set (WithIdealFilter F)},
s ∈ nhds a ↔ ∃ I ∈ F, a +ᵥ WithIdealFilter.idealSet I ⊆ s | A set `s` is a neighbourhood of `a` iff it contains a left-additive coset of some ideal
`I ∈ F`. | true |
isBoundedBilinearMap_smul | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : CommSemiring 𝕜] [inst_1 : SeminormedRing A] [inst_2 : Algebra 𝕜 A]
{E : Type u_3} [inst_3 : SeminormedAddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Module A E] [IsBoundedSMul A E]
[IsScalarTower 𝕜 A E], IsBoundedBilinearMap 𝕜 fun p => p.1 • p.2 | Scalar multiplication (for a normed `𝕜`-algebra acting on a normed `𝕜`-module) as a bounded
bilinear map. | true |
CategoryTheory.Limits.HasFiniteColimits.mk | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
(∀ (J : Type) [𝒥 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J],
CategoryTheory.Limits.HasColimitsOfShape J C) →
CategoryTheory.Limits.HasFiniteColimits C | null | true |
AddSubgroup.mem_even | Mathlib.Algebra.Group.Subgroup.Even | ∀ {G : Type u_1} [inst : AddCommGroup G] {a : G}, a ∈ AddSubgroup.even G ↔ Even a | null | true |
Order.Ideal.PrimePair.disjoint | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), Disjoint ↑IF.I ↑IF.F | null | true |
_private.Mathlib.Data.List.Chain.0.List.isChain_map._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {β : Type u_2} {R : α → α → Prop} (f : β → α) (x : β),
List.IsChain R (List.map f [x]) ↔ List.IsChain (fun a b => R (f a) (f b)) [x] | null | false |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_32 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), ¬a.comp a_1 = a_2.cons a_3 | null | false |
instPreirreducibleSpaceOfSubsingleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [Subsingleton X], PreirreducibleSpace X | null | true |
Localization.recOnSubsingleton₂ | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{r : Localization S → Localization S → Sort u} →
[h : ∀ (a c : M) (b d : ↥S), Subsingleton (r (Localization.mk a b) (Localization.mk c d))] →
(x y : Localization S) → ((a c : M) → (b d : ↥S) → r (Localization.mk a b) (Localizatio... | Copy of `Quotient.recOnSubsingleton₂` for `Localization` | true |
CategoryTheory.Limits.piConst._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C] (X : C)
{X_1 Y Z : Type u_1ᵒᵖ} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.Limits.Pi.map' ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g).unop)
fun x => CategoryTheory.Ca... | null | false |
Lean.Elab.Do.MutVar.ctorIdx | Lean.Elab.Do.Basic | Lean.Elab.Do.MutVar → ℕ | null | false |
List.nodup_ofFn_ofInjective | Mathlib.Data.List.FinRange | ∀ {α : Type u} {n : ℕ} {f : Fin n → α}, Function.Injective f → (List.ofFn f).Nodup | null | true |
HNNExtension.NormalWord.cons.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(u : ℤˣ) (w : HNNExtension.NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u'),
HNNExtension.NormalWord.cons g u w h1... | null | true |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.pderiv_one_equivMvPolynomial._simp_1_3 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | null | false |
CategoryTheory.MonoidalOpposite.tensorIso_hom_app_unmop | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : Cᴹᵒᵖ × Cᴹᵒᵖ),
((CategoryTheory.MonoidalOpposite.tensorIso C).hom.app X).unmop =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X.2.unmop X.1.unmop) | null | true |
Std.Ric.size_eq_match_rcc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Ric α} [inst : Std.PRange.Least? α] [inst_1 : LE α] [DecidableLE α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.Rxc.HasSize α] [Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α] [Std.Rxc.LawfulHasSize α],
r.size =
match S... | null | true |
instToStringOption | Init.Data.ToString.Basic | {α : Type u} → [ToString α] → ToString (Option α) | null | true |
Set.fintypeTop._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1}, Function.Injective ⇑(Equiv.Set.univ α).symm | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_rat_of_even_num.match_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (q : ℚ) (motive : (∃ r, q.num = 2 • r) → Prop) (x : ∃ r, q.num = 2 • r),
(∀ (n : ℤ) (hn : q.num = 2 • n), motive ⋯) → motive x | null | false |
Matrix.exp_neg | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_5} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedCommRing 𝔸]
[NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] (A : Matrix m m 𝔸), NormedSpace.exp (-A) = (NormedSpace.exp A)⁻¹ | null | true |
le_max_of_le_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a ≤ b → a ≤ max b c | null | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion.0.MeasureTheory.contDiff_charFun'._simp_1_1 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion | ∀ {S : Type u_3} {M : outParam (Type u_4)} {inst : One M} {inst_1 : SetLike S M} [self : OneMemClass S M] (s : S),
(1 ∈ s) = True | null | false |
MvPowerSeries.IsRestricted.subring._proof_3 | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_2} [inst : NormedRing R] {σ : Type u_1} (c : σ → ℝ) {x : MvPowerSeries σ R},
x ∈ (MvPowerSeries.IsRestricted.addSubgroup c).carrier → -x ∈ (MvPowerSeries.IsRestricted.addSubgroup c).carrier | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_115 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw ln : ℕ) (lexpr : Std.Tactic.BVDecide.BVExpr lw) (lh : w = lw * ln) (idx : ℕ),
¬Std.Tactic.BVDecide.BVExpr.replicate ln lexpr lh = Std.Tactic.BVDecide.BVExpr.var idx | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β) (out : β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.yield it' out with... | null | true |
Lean.ConstructorVal.casesOn | Lean.Declaration | {motive : Lean.ConstructorVal → Sort u} →
(t : Lean.ConstructorVal) →
((toConstantVal : Lean.ConstantVal) →
(induct : Lean.Name) →
(cidx numParams numFields : ℕ) →
(isUnsafe : Bool) →
motive
{ toConstantVal := toConstantVal, induct := induct, cidx := cid... | null | false |
Mathlib.Tactic.withResetServerInfo.Result.rec | Mathlib.Tactic.Basic | {α : Type} →
{motive : Mathlib.Tactic.withResetServerInfo.Result α → Sort u} →
((result? : Option α) →
(msgs : Lean.MessageLog) →
(trees : Lean.PersistentArray Lean.Elab.InfoTree) →
motive { result? := result?, msgs := msgs, trees := trees }) →
(t : Mathlib.Tactic.withResetServ... | null | false |
CategoryTheory.MonoidalClosed.ihomUncurry | Mathlib.CategoryTheory.Monoidal.Closed.InternalCurrying | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(x y z : C) →
[inst_2 : CategoryTheory.Closed x] →
[inst_3 : CategoryTheory.Closed y] →
[inst_4 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj x y... | The uncurrying operation taking a morphism `y ⟶ C(x, z)` to a morphism `(x ⊗ y) ⟶ z`,
constructed as a morphism in `C` between internal homs. | true |
UInt32.instIsAlwaysFinite | Init.Data.Range.Polymorphic.UInt | Std.Rxc.IsAlwaysFinite UInt32 | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.hasFDerivWithinAt_comp_add_left._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {α : Type u_1} {β : Type u_2} [inst : VAdd α β] {t : Set β} {a : α}, a +ᵥ t = (fun x => a +ᵥ x) '' t | null | false |
Lean.SubExpr.ctorIdx | Lean.SubExpr | Lean.SubExpr → ℕ | null | false |
LinearEquiv.toModuleIsoₛ | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} →
[inst : Semiring R] →
{X₁ X₂ : Type v} →
{g₁ : AddCommMonoid X₁} →
{g₂ : AddCommMonoid X₂} → {m₁ : Module R X₁} → {m₂ : Module R X₂} → (X₁ ≃ₗ[R] X₂) → (↧X₁ ≅ ↧X₂) | Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. | true |
CategoryTheory.IsAddMonHom.instNormalOfIsCommAddMonObjOfMono | Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H : C} [inst_2 : CategoryTheory.AddGrpObj G] [inst_3 : CategoryTheory.AddGrpObj H] {φ : H ⟶ G}
[inst_4 : CategoryTheory.BraidedCategory C] [CategoryTheory.IsCommAddMonObj G] [CategoryTheory.IsAddM... | null | true |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.SmallCategory J] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete J) D] →
[Catego... | If a functor creates coequalizers and the appropriate coproducts, it creates colimits.
We additionally require the rather strong condition that the functor reflects isomorphisms. It is
unclear whether the statement remains true without this condition. There are various definitions of
"creating colimits" in the literat... | true |
InnerProductSpace.Core.mk._flat_ctor | Mathlib.Analysis.InnerProductSpace.Defs | {𝕜 : Type u_4} →
{F : Type u_5} →
[inst : RCLike 𝕜] →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] →
(inner : F → F → 𝕜) →
(∀ (x y : F), (starRingEnd 𝕜) (inner y x) = inner x y) →
(∀ (x : F), 0 ≤ RCLike.re (inner x x)) →
(∀ (x y z : F), i... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.