name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.MeasureTheory.Measure.Haar.Quotient.0._aux_Mathlib_MeasureTheory_Measure_Haar_Quotient___macroRules__private_Mathlib_MeasureTheory_Measure_Haar_Quotient_0_termπ_2_1 | Mathlib.MeasureTheory.Measure.Haar.Quotient | Lean.Macro | null | false |
Polynomial.toFinsuppIsoLinear_symm_apply_toFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ (R : Type u) [inst : Semiring R] (a : AddMonoidAlgebra R ℕ), ((Polynomial.toFinsuppIsoLinear R).symm a).toFinsupp = a | null | true |
Mathlib.Meta.NormNum.Result.toSimpResult | Mathlib.Tactic.NormNum.Result | {u : Lean.Level} → {α : Q(Type u)} → {e : Q(«$α»)} → Mathlib.Meta.NormNum.Result e → Lean.MetaM Lean.Meta.Simp.Result | Convert a `Result` to a `Simp.Result`. | true |
Std.TreeMap.getKey!_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
[inst_2 : Inhabited α] {l : List (α × β)} {k : α},
(List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp).getKey! k = default | null | true |
ENat.le_one_iff_eq_zero_or_eq_one | Mathlib.Order.SuccPred.ENat | ∀ {n : ℕ∞}, n ≤ 1 ↔ n = 0 ∨ n = 1 | null | true |
Real.Angle.sign_antiperiodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Function.Antiperiodic Real.Angle.sign ↑Real.pi | null | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.cocone_nonempty._simp_1_3 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
Equiv.Perm.Disjoint.zpow_disjoint_zpow | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {σ τ : Equiv.Perm α}, σ.Disjoint τ → ∀ (m n : ℤ), (σ ^ m).Disjoint (τ ^ n) | null | true |
Aesop.Subgoal.mk._flat_ctor | Aesop.RuleTac.Basic | Aesop.GoalDiff → Aesop.Subgoal | null | false |
Fin.succAboveCases._proof_4 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (i j : Fin (n + 1)) (hj : ¬j = i) (hlt : ¬j < i), i.succAbove (j.pred ⋯) = j | null | false |
CategoryTheory.Mat_.embedding_obj_fintype | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] (X : C),
((CategoryTheory.Mat_.embedding C).obj X).fintype = PUnit.fintype | null | true |
Pi.nonUnitalNormedRing | Mathlib.Analysis.Normed.Ring.Lemmas | {ι : Type u_2} →
{R : ι → Type u_3} → [Fintype ι] → [(i : ι) → NonUnitalNormedRing (R i)] → NonUnitalNormedRing ((i : ι) → R i) | Normed ring structure on the product of finitely many non-unital normed rings, using the sup
norm. | true |
BitVec.DivModArgs.noConfusion | Init.Data.BitVec.Bitblast | {P : Sort u} →
{w : ℕ} →
{t : BitVec.DivModArgs w} →
{w' : ℕ} → {t' : BitVec.DivModArgs w'} → w = w' → t ≍ t' → BitVec.DivModArgs.noConfusionType P t t' | null | false |
Lean.Server.GoToKind.type.sizeOf_spec | Lean.Server.GoTo | sizeOf Lean.Server.GoToKind.type = 1 | null | true |
WeierstrassCurve.Projective.negAddY_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q →
P 2 ≠ 0 →
Q 2 ≠ 0 →
W.negAddY P Q =
((P 1 * Q 2 - Q 1 * P 2) *
((P 1 * Q 2 - Q 1 * P 2) ^ 2 * P 2 * Q 2 +
W.a₁ * (P... | null | true |
Submonoid.toMulOneClass.eq_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_5} [inst : MulOneClass M] (S : Submonoid M), S.toMulOneClass = SubmonoidClass.toMulOneClass S | null | true |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.map_comap_subtype.match_1_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p p' : Submodule R M) (x : M) (motive : x ∈ p ⊓ p' → Prop) (x_1 : x ∈ p ⊓ p'),
(∀ (h₁ : x ∈ ↑p) (h₂ : x ∈ ↑p'), motive ⋯) → motive x_1 | null | false |
_private.Lean.LocalContext.0.Lean.LocalDecl.setBinderInfo.match_1 | Lean.LocalContext | (motive : Lean.LocalDecl → Lean.BinderInfo → Sort u_1) →
(x : Lean.LocalDecl) →
(x_1 : Lean.BinderInfo) →
((index : ℕ) →
(id : Lean.FVarId) →
(n : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(k : Lean.LocalDeclKind) →
... | null | false |
_private.Mathlib.RingTheory.Localization.Module.0.IsLocalizedModule.linearIndependent_lift._simp_1_2 | Mathlib.RingTheory.Localization.Module | ∀ {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X), c • f x = f (c • x) | null | false |
_private.Lean.Meta.NatTable.0.Lean.mkNatLookupTable._auto_3 | Lean.Meta.NatTable | Lean.Syntax | null | false |
map_neg | Mathlib.Algebra.Group.Hom.Defs | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (a : G), f (-a) = -f a | Additive group homomorphisms preserve negation. | true |
FundamentalGroupoidFunctor.proj._proof_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ {I : Type u_1} (X : I → TopCat) (i : I), Continuous fun p => p i | null | false |
SSet.unique_nonDegenerate_dim | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | ∀ (X : SSet) {n : ℕ} (x : X.obj (Opposite.op { len := n })) {m₁ m₂ : ℕ} (f₁ : { len := n } ⟶ { len := m₁ })
[CategoryTheory.Epi f₁] (y₁ : ↑(X.nonDegenerate m₁)),
x = (CategoryTheory.ConcreteCategory.hom (X.map f₁.op)) ↑y₁ →
∀ (f₂ : { len := n } ⟶ { len := m₂ }) [CategoryTheory.Epi f₂] (y₂ : ↑(X.nonDegenerate m₂... | null | true |
DirectSum.Gmodule.toGdistribMulAction | Mathlib.Algebra.Module.GradedModule | {ιA : Type u_1} →
{ιB : Type u_2} →
{A : ιA → Type u_3} →
{M : ιB → Type u_4} →
{inst : AddMonoid ιA} →
{inst_1 : VAdd ιA ιB} →
{inst_2 : (i : ιA) → AddMonoid (A i)} →
{inst_3 : (i : ιB) → AddMonoid (M i)} →
{inst_4 : GradedMonoid.GMonoid A} → [sel... | null | true |
Std.HashSet.Equiv.get?_eq | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
m₁.Equiv m₂ → m₁.get? k = m₂.get? k | null | true |
Lean.Lsp.SymbolKind.string.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 14 → motive Lean.Lsp.SymbolKind.string → motive t | null | false |
AlgEquiv.op._proof_6 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) (x y : A),
(RingEquiv.unop f.toRingEquiv).toFun (x * y) =
(RingEquiv.unop f.toRingEquiv).toFun x * (RingEquiv.unop f.toRingEquiv)... | null | false |
HahnSeries.ofSuppBddBelow_zero._proof_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : LinearOrder Γ] [Nonempty Γ], BddBelow (Function.support 0) | null | false |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesSum._sparseCasesOn_1 | Lean.Meta.MkIffOfInductiveProp | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
MvPolynomial.IsHomogeneous.C_mul | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {φ : MvPolynomial σ R} {m : ℕ},
φ.IsHomogeneous m → ∀ (r : R), (MvPolynomial.C r * φ).IsHomogeneous m | null | true |
Lean.LibrarySuggestions.Config.ctorIdx | Lean.LibrarySuggestions.Basic | Lean.LibrarySuggestions.Config → ℕ | null | false |
Affine.Simplex.excenterWeights_empty_lt_inv_two | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) [n.AtLeastTwo]
(i : Fin (n + 1)), s.excenterWeights ∅ i < 2⁻¹ | The barycentric coordinates of the incenter are less than `2⁻¹` (thus, it lies closer on an
angle bisector to the opposite side than to the vertex, or equivalently the image of the incenter
under a homothety with scale factor 2 about a vertex lies outside the simplex). | true |
Lean.Meta.Grind.TheoremGuard.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.TheoremGuard → Sort u} →
((e : Lean.Expr) → (check : Bool) → motive { e := e, check := check }) → (t : Lean.Meta.Grind.TheoremGuard) → motive t | null | false |
CategoryTheory.CosimplicialObject.cechConerveAdjunction | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] →
CategoryTheory.CosimplicialObject.augmentedCechConerve ⊣ CategoryTheory.CosimplicialObject.Augmented... | The augmented Čech conerve construction is left adjoint to the `toArrow` functor. | true |
AddCon.symm | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {x y : M}, c x y → c y x | Additive congruence relations are symmetric. | true |
Ordnode.Emem.eq_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (x : α), Ordnode.Emem x = Ordnode.Any (Eq x) | null | true |
IsStarNormal.cfc_map | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
_private.Mathlib.RingTheory.Multiplicity.0.Prime.finiteMultiplicity_mul.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p b : α} (motive : FiniteMultiplicity p b → Prop)
(x : FiniteMultiplicity p b), (∀ (m : ℕ) (hm : ¬p ^ (m + 1) ∣ b), motive ⋯) → motive x | null | false |
instCoeTCBiheytingHomOfBiheytingHomClass._proof_2 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_1} [inst : FunLike F α β] [inst_1 : BiheytingAlgebra α]
[inst_2 : BiheytingAlgebra β] [BiheytingHomClass F α β] (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b | null | false |
Int8.shiftLeft_and | Init.Data.SInt.Bitwise | ∀ {a b c : Int8}, (a &&& b) <<< c = a <<< c &&& b <<< c | null | true |
ProofWidgets.«_aux_ProofWidgets_Component_OfRpcMethod___elabRules_ProofWidgets_termMk_rpc_widget%__1» | ProofWidgets.Component.OfRpcMethod | Lean.Elab.Term.TermElab | The elaborator `mk_rpc_widget%` allows writing certain widgets in Lean instead of JavaScript.
Specifically, it translates an RPC method of type `MyProps → RequestM (RequestTask Html)`
into a widget component of type `Component MyProps`.
Even more specifically, we can write:
```lean
open Lean Server
structure MyProps ... | false |
CategoryTheory.ShortComplex.ShortExact.projectiveDimension_X₃_le_sup | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C},
S.ShortExact →
CategoryTheory.projectiveDimension S.X₃ ≤
max (CategoryTheory.projectiveDimension S.X₂) (CategoryTheory.projectiveDimension S.X₁ + 1) | In a short exact complex, the projective dimension of the right object is bounded by
`max (projectiveDimension S.X₂) (projectiveDimension S.X₁ + 1)`. | true |
Finset.sum_mk | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddCommMonoid M] (s : Multiset ι) (hs : s.Nodup) (f : ι → M),
{ val := s, nodup := hs }.sum f = (Multiset.map f s).sum | null | true |
Std.Time.Millisecond.Offset.ofNat | Std.Time.Time.Unit.Millisecond | ℕ → Std.Time.Millisecond.Offset | Creates an `Offset` from a natural number.
| true |
AlgebraicGeometry.Scheme.emptyTo_base | Mathlib.AlgebraicGeometry.Limits | ∀ (X : AlgebraicGeometry.Scheme), X.emptyTo.base = TopCat.ofHom { toFun := fun x => x.elim, continuous_toFun := ⋯ } | null | true |
CategoryTheory.instDecidableEqPairwise.decEq._proof_6 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} (a a_1 b : ι), ¬a_1 = b → ¬CategoryTheory.Pairwise.pair a a_1 = CategoryTheory.Pairwise.pair a b | null | false |
Lean.Environment.contains | Lean.Environment | Lean.Environment → Lean.Name → optParam Bool true → Bool | Checks whether `findAsync?` would return a result.
NOTE: Unlike `findAsync`, this function defaults `skipRealize` to `true` to avoid unnecessary
blocking on realizations, which should always be brought into scope by running `realizeConst`, which
does its own, optimized existence check.
| true |
CauSeq.Completion.instNNRatCast | Mathlib.Algebra.Order.CauSeq.Completion | {α : Type u_1} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
{β : Type u_2} →
[inst_3 : DivisionRing β] →
{abv : β → α} → [inst_4 : IsAbsoluteValue abv] → NNRatCast (CauSeq.Completion.Cauchy abv) | null | true |
AddOpposite.instAddRightCancelSemigroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddLeftCancelSemigroup α], IsRightCancelAdd αᵃᵒᵖ | null | false |
Lean.Meta.Match.AltParamInfo.ctorIdx | Lean.Meta.Match.MatcherInfo | Lean.Meta.Match.AltParamInfo → ℕ | null | false |
IO.Process.Stdio.ctorElimType | Init.System.IO | {motive : IO.Process.Stdio → Sort u} → ℕ → Sort (max 1 u) | null | false |
Representation.IntertwiningMap.coe_add | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (f g : ρ.IntertwiningMap σ), ⇑(f + g) = ⇑f + ⇑g | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Basic.0.MeasureTheory.VectorMeasure.exists_variation_le_add'._simp_1_7 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
AddChar.zmod_add | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {n : ℕ} [inst : NeZero n] (x y : ZMod n), AddChar.zmod n (x + y) = AddChar.zmod n x * AddChar.zmod n y | null | true |
SemiNormedGrp₁.Hom._sizeOf_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp₁} → M.Hom N → ℕ | null | false |
CategoryTheory.JointlyReflectIsomorphisms.mk._flat_ctor | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
(∀ {X Y : C} (f : X ⟶ Y) [∀ (i : I), CategoryTheory.IsIso ((F i).map f)], CategoryTheory.IsIso f) →
Categ... | null | false |
ENNReal.sum_le_tsum | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → ENNReal} (s : Finset α), ∑ x ∈ s, f x ≤ ∑' (x : α), f x | null | true |
_private.Mathlib.Algebra.Order.Round.0.round_neg_two_inv._simp_1_1 | Mathlib.Algebra.Order.Round | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : FloorRing α] {x : α}
{n : ℤ}, (round x = n) = (x ∈ Set.Ico (↑n - 1 / 2) (↑n + 1 / 2)) | null | false |
eVariationOn.comp_le_of_monotoneOn | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : TopologicalSpace E] [inst_2 : WeakPseudoEMetricSpace E]
{β : Type u_4} [inst_3 : LinearOrder β] (f : α → E) {s : Set α} {t : Set β} (φ : β → α),
MonotoneOn φ t → Set.MapsTo φ t s → eVariationOn (f ∘ φ) t ≤ eVariationOn f s | null | true |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_1 | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : PartialOrder N] {f : ι → N} {s : Finset ι}
[IsOrderedAddMonoid N], (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i = 0) = ∀ i ∈ s, f i = 0 | null | false |
Aesop.Frontend.TacticConfig.erasedRules | Aesop.Frontend.Tactic | Aesop.Frontend.TacticConfig → Array Aesop.Frontend.RuleExpr | null | true |
AlgebraicGeometry.instMonObjSpecAsOverSpec | Mathlib.AlgebraicGeometry.Group.Affine | {R A : CommRingCat} →
[inst : Bialgebra ↑R ↑A] → CategoryTheory.MonObj ((AlgebraicGeometry.Spec A).asOver (AlgebraicGeometry.Spec R)) | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo._simp_1_10 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a * a ^ n = a ^ (1 + n) | null | false |
Std.Packages.LinearPreorderOfLEArgs.isGE_compare | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearPreorderOfLEArgs α),
let this := self.le;
let this_1 := self.decidableLE;
have this_2 := ⋯;
let this_3 := self.ord;
∀ (a b : α), (compare a b).isGE = true ↔ b ≤ a | null | true |
Std.Http.Protocol.H1.RedirectPlan.headers | Std.Http.Protocol.H1.Redirect | Std.Http.Protocol.H1.RedirectPlan → Std.Http.Headers | Headers for the redirected request after cross-origin and method-change scrubbing.
| true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.zetaMul_prime_pow_nonneg._simp_1_3 | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Lean.Language.Lean.HeaderProcessedState | Lean.Language.Lean.Types | Type | State after successful importing. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int16.reduceBNe._regBuiltin.Int16.reduceBNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.1259268813._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
MoritaEquivalence.ofAlgEquiv | Mathlib.RingTheory.Morita.Basic | {R : Type u₀} →
[inst : CommSemiring R] →
{A : Type u₁} →
{B : Type u₂} →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] → [inst_3 : Ring B] → [inst_4 : Algebra R B] → (A ≃ₐ[R] B) → MoritaEquivalence R A B | Isomorphic `R`-algebras are Morita equivalent.
| true |
_private.Mathlib.CategoryTheory.Monoidal.Free.Coherence.0.CategoryTheory.FreeMonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Free_Coherence___macroRules__private_Mathlib_CategoryTheory_Monoidal_Free_Coherence_0_CategoryTheory_FreeMonoidalCategory_termF_1 | Mathlib.CategoryTheory.Monoidal.Free.Coherence | Lean.Macro | null | false |
WeierstrassCurve.Projective.nonsingular_some | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (a b : R),
W'.Nonsingular ![a, b, 1] ↔ W'.toAffine.Nonsingular a b | null | true |
_private.Lean.Compiler.LCNF.PropagateBorrow.0.Lean.Compiler.LCNF.Decl.analyzePropagatedBorrows.collectCode._sparseCasesOn_1 | Lean.Compiler.LCNF.PropagateBorrow | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.Arg pu → Sort u} →
(t : Lean.Compiler.LCNF.Arg pu) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Rat.ctorIdx | Init.Data.Rat.Basic | ℚ → ℕ | null | false |
Lean.Elab.Deriving.Context.noConfusionType | Lean.Elab.Deriving.Util | Sort u → Lean.Elab.Deriving.Context → Lean.Elab.Deriving.Context → Sort u | null | false |
MeasureTheory.lintegral_deriv_eq_volume_image_of_monotoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
MonotoneOn f s → ∫⁻ (x : ℝ) in s, ENNReal.ofReal (f' x) = MeasureTheory.volume (f '' s) | Change of variable formula for differentiable functions, set version: if a real function `f` is
monotone and differentiable on a measurable set `s`, then the measure of `f '' s` is given by the
integral of `f' x` on `s` .
Note that the measurability of `f '' s` is given by `MeasurableSet.image_of_monotoneOn`. | true |
Function.bicompl.bifunctor | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} →
[Bifunctor F] →
(G : Type u_1 → Type u₀) → (H : Type u_2 → Type u₁) → [Functor G] → [Functor H] → Bifunctor (Function.bicompl F G H) | null | true |
AlgEquiv.mopMatrix_apply | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {R : Type u_4} {α : Type u_8} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : CommSemiring R]
[inst_3 : Semiring α] [inst_4 : Algebra R α] (M : Matrix m m αᵐᵒᵖ),
AlgEquiv.mopMatrix M = MulOpposite.op (M.transpose.map MulOpposite.unop) | null | true |
QuasiIsoAt.quasiIso | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} {inst : CategoryTheory.Category.{v, u} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {c : ComplexShape ι} {K L : HomologicalComplex C c} {f : K ⟶ L}
{i : ι} {inst_2 : K.HasHomology i} {inst_3 : L.HasHomology i} [self : QuasiIsoAt f i],
CategoryTheory.ShortComplex.QuasiIso ((... | null | true |
Path.Homotopy.transReflReparamAux_zero | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Path.Homotopy.transReflReparamAux 0 = 0 | null | true |
Finset.weightedVSub_empty | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_4} (w : ι → k) (p : ι → P), (∅.weightedVSub p) w = 0 | The `weightedVSub` for an empty set is 0. | true |
WType.Natα.zero.elim | Mathlib.Data.W.Constructions | {motive : WType.Natα → Sort u} → (t : WType.Natα) → t.ctorIdx = 0 → motive WType.Natα.zero → motive t | null | false |
_private.Mathlib.LinearAlgebra.Coevaluation.0.contractLeft_assoc_coevaluation._simp_1_2 | Mathlib.LinearAlgebra.Coevaluation | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Polynomial.roots_C_mul_X_sub_C_of_IsUnit | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (b : R) (a : Rˣ),
(Polynomial.C ↑a * Polynomial.X - Polynomial.C b).roots = {↑a⁻¹ * b} | null | true |
Std.ExtDHashMap.get!_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k a : α}
[inst_1 : Inhabited (β a)] {v : β k},
(m.insertIfNew k v).get! a = if h : (k == a) = true ∧ k ∉ m then cast ⋯ v else m.get! a | null | true |
AlgHom.ofClass._proof_3 | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {F : Type u_3} [inst_5 : FunLike F A B] [inst_6 : AlgHomClass F R A B]
(f : F), (↑↑↑f).toFun 0 = 0 | null | false |
LightProfinite.of | Mathlib.Topology.Category.LightProfinite.Basic | (X : Type u_1) →
[inst : TopologicalSpace X] →
[CompactSpace X] → [T2Space X] → [TotallyDisconnectedSpace X] → [SecondCountableTopology X] → LightProfinite | Construct a term of `LightProfinite` from a type endowed with the structure of a compact,
Hausdorff, totally disconnected and second countable topological space.
| true |
Filter.frequently_imp_distrib | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p q : α → Prop},
(∃ᶠ (x : α) in f, p x → q x) ↔ (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x | null | true |
Set.sumEquiv_apply | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} (s : Set (α ⊕ β)), Set.sumEquiv s = (Sum.inl ⁻¹' s, Sum.inr ⁻¹' s) | null | true |
BitVec.shiftLeft_add_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w} {n : ℕ}, (x + y) <<< n = x <<< n + y <<< n | null | true |
SaturatedAddSubmonoid._sizeOf_inst | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → {inst : AddZeroClass M} → [SizeOf M] → SizeOf (SaturatedAddSubmonoid M) | null | false |
SSetPair.homologyMap_id | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (P : SSetPair) (R : C) [inst_3 : CategoryTheory.CategoryWithHomology C]
(n : ℕ),
SSetPair.homologyMap (CategoryTheory.CategoryStruct.id P) R n = CategoryTheory.Ca... | null | true |
Std.DHashMap.Raw.Const.getD_filter' | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{f : α → β → Bool} {k : α} {fallback : β},
m.WF →
Std.DHashMap.Raw.Const.getD (Std.DHashMap.Raw.filter f m) k fallback =
(Option.filter (f k) (Std.DHashMap.Raw.Const.get? m k)).getD fallback | Simpler variant of `getD_filter` when `LawfulBEq` is available. | true |
Set.univ_disjoint._simp_1 | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} {s : Set α}, Disjoint Set.univ s = (s = ∅) | null | false |
_private.Mathlib.Data.List.Sort.0.List.sortedGT_nil._proof_1_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α], [].SortedGT | null | false |
CochainComplex.HomComplex.Cochain.v_comp_XIsoOfEq_inv_assoc | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain F G n) (p q q' : ℤ) (hpq : p + n = q)
(hq' : q' = q) {Z : C} (h : G.X q' ⟶ Z),
CategoryTheory.CategoryStruct.comp (γ.v p q hpq)
(Category... | null | true |
IsLocalization.Away.of_surjective | Mathlib.RingTheory.Localization.Away.Basic | ∀ {S : Type u_4} {T : Type u_5} [inst : CommRing S] [inst_1 : CommRing T] [inst_2 : Algebra S T],
Function.Surjective ⇑(algebraMap S T) →
∀ {r : S},
IsUnit ((algebraMap S T) r) → ∀ (n : ℕ), r ^ n • RingHom.ker (algebraMap S T) ≤ ⊥ → IsLocalization.Away r T | Suppose `I` is an ideal of `R`, then `R / I` is the localization away from `r : R`
if `r - 1 ∈ I` and for some `n`, `r ^ n • I = ⊥`.
For sake of usability, we state this for surjective ring maps instead of ideals.
For a version with two ideals, see `Away.of_sub_one_mem_ker'`. | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.let.docString_3 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified.0.AlgebraicGeometry.FormallyUnramified.instIsSeparableCarrierResidueFieldCoeContinuousMapCarrierCarrierCommRingCatHomTopCatBaseOfLocallyOfFiniteType._proof_1 | Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X),
IsLocalHom (algebraMap ↑(Y.presheaf.stalk (f x)) ↑(X.presheaf.stalk x)) | null | false |
_private.Init.Data.List.MapIdx.0.List.mapFinIdx_append._proof_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {xs ys : List α}, ∀ i < xs.length, ¬i < xs.length + ys.length → False | null | false |
isSpectralMap_id | Mathlib.Topology.Spectral.Hom | ∀ {α : Type u_2} [inst : TopologicalSpace α], IsSpectralMap id | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.