name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddCommGrpCat.forget_commGrp_preserves_epi | Mathlib.Algebra.Category.Grp.EpiMono | (CategoryTheory.forget AddCommGrpCat).PreservesEpimorphisms | null | true |
IsAdicComplete.toIsPrecomplete | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {inst : CommRing R} {I : Ideal R} {M : Type u_4} {inst_1 : AddCommGroup M} {inst_2 : Module R M}
[self : IsAdicComplete I M], IsPrecomplete I M | null | true |
CategoryTheory.RegularMono._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {X Y : C} → {f : X ⟶ Y} → [SizeOf C] → CategoryTheory.RegularMono f → ℕ | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceLT._regBuiltin.Int32.reduceLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.184 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
FirstOrder.Language.PartialEquiv.mk.inj | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} {inst : L.Structure M} {inst_1 : L.Structure N}
{dom : L.Substructure M} {cod : L.Substructure N} {toEquiv : L.Equiv ↥dom ↥cod} {dom_1 : L.Substructure M}
{cod_1 : L.Substructure N} {toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1},
{ dom := dom, cod := cod, toEquiv := toE... | null | true |
Condensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
FintypeCat.toProfinite.op.comp
(Condensed.locallyConstantPresheaf (F.obj (FintypeCat.toProfinite.op.obj (Opposite.op ↧PUnit.{u + 1})))) ≅
Condensed.finYoneda F | `locallyConstantPresheaf` restricted to finite sets is isomorphic to `finYoneda F`. | true |
CategoryTheory.Limits.Concrete.initial_of_empty_of_reflects | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Functor.empty C) (CategoryTheory.forget C)] (X : C),
IsEmp... | If `forget C` reflects initials and `ToType X` is empty, then `X` is initial. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsCycles.other_adj_of_adj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), G.Adj v w = (w ∈ G.neighborSet v) | null | false |
AddCommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : AddCommGroup α] [inst_2 : AddLeftMono α],
AddCommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | null | true |
Aesop.instInhabitedMVarClusterData.default | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp | null | true |
ContinuousAffineMap.decompEquiv_symm_apply | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) (V : Type u_3) {W : Type u_4} (Q : Type u_5) [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] [inst_8 : AddTorsor W Q] [inst_9 : TopologicalS... | null | true |
_private.Mathlib.Tactic.ClickSuggestions.FindPremises.0.Mathlib.Tactic.ClickSuggestions.Entries.mk.inj | Mathlib.Tactic.ClickSuggestions.FindPremises | ∀
{rw :
Array
(Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry × Mathlib.Tactic.ClickSuggestions.RwLemma)}
{grw :
Array
(Lean.Meta.RefinedDiscrTree.Key ×
Lean.Meta.RefinedDiscrTree.LazyEntry × Mathlib.Tactic.ClickSuggestions.GrwLemma)}
{app :
Array
(Lean... | null | true |
instNonUnitalNonAssocRingCommutatorRing._proof_28 | Mathlib.Algebra.Lie.NonUnitalNonAssocAlgebra | ∀ (L : Type u_1) (this : NonUnitalNonAssocRing L) (a : CommutatorRing L), 0 * a = 0 | null | false |
Float32.pi | Batteries.Data.Float.Basic | Float32 | The floating point value closest to the mathematical constant `π`.
| true |
Lean.Elab.Term.SyntheticMVarKind.typeClass.inj | Lean.Elab.Term.TermElabM | ∀ {extraErrorMsg? extraErrorMsg?_1 : Option Lean.MessageData},
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg? =
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?_1 →
extraErrorMsg? = extraErrorMsg?_1 | null | true |
Lean.PrefixTreeNode.below_2 | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Mathlib.Notation3.MatchState.noConfusion | Mathlib.Util.Notation3 | {P : Sort u} → {t t' : Mathlib.Notation3.MatchState} → t = t' → Mathlib.Notation3.MatchState.noConfusionType P t t' | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.Units.0.Polynomial.isUnit_iff.match_1_1 | Mathlib.Algebra.Polynomial.Degree.Units | ∀ {R : Type u_1} [inst : Semiring R] {p : Polynomial R} (motive : (∃ r, IsUnit r ∧ Polynomial.C r = p) → Prop)
(x : ∃ r, IsUnit r ∧ Polynomial.C r = p), (∀ (w : R) (hr : IsUnit w) (hrp : Polynomial.C w = p), motive ⋯) → motive x | null | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk.noConfusion | Mathlib.Tactic.Linter.FindDeprecations | {P : Sort u} →
{module decl : Lean.Name} →
{rgStart rgStop : Lean.Position} →
{since : String} →
{module' decl' : Lean.Name} →
{rgStart' rgStop' : Lean.Position} →
{since' : String} →
{ module := module, decl := decl, rgStart := rgStart, rgStop := rgStop, since :=... | null | false |
CategoryTheory.Functor.IsRepresentedBy.representableBy | Mathlib.CategoryTheory.RepresentedBy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{X : C} → {x : F.obj (Opposite.op X)} → F.IsRepresentedBy x → F.RepresentableBy X | The canonical representation induced by the universal element `x : F.obj X`. | true |
integrable_cexp_quadratic' | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ},
b.re < 0 → ∀ (c d : ℂ), MeasureTheory.Integrable (fun x => Complex.exp (b * ↑x ^ 2 + c * ↑x + d)) MeasureTheory.volume | null | true |
Ordinal.IsFundamentalSeq.id | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {o : Ordinal.{u_1}}, o ≤ o.cof.ord → Ordinal.IsFundamentalSeq id | A regular ordinal `o` has a fundamental sequence given by all smaller ordinals. | true |
Lake.Date | Lake.Util.Date | Type | A date (year-month-day). | true |
Lean.Doc.Inline.emph.injEq | Lean.DocString.Types | ∀ {i : Type u} (content content_1 : Array (Lean.Doc.Inline i)),
(Lean.Doc.Inline.emph content = Lean.Doc.Inline.emph content_1) = (content = content_1) | null | true |
CategoryTheory.Functor.toPrefunctor | Mathlib.CategoryTheory.Functor.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → C ⥤q D | The prefunctor between the underlying quivers. | true |
Lean.Meta.saveState | Lean.Meta.Basic | Lean.MetaM Lean.Meta.SavedState | null | true |
AffineSubspace.map_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂), AffineSubspace.map f ⊥ = ⊥ | null | true |
Lean.Constructor.mk.injEq | Lean.Declaration | ∀ (name : Lean.Name) (type : Lean.Expr) (name_1 : Lean.Name) (type_1 : Lean.Expr),
({ name := name, type := type } = { name := name_1, type := type_1 }) = (name = name_1 ∧ type = type_1) | null | true |
Filter.eventually_bind._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → Filter β} {p : β → Prop},
(∀ᶠ (y : β) in f.bind m, p y) = ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y | null | false |
PartialDiffeomorph.trans._proof_2 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_9} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {F' : Type u_5}
[inst_5 : NormedAddCommGroup F'] [inst_6 : NormedSpace 𝕜 F'] {H₁ : Type u_3} [inst_7 : Topologi... | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m (Std.IterM m β)]
{it₁ : Std.IterM m (Std.IterM m β)} (motive : it₁.Step → Sort u_3) (it₁' : Std.IterM m (Std.IterM m β))
(it₂' : Std.IterM m β) (h : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂'))
(h_1 :
(it₁' : Std.IterM m (Std.Iter... | null | true |
AlgebraicGeometry.IsAffineOpen.isoSpec_hom_fromSpec | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp hU.isoSpec.hom hU.fromSpec = U.ι | null | true |
CategoryTheory.MorphismProperty.isLocal_antitone | Mathlib.CategoryTheory.ObjectProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W W' : CategoryTheory.MorphismProperty C},
W ≤ W' → W'.isLocal ≤ W.isLocal | null | true |
Irrational.of_mul_ratCast | Mathlib.NumberTheory.Real.Irrational | ∀ (q : ℚ) {x : ℝ}, Irrational (x * ↑q) → Irrational x | null | true |
Set.Finite.cast_ncard_eq | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Finite → ↑s.ncard = s.encard | null | true |
LinearMap.transvection.comp_of_left_eq | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid V] [inst_2 : Module R V]
{f : Module.Dual R V} {v w : V},
f w = 0 → LinearMap.transvection f v ∘ₗ LinearMap.transvection f w = LinearMap.transvection f (v + w) | null | true |
AlgebraicGeometry.instIsLocallyArtinianFiberOfLocallyQuasiFinite | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyQuasiFinite f] (y : ↥Y),
AlgebraicGeometry.IsLocallyArtinian (AlgebraicGeometry.Scheme.Hom.fiber f y) | null | true |
ENNReal.mul_eq_left | Mathlib.Basic.ENNReal.Operations | ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → (a * b = a ↔ b = 1) | null | true |
Equiv.piOptionEquivProd_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {β : Option α → Type u_8} (f : (a : Option α) → β a),
Equiv.piOptionEquivProd f = (f none, fun a => f (some a)) | null | true |
MeasureTheory.ae_eq_comp | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{μ : MeasureTheory.Measure α} {f : α → β} {g g' : β → δ},
AEMeasurable f μ → g =ᵐ[MeasureTheory.Measure.map f μ] g' → g ∘ f =ᵐ[μ] g' ∘ f | null | true |
ByteArray.ofFn | Batteries.Data.ByteArray | {n : ℕ} → (Fin n → UInt8) → ByteArray | - `ofFn f` with `f : Fin n → UInt8` returns the byte array whose `i`th element is `f i`. - | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_17 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_3) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_1} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} [inst_6 : Algebra ℝ 𝕜] [inst_7 : IsScalarTowe... | null | false |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Poly.maxDegreeOf.go._sunfold | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → ℕ → ℕ | null | false |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K] {x : NumberField.RingOfIntegers K},
hζ.toInteger - 1 ∣ x + 1 → (hζ.toInteger - 1) ^ 4 ∣ x ^ 3 + 1 | If `λ` divides `x + 1`, then `λ ^ 4` divides `x ^ 3 + 1`. | true |
IsManifold.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : 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} →
{n : WithTop ℕ∞} →
... | null | false |
Convert.CheapConfig.closePost._inherited_default | Mathlib.Tactic.Convert | Bool | null | false |
MeasureTheory.VectorMeasure.of_biUnion_finset | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
{v : MeasureTheory.VectorMeasure α M} [T2Space M] {ι : Type u_4} {s : Finset ι} {f : ι → Set α},
(↑s).PairwiseDisjoint f → (∀ b ∈ s, MeasurableSet (f b)) → v (⋃ b ∈ s, f b) = ∑ p ∈ s, v (f p) | null | true |
Set.powersetCard.ofFinEmb.eq_1 | Mathlib.Data.Set.PowersetCard | ∀ (n : ℕ) (β : Type u_2) (f : Fin n ↪ β), Set.powersetCard.ofFinEmb n β f = Set.powersetCard.map n f ⟨Finset.univ, ⋯⟩ | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | null | false |
CategoryTheory.Limits.productUniqueIso.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : Unique β] (f : β → C),
CategoryTheory.Limits.productUniqueIso f =
(CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor f)).conePointUniqueUpToIso
(CategoryTheory.Limits.limitConeOfUnique f).isLimit | null | true |
UniformSpace.Completion.ring._proof_26 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(x : UniformSpace.Completion α), x ^ 0 = 1 | null | false |
ModuleCat.instModuleCarrierObjRestrictScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] {f : R →+* S} {M : ModuleCat S}
(b : ↑((ModuleCat.restrictScalars f).obj M)), 1 • b = b | null | false |
Std.Http.Method.noConfusion | Std.Http.Data.Method | {P : Sort v✝} → {x y : Std.Http.Method} → x = y → Std.Http.Method.noConfusionType P x y | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.AddAndFinalizeContext✝ → Array Lean.Expr | null | true |
TopModuleCat.instAddCommGroupHom | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → {X Y : TopModuleCat R} → AddCommGroup (X ⟶ Y) | null | true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | null | true |
Filter.covariant_vadd | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β],
CovariantClass (Filter α) (Filter β) (fun x1 x2 => x1 +ᵥ x2) fun x1 x2 => x1 ≤ x2 | null | true |
grade_strictMono | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
StrictMono (grade 𝕆) | null | true |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (h : j < i),
(xs.set i a w).eraseIdx j ⋯ = (xs.eraseIdx j ⋯).set (i - 1) a ⋯ | null | true |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X ⟶ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom | null | true |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} → [inst : DivisionRing K] → PartialOrder (Subfield K) | null | true |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | (L : FirstOrder.Language) → (M : Type w) → [L.Structure M] → Set (CategoryTheory.Bundled L.Structure) | The age of a structure `M` is the class of finitely-generated structures that embed into it. | true |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [inst_3 : Zero γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | null | true |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α : Type u_1} (a : α), Std.Do.PredTrans.Conjunctive fun Q => Q.1 a | null | false |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : ℕ),
0 < ↑x ^ n | null | false |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5 | Mathlib.Tactic.MkIffOfInductiveProp | (motive : ℕ → ℕ → Sort u_1) →
(m n : ℕ) →
(Unit → motive 0 0) →
((n : ℕ) → motive 0 n.succ) → ((m n : ℕ) → motive m.succ n.succ) → ((x x_1 : ℕ) → motive x x_1) → motive m n | null | false |
NNRat.nndist_eq._simp_1 | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist ↑p ↑q = nndist p q | null | false |
List.Sublist.tail | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.tail.Sublist l₂.tail | null | true |
«term_<|_» | Init.Notation | Lean.TrailingParserDescr | A pipe operator that feeds values from the right into functions on the left.
`f <| x` means the same as `f x`, except that it parses `x` with lower precedence, which means that
`f <| g <| x` is interpreted as `f (g x)` rather than `(f g) x`.
| true |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.elabDeriving._regBuiltin.Lean.Elab.elabDeriving.declRange_3 | Lean.Elab.Deriving.Basic | IO Unit | null | false |
CategoryTheory.Under.map.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y),
CategoryTheory.Under.map f =
CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun x => f) | null | true |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.format | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfoMap → Lean.Compiler.LCNF.CompilerM Std.Format | null | true |
smul_nonneg_iff_neg_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[PosSMulStrictMono α β] {a : α} {b : β}, 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) | null | true |
Projectivization.logHeight_mk | Mathlib.NumberTheory.Height.Projectivization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [inst_2 : Finite ι] {x : ι → K}
(hx : x ≠ 0), (Projectivization.mk K x hx).logHeight = Height.logHeight x | null | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right' | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
CategoryTheory.Limits.HasLimit
(CategoryTheory.Limits.cospan
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.Sheaf... | null | true |
ENat.forall_natCast_le_iff_le | Mathlib.Data.ENat.Basic | ∀ {m n : ℕ∞}, (∀ (a : ℕ), ↑a ≤ m → ↑a ≤ n) ↔ m ≤ n | Version of `WithTop.forall_natCast_le_iff_le` using `Nat.cast` rather than `WithTop.some`. | true |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n : ℕ), ¬Std.Tactic.BVDecide.BVUnOp.reverse = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n | null | false |
CochainComplex.HomComplex.Cocycle.instAddCommGroup._aux_14 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(F G : CochainComplex C ℤ) →
(n : ℤ) →
CochainComplex.HomComplex.Cocycle F G n →
CochainComplex.HomComplex.Cocycle F G n → CochainComplex.HomComplex.Cocycle F G n | null | false |
Plausible.Testable.mk | Plausible.Testable | {p : Prop} → (Plausible.Configuration → Bool → Plausible.Gen (Plausible.TestResult p)) → Plausible.Testable p | null | true |
Complex.arg_of_im_pos | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, 0 < z.im → z.arg = Real.arccos (z.re / ‖z‖) | null | true |
Nat.dfold_zero._proof_7 | Init.Data.Nat.Fold | 0 ≤ 0 | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_70 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Ideal.comap_map_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided],
I ≤ J → Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J | null | true |
prodXSubSMul.eval | Mathlib.Algebra.Polynomial.GroupRingAction | ∀ (G : Type u_2) [inst : Group G] [inst_1 : Fintype G] (R : Type u_3) [inst_2 : CommRing R]
[inst_3 : MulSemiringAction G R] (x : R), Polynomial.eval x (prodXSubSMul G R x) = 0 | null | true |
QuotientGroup.instSeminormedCommGroup._proof_4 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M) (x y z : M ⧸ S), dist x z ≤ dist x y + dist y z | null | false |
Convexity.ConvexSpace | Mathlib.Geometry.Convex.ConvexSpace.Defs | (R : Type u) →
Type v → [inst₁ : PartialOrder R] → [inst₂ : Semiring R] → [inst₃ : IsStrictOrderedRing R] → Type (max u v) | A set equipped with an operation of finite convex combinations,
where the coefficients must be non-negative and sum to 1.
| true |
Order.IsIntent.eq | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} {t : Set β}, Order.IsIntent r t → upperPolar r (lowerPolar r t) = t | **Alias** of the forward direction of `Order.isIntent_iff`. | true |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum'_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_3} {β : Type u_4} {M : Matroid α} (f : α ≃ β) {I X : Set β},
(M.mapEquiv f).IsBasis I X = M.IsBasis (⇑f.symm '' I) (⇑f.symm '' X) | null | false |
Set.InjOn.eq_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x = f y ↔ x = y) | null | true |
CategoryTheory.Limits.image.fac | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ι f) = f | null | true |
DomAddAct.instAddCommMonoidOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [AddCommMonoid Mᵃᵒᵖ] → AddCommMonoid Mᵈᵃᵃ | null | true |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_le_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander | null | false |
Metric.PiNatEmbed.recOn | Mathlib.Topology.MetricSpace.PiNat | {ι : Type u_2} →
{X : Type u_5} →
{Y : ι → Type u_6} →
{f : (i : ι) → X → Y i} →
{motive : Metric.PiNatEmbed X Y f → Sort u} →
(t : Metric.PiNatEmbed X Y f) → ((ofPiNat : X) → motive { ofPiNat := ofPiNat }) → motive t | null | false |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.generatorIndex.congr_simp | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E E_1 : IntermediateField K (RatFunc K)} (e_E : E = E_1) (h : E ≠ ⊥),
RatFunc.Luroth.generatorIndex✝ h = RatFunc.Luroth.generatorIndex✝ ⋯ | null | true |
jacobiSym.mul_right' | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b₁ b₂ : ℕ}, b₁ ≠ 0 → b₂ ≠ 0 → jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂ | The Jacobi symbol is multiplicative in its second argument. | true |
TopCommRingCat.hasForgetToTopCat | Mathlib.Topology.Category.TopCommRingCat | CategoryTheory.HasForget₂ TopCommRingCat TopCat | The forgetful functor to `TopCat`. | true |
Equiv.Perm.coe_pow._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} (f : Equiv.Perm α) (n : ℕ), (⇑f)^[n] = ⇑(f ^ n) | null | false |
CategoryTheory.ShiftMkCore.casesOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.ShiftMkCore C A → Sort u_2} →
(t : CategoryTheory.ShiftMkCore C A) →
((F : A → CategoryTheory.Functor C C) →
(zero : F 0 ≅ CategoryTheor... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.