name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ideal.mem_iInf_smul_pow_eq_bot_iff | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
[IsNoetherianRing R] [Module.Finite R M] (x : M), x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x | null | true |
PowerSeries.rescale_eq_subst | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (r : R) (f : PowerSeries R),
(PowerSeries.rescale r) f = PowerSeries.subst (r • PowerSeries.X) f | null | true |
_private.Lean.Syntax.0.Lean.Syntax.identComponents.match_1 | Lean.Syntax | (motive : Option (List Lean.Syntax × List Lean.Syntax) → Sort u_1) →
(x : Option (List Lean.Syntax × List Lean.Syntax)) →
((components snd : List Lean.Syntax) → motive (some (components, snd))) →
((x : Option (List Lean.Syntax × List Lean.Syntax)) → motive x) → motive x | null | false |
Std.HashMap.mem_of_mem_insert | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β}, a ∈ m.insert k v → (k == a) = false → a ∈ m | null | true |
Lean.Elab.Tactic.refineCore | Lean.Elab.Tactic.ElabTerm | Lean.Syntax → Lean.Name → Bool → Lean.Elab.Tactic.TacticM Unit | If `allowNaturalHoles == true`, then we allow the resultant expression to contain unassigned "natural" metavariables.
Recall that "natural" metavariables are created for explicit holes `_` and implicit arguments. They are meant to be
filled by typing constraints.
"Synthetic" metavariables are meant to be filled by tact... | true |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_4 | Lean.Compiler.ExternAttr | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Maximal.eq_of_superset | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : Set α → Prop} {s t : Set α}, Maximal P s → P t → s ⊆ t → t = s | null | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv'._proof_5 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {ℰ : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} ℰ] (A : CategoryTheory.Functor C ℰ)
(P : CategoryTheory.Functor Cᵒᵖ (Type (max u_4 u_2 u_3))) (E : ℰ)
(g : P ⟶ (CategoryTheory.Presheaf.restrictedULiftYoneda A).obj E),
(fun f =>
{
... | null | false |
AlgebraicGeometry.Scheme.Cover.property_trans | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀} (hij : i ⟶ j),
P (𝒰.trans hij) | null | true |
Std.HashSet.Raw.ofList_singleton | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {k : α}, Std.HashSet.Raw.ofList [k] = ∅.insert k | null | true |
Lean.Grind.Ring.intCast_one | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α], ↑1 = 1 | null | true |
MvPolynomial.monomial_sum_one | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} (s : Finset α) (f : α → σ →₀ ℕ),
(MvPolynomial.monomial (∑ i ∈ s, f i)) 1 = ∏ i ∈ s, (MvPolynomial.monomial (f i)) 1 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_get?_eq_some._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
String.Slice.Pattern.Model.isLongestMatchAt_startPos_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {endPos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt pat s.startPos endPos ↔
String.Slice.Pattern.Model.IsLongestMatch pat endPos | null | true |
List.lt_asymm | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] [i : Std.Asymm fun x1 x2 => x1 < x2] {l₁ l₂ : List α}, l₁ < l₂ → ¬l₂ < l₁ | null | true |
_private.Mathlib.RingTheory.Nullstellensatz.0.MvPolynomial.isMaximal_iff_eq_vanishingIdeal_singleton.match_1_1 | Mathlib.RingTheory.Nullstellensatz | ∀ {K : Type u_1} [inst : Field K] {σ : Type u_2} {I : Ideal (MvPolynomial σ K)}
(motive : (∃ x, I = MvPolynomial.vanishingIdeal K {x}) → Prop) (x : ∃ x, I = MvPolynomial.vanishingIdeal K {x}),
(∀ (w : σ → K) (hx : I = MvPolynomial.vanishingIdeal K {w}), motive ⋯) → motive x | null | false |
Subgroup.isCyclic_of_disjoint_Ioo_one | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] [MulArchimedean G] {H : Subgroup G}
{a : G}, 1 < a → Disjoint (↑H) (Set.Ioo 1 a) → IsCyclic ↥H | If a subgroup of a linear ordered commutative group is disjoint with the
interval `Set.Ioo 1 a` for some `1 < a`, then this is a cyclic subgroup. | true |
Rep.applyAsHom_comm_assoc | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} [inst : Semiring k] {G : Type v} [inst_1 : CommMonoid G] {A B : Rep.{u_1, u, v} k G} (f : A ⟶ B) (g : G)
{Z : Rep.{u_1, u, v} k G} (h : B ⟶ Z),
CategoryTheory.CategoryStruct.comp (A.applyAsHom g) (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Categ... | null | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m sofar : Std.DHashMap.Internal.Raw₀ α β) (k : α),
m.interSmallerFn sofar k =
match m.getEntry? k with
| some kv' => sofar.insert kv'.fst kv'.snd
| none => sofar | null | true |
Int64.neg_mul_comm | Init.Data.SInt.Lemmas | ∀ (a b : Int64), -a * b = a * -b | null | true |
Std.Internal.List.modifyKey_eq_alterKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (k : α) (f : β k → β k)
(l : List ((a : α) × β a)),
Std.Internal.List.modifyKey k f l = Std.Internal.List.alterKey k (fun x => Option.map f x) l | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.UniformCauchySeqOn.prodMap._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.casesOn | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremConstraint → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremConstraint) →
((lhs : ℕ) → (rhs : Lean.Meta.Grind.CnstrRHS) → motive (Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq lhs rhs)) →
((lhs : ℕ) → (rhs : Lean.Meta.Grind.CnstrRHS) → motive (Lean.Meta.Grind.EMatchThe... | null | false |
Lean.Level.PP.Result._sizeOf_2 | Lean.Level | List Lean.Level.PP.Result → ℕ | null | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.comp | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
{F : CategoryTheory.Functor C FintypeCat} {A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F}
(self : A.Hom B), (CategoryTheory.ConcreteCategory.hom (F.map self.val)) A.pt = B.pt | The distinguished point of `A` is mapped to the distinguished point of `B`. | true |
Filter.IsMeasurablyGenerated | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} → [MeasurableSpace α] → Filter α → Prop | A filter `f` is measurably generated if each `s ∈ f` includes a measurable `t ∈ f`. | true |
LocallyLipschitzOn.add | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedAddCommGroup E] [inst_1 : PseudoEMetricSpace α] {f g : α → E}
{s : Set α}, LocallyLipschitzOn s f → LocallyLipschitzOn s g → LocallyLipschitzOn s fun x => f x + g x | null | true |
Complex.im_qsmul | Mathlib.Basic.Complex.Basic | ∀ (q : ℚ) (z : ℂ), (q • z).im = q • z.im | null | true |
Batteries.UnionFind.rootD_rootD | Batteries.Data.UnionFind.Basic | ∀ {self : Batteries.UnionFind} {x : ℕ}, self.rootD (self.rootD x) = self.rootD x | null | true |
WeierstrassCurve.Projective.negDblY_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
P 2 ≠ 0 →
Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 = Q 1 * P 2 → P 1 * Q 2 = W.negY Q * P 2 → W.negDblY P = -W.dblU P | null | true |
Polynomial.nthRootsFinset.eq_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ (n : ℕ) {R : Type u_1} (a : R) [inst : CommRing R] [inst_1 : IsDomain R],
Polynomial.nthRootsFinset n a = (Polynomial.nthRoots n a).toFinset | null | true |
Lean.Meta.mkPProdSnd | Lean.Meta.PProdN | Lean.Expr → Lean.Expr → Lean.Expr | `PProd.snd` or `And.right` (using `.proj`) | true |
_private.Init.Data.UInt.Lemmas.0.UInt64.not_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toBitVec ≤ b.toBitVec) | null | false |
instAssociativeUInt32HXor | Init.Data.UInt.Bitwise | Std.Associative fun x1 x2 => x1 ^^^ x2 | null | true |
Std.DHashMap.Raw.Const.getKey?_ofList_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
k ∈ List.map Prod.fst l → (Std.DHashMap.Raw.Const.ofList l).getKey? k' = some k | null | true |
CategoryTheory.Limits.coprod.map.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
(f : Y ⟶ W) (g : Z ⟶ X),
CategoryTheory.Limits.coprod.map f g = CategoryTheory.Limits.colimMap (CategoryTheory.Limits.mapPair f g) | null | true |
linearIndependent_of_top_le_span_of_card_eq_finrank | Mathlib.LinearAlgebra.Dimension.OrzechProperty | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [OrzechProperty R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
{ι : Type u_3} [inst_4 : Fintype ι] {b : ι → M},
⊤ ≤ Submodule.span R (Set.range b) → Fintype.card ι = Module.finrank R M → LinearIndependent R b | null | true |
Sym2.map_pmap | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {Q : β → Prop} (f : α → β) (g : (b : β) → Q b → γ) (z : Sym2 α)
(h : ∀ b ∈ Sym2.map f z, Q b), Sym2.pmap g (Sym2.map f z) h = Sym2.pmap (fun a ha => g (f a) ⋯) z ⋯ | null | true |
CategoryTheory.Functor.map_mono | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.PreservesMonomorphisms] {X Y : C} (f : Y ⟶ X) [CategoryTheory.Mono f],
CategoryTheory.Mono (F.map f) | null | true |
RBTree.RBNode.lowerBound?._unsafe_rec | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → (α → Ordering) → RBTree.RBNode α → optParam (Option α) none → Option α | null | false |
IsCompact.isOpen_constructibleTopology_of_isOpen | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsOpen s → IsOpen s | null | true |
Prod.instRightCancelSemigroup | Mathlib.Algebra.Group.Prod | {G : Type u_1} → {H : Type u_2} → [RightCancelSemigroup G] → [RightCancelSemigroup H] → RightCancelSemigroup (G × H) | null | true |
CategoryTheory.ShortComplex.Homotopy.noConfusionType | Mathlib.Algebra.Homology.ShortComplex.Preadditive | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ : S₁ ⟶ S₂} →
CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ →
{C' : Type u_1} →
[inst' ... | null | false |
Module.DirectedSystem.map_self | Mathlib.Algebra.Colimit.Module | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] ⦃i : ι⦄ (x : F i), (f i i ⋯) x = x | **Alias** of `DirectedSystem.map_self'`. | true |
Lean.Meta.Sym.Arith.CommSemiring.noConfusion | Lean.Meta.Sym.Arith.Types | {P : Sort u} →
{t t' : Lean.Meta.Sym.Arith.CommSemiring} → t = t' → Lean.Meta.Sym.Arith.CommSemiring.noConfusionType P t t' | null | false |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.coev_app._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {V : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] [inst_4 : CategoryTheory.MonoidalClosed V]
{F H G : CategoryTheory.Functor C V} [inst_5 : Category... | null | false |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.ext_iff.match_1_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_1} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_4} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {f g : E →ₛₗ.[σ] F}
(motive : (f.domain = g.domain ∧ ∀ ⦃x : E⦄ ⦃hf : x ∈ f.domain⦄ ⦃hg : x ∈ g.domain⦄, ↑f ⟨x,... | null | false |
groupCohomology.isoCocycles₂_hom_comp_i | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.CategoryStruct.comp (groupCohomology.isoCocycles₂ A).hom
(groupCohomology.shortComplexH2 A).moduleCatLeftHomologyData.i =
CategoryTheory.CategoryStruct.comp (groupCohomology.iCocycles A 2) (groupCohomology.cochai... | null | true |
Int.Internal.Linear.of_var_eq_var_cert.eq_1 | Init.Data.Int.Linear | ∀ (x y : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly),
Int.Internal.Linear.of_var_eq_var_cert x y p =
p.beq' (Int.Internal.Linear.Poly.add 1 x (Int.Internal.Linear.Poly.add (-1) y (Int.Internal.Linear.Poly.num 0))) | null | true |
_private.Mathlib.Logic.Function.Basic.0.Function.injective_comp_right_iff_surjective.match_1_1 | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} (motive : (∃ x, ¬∃ a, f a = x) → Prop) (x : ∃ x, ¬∃ a, f a = x),
(∀ (b₀ : β) (hb : ¬∃ a, f a = b₀), motive ⋯) → motive x | null | false |
String.getUTF8Byte_eq_getUTF8Byte_toSlice._proof_1 | Init.Data.String.Lemmas.Basic | ∀ {s : String} {p : String.Pos.Raw} {h : p < s.rawEndPos}, p < s.toSlice.rawEndPos | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.toArray_ne_nil._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rci α} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α], r.toArray = r.toList.toArray | null | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.LawfulBackwardPatternModel.skipSuffix?_sliceTo_eq_none_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} {inst : String.Slice.Pattern.BackwardPattern pat}
{inst_1 : String.Slice.Pattern.Model.PatternModel pat}
[self : String.Slice.Pattern.Model.LawfulBackwardPatternModel pat] {s : String.Slice} (pos : s.Pos),
(String.Slice.Pattern.BackwardPattern.skipSuffix? pat s = some pos) =
String.Slic... | null | false |
Lean.Meta.GeneralizeArg.rec | Lean.Meta.Tactic.Generalize | {motive : Lean.Meta.GeneralizeArg → Sort u} →
((expr : Lean.Expr) →
(xName? hName? : Option Lean.Name) → motive { expr := expr, xName? := xName?, hName? := hName? }) →
(t : Lean.Meta.GeneralizeArg) → motive t | null | false |
CompHausLike.productIsLimit._proof_6 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) (s : CategoryTheory.Limits.BinaryFan X Y),
CompHausLike.HasProp P ↑s.1.toTop | null | false |
FirstOrder.Language.ElementaryEmbedding.instFunLike | Mathlib.ModelTheory.ElementaryMaps | {L : FirstOrder.Language} →
{M : Type u_1} →
{N : Type u_2} → [inst : L.Structure M] → [inst_1 : L.Structure N] → FunLike (L.ElementaryEmbedding M N) M N | null | true |
Equiv.prodUnique_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} [inst : Unique β] (x : α × β), (Equiv.prodUnique α β) x = x.1 | null | true |
FiniteField.splits_X_pow_card_sub_X | Mathlib.FieldTheory.Finite.GaloisField | ∀ (p : ℕ) [h_prime : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : Fintype K]
[inst_2 : Algebra (ZMod p) K],
(Polynomial.map (algebraMap (ZMod p) K) (Polynomial.X ^ Fintype.card K - Polynomial.X)).Splits | null | true |
CategoryTheory.Functor.leftUnitor._proof_9 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D),
CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }
{ app := fun X => CategoryTheory.Ca... | null | false |
_private.Mathlib.AlgebraicTopology.DoldKan.Faces.0.AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq._proof_1_13 | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {a : ℕ} (k : ℕ), a + 1 + 1 < a + 3 + k | null | false |
String.get!_eq_get | Init.Data.String.Basic | ∀ (s : String) (p : String.Pos.Raw), String.Pos.Raw.get! s p = String.Pos.Raw.get s p | null | true |
CategoryTheory.Functor.coconeTypes | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} → [inst : CategoryTheory.Category.{v, u} J] → (F : CategoryTheory.Functor J (Type w₀)) → F.CoconeTypes | The cocone corresponding to `F.ColimitType`. | true |
WeierstrassCurve.j_of_isCharTwoJNeZeroNF_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {F : Type u_2} [inst : Field F] (W : WeierstrassCurve F) [inst_1 : W.IsElliptic] [W.IsCharTwoJNeZeroNF] [CharP F 2],
W.j = 1 / W.a₆ | null | true |
SSet.Truncated.Path.mk₂ | Mathlib.AlgebraicTopology.SimplicialSet.Path | {n : ℕ} → {X : SSet.Truncated (n + 1)} → (p q : X.Path 1) → p.vertex 1 = q.vertex 0 → X.Path 2 | Constructor for paths of length `2` from two paths of length `1`. | true |
Lean.Parser.checkLineEq | Lean.Parser.Basic | optParam String "checkLineEq" → Lean.Parser.Parser | The `lineEq` parser requires that the current token is on the same line as the saved position
(see `withPosition`). This can be used to ensure that composite tokens are not "broken up" across
different lines. For example, `else if` is parsed using `lineEq` to ensure that the two tokens
are on the same line.
This parse... | true |
_private.Batteries.Recycling.RBTree.Basic.0.RBTree.RBNode.any.eq_1 | Batteries.Recycling.RBTree.Basic | ∀ {α : Type u_1} (p : α → Bool), RBTree.RBNode.any p RBTree.RBNode.nil = false | null | true |
ProfiniteGrp.rec | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {motive : ProfiniteGrp.{u} → Sort u_1} →
((toProfinite : Profinite) →
[group : Group ↑toProfinite.toTop] →
[isTopologicalGroup : IsTopologicalGroup ↑toProfinite.toTop] →
motive { toProfinite := toProfinite, group := group, isTopologicalGroup := isTopologicalGroup }) →
(t : ProfiniteGrp.{u}... | null | false |
_private.Std.Http.Protocol.H1.Writer.0.Std.Http.Protocol.H1.Writer.instBEqState.beq._sparseCasesOn_6 | Std.Http.Protocol.H1.Writer | {motive : Std.Http.Protocol.H1.Writer.State → Sort u} →
(t : Std.Http.Protocol.H1.Writer.State) →
motive Std.Http.Protocol.H1.Writer.State.writingBodyClosingFrame →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Arrow.RightHomotopy.equivSubZero | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{u v : CategoryTheory.Arrow V} →
{f g : u ⟶ v} → CategoryTheory.Arrow.RightHomotopy f g ≃ CategoryTheory.Arrow.RightHomotopy (f - g) 0 | `f` is right homotopic to `g` iff `f - g` is righthomotopic to `0`. | true |
Lean.Expr.withAppAux._f | Lean.Expr | {α : Sort u_1} →
(Lean.Expr → Array Lean.Expr → α) →
(x : Lean.Expr) → Lean.Expr.below (motive := fun x => Array Lean.Expr → ℕ → α) x → Array Lean.Expr → ℕ → α | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.primitiveTriangle._proof_28 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, 0 < n + 2 → 0 < n + 4 | null | false |
Std.DHashMap.Const.getD_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α} {fallback : β} {f : β → β},
Std.DHashMap.Const.getD (Std.DHashMap.Const.modify m k f) k fallback =
(Option.map f (Std.DHashMap.Const.get? m k)).getD fallback | null | true |
PresheafOfModules.isoMk._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X),
(∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map f)
((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map... | null | false |
hasFDerivWithinAt_sub_const_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (c : F), HasFDerivWithinAt (fun x => f x - c) f' s x = HasFDer... | null | false |
ContDiffMapSupportedIn.copy | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
(f : ContDiffMapSupportedIn E F n K) → (f' ... | Copy of a `ContDiffMapSupportedIn` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. | true |
Homotopy.zero | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} (self : Homotopy f g) (i j : ι),
¬c.Rel j i → self.hom i j = 0 | null | true |
CategoryTheory.sheafBotEquivalence_inverse_map_hom | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (A : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y), ((CategoryTheory.sheafBotEquivalence A).inverse.map f).hom = f | null | true |
FreeMagma.pure_seq | Mathlib.Algebra.Free | ∀ {α β : Type u} {f : α → β} {x : FreeMagma α}, pure f <*> x = f <$> x | null | true |
Multiset.bind_filter | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (m : Multiset α) (p : α → Prop) (f : α → Multiset β) [inst : DecidablePred p],
(Multiset.filter p m).bind f = m.bind fun a => if p a then f a else 0 | null | true |
MeasureTheory.Measure.volume_eq_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ (α : Type u_4) (β : Type u_5) [inst : MeasureTheory.MeasureSpace α] [inst_1 : MeasureTheory.MeasureSpace β],
MeasureTheory.volume = MeasureTheory.volume.prod MeasureTheory.volume | null | true |
CategoryTheory.ExponentiableMorphism.OverMkHom._aux_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{I J : C} →
{f : I ⟶ J} →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
[CategoryTheory.ExponentiableMorphism f] → CategoryTheory.ExponentiableMorphism (CategoryTheory.Over.mk f).hom | null | false |
RCLike.ext_iff | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {z w : K}, z = w ↔ RCLike.re z = RCLike.re w ∧ RCLike.im z = RCLike.im w | null | true |
RingHom.Flat.eq_1 | Mathlib.RingTheory.RingHom.Flat | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S), f.Flat = Module.Flat R S | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.go.goArg.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Meta.Grind.NormalizePattern.ParentKind✝ → Sort u_1) →
(parentKind : Lean.Meta.Grind.NormalizePattern.ParentKind✝) →
(Unit → motive Lean.Meta.Grind.NormalizePattern.ParentKind.regular✝) →
((x : Lean.Meta.Grind.NormalizePattern.ParentKind✝) → motive x) → motive parentKind | null | false |
Ideal.ramificationIdx_pos_of_isDedekindDomain | Mathlib.RingTheory.RamificationInertia.Ramification | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
(q : Ideal S) [inst_3 : q.IsPrime] [q.LiesOver p],
Ideal.map (algebraMap R S) p ≠ ⊥ →
∀ [Ring.DimensionLEOne S]
[IsNoetherianRing (Localization.AtPrime q ⧸ Ideal.map (algebraMap R (Localization.A... | This theorem proves positivity of `ramificationIdx` when `S` is a Dedekind domain.
In particular, the dimension and Noetherian assumptions hold under `[IsDedekindDomain S]`.
See `Ideal.ramificationIdx_pos` for a version that holds when `S` is finite as an `R`-module. | true |
_private.Init.Data.String.Extra.0.String.crlfToLf.go._unsafe_rec | Init.Data.String.Extra | String → String → String.Pos.Raw → String.Pos.Raw → String | null | false |
UInt8.add_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a + b = { toBitVec := a.toBitVec + b.toBitVec } | null | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.mk_dvdNotUnit_mk_iff._simp_1_3 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a : M}, IsUnit (Associates.mk a) = IsUnit a | null | false |
Std.DTreeMap.Internal.Impl.Const.get!_eq_get! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] [inst_1 : Inhabited β],
t.WF → ∀ {a : α}, Std.DTreeMap.Internal.Impl.Const.get! t a = t.get! a | null | true |
Lean.Widget.TaggedText.recOn | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
{motive_2 : Array (Lean.Widget.TaggedText α) → Sort u_1} →
{motive_3 : List (Lean.Widget.TaggedText α) → Sort u_1} →
(t : Lean.Widget.TaggedText α) →
((a : String) → motive_1 (Lean.Widget.TaggedText.text a)) →
((... | null | false |
LieSubalgebra.coe_ad | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (H : LieSubalgebra R L)
(x y : ↥H), ↑(((LieAlgebra.ad R ↥H) x) y) = ((LieAlgebra.ad R L) ↑x) ↑y | null | true |
Std.ExtDTreeMap.get!_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} [inst_2 : Inhabited (β k)], k ∉ t₁ → (t₁ ∪ t₂).get! k = t₂.get! k | null | true |
Lean.Elab.ConfigEval.defEvalConfigItem | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Option (Lean.TSyntax `Lean.Parser.Command.docComment) →
Option (Lean.TSyntax `Lean.Parser.Command.visibility) →
Lean.TSyntax `Lean.Parser.Term.attrKind →
Lean.Syntax →
Lean.Ident →
Lean.Ident →
Lean.TSyntaxArray `Lean.Parser.Term.bracketedBinder →
Lean.Elab.Config... | Makes an `EvalConfigItem` for the structure.
Supports structures with no parameters or universes.
| true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.leadingExp | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.MultiseriesExpansion (basis_hd :: basis_tl) → WithBot ℝ | The leading exponent of a multiseries with non-empty basis. For `ms = []` it is `⊥`. | true |
eventuallyMeasurableSpace.match_1 | Mathlib.MeasureTheory.MeasurableSpace.EventuallyMeasurable | ∀ {α : Type u_1} (m : MeasurableSpace α) (l : Filter α) (x : Set α) (motive : (∃ t, MeasurableSet t ∧ x =ᶠ[l] t) → Prop)
(x_1 : ∃ t, MeasurableSet t ∧ x =ᶠ[l] t),
(∀ (t : Set α) (ht : MeasurableSet t) (hts : x =ᶠ[l] t), motive ⋯) → motive x_1 | null | false |
Lean.Elab.Tactic.evalTraceState | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosDef.natCast._simp_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
Nat.instLinearOrder._proof_2 | Mathlib.Data.Nat.Basic | ∀ (a b : ℕ), max a b = if a.le b then b else a | null | false |
Projectivization.Subspace.noConfusionType | Mathlib.LinearAlgebra.Projectivization.Subspace | Sort u →
{K : Type u_1} →
{V : Type u_2} →
[inst : DivisionRing K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] →
Projectivization.Subspace K V →
{K' : Type u_1} →
{V' : Type u_2} →
[inst' : DivisionRing K'] →
... | null | false |
SubMulAction.ofFixingSubgroup_of_singleton._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_2) {α : Type u_1} [inst : Group M] [inst_1 : MulAction M α] (a : α)
(x : ↥(SubMulAction.ofFixingSubgroup M {a})), ↑x ∈ SubMulAction.ofStabilizer M a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.