name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProofWidgets.InteractiveCodeProps.ctorIdx | ProofWidgets.Component.Basic | ProofWidgets.InteractiveCodeProps → ℕ | null | false |
MeromorphicOn.divisor_of_toMeromorphicNFOn | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜},
MeromorphicOn f U → MeromorphicOn.divisor (toMeromorphicNFOn f U) U = MeromorphicOn.divisor f U | Conversion of normal form does not affect divisors. | true |
CategoryTheory.Functor.map_hom_inv'_apply | Mathlib.CategoryTheory.Types.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ≅ Y) {F_1 : D → D → Type uF} {carrier : D → Type w}
{instFunLike : (X Y : D) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : CategoryTheory.Co... | null | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.minEntry?.match_1.eq_3 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (k : α) (v : β k)
(size_1 : ℕ) (k_1 : α) (v_1 : β k_1) (l r r_1 : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
... | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.NewFact.toExpr.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Grind.NewFact → Sort u_1) →
(x : Lean.Meta.Grind.NewFact) →
((lhs rhs proof : Lean.Expr) → (isHEq : Bool) → motive (Lean.Meta.Grind.NewFact.eq lhs rhs proof isHEq)) →
((p proof : Lean.Expr) → (generation : ℕ) → motive (Lean.Meta.Grind.NewFact.fact p proof generation)) → motive x | null | false |
Nat.instCeilDiv._proof_4 | Mathlib.Algebra.Order.Floor.Div | ∀ (a : ℕ), (0 + a - 1) / a = 0 | null | false |
ContinuousSub.casesOn | Mathlib.Topology.Algebra.Group.Defs | {G : Type u_4} →
[inst : TopologicalSpace G] →
[inst_1 : Sub G] →
{motive : ContinuousSub G → Sort u} →
(t : ContinuousSub G) → ((continuous_sub : Continuous fun p => p.1 - p.2) → motive ⋯) → motive t | null | false |
AffineIndepOn.congr | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} {p q : ι → P} {s : Set ι},
AffineIndepOn k p s → Set.EqOn p q s → AffineIndepOn k q s | null | true |
CategoryTheory.Limits.Fork.ofι_pt | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y} {P : C} (ι : P ⟶ X)
(w : CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g),
(CategoryTheory.Limits.Fork.ofι ι w).pt = P | null | true |
CategoryTheory.HasShift.mk.noConfusion | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_2} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : AddMonoid A} →
{P : Sort u_1} →
{shift : CategoryTheory.Functor (CategoryTheory.Discrete A) (CategoryTheory.Functor C C)} →
{shiftMonoidal : autoParam shift.Monoidal CategoryTheory.HasShift.sh... | null | false |
MeasureTheory.lintegral_mono_ae | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
(∀ᵐ (a : α) ∂μ, f a ≤ g a) → ∫⁻ (a : α), f a ∂μ ≤ ∫⁻ (a : α), g a ∂μ | null | true |
CategoryTheory.Lax.OplaxTrans.Modification.instInhabited | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} → {η : F ⟶ G} → Inhabited (CategoryTheory.Lax.OplaxTrans.Modification η η) | null | true |
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidalObj_μ | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.Mon C) (X Y : CategoryTheory.Discrete PUnit.{u_1 + 1}),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidalObj A) X Y =
CategoryTheory.M... | null | true |
Aesop.BaseRuleSet.noConfusion | Aesop.RuleSet | {P : Sort u} → {t t' : Aesop.BaseRuleSet} → t = t' → Aesop.BaseRuleSet.noConfusionType P t t' | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.card_pair_lcm_eq.f_surj | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {n : ℕ},
n ≠ 0 →
∀
b ∈
{x ∈ n.divisors ×ˢ n.divisors |
match x with
| (x, y) => x.lcm y = n},
∃ a, ∃ (ha : a ∈ Nat.finMulAntidiag 3 n), Nat.card_pair_lcm_eq.f✝ a ha = b | null | true |
OrderHom.curry._proof_6 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(f : α →o β →o γ) (x y : α × β), x ≤ y → (f x.1) x.2 ≤ Function.uncurry (fun x => ⇑(f x)) y | null | false |
_private.Mathlib.Data.Part.0.Part.mem_map_iff.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) {o : Part α} (motive : (b : β) → b ∈ Part.map f o → Prop) (b : β)
(hb : b ∈ Part.map f o), (∀ (w : (Part.map f o).Dom), motive ((Part.map f o).get w) ⋯) → motive b hb | null | false |
Set.image_subtype_val_Iio_Iio | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (b : ↑(Set.Iio a)), Subtype.val '' Set.Iio b = Set.Iio ↑b | null | true |
Matroid.comapOn_dual_eq_of_bijOn | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {N : Matroid β} {E : Set α},
Set.BijOn f E N.E → (N.comapOn E f)✶ = N✶.comapOn E f | null | true |
List.eraseP._sunfold | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α | null | false |
Finset.Icc_min_max | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b : α},
Finset.Icc (min a b) (max a b) = Finset.uIcc a b | null | true |
Order.IsSuccLimit.le_succ_iff | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a b : α} [inst : LinearOrder α] [inst_1 : SuccOrder α],
Order.IsSuccLimit b → (b ≤ Order.succ a ↔ b ≤ a) | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.chevalley_mvPolynomialC._simp_1_8 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] (V : Submodule R M)
(m : M), (m ∈ Submodule.restrictScalars S V) = (m ∈ V) | null | false |
Lean.DataValue.ofInt.inj | Lean.Data.KVMap | ∀ {v v_1 : ℤ}, Lean.DataValue.ofInt v = Lean.DataValue.ofInt v_1 → v = v_1 | null | true |
Subalgebra.fg_of_submodule_fg | Mathlib.RingTheory.Adjoin.FG | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A], ⊤.FG → ⊤.FG | null | true |
finprod_mem_coe_finset | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) (s : Finset α),
∏ᶠ (i : α) (_ : i ∈ ↑s), f i = ∏ i ∈ s, f i | null | true |
CategoryTheory.Monad.beckCofork_pt | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckCofork X).pt = X.A | null | true |
Finset.sup_product_left | Mathlib.Data.Finset.Lattice.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (s : Finset β)
(t : Finset γ) (f : β × γ → α), (s ×ˢ t).sup f = s.sup fun i => t.sup fun i' => f (i, i') | See also `Finset.product_biUnion`. | true |
CategoryTheory.Subfunctor.familyOfElementsOfSection | Mathlib.CategoryTheory.Subfunctor.Sieves | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
(G : CategoryTheory.Subfunctor F) →
{U : Cᵒᵖ} → (s : F.obj U) → CategoryTheory.Presieve.FamilyOfElements G.toFunctor (G.sieveOfSection s).arrows | Given an `F`-section `s` on `U` and a subpresheaf `G`, we may define a family of elements in
`G` consisting of the restrictions of `s` | true |
Mathlib.Tactic.Widget.StringDiagram.Node._sizeOf_inst | Mathlib.Tactic.Widget.StringDiagram | SizeOf Mathlib.Tactic.Widget.StringDiagram.Node | null | false |
_private.Lean.Meta.Tactic.Grind.MatchDiscrOnly.0.Lean.Meta.Grind.reduceSimpMatchDiscrsOnly.match_6 | Lean.Meta.Tactic.Grind.MatchDiscrOnly | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
SSet.stdSimplex.nonDegenerateEquiv'_iff | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n d : ℕ} (x : ↑((SSet.stdSimplex.obj { len := n }).nonDegenerate d)) (j : Fin (n + 1)),
j ∈ ↑(SSet.stdSimplex.nonDegenerateEquiv' x) ↔ ∃ i, ↑x i = j | null | true |
Rep.indToCoind | Mathlib.RepresentationTheory.FiniteIndex | {k : Type u} →
{G : Type v} →
[inst : CommRing k] →
[inst_1 : Group G] →
{S : Subgroup G} →
[DecidableRel ⇑(QuotientGroup.rightRel S)] →
(A : Rep.{w, u, v} k ↥S) → ↑(Rep.ind S.subtype A) →ₗ[k] ↑(Rep.coind.{u, v, v, w} S.subtype A) | Let `S ≤ G` be a subgroup and `A` a `k`-linear `S`-representation. This is the `k`-linear map
`Ind_S^G(A) →ₗ[k] Coind_S^G(A)` sending `(⟦g ⊗ₜ[k] a⟧, sg) ↦ ρ(s)(a)`. | true |
Std.DHashMap.Internal.AssocList.alter._f | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
(a : α) →
(Option (β a) → Option (β a)) →
(x : Std.DHashMap.Internal.AssocList α β) →
Std.DHashMap.Internal.AssocList.below x → Std.DHashMap.Internal.AssocList α β | null | false |
CategoryTheory.CostructuredArrow.grothendieckPrecompFunctorEquivalence._proof_6 | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_3, u_6} D] {E : Type u_1} [inst_2 : CategoryTheory.Category.{u_2, u_1} E]
(L : CategoryTheory.Functor C D) (R : CategoryTheory.Functor E D)
(X : CategoryTheory.Grothendieck (R.comp (CategoryTheory.Co... | null | false |
HomotopicalAlgebra.PrepathObject.RightHomotopy.fullSubcategoryEquiv | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{X Y : P.FullSubcategory} →
{Q : HomotopicalAlgebra.PrepathObject Y} →
{f g : X ⟶ Y} → Q.RightHomotopy f g ≃ (Q.map P.ι).RightHomotopy f.hom g.hom | Right homotopies in a full subcategory identify to right homotopies in the
ambient category. | true |
SSet.PtSimplex.MulStruct.casesOn | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op { len := 0 })} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
{motive : f.MulStruct g fg i → Sort u_1} →
(t : f.MulStruct g fg i) →
((map : SSet.stdSimplex.obj { len := n + 1 } ⟶ X) →
(δ_castSucc_castS... | null | false |
PUnit.instSMul_mathlib.eq_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_1}, PUnit.instSMul_mathlib = { smul := fun x x_1 => x_1 } | null | true |
Lean.Grind.Ring.OfSemiring.instLEQOfOrderedAdd | Init.Grind.Ring.Envelope | {α : Type u} →
[inst : Lean.Grind.Semiring α] →
[inst_1 : LE α] → [inst_2 : Std.IsPreorder α] → [Lean.Grind.OrderedAdd α] → LE (Lean.Grind.Ring.OfSemiring.Q α) | null | true |
Cardinal.prod | Mathlib.SetTheory.Cardinal.Defs | {ι : Type u} → (ι → Cardinal.{u_1}) → Cardinal.{max u u_1} | The indexed product of cardinals is the cardinality of the Pi type
(dependent product). | true |
Lean.Meta.DiscrTree.Trie.rec_2 | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive_1 : Lean.Meta.DiscrTree.Trie α → Sort u} →
{motive_2 : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_3 : List (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_4 : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → ... | null | false |
CategoryTheory.Functor.const.opObjOp._proof_2 | Mathlib.CategoryTheory.Functor.Const | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (X : C) ⦃X_1 Y : Jᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj X).op.map f)
(CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.... | null | false |
AlgebraicGeometry.LocallyRingedSpace.instFieldCarrierResidueField._proof_22 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) (x : ↑X.toTopCat),
autoParam (∀ (q : ℚ), ↑q = ↑q.num / ↑q.den) DivisionRing.ratCast_def._autoParam | null | false |
Equiv.Set.congr_apply | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} {s t : Set α} (h : s = t) (a : { a // (fun x => x ∈ s) a }), (Set.equivOfEq h) a = ⟨↑a, ⋯⟩ | **Alias** of `Set.equivOfEq_apply`. | true |
_private.Mathlib.Tactic.DeriveTraversable.0.Mathlib.Deriving.Traversable.getAuxDefOfDeclName.match_1 | Mathlib.Tactic.DeriveTraversable | (motive : List Lean.FVarId → Sort u_1) →
(fvars : List Lean.FVarId) →
(Unit → motive []) → ((fvar : Lean.FVarId) → motive [fvar]) → ((x : List Lean.FVarId) → motive x) → motive fvars | null | false |
Std.Time.Modifier.y | Std.Time.Format.Modifier | Std.Time.Year → Std.Time.Modifier | `y`: Year of era (e.g., 2004, 04, 0002, 2). Never negative: year 1 BC is formatted as `1` paired with a BC era
designator. Use `u` instead when you need the proleptic/astronomical year (which can be negative).
| true |
nhdsSet_le | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {f : Filter X} {s : Set X}, nhdsSet s ≤ f ↔ ∀ x ∈ s, nhds x ≤ f | null | true |
Metric.forall_of_forall_mem_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (p : α → Prop) (x : α),
(∃ᶠ (R : ℝ) in Filter.atTop, ∀ y ∈ Metric.ball x R, p y) → ∀ (y : α), p y | If a property holds for all points in balls of arbitrarily large radii, then it holds for all
points. | true |
List.getLastI.eq_def | Mathlib.Data.List.Basic | ∀ {α : Type u_1} [inst : Inhabited α] (x : List α),
x.getLastI =
match x with
| [] => default
| [a] => a
| [head, b] => b
| head :: head_1 :: l => l.getLastI | null | true |
DFinsupp.sum_mapRange_index.linearMap | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
{β₁ : ι → Type u_8} {β₂ : ι → Type u_9} [inst_3 : (i : ι) → AddCommMonoid (β₁ i)]
[inst_4 : (i : ι) → AddCommMonoid (β₂ i)] [inst_5 : (i : ι) → Module R (β₁ i)] [inst_6 : (i : ι) → Module R (β₂ i)]
... | null | true |
BoundedContinuousFunction.instPartialOrder | Mathlib.Topology.ContinuousMap.Bounded.Normed | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : NormedAddCommGroup β] → [Lattice β] → PartialOrder (BoundedContinuousFunction α β) | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt8.ofNat_mod._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt8), (UInt8.ofNat a = b) = (a % 2 ^ 8 = b.toNat) | null | false |
affineSpan_convexHull | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), affineSpan 𝕜 ((convexHull 𝕜) s) = affineSpan 𝕜 s | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_filterMap._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Real.sin_pi_div_eight | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Real.sin (Real.pi / 8) = √(2 - √2) / 2 | null | true |
Equiv.lieAlgebra | Mathlib.Algebra.Lie.TransferInstance | {R : Type u_1} →
{M : Type u_2} →
{L : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → [inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (e : M ≃ₗ[R] L) → LieAlgebra R M | **Alias** of `LinearEquiv.lieAlgebra`.
---
Transfer `LieAlgebra` across a `LinearEquiv` | true |
Vector.prod_eq_foldl | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : One α] [inst_1 : Mul α] [Std.Associative fun x1 x2 => x1 * x2]
[Std.LawfulIdentity (fun x1 x2 => x1 * x2) 1] {xs : Vector α n}, xs.prod = Vector.foldl (fun x1 x2 => x1 * x2) 1 xs | null | true |
MvPolynomial.universalFactorizationMap._proof_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (m : ℕ), SMulCommClass R R (MvPolynomial (Fin m) R) | null | false |
AlgebraicGeometry.Scheme.germ_stalkClosedPointTo_Spec_fromSpecStalk | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {R : CommRingCat} [inst : IsLocalRing ↑R] {x : ↥X} (f : X.presheaf.stalk x ⟶ R)
[inst_1 : IsLocalHom (CommRingCat.Hom.hom f)] (U : X.Opens)
(hU :
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map f) (X.fromSpecStalk x))
(IsLocalRing.closedPoint ↑R) ∈
... | null | true |
Lean.Doc.Parser.metadataBlock | Lean.DocString.Parser | optParam Lean.Doc.Parser.BlockCtxt { } → Lean.Parser.ParserFn | Parses a metadata block, which contains the contents of a Lean structure initialization but is
surrounded by `%%%` on each side.
| true |
HolderOnWith.interpolate | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {r : NNReal} {f : X → Y}
{C₁ C₂ s t₁ t₂ : NNReal} {A : Set X},
HolderOnWith C₁ r f A → HolderOnWith C₂ s f A → t₁ + t₂ = 1 → HolderOnWith (C₁ ^ ↑t₁ * C₂ ^ ↑t₂) (r * t₁ + s * t₂) f A | If a function is `(C₁, r)`-Hölder and `(C₂, s)`-Hölder, then it is
`(C₁ ^ t₁ * C₂ ^ t₂, r * t₁ + s * t₂)`-Hölder for all `t₁ t₂ : ℝ≥0` such that
`t₁ + t₂ = 1`. | true |
IsOpen.rightCoset | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] {U : Set G},
IsOpen U → ∀ (x : G), IsOpen (MulOpposite.op x • U) | null | true |
Std.HashMap.Raw._sizeOf_1 | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [SizeOf α] → [SizeOf β] → Std.HashMap.Raw α β → ℕ | null | false |
CategoryTheory.Functor.CoreMonoidal.mk'._proof_3 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(μIso :
(X Y : C) →
CategoryTheory.MonoidalCategoryStru... | null | false |
_private.Mathlib.Data.Int.Bitwise.0.Int.bodd_add_div2.match_1_1 | Mathlib.Data.Int.Bitwise | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_σ_self._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (i j : ℕ), j < i → i < j → j - 1 = j | null | false |
ContinuousAlgEquiv.coe_coe | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B), ⇑↑e = ⇑e | null | true |
RootPairing.map._proof_2 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_6} {R : Type u_1} {M : Type u_5} {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] {P : RootPairing ι R M N} {ι₂ : Type u_7}
{M₂ : Type u_3} {N₂ : Type u_2} [inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddC... | null | false |
instDecidableEqInt32 | Init.Data.SInt.Basic | DecidableEq Int32 | null | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.rpc.match_6 | Mathlib.Tactic.Widget.LibraryRewrite | (motive :
Array (Array Mathlib.Tactic.LibraryRewrite.RewriteInterface × Mathlib.Tactic.LibraryRewrite.Kind) ×
Array (Array Mathlib.Tactic.LibraryRewrite.RewriteInterface × Mathlib.Tactic.LibraryRewrite.Kind) →
Sort u_1) →
(x :
Array (Array Mathlib.Tactic.LibraryRewrite.RewriteInterface × Mathl... | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints.0.UpperHalfPlane.forall_smul_eq_self_iff_mem_center._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftStrictMono α],
b < c → 0 < a → (b < c + a) = True | null | false |
Std.ExtDTreeMap.Const.getEntryGT | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{β : Type v} →
[inst : Std.TransCmp cmp] →
(t : Std.ExtDTreeMap α (fun x => β) cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.gt) → α × β | Given a proof that such a mapping exists, retrieves the key-value pair with the smallest key that is
greater than the given key.
| true |
cfcₙHom_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
linearIndependent_le_span_aux' | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type u_2} [inst_4 : Fintype ι] (v : ι → M),
LinearIndependent R v →
∀ (w : Set M) [inst_5 : Fintype ↑w], Set.range v ⊆ ↑(Submodule.span R w) → Fintype.card ι ≤ Fintype.card ↑w | null | true |
MulAut.toPerm._proof_2 | Mathlib.Algebra.Group.End | ∀ (M : Type u_1) [inst : Mul M] (x x_1 : MulAut M), (x * x_1).toEquiv = (x * x_1).toEquiv | null | false |
IsDiscrete.mk | Mathlib.Topology.Constructions | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, DiscreteTopology ↑s → IsDiscrete s | null | true |
LinearIndependent.finrank_eq_zero_of_infinite | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Nontrivial R]
{ι : Type u_1} [Infinite ι] {v : ι → M}, LinearIndependent R v → Module.finrank R M = 0 | null | true |
Lean.IR.Arg.erased.sizeOf_spec | Lean.Compiler.IR.Basic | sizeOf Lean.IR.Arg.erased = 1 | null | true |
Lean.Compiler.LCNF.Simp.elimVar? | Lean.Compiler.LCNF.Simp.Main | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.Simp.SimpM (Option Lean.FVarId) | null | true |
Std.Rio.isSome_succMany?_of_lt_size_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite... | null | true |
ClosedSubmodule.mem_bot._simp_1 | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] {x : M} [inst_4 : T1Space M], (x ∈ ⊥) = (x = 0) | null | false |
_private.Std.Http.Data.Body.Full.0.Std.Http.Body.Full.State.sent | Std.Http.Data.Body.Full | Std.Http.Body.Full.State✝ | null | true |
Irrational.ne_rational | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (a b : ℤ), x ≠ ↑a / ↑b | null | true |
Polynomial.degree_comp | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
0 < q.degree → (p.comp q).degree = p.degree * q.degree | null | true |
CategoryTheory.Functor.preservesBinaryCoproducts_of_preservesCokernels | Mathlib.CategoryTheory.Preadditive.LeftExact | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[F.PreservesZeroMorphisms]
[∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.Preser... | A cokernel-preserving functor between preadditive categories preserves binary coproducts. | true |
CommRingCat.limitCommRing._proof_25 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt), a * 0 = 0 | null | false |
CategoryTheory.CoreHom.rec | Mathlib.CategoryTheory.Core | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : CategoryTheory.Core C} →
{motive : CategoryTheory.CoreHom X Y → Sort u} →
((iso : X.of ≅ Y.of) → motive { iso := iso }) → (t : CategoryTheory.CoreHom X Y) → motive t | null | false |
exists_seq_tendsto_limsup | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] [FirstCountableTopology α] {f : Filter β} [f.NeBot] [f.IsCountablyGenerated] {u : β → α},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) exists_seq_tendsto_limsup._auto_1 →
... | null | true |
QuaternionAlgebra.imI_zero | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : Zero R], QuaternionAlgebra.imI 0 = 0 | null | true |
Set.OrdConnected.casesOn | Mathlib.Order.Interval.Set.Defs | {α : Type u_1} →
[inst : Preorder α] →
{s : Set α} →
{motive : s.OrdConnected → Sort u} →
(t : s.OrdConnected) → ((out' : ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → Set.Icc x y ⊆ s) → motive ⋯) → motive t | null | false |
Std.DHashMap.Raw.Const.mem_toArray_iff_getKey?_eq_some_and_get?_eq_some | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k : α} {v : β},
(k, v) ∈ Std.DHashMap.Raw.Const.toArray m ↔ m.getKey? k = some k ∧ Std.DHashMap.Raw.Const.get? m k = some v | null | true |
ModelWithCorners.MfldCat.hom_id | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | ∀ {𝕜 : 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 ℕ∞}
{M : I.MfldCat n}, ModelWithCorners.MfldCat.Hom.hom (CategoryTheory.CategoryStruct.id M) = Cont... | null | true |
Lean.Elab.InfoTree.addTrailing?._unsafe_rec | Lean.Elab.InfoTree.Basic | Substring.Raw → Lean.Elab.InfoTree → Option Lean.Elab.InfoTree | null | false |
ComplexShape.instHasNoLoopNatUp | Mathlib.Algebra.Homology.HasNoLoop | (ComplexShape.up ℕ).HasNoLoop | null | true |
Std.DTreeMap.Internal.RcoSliceData.recOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RcoSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RcoSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Rco α) → motive { treeMap := treeMap, range := range }) ... | null | false |
Std.ExtTreeMap.minKey!_insert_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β}, (cmp (t.insert k v).minKey! k).isLE = true | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Ker.0.Subgroup.subgroupOf_map_powMonoidHom_eq_range._proof_1_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {M : Type u_1} [inst : CommGroup M] (S : Subgroup M) (n : ℕ), ∀ a ∈ S, a ^ n ∈ S | null | false |
Std.HashMap.size_unitOfList | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α},
List.Pairwise (fun a b => (a == b) = false) l → (Std.HashMap.unitOfList l).size = l.length | null | true |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.simpExists.match_3 | Lean.Meta.Tactic.Grind.ForallProp | (motive : Lean.Expr → Sort u_1) →
(fn : Lean.Expr) →
((x : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam x binderType b binderInfo)) →
((x : Lean.Expr) → motive x) → motive fn | null | false |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.maxChild_ge_right._proof_1_8 | Batteries.Data.BinaryHeap.Lemmas | ∀ {sz : ℕ} (i : Fin sz), 2 * ↑i + 2 ≤ sz → 2 * ↑i + 1 < sz | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.