name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Lean.Name.0.allNamesByModule.match_1 | Mathlib.Lean.Name | (motive : Option (Array Lean.Name) → Sort u_1) →
(x : Option (Array Lean.Name)) → ((others : Array Lean.Name) → motive (some others)) → (Unit → motive none) → motive x | null | false |
Nat.Partition.le_of_mem_parts | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ {n : ℕ} {p : n.Partition} {m : ℕ}, m ∈ p.parts → m ≤ n | null | true |
Std.Http.Config.maxTrailerHeaders | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum number of trailer headers (default: 20)
| true |
IsUltraUniformity.rec | Mathlib.Topology.UniformSpace.Ultra.Basic | {X : Type u_1} →
[inst : UniformSpace X] →
{motive : IsUltraUniformity X → Sort u} →
((hasBasis : (uniformity X).HasBasis (fun s => s ∈ uniformity X ∧ s.IsSymm ∧ s.IsTrans) id) → motive ⋯) →
(t : IsUltraUniformity X) → motive t | null | false |
CategoryTheory.OverPresheafAux.counitBackward | Mathlib.CategoryTheory.Comma.Presheaf.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : CategoryTheory.Functor Cᵒᵖ (Type v)} →
(F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) →
(s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) →
CategoryTheory.OverPr... | Backward direction of the counit. | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_principal_iff._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {s t : Set α}, (s ∈ Filter.principal t) = (t ⊆ s) | null | false |
MeasureTheory.etvDist_add_of_ac_of_mutuallySingular | Mathlib.MeasureTheory.Measure.TotalVariation.Basic | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν] {μ' : MeasureTheory.Measure 𝓧} [MeasureTheory.IsFiniteMeasure μ'],
μ.AbsolutelyContinuous ν →
μ'.MutuallySingular ν → MeasureTheory.etvDist (μ + μ') ν = MeasureTheor... | null | true |
ReaderT.instAlternativeOfMonad | Init.Control.Reader | {m : Type u_1 → Type u_2} → {ρ : Type u_1} → [Alternative m] → [Monad m] → Alternative (ReaderT ρ m) | null | true |
TrivialLieModule | Mathlib.Algebra.Lie.Abelian | Type u_1 → Type u_2 → Type u_3 → Type u_3 | A type synonym for an `R`-module to have a trivial Lie module structure. | true |
_private.Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy.0.HomotopicalAlgebra.BifibrantObject.instIsLocalizationCompFibrantObjectιFibrantObjectWeakEquivalences._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(L : CategoryTheory.Functor (HomotopicalAlgebra.FibrantObject C) D)
[L.IsLocalization (HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra... | null | false |
Real.rpow_lt_self_of_lt_one | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ}, 0 < x → x < 1 → 1 < y → x ^ y < x | null | true |
Mathlib.Tactic.Ring.RatCoeff.mk | Mathlib.Tactic.Ring.Common | {u : Lean.Level} → {α : Q(Type u)} → {e : Q(«$α»)} → ℚ → Option Lean.Expr → Mathlib.Tactic.Ring.RatCoeff e | null | true |
essSup_comp_le_essSup_map_measure._auto_1 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
OpenPartialHomeomorph.coe_ofContinuousOpen_symm | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialEquiv X Y)
(hc : ContinuousOn (↑e) e.source) (ho : IsOpenMap ↑e) (hs : IsOpen e.source),
↑(OpenPartialHomeomorph.ofContinuousOpen e hc ho hs).symm = ↑e.symm | null | true |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.applyImplementedBy?.match_1 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((declNameNew : Lean.Name) → motive (some declNameNew)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
Submodule.smul_mono | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A] {M : Type u_1}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M]
{I J : Submodule R A} {N P : Submodule R M}, I ≤ J → N ≤ P → I • N ≤ J • P | null | true |
Lean.Grind.CutsatConfig.ext._inherited_default | Init.Grind.Config | Bool | null | false |
ContinuousMultilinearMap.alternatization.eq_1 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N] [inst_8 : Fintype ι] [inst_9 : DecidableEq... | null | true |
Rat.ofInt._proof_1 | Init.Data.Rat.Basic | ∀ (num : ℤ), num.natAbs.Coprime 1 | null | false |
Std.Http.URI.EncodedFragment | Std.Http.Data.URI.Encoding | Type | A percent-encoded URI fragment component. Valid characters are `pchar / "/" / "?"`.
| true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.neg_bmod._proof_1_5 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} {b : ℕ}, b > 0 → ¬-((↑b + 1) / 2) < 0 → False | null | false |
List.filterTR.loop._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α → List α | null | false |
bihimp_hnot_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), bihimp a aᶜ = ⊥ | **Alias** of `bihimp_compl_self`. | true |
Mathlib.Tactic.CategoryTheory.ToApp.toNatTransExpr | Mathlib.Tactic.CategoryTheory.ToApp | Lean.Expr → Lean.MetaM Lean.Expr | Given morphisms `f g : C ⟶ D` in the bicategory `Cat`, and an equation `η = θ` between 2-morphisms
(possibly after a `∀` binder), produce the equation `η.toNatTrans = θ.toNatTrans`
| true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.InductionObj.coeffSubmodule.eq_1 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (R₀ : Type u_1) {R : Type u_2} [inst : CommRing R₀] [inst_1 : CommRing R] [inst_2 : Algebra R₀ R] {n : ℕ}
(e : ChevalleyThm.PolynomialC.InductionObj✝ R n),
ChevalleyThm.PolynomialC.InductionObj.coeffSubmodule✝ R₀ e =
Submodule.span R₀ ({1} ∪ ⋃ i, Set.range ⇑(ChevalleyThm.PolynomialC.InductionObj.val✝ e i).coe... | null | true |
CategoryTheory.subterminalsEquivMonoOverTerminal._proof_11 | Mathlib.CategoryTheory.Subterminal | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasTerminal C]
(X : CategoryTheory.Subterminals C),
CategoryTheory.CategoryStruct.comp
({ obj := fun X => { obj := CategoryTheory.Over.mk (CategoryTheory.Limits.terminal.from X.obj), property := ⋯ },
map... | null | false |
IsMin.pred_eq | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a : α}, IsMin a → Order.pred a = a | **Alias** of the reverse direction of `Order.pred_eq_iff_isMin`. | true |
MonoidHom.subgroupComap | Mathlib.Algebra.Group.Subgroup.Map | {G : Type u_1} →
{G' : Type u_2} →
[inst : Group G] → [inst_1 : Group G'] → (f : G →* G') → (H' : Subgroup G') → ↥(Subgroup.comap f H') →* ↥H' | The `MonoidHom` from the preimage of a subgroup to itself. | true |
Lake.ComparatorOp.ne.sizeOf_spec | Lake.Util.Version | sizeOf Lake.ComparatorOp.ne = 1 | null | true |
_private.Std.Http.Data.Headers.Value.0.Std.Http.Header.instDecidableEqValue.decEq._proof_2 | Std.Http.Data.Headers.Value | ∀ (a : String) (a_1 : Std.Http.Header.IsValidHeaderValue a),
{ value := a, isValidHeaderValue := a_1 } = { value := a, isValidHeaderValue := a_1 } | null | false |
CategoryTheory.SimplicialThickening.Path.mk.sizeOf_spec | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] {i j : J} [inst_1 : SizeOf J] (I : Set J)
(left : autoParam (i ∈ I) CategoryTheory.SimplicialThickening.Path.left._autoParam)
(right : autoParam (j ∈ I) CategoryTheory.SimplicialThickening.Path.right._autoParam)
(left_le : autoParam (∀ k ∈ I, i ≤ k) CategoryTheory.Simplicia... | null | true |
_private.Lake.Util.Version.0.Lake.parseVerComponents.go._unary.eq_def | Lake.Util.Version | ∀ (s : String) (_x : (_ : Array String.Slice) ×' (iniPos : s.Pos) ×' (p : s.Pos) ×' iniPos ≤ p),
Lake.parseVerComponents.go._unary✝ s _x =
PSigma.casesOn _x fun cs iniPos =>
PSigma.casesOn iniPos fun iniPos p =>
PSigma.casesOn p fun p iniPos_le =>
if h : p = s.endPos then
have ... | null | false |
Polynomial.evalEval | Mathlib.Algebra.Polynomial.Bivariate | {R : Type u_1} → [inst : Semiring R] → R → R → Polynomial (Polynomial R) → R | `evalEval x y p` is the evaluation `p(x,y)` of a two-variable polynomial `p : R[X][Y]`. | true |
CategoryTheory.ShortComplex.comp_τ₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁₂ : S₁ ⟶ S₂) (φ₂₃ : S₂ ⟶ S₃),
(CategoryTheory.CategoryStruct.comp φ₁₂ φ₂₃).τ₃ = CategoryTheory.CategoryStruct.comp φ₁₂.τ₃ φ₂₃.τ₃ | null | true |
Lean.Lsp.SignatureHelpContext.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpTriggerKind → Option String → Bool → Option Lean.Lsp.SignatureHelp → Lean.Lsp.SignatureHelpContext | null | false |
HasStrictDerivAt.of_notMem_tsupport | Mathlib.Analysis.Calculus.Deriv.Support | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, x ∉ tsupport f → HasStrictDerivAt f 0 x | null | true |
Std.HashMap.getKey_eq_get_getKey? | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α} {h : a ∈ m}, m.getKey a h = (m.getKey? a).get ⋯ | null | true |
_private.Std.Http.Test.Helpers.0.Std.Http.Internal.Test.check.match_1 | Std.Http.Test.Helpers | (motive : Std.Http.Internal.Mock.Client × Std.Http.Internal.Mock.Server → Sort u_1) →
(x : Std.Http.Internal.Mock.Client × Std.Http.Internal.Mock.Server) →
((client : Std.Http.Internal.Mock.Client) → (server : Std.Http.Internal.Mock.Server) → motive (client, server)) →
motive x | null | false |
CategoryTheory.Functor.EssSurj.rec | Mathlib.CategoryTheory.EssentialImage | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.EssSurj → Sort u} →
((mem_essImage : ∀ (Y : D), F.essImage Y) → motive ⋯) → (t : F.EssSurj) → motive t | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.CacheKey.mk.noConfusion | Lean.Compiler.LCNF.ToLCNF | {P : Sort u} →
{expr : Lean.Expr} →
{expectedType? : Option Lean.Expr} →
{ignoreNoncomputable : Bool} →
{expr' : Lean.Expr} →
{expectedType?' : Option Lean.Expr} →
{ignoreNoncomputable' : Bool} →
{ expr := expr, expectedType? := expectedType?, ignoreNoncomputable ... | null | false |
TopCat.GlueData.fromOpenSubsetsGlue_isOpenEmbedding | Mathlib.Topology.Gluing | ∀ {α : Type u} [inst : TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U)) | null | true |
Monoid.CoprodI.Word.Pair._sizeOf_inst | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
(M : ι → Type u_2) →
{inst : (i : ι) → Monoid (M i)} →
(i : ι) → [SizeOf ι] → [(a : ι) → SizeOf (M a)] → SizeOf (Monoid.CoprodI.Word.Pair M i) | null | false |
DiffeologicalSpace.CorePlotsOn.noConfusionType | Mathlib.Geometry.Diffeology.Basic | Sort u →
{X : Type u_1} → DiffeologicalSpace.CorePlotsOn X → {X' : Type u_1} → DiffeologicalSpace.CorePlotsOn X' → Sort u | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.logb_eq_zero._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (a / b = 0) = (a = 0 ∨ b = 0) | null | false |
FirstOrder.Language.infiniteTheory | Mathlib.ModelTheory.Syntax | (L : FirstOrder.Language) → L.Theory | A theory indicating that a structure is infinite. | true |
Std.Http.URI.Origin._sizeOf_1 | Std.Http.Data.URI.Basic | Std.Http.URI.Origin → ℕ | null | false |
ComplexShape.Embedding.AreComplementary.Boundary.equiv._proof_10 | Mathlib.Algebra.Homology.Embedding.AreComplementary | ∀ {ι : Type u_2} {ι₁ : Type u_3} {ι₂ : Type u_1} {c : ComplexShape ι} {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{e₁ : c₁.Embedding c} {e₂ : c₂.Embedding c} (ac : e₁.AreComplementary e₂) (i₂ : ι₂) (h : e₂.BoundaryGE i₂),
(fun x =>
match x with
| ⟨i₁, h⟩ => ⟨ComplexShape.Embedding.AreComplementary... | null | false |
Mathlib.Meta.SetNotationForOrder.ssupsetStx' | Mathlib.Tactic.SetNotationForOrder | Lean.TrailingParserDescr | Strict superset relation: `a ⊃ b`.
For types tagged with `@[use_set_notation_for_order]`,
the relation `GT.gt` is used instead of `SSuperset`.
The hover info shows which one is used.
Conventions for notations in identifiers:
* The recommended spelling of `⊃` in identifiers is `ssuperset`. | true |
LieDerivation.lie_der_ad_eq_ad_der | Mathlib.Algebra.Lie.AdjointAction.Derivation | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(D : LieDerivation R L L) (x : L), ⁅D, (LieDerivation.ad R L) x⁆ = (LieDerivation.ad R L) (D x) | The commutator of a derivation `D` and a derivation of the form `ad x` is `ad (D x)`. | true |
HasFDerivAt.fst | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {f₂ : E → F × G} {f₂' : E →L[... | null | true |
CategoryTheory.MonoidalCategoryStruct.mk | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[𝒞 : CategoryTheory.Category.{v, u} C] →
(tensorObj : C → C → C) →
((X : C) → {Y₁ Y₂ : C} → (Y₁ ⟶ Y₂) → (tensorObj X Y₁ ⟶ tensorObj X Y₂)) →
({X₁ X₂ : C} → (X₁ ⟶ X₂) → (Y : C) → tensorObj X₁ Y ⟶ tensorObj X₂ Y) →
({X₁ Y₁ X₂ Y₂ : C} → (X₁ ⟶ Y₁) → (X₂ ⟶ Y₂) → (tensorObj X₁ X₂... | null | true |
MvPolynomial.finsum_weightedHomogeneousComponent | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M)
(φ : MvPolynomial σ R), ∑ᶠ (m : M), (MvPolynomial.weightedHomogeneousComponent w m) φ = φ | null | true |
Finmap.notMem_erase_self | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Finmap β}, a ∉ Finmap.erase a s | null | true |
Mathlib.Tactic.Sat.LRATStep.add.injEq | Mathlib.Tactic.Sat.FromLRAT | ∀ (id : ℕ) (lits proof : Array ℤ) (id_1 : ℕ) (lits_1 proof_1 : Array ℤ),
(Mathlib.Tactic.Sat.LRATStep.add id lits proof = Mathlib.Tactic.Sat.LRATStep.add id_1 lits_1 proof_1) =
(id = id_1 ∧ lits = lits_1 ∧ proof = proof_1) | null | true |
LinearMap.mem_fixedSubmodule_iff._simp_1 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_1} [inst : Semiring R] {V : Type u_3} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] {f : V →ₗ[R] V}
{v : V}, (v ∈ f.fixedSubmodule) = (f v = v) | null | false |
CategoryTheory.Equivalence.instMonoidalFunctorTrans._proof_22 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_mapComp_inv_τr | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {a b c : CategoryTheory.LocallyDiscrete AlgebraicGeometry.Schemeᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c),
(AlgebraicGeometry.Scheme.Modules.pseudofunctor.mapComp x x_1).inv.τr =
CategoryTheory.NatTrans.toCatHom₂ (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.as.unop x.as.unop).inv | null | true |
NumberField.InfinitePlace.IsRamified | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | (k : Type u_1) →
[inst : Field k] → {K : Type u_2} → [inst_1 : Field K] → [Algebra k K] → NumberField.InfinitePlace K → Prop | An infinite place is ramified in a field extension if it is not unramified.
| true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.equiv_iff_toList_perm_toList.match_1_2 | Std.Data.DHashMap.Internal.RawLemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((x : α) → (y : β) → motive (x, y)) → motive x | null | false |
HasCompactMulSupport.is_one_at_infty | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_2} {γ : Type u_5} [inst : TopologicalSpace α] [inst_1 : One γ] {f : α → γ} [inst_2 : TopologicalSpace γ],
HasCompactMulSupport f → Filter.Tendsto f (Filter.cocompact α) (nhds 1) | If `f` has compact multiplicative support, then `f` tends to 1 at infinity. | true |
_private.Mathlib.Data.Finset.Sups.0.Finset.disjSups_comm._simp_1_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = Disjoint b a | null | false |
Associates.instCommMonoid._proof_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M]
(_x_1 : ∀ (a' b' c' : Associates M) (a b c : M), ⟦a⟧ * ⟦b⟧ * ⟦c⟧ = ⟦a⟧ * (⟦b⟧ * ⟦c⟧)),
(∀ (x : Associates M), x ^ 0 = 1) → ∀ (x : Associates M), x ^ 0 = 1 | null | false |
PrimeSpectrum.rankAtStalk_pos_iff_comap_surjective | Mathlib.RingTheory.Flat.Rank | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Module.Flat R S]
[Module.Finite R S],
(∀ (p : PrimeSpectrum R), 0 < Module.rankAtStalk S p) ↔ Function.Surjective (PrimeSpectrum.comap (algebraMap R S)) | The rank is positive at all stalks if and only if the induced map on prime spectra is
surjective. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
{inst : Hashable α} →
{inst_1 : DecidableEq α} →
{aig : Std.Sat.AIG α} → {len : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len → ℕ | null | false |
Matrix.toLin'_apply | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Matrix m n R) (v : n → R), (Matrix.toLin' M) v = M.mulVec v | null | true |
Ideal.comap | Mathlib.RingTheory.Ideal.Maps | {R : Type u} →
{S : Type v} →
{F : Type u_1} →
[inst : Semiring R] →
[inst_1 : Semiring S] → [inst_2 : FunLike F R S] → F → [RingHomClass F R S] → Ideal S → Ideal R | `I.comap f` is the preimage of `I` under `f`. | true |
Valuation.absoluteValue._proof_3 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : DivisionRing L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation L Γ₀) [hv : v.RankLeOne] (x : L), v.norm x = 0 ↔ x = 0 | null | false |
String.Pos.Raw.instLawfulOrderBEq | Init.Data.String.OrderInstances | Std.LawfulOrderBEq String.Pos.Raw | null | true |
_private.Lean.Meta.Tactic.Grind.CheckResult.0.Lean.Meta.Grind.CheckResult.lt.match_1 | Lean.Meta.Tactic.Grind.CheckResult | (motive : Lean.Meta.Grind.CheckResult → Lean.Meta.Grind.CheckResult → Sort u_1) →
(r₁ r₂ : Lean.Meta.Grind.CheckResult) →
((x : Lean.Meta.Grind.CheckResult) → motive x Lean.Meta.Grind.CheckResult.none) →
((x : Lean.Meta.Grind.CheckResult) → motive Lean.Meta.Grind.CheckResult.none x) →
((x : Lean.Met... | null | false |
Polynomial.cauchyBound_X_sub_C | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (x : K), (Polynomial.X - Polynomial.C x).cauchyBound = ‖x‖₊ + 1 | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.termα | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | Lean.ParserDescr | null | true |
Orientation.oangle_rotation_oangle_left | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), o.oangle ((o.rotation (o.oangle x y)) x) y = 0 | Rotating the first vector by the angle between the two vectors results in an angle of 0. | true |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_iff_coborder_mem_nhds._proof_1_1 | Mathlib.Topology.LocallyClosed | 1 ≠ 0 | null | false |
OrderIso.map_sup | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] (f : α ≃o β) (x y : α),
f (x ⊔ y) = f x ⊔ f y | null | true |
LinearMap.iterateRange_succ | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M →ₗ[R] M}
{n : ℕ}, f.iterateRange (n + 1) = Submodule.map f (f.iterateRange n) | null | true |
_private.Lean.Meta.MethodSpecs.0.Lean.startsWithFollowedByNumber | Lean.Meta.MethodSpecs | String → String → Bool | null | true |
HasFiniteFPowerSeriesOnBall.eq_const_of_bound_one | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{pf : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
HasFiniteFPowerSeriesOnBall f pf x 1 ... | If `f` has a formal power series on a ball bounded by `1`, then `f` is constant equal
to `f x` on the ball. | true |
CategoryTheory.Bicategory.Pith.whiskerLeft_iso_inv | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Pith B} (x : a ⟶ b)
(x_1 x_2 : b ⟶ c) (f : x_1 ⟶ x_2),
(CategoryTheory.Bicategory.whiskerLeft x f).iso.inv = CategoryTheory.Bicategory.whiskerLeft x.of f.iso.inv | null | true |
MeasurableSpace.DynkinSystem.ofMeasurableSpace | Mathlib.MeasureTheory.PiSystem | {α : Type u_3} → MeasurableSpace α → MeasurableSpace.DynkinSystem α | Every measurable space (σ-algebra) forms a Dynkin system | true |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.emultiplicity_eq_card_pow_dvd._simp_1_1 | Mathlib.Data.Nat.Multiplicity | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
_private.Mathlib.Topology.UniformSpace.CompactConvergence.0.ContinuousMap.mem_compactConvergence_entourage_iff._simp_1_1 | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
_private.Mathlib.Topology.Algebra.RestrictedProduct.Units.0.RestrictedProduct.eventually_isUnit_of_isUnit._simp_1_3 | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
Bornology.IsVonNBounded.image | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {E : Type u_3} {F : Type u_4} {𝕜₁ : Type u_6} {𝕜₂ : Type u_7} [inst : NormedDivisionRing 𝕜₁]
[inst_1 : NormedDivisionRing 𝕜₂] [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F]
[inst_5 : Module 𝕜₂ F] [inst_6 : TopologicalSpace E] [inst_7 : TopologicalSpace F] {σ : 𝕜₁ →+* 𝕜₂}
[Rin... | A continuous linear image of a bounded set is bounded. | true |
CategoryTheory.IsCardinalAccessibleCategory | Mathlib.CategoryTheory.Presentable.LocallyPresentable | (C : Type u) → [CategoryTheory.Category.{v, u} C] → (κ : Cardinal.{w}) → [Fact κ.IsRegular] → Prop | Given a regular cardinal `κ`, a category `C` is `κ`-accessible
if it has `κ`-filtered colimits and admits a (small) family `G : ι → C` of `κ`-presentable
objects such that any object identifies as a `κ`-filtered colimit of these objects. | true |
MvPowerSeries.le_order_mul | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {f g : MvPowerSeries σ R}, f.order + g.order ≤ (f * g).order | The order of the product of two formal power series
is at least the sum of their orders. | true |
UniformSpace.toTopologicalSpace.hcongr_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ (α α' : Type u),
α = α' →
∀ (self : UniformSpace α) (self' : UniformSpace α'),
self ≍ self' → self.toTopologicalSpace ≍ self'.toTopologicalSpace | null | true |
Finsupp.update_eq_erase_add_single | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] (f : ι →₀ M) (a : ι) (b : M),
f.update a b = Finsupp.erase a f + fun₀ | a => b | null | true |
List.takeI_length | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} [inst : Inhabited α] (n : ℕ) (l : List α), (List.takeI n l).length = n | null | true |
_private.Init.Data.List.Find.0.List.findIdx?_go_nil | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ}, List.findIdx?.go p [] i = none | null | true |
CategoryTheory.InjectiveResolution.homotopyEquiv_hom_ι_assoc | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(I J : CategoryTheory.InjectiveResolution X) {Z : CochainComplex C ℕ} (h : J.cocomplex ⟶ Z),
CategoryTheory.CategoryStruct.comp I.ι (CategoryTheory.CategoryStruct.comp (I.homotopyEquiv J).hom h) =
CategoryTheory... | null | true |
InitialSeg._sizeOf_1 | Mathlib.Order.InitialSeg | {α : Type u_4} →
{β : Type u_5} →
{r : α → α → Prop} →
{s : β → β → Prop} →
[SizeOf α] →
[SizeOf β] → [(a a_1 : α) → SizeOf (r a a_1)] → [(a a_1 : β) → SizeOf (s a a_1)] → InitialSeg r s → ℕ | null | false |
_private.Std.Do.SPred.SVal.0.Std.Do.SVal.uncurry.match_3.eq_2 | Std.Do.SPred.SVal | ∀ {α : Type u_1} (motive : (σs : List (Type u_1)) → Std.Do.SVal σs α → Sort u_2) (head : Type u_1)
(tail : List (Type u_1)) (f : Std.Do.SVal (head :: tail) α) (h_1 : (f : Std.Do.SVal [] α) → motive [] f)
(h_2 : (head : Type u_1) → (tail : List (Type u_1)) → (f : Std.Do.SVal (head :: tail) α) → motive (head :: tail)... | null | true |
TensorProduct.definition._proof_1._@.Mathlib.LinearAlgebra.TensorProduct.Graded.External.2950040696._hygCtx._hyg.8 | Mathlib.LinearAlgebra.TensorProduct.Graded.External | ∀ (R : Type u_1) {ι : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι] (𝒜 : ι → Type u_3)
[inst_2 : CommRing R] [inst_3 : (i : ι) → AddCommGroup (𝒜 i)] [inst_4 : (i : ι) → Module R (𝒜 i)]
[inst_5 : DirectSum.GRing 𝒜] [inst_6 : DirectSum.GAlgebra R 𝒜],
SMulCommClass R (DirectSum ι fun i => 𝒜 i) (Di... | null | false |
Real.rpow_one | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), x ^ 1 = x | null | true |
FractionRing.unique | Mathlib.RingTheory.Localization.FractionRing | (R : Type u_1) → [inst : CommRing R] → [Subsingleton R] → Unique (FractionRing R) | null | true |
lp.instModuleSubtypePreLpMemAddSubgroup._proof_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_3} {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)]
[inst_1 : NormedRing 𝕜] [inst_2 : (i : α) → Module 𝕜 (E i)] [inst_3 : ∀ (i : α), IsBoundedSMul 𝕜 (E i)] (a : 𝕜),
a • 0 = 0 | null | false |
Group.Presentation._sizeOf_1 | Mathlib.GroupTheory.Presentation | {G : Type u_3} → {ι : Type u_4} → {inst : Group G} → [SizeOf G] → [SizeOf ι] → Group.Presentation G ι → ℕ | null | false |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar.match_1 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs rhs : Lean.Expr) → motive (some (fst, lhs, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive __do_lift | null | false |
Mathlib.Tactic.Ring.Common.evalMul₁ | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a b : Q(«$α»)} →
Mathli... | Multiplies a monomial `va` to a polynomial `vb` to get a normalized result polynomial.
* `a * 0 = 0`
* `a * (b₁ + b₂) = (a * b₁) + (a * b₂)`
| true |
AlgebraicGeometry.SmoothOfRelativeDimension.exists_isStandardSmoothOfRelativeDimension | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ {n : ℕ} {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.SmoothOfRelativeDimension n f]
(x : ↥X),
∃ U,
∃ (_ : AlgebraicGeometry.IsAffineOpen U),
∃ V,
∃ (_ : AlgebraicGeometry.IsAffineOpen V) (_ : x ∈ V) (e : V ≤ (TopologicalSpace.Opens.map f.base).obj U),
RingHom.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.