name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Vector.mem_insertIdx | Init.Data.Vector.InsertIdx | ∀ {α : Type u} {a : α} {n i : ℕ} {b : α} {xs : Vector α n} {h : i ≤ n}, a ∈ xs.insertIdx i b h ↔ a = b ∨ a ∈ xs | null | true |
FractionalIdeal.inv_le_inv_iff._simp_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} {K : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : IsDedekindDomain A]
[inst_3 : Algebra A K] [inst_4 : IsFractionRing A K] {I J : FractionalIdeal (nonZeroDivisors A) K},
I ≠ 0 → J ≠ 0 → (I⁻¹ ≤ J⁻¹) = (J ≤ I) | null | false |
Std.ExtDHashMap.Const.size_alter_eq_sub_one | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∈ m → (f (Std.ExtDHashMap.Const.get? m k)).isNone = true → (Std.ExtDHashMap.Const.alter m k f).size = m.size - 1 | null | true |
IsMIntegralCurveAt.comp_mul_ne_zero | Mathlib.Geometry.Manifold.IntegralCurve.Transform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {t₀ : ℝ},
IsMIntegralCurveAt γ v t₀ → ∀ {a : ℝ},... | null | true |
Lean.Widget.RpcEncodablePacket.mk._flat_ctor._@.Lean.Widget.UserWidget.3433604829._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Json → Lean.Json → Lean.Json → Option Lean.Json → Option Lean.Json → Lean.Widget.RpcEncodablePacket✝ | null | false |
IsGaloisGroup.mulEquivCongr | Mathlib.FieldTheory.Galois.IsGaloisGroup | (G : Type u_1) →
(G' : Type u_2) →
[inst : Group G] →
[inst_1 : Group G'] →
(A : Type u_5) →
(B : Type u_6) →
[inst_2 : CommRing A] →
[inst_3 : CommRing B] →
[IsDomain B] →
[inst_5 : Algebra A B] →
[inst_6 : Mu... | If `G` and `G'` are finite Galois groups for `B/A`, then `G` is isomorphic to `G'`. | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«_aux_Mathlib_NumberTheory_NumberField_Cyclotomic_Ideal___delab_app__private_Mathlib_NumberTheory_NumberField_Cyclotomic_Ideal_0_IsCyclotomicExtension_Rat_term𝒑_1» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
division_def | Mathlib.Algebra.Group.DivInvMonoid | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a / b = a * b⁻¹ | **Alias** of `div_eq_mul_inv`.
---
Dividing by an element is the same as multiplying by its inverse.
This is a duplicate of `DivInvMonoid.div_eq_mul_inv` ensuring that the types unfold better.
| true |
Representation.LinearizeMonoidal.rTensor_comp_δ | Mathlib.RepresentationTheory.Action | ∀ {G : Type v} [inst : Monoid G] {X Y : Action (Type w) G} (Z : Action (Type w) G) {k : Type u}
[inst_1 : CommSemiring k] (f : X ⟶ Y),
(Representation.IntertwiningMap.rTensor (Representation.linearize k G Z) (Representation.linearizeMap f)).comp
(Representation.LinearizeMonoidal.δ X Z) =
(Representation.L... | null | true |
Matrix.permMatrix_mem_rowStochastic._simp_1 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
(Equiv.Perm.permMatrix R σ ∈ Matrix.rowStochastic R n) = True | null | false |
CategoryTheory.Limits.colimitCoconeOfUnique.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type u_1} →
(motive : CategoryTheory.Discrete β → Sort u_2) →
(x : CategoryTheory.Discrete β) → ((j : β) → motive { as := j }) → motive x | null | false |
FreeAddGroupBasis.lift | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | {ι : Type u_1} →
{G : Type u_3} →
{H : Type u_4} → [inst : AddGroup G] → [inst_1 : AddGroup H] → FreeAddGroupBasis ι G → (ι → H) ≃ (G →+ H) | Given an additive free group basis of `G` over `ι`, there is a canonical bijection between
maps from `ι` to an additive group `H` and morphisms from `G` to `H`. | true |
Std.Http.Header.ctorIdx | Std.Http.Data.Headers.Basic | {α : Type} → Std.Http.Header α → ℕ | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Hom.0.RootPairing.Equiv.reflection_inv._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | false |
coe_lt_enorm._simp_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_4} [inst : NNNorm E] {x : E} {r : NNReal}, (↑r < ‖x‖ₑ) = (r < ‖x‖₊) | null | false |
Ordnode.Sized._f | Mathlib.Data.Ordmap.Invariants | {α : Type u_1} → (x : Ordnode α) → Ordnode.below x → Prop | null | false |
Option.min_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α}, o ⊓ o' = some a ↔ ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a | null | true |
Int8.add_neg_eq_sub | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, a + -b = a - b | null | true |
Std.Http.Header.TransferEncoding.mk.noConfusion | Std.Http.Data.Headers.Basic | {P : Sort u} →
{codings : Array String} →
{isValid : Std.Http.Header.TransferEncoding.Validate codings = true} →
{codings' : Array String} →
{isValid' : Std.Http.Header.TransferEncoding.Validate codings' = true} →
{ codings := codings, isValid := isValid } = { codings := codings', isValid ... | null | false |
AddActionHom.fst_apply | Mathlib.GroupTheory.GroupAction.Hom | ∀ (M : Type u_1) (α : Type u_2) (β : Type u_3) [inst : VAdd M α] [inst_1 : VAdd M β],
⇑(AddActionHom.fst M α β) = Prod.fst | null | true |
ENNReal.zpow_le_of_le | Mathlib.Basic.ENNReal.Inv | ∀ {x : ENNReal}, 1 ≤ x → ∀ {a b : ℤ}, a ≤ b → x ^ a ≤ x ^ b | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.δ._simp_8 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
Submodule.mem_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_3 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_4 : (r : ↑s) → Module R (Mₚ r)]
(f : (r : ↑s) → M →ₗ[R] Mₚ r) [inst_5 : ∀ (r : ↑s), IsLocalizedModu... | null | true |
MulAut.congr_symm_apply | Mathlib.Algebra.Group.End | ∀ {G : Type u_3} [inst : Group G] {H : Type u_7} [inst_1 : Group H] (ϕ : G ≃* H) (f : MulAut H),
(MulAut.congr ϕ).symm f = ϕ.trans (MulEquiv.trans f ϕ.symm) | null | true |
Matrix.nonUnitalNonAssocRing._proof_1 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalNonAssocRing α] (a b : Matrix n n α), a - b = a + -b | null | false |
ImportGraph.Lake.BaseWorkspace.mk.noConfusion | ImportGraph.WorkspaceModel.Base | {P : Sort u} →
{dir sysroot leanLibDir lakeSrcDir leanSrcDir : System.FilePath} →
{version : Option Lake.ToolchainVer} →
{leanGitHash : String} →
{manifestFile dir' sysroot' leanLibDir' lakeSrcDir' leanSrcDir' : System.FilePath} →
{version' : Option Lake.ToolchainVer} →
{leanGi... | null | false |
Lean.Compiler.LCNF.Simp.DiscrM.Context._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | SizeOf Lean.Compiler.LCNF.Simp.DiscrM.Context | null | false |
Lean.Parser.Term.doCatchMatch.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | null | true |
bot_ne_top._simp_2 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [Nontrivial α], (⊥ = ⊤) = False | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.end._regBuiltin.Lean.Parser.Command.end.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
FaithfulSMul.algebraMap_eq_one_iff | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [FaithfulSMul R A]
{r : R}, (algebraMap R A) r = 1 ↔ r = 1 | null | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_one._proof_1_1 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {i : ℕ}, i + 1 ≤ a.size → ¬min (i + 1) a.size - i = 1 → False | null | false |
MeasureTheory.measure_inv_smul_sdiff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
(μ : MeasureTheory.Measure α) [MeasureTheory.SMulInvariantMeasure G α μ] (c : G) (s t : Set α),
μ (c⁻¹ • s \ t) = μ (s \ c • t) | null | true |
Aesop.SearchM.State.maxRuleApplicationDepthReached | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM.State Q → Bool | null | true |
IsDiffImmersionAt.comp_isInvertible_mfderiv_left | Mathlib.Geometry.Manifold.ImmersionDiff | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {F : Type u_3} {E' : Type u}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E']
[inst_4 : NormedSpace 𝕜 E'] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_6}
[inst_7 : Topologic... | null | true |
CategoryTheory.Span.hom_ext_iff | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C} {c c' : C}
{S S' : CategoryTheory.Span Wₗ Wᵣ c c'} {f g : S ⟶ S'}, f = g ↔ f.hom = g.hom | null | true |
MagmaCat.Hom.casesOn | Mathlib.Algebra.Category.Semigrp.Basic | {A B : MagmaCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₙ* ↑B) → motive { hom' := hom' }) → motive t | null | false |
Std.Time.PlainDateTime.ext | Std.Time.DateTime.PlainDateTime | ∀ {x y : Std.Time.PlainDateTime}, x.date = y.date → x.time = y.time → x = y | null | true |
continuousSubmonoid._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MulOneClass β]
[ContinuousMul β] {a b : α → β}, a ∈ {f | Continuous f} → b ∈ {f | Continuous f} → Continuous (a * b) | null | false |
Mathlib.Tactic.Sat.LClause.ctorIdx | Mathlib.Tactic.Sat.FromLRAT | Mathlib.Tactic.Sat.LClause → ℕ | null | false |
signedDist._proof_8 | Mathlib.Geometry.Euclidean.SignedDist | IsTopologicalAddTorsor ℝ | null | false |
CategoryTheory.Limits.Cocone.rec | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{motive : CategoryTheory.Limits.Cocone F → Sort u} →
((pt : C) → (ι : F ⟶ (CategoryTheory.Functor.const J).obj pt) → ... | null | false |
nhdsLE_basis_Ioc | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [NoMinOrder α] (a : α),
(nhdsWithin a (Set.Iic a)).HasBasis (fun u => u < a) fun b => Set.Ioc b a | null | true |
Lean.Meta.Match.MatcherInfo.getAltRange | Lean.Meta.Match.MatcherInfo | Lean.Meta.MatcherInfo → Std.Rco ℕ | null | true |
curveIntegralFun_cast | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b c d : E}
(ω : E → E →L[𝕜] F) (γ : Path a b) (hc : c = a) (hd : d = b), curveIntegralFun ω (γ.cast hc hd) = curveIntegralFun... | null | true |
IsTopologicalGroup.toHSpace._proof_4 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : MulOneClass M], 1 * 1 = 1 | null | false |
HomotopicalAlgebra.Precylinder.LeftHomotopy.fullSubcategoryEquiv._proof_6 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.ObjectProperty C}
{X Y : P.FullSubcategory} {Q : HomotopicalAlgebra.Precylinder X} {f g : X ⟶ Y},
Function.RightInverse (fun h => { h := CategoryTheory.ObjectProperty.homMk h.h, h₀ := ⋯, h₁ := ⋯ }) fun h =>
{ h := h.h.hom, h₀ := ... | null | false |
AdjoinRoot.powerBasis.eq_1 | Mathlib.FieldTheory.Galois.NormalBasis | ∀ {K : Type u_5} [inst : Field K] {f : Polynomial K} (hf : f ≠ 0),
AdjoinRoot.powerBasis hf =
{ gen := AdjoinRoot.root f, dim := f.natDegree, basis := AdjoinRoot.powerBasisAux hf, basis_eq_pow := ⋯ } | null | true |
Std.DTreeMap.Internal.Unit.RicSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Unit.RicSliceData α → Sort u_1} →
(t : Std.DTreeMap.Internal.Unit.RicSliceData α) →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
m... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchDiagnostics.0.Lean.Meta.Grind.NodeInfo.noConfusion | Lean.Meta.Tactic.Grind.EMatchDiagnostics | {P : Sort u} → {t t' : Lean.Meta.Grind.NodeInfo✝} → t = t' → Lean.Meta.Grind.NodeInfo.noConfusionType✝ P t t' | null | false |
Lean.Meta.Tactic.TryThis.Suggestion.preInfo? | Lean.Meta.TryThis | Lean.Meta.Tactic.TryThis.Suggestion → Option String | Optional info to be printed immediately before replacement text in a widget. | true |
Matroid.closure_inter_ground | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X : Set α), M.closure (X ∩ M.E) = M.closure X | null | true |
MeromorphicOn.exists_ecanonicalDecomp | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {R : ℝ} {f : ℂ → E},
MeromorphicOn f (Metric.closedBall 0 R) →
(∀ (u : ↑(Metric.closedBall 0 R)), meromorphicOrderAt f ↑u ≠ ⊤) → ∃ h, Complex.ECanonicalDecomp f h R | **Extended canonical decomposition:** A meromorphic function on a closed disk is equal, up to
modification over a discrete set, to a product of a non-vanishing analytic function, canonical
factors and meromorphic functions of the form `(x - const) ^ n` where `const` is on the
circumference of the disk.
| true |
Lean.IR.FnBody.sset.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} →
{x : Lean.IR.VarId} →
{i offset : ℕ} →
{y : Lean.IR.VarId} →
{ty : Lean.IR.IRType} →
{b : Lean.IR.FnBody} →
{x' : Lean.IR.VarId} →
{i' offset' : ℕ} →
{y' : Lean.IR.VarId} →
{ty' : Lean.IR.IRType} →
... | null | false |
Bornology.IsBounded.image_eval | Mathlib.Topology.Bornology.Constructions | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (i : ι) → Bornology (X i)] {s : Set ((i : ι) → X i)},
Bornology.IsBounded s → ∀ (i : ι), Bornology.IsBounded (Function.eval i '' s) | null | true |
ImportGraph.Lake.instFromJsonBaseWorkspace | ImportGraph.WorkspaceModel.Base | Lean.FromJson ImportGraph.Lake.BaseWorkspace | null | true |
SmoothBumpFunction.instNonempty | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M},
Nonempty (SmoothBumpFunction I c) | null | true |
List.traverse_cons | Mathlib.Control.Traversable.Instances | ∀ {F : Type u → Type u} [inst : Applicative F] {α' β' : Type u} (f : α' → F β') (a : α') (l : List α'),
traverse f (a :: l) = (fun x1 x2 => x1 :: x2) <$> f a <*> traverse f l | null | true |
Lean.Linter.CodeQuality.Value.dict.sizeOf_spec | Lean.Linter.CodeQuality.Basic | ∀ (dictionary : Std.TreeMap String Float compare),
sizeOf (Lean.Linter.CodeQuality.Value.dict dictionary) = 1 + sizeOf dictionary | null | true |
Valuation.IsRankOneDiscrete.generator_eq_exp_neg_one_of_surjective | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {A : Type u_2} [inst : Ring A] {v : Valuation A (WithZero (Multiplicative ℤ))} [hv : v.IsRankOneDiscrete],
Function.Surjective ⇑v →
Valuation.IsRankOneDiscrete.generator v =
Units.mk0 (WithZero.exp (-1)) Valuation.IsRankOneDiscrete.generator_eq_exp_neg_one_of_mem_range._proof_1 | The generator of a surjective discrete valuation in `ℤᵐ⁰` is equal to `exp (-1)`. | true |
Std.CancellationToken.noConfusionType | Std.Sync.CancellationToken | Sort u → Std.CancellationToken → Std.CancellationToken → Sort u | null | false |
Mathlib.Tactic.ClickSuggestions.Context.goal | Mathlib.Tactic.ClickSuggestions.Util | Mathlib.Tactic.ClickSuggestions.Context → Lean.MVarId | The main goal. | true |
«term_≃ₗᵢ⋆[_]_» | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.TrailingParserDescr | An antilinear isometric equivalence between two normed vector spaces. | true |
AlgebraicGeometry.IsAffineOpen.fromSpecStalk.eq_1 | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) {x : ↥X} (hxU : x ∈ U),
hU.fromSpecStalk hxU =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.presheaf.germ U x hxU)) hU.fromSpec | null | true |
Lean.MVarId.propext | Lean.Meta.Tactic.Apply | Lean.MVarId → Lean.MetaM Lean.MVarId | Try to convert an `Eq` into an `Iff` by applying `propext`.
If successful, then returns then new goal, otherwise returns the original `MVarId`.
| true |
AlgebraicGeometry.Scheme.PartialMap.restrict_domain | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialMap Y) (U : X.Opens) (hU : Dense ↑U) (hU' : U ≤ f.domain),
(f.restrict U hU hU').domain = U | null | true |
StrictConvex.neg | Mathlib.Analysis.Convex.Strict | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : TopologicalSpace E]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {s : Set E} [IsTopologicalAddGroup E],
StrictConvex 𝕜 s → StrictConvex 𝕜 (-s) | null | true |
CategoryTheory.Sieve.mem_functorPushforward_inverse | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{Y : C} {X : D} {S : CategoryTheory.Sieve X} {e : C ≌ D} {f : Y ⟶ e.inverse.obj X},
(CategoryTheory.Sieve.functorPushforward e.inverse S).arrows f ↔
S.arrows (CategoryTheory.CategoryStruct.com... | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction._proof_13 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : Dᵒᵖ} (x : d ⟶ d'),
CategoryTheory.CategoryStruct.comp
(Category... | null | false |
lowerClosure_eq._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, (↑(lowerClosure s) = s) = IsLowerSet s | null | false |
Nat.ModEq.mul_right_cancel' | Mathlib.Data.Nat.ModEq | ∀ {a b c m : ℕ}, c ≠ 0 → a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m] | Cancel right multiplication on both sides of the `≡` and in the modulus.
For cancelling right multiplication in the modulus, see `Nat.ModEq.of_mul_right`. | true |
HasSSubset.SSubset.trans_eq | Mathlib.Order.RelClasses | ∀ {α : Type u_1} {a b c : α} [inst : LT α], a < b → b = c → a < c | **Alias** of `LT.lt.trans_eq`. | true |
Filter.isBoundedUnder_of | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {f : Filter β} {u : β → α},
(∃ b, ∀ (x : β), r (u x) b) → Filter.IsBoundedUnder r f u | A bounded function `u` is in particular eventually bounded. | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr_trans_hom_assoc | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} {x y z : AlgebraicGeometry.Scheme.Pullback.Triplet f g}
(e : x = y) (e' : y = z) {Z : CommRingCat} (h : z.tensor ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e).hom
(CategoryTheory.CategoryStruct.co... | null | true |
Std.ExtTreeMap.contains_insertMany_list | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α},
(t.insertMany l).contains k = (t.contains k || (List.map Prod.fst l).contains k) | null | true |
CategoryTheory.Triangulated.Octahedron.casesOn | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | null | false |
_private.Lean.Elab.DeprecatedSyntax.0.Lean.Elab.checkDeprecatedSyntax.match_4 | Lean.Elab.DeprecatedSyntax | (motive : Lean.Elab.MacroStack → Sort u_1) →
(macroStack : Lean.Elab.MacroStack) →
((macroStx after callerStx after_1 : Lean.Syntax) →
(tail : List Lean.Elab.MacroStackElem) →
motive ({ before := macroStx, after := after } :: { before := callerStx, after := after_1 } :: tail)) →
((macroStx... | null | false |
StrictConvexOn.convex_lt | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 β]
[IsOrderedAddMonoid β] [PosSMulMono 𝕜 β] {s : Set E} {f : E → β},
StrictConvexOn 𝕜 s f → ∀... | null | true |
Std.Time.PlainDateTime.toEpochDay | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Day.Offset | Returns the local (civil) date of the `PlainDateTime` as a `Day.Offset` relative to 1970-01-01.
| true |
HomologicalComplex.homotopyCofiber.sndX.eq_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i : ι),
HomologicalComplex.homotopyCofiber.sndX φ ... | null | true |
Lean.Meta.Grind.Origin.key | Lean.Meta.Tactic.Grind.Theorems | Lean.Meta.Grind.Origin → Lean.Name | A unique identifier corresponding to the origin. | true |
AlgebraicGeometry.Scheme.PartialMap.comp_id | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {X Y : AlgebraicGeometry.Scheme} [inst : PreirreducibleSpace ↥X] [inst_1 : Nonempty ↥Y] (f : X.PartialMap Y)
[inst_2 : AlgebraicGeometry.IsDominant f.hom], f.comp (AlgebraicGeometry.Scheme.PartialMap.id Y) = f | null | true |
Lean.Meta.LazyDiscrTree.Key.proj.sizeOf_spec | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.Name) (a_1 a_2 : ℕ),
sizeOf (Lean.Meta.LazyDiscrTree.Key.proj a a_1 a_2) = 1 + sizeOf a + sizeOf a_1 + sizeOf a_2 | null | true |
IterateAddAct.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} → {f : α → α} → ℕ → IterateAddAct f | null | false |
ULift.up_ofNat | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u} [inst : NatCast R] (n : ℕ) [inst_1 : n.AtLeastTwo], { down := OfNat.ofNat n } = OfNat.ofNat n | null | true |
Lean.Parser.Term.doLetElse.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | null | true |
Matrix.kroneckerTMulStarAlgEquiv._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_2) (n : Type u_4) (R : Type u_1) (S : Type u_6) (A : Type u_3) (B : Type u_5) [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | null | false |
Matrix.eRank_toNat_eq_finrank | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} {R : Type uR} [inst : Semiring R] (A : Matrix m n R),
A.eRank.toNat = Module.finrank R ↥(Submodule.span R (Set.range A.col)) | null | true |
Mathlib.Tactic.BicategoryLike.MkEvalWhiskerLeft | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (Type → Type) → Type | Evaluate the expression `f ◁ η`. | true |
_private.Mathlib.Tactic.ProxyType.0.Mathlib.ProxyType.ensureProxyEquiv.match_3 | Mathlib.Tactic.ProxyType | (motive :
Option
((Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term) ×
Subarray (Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term)) →
Sort u_1) →
(x :
Option
((Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term) ×
Subarray (Lean.Name × Lean.Expr × Le... | null | false |
_private.Init.Data.Array.Lemmas.0.Array.ne_of_not_mem_push._simp_1_1 | Init.Data.Array.Lemmas | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.sqrt_ringInverse._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | (1 + 1).AtLeastTwo | null | false |
StrictConvexOn.slope_lt_of_hasDerivWithinAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ},
StrictConvexOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivWithinAt f f' S y → slope f x y < f' | If `f : ℝ → ℝ` is strictly convex on `S` and differentiable within `S` at `y ∈ S`, then the
slope of any secant line with right endpoint at `y` is strictly less than the derivative of `f`
within `S` at `y`.
This is fractionally weaker than `StrictConvexOn.slope_lt_of_hasDerivWithinAt_Iio` but simpler to
apply under a ... | true |
Seminorm.mk | Mathlib.Analysis.Normed.Module.Seminorm.Basic | {𝕜 : Type u_12} →
{E : Type u_13} →
[inst : SeminormedRing 𝕜] →
[inst_1 : AddGroup E] →
[inst_2 : SMul 𝕜 E] →
(toAddGroupSeminorm : AddGroupSeminorm E) →
(∀ (a : 𝕜) (x : E), toAddGroupSeminorm.toFun (a • x) = ‖a‖ * toAddGroupSeminorm.toFun x) → Seminorm 𝕜 E | null | true |
CategoryTheory.IsFiltered.SmallFilteredIntermediate.factoring | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.IsFilteredOrEmpty C] →
{D : Type u₁} →
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] →
(F : CategoryTheory.Functor D C) →
CategoryTheory.Functor D (CategoryTheory.IsFiltered.SmallFilteredInterme... | The first part of a factoring of a functor from a small category to a filtered category through
a small filtered category. | true |
Module.Finite.self | Mathlib.RingTheory.Finiteness.Basic | ∀ (R : Type u_1) [inst : Semiring R], Module.Finite R R | null | true |
_private.Lean.Message.0.Lean.MessageData.originatingSyntax?.match_1 | Lean.Message | (motive : Lean.MessageData → Sort u_1) →
(x : Lean.MessageData) →
((stx : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.MessageData.ofOriginatingSyntax stx msg)) →
((msg : Lean.MessageData) → motive msg) → motive x | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Basic.0.Filter.atBot_neBot_iff.match_1_1 | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_1} [inst : Preorder α] (motive : Nonempty α ∧ IsCodirectedOrder α → Prop)
(x : Nonempty α ∧ IsCodirectedOrder α), (∀ (h₁ : Nonempty α) (h₂ : IsCodirectedOrder α), motive ⋯) → motive x | null | false |
AlgCat.restrictScalarsComp' | Mathlib.Algebra.Category.AlgCat.Basic | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : CommRing T] →
(f : R →+* S) →
(g : S →+* T) →
(gf : R →+* T) →
gf = g.comp f →
(AlgCat.restrictScalars ... | Restricting scalars along a composition is isomorphic to the composition
of restriction of scalars. | true |
inv_mul_lt_iff₀' | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b c : G₀},
0 < c → (c⁻¹ * b < a ↔ b < a * c) | See `inv_mul_lt_iff₀` for a version with multiplication on the other side. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.