name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicIndependent.isEmpty_of_isAlgebraic | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A], AlgebraicIndependent R x → ∀ [Algebra.IsAlgebraic R A], IsEmpty ι | If `A/R` is algebraic, then all algebraically independent families are empty. | true |
LinearMap.mk.congr_simp | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_14} {S : Type u_15} [inst : Semiring R] [inst_1 : Semiring S] {σ : R →+* S} {M : Type u_16}
{M₂ : Type u_17} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂]
(toAddHom toAddHom_1 : M →ₙ+ M₂) (e_toAddHom : toAddHom = toAddHom_1)
(map_smul' : ∀ (m : R... | null | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.zero_mem_resolventSet_of_unit._simp_1_3 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
(0 ∉ spectrum R a) = IsUnit a | null | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.mulSupport_update._simp_1_1 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {x : ι}, (x ∈ Function.mulSupport f) = (f x ≠ 1) | null | false |
_private.Init.Data.Nat.Basic.0.Nat.le.dest.match_1_1 | Init.Data.Nat.Basic | ∀ (n m : ℕ) (motive : (∃ k, n + k = m) → Prop) (this : ∃ k, n + k = m),
(∀ (k : ℕ) (h : n + k = m), motive ⋯) → motive this | null | false |
CategoryTheory.GrothendieckTopology.instIsContinuousOverStarOver | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v_1, u'} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
{J : CategoryTheory.GrothendieckTopology C} (X : C), (CategoryTheory.Over.star X).IsContinuous J (J.over X) | null | true |
HahnSeries.finiteArchimedeanClassOrderHomInvLex._proof_3 | Mathlib.RingTheory.HahnSeries.Lex | ∀ (Γ : Type u_2) (R : Type u_1) [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R] (a b : Lex (Γ × FiniteArchimedeanClass R)),
a ≤ b →
(FiniteArchimedeanClass.liftOrderHom
(fun a_2 => FiniteArchimedeanClass.mk (toLex ((HahnSeries.single (ofLex a).... | null | false |
Representation.IntertwiningMap.comp_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] (ρ : Representation A G V) (σ : Representation A G W... | null | true |
Matrix.natCast_mulVec | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (x : ℕ)
(v : m → α), (↑x).mulVec v = ↑x • v | null | true |
ULift.compactSpace | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactSpace X], CompactSpace (ULift.{v, u} X) | null | true |
Filter.Tendsto.nhds | Mathlib.Topology.Filter | ∀ {α : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : α → X} {l : Filter α} {x : X},
Filter.Tendsto f l (nhds x) → Filter.Tendsto (nhds ∘ f) l (nhds (nhds x)) | null | true |
Std.Http.RequestTarget.asteriskForm.elim | Std.Http.Data.URI.Basic | {motive : Std.Http.RequestTarget → Sort u} →
(t : Std.Http.RequestTarget) → t.ctorIdx = 3 → motive Std.Http.RequestTarget.asteriskForm → motive t | null | false |
Polynomial.toFinsupp_injective | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R], Function.Injective Polynomial.toFinsupp | null | true |
instIsAlgebraicSubtypeMemSubalgebraAlgebraicClosure | Mathlib.RingTheory.Algebraic.Integral | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : IsDomain R],
Algebra.IsAlgebraic R ↥(Subalgebra.algebraicClosure R S) | null | true |
RegularExpression.comp.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 4 → ((a a_1 : RegularExpression α) → motive (a.comp a_1)) → motive t | null | false |
sup_congr_right | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, a ≤ b ⊔ c → b ≤ a ⊔ c → a ⊔ c = b ⊔ c | null | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.isColoop_iff_forall_mem_compl_isCircuit._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α},
autoParam (e ∈ M.E) Matroid.isColoop_iff_forall_notMem_isCircuit._auto_1 →
M.IsColoop e = ∀ ⦃C : Set α⦄, M.IsCircuit C → e ∉ C | null | false |
ProbabilityTheory.«term_∥ₖ_» | Mathlib.Probability.Kernel.Composition.ParallelComp | Lean.TrailingParserDescr | Parallel product of two kernels. | true |
UInt8.left_le_or | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, a ≤ a ||| b | null | true |
Int.eq_zero_of_lcm_eq_zero | Init.Data.Int.Gcd | ∀ {m n : ℤ}, m.lcm n = 0 → m = 0 ∨ n = 0 | null | true |
RCLike.complexLinearIsometryEquiv._proof_2 | Mathlib.Analysis.Complex.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] (h : RCLike.im RCLike.I = 1) (x : ℝ) (x_1 : 𝕜),
(RCLike.complexRingEquiv h).toFun (x • x_1) = (RingHom.id ℝ) x • (RCLike.complexRingEquiv h).toFun x_1 | null | false |
Polynomial.UniversalCoprimeFactorizationRing.homEquiv._proof_11 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_2} (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {n : ℕ} (m k : ℕ)
(hn : n = m + k) (p : Polynomial.MonicDegreeEq R n)
(q : { q // ↑q.1 * ↑q.2 = Polynomial.map (algebraMap R S) ↑p ∧ IsCoprime ↑q.1 ↑q.2 }),
IsUnit
(((Polynomial.UniversalFactorizationRing.homEquiv... | null | false |
LieAlgebra.IsKilling.neg_root_eq | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
[inst_5 : LieAlgebra.IsKilling K L] [inst_6 : LieModule.IsTriangularizable K (↥H) L] {i : ↥LieSubalgebra.root},
-i = ⟨-↑i, ⋯⟩ | null | true |
CategoryTheory.«term_≫=_» | Mathlib.CategoryTheory.Category.Basic | Lean.TrailingParserDescr | Notation for whiskering an equation by a morphism (on the left).
If `g h : Y ⟶ Z` and `w : g = h` and `f : X ⟶ Y`, then `f ≫= w : f ≫ g = f ≫ h`.
| true |
AddSubmonoid.closure_empty | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M], AddSubmonoid.closure ∅ = ⊥ | null | true |
CategoryTheory.ShortComplex.Exact.op | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.op.Exact | null | true |
emultiplicity_ne_of_multiplicity_ne | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b : α} {n : ℕ}, multiplicity a b ≠ n → emultiplicity a b ≠ ↑n | null | true |
Mathlib.Meta.NormNum.NormNums.casesOn | Mathlib.Tactic.NormNum.Core | {motive : Mathlib.Meta.NormNum.NormNums → Sort u} →
(t : Mathlib.Meta.NormNum.NormNums) →
((tree : Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt) →
(erased : Lean.PHashSet Lean.Name) → motive { tree := tree, erased := erased }) →
motive t | null | false |
Multiset.count_nsmul | Mathlib.Algebra.Order.Group.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (n : ℕ) (s : Multiset α),
Multiset.count a (n • s) = n * Multiset.count a s | null | true |
CategoryTheory.SmallObject.SuccStruct.ofCocone._proof_6 | Mathlib.CategoryTheory.SmallObject.Iteration.FunctorOfCocone | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J} {x i₃ : ↑(Set.Iic j)} (x_1 : x ⟶ i₃), ↑x ≤ j | null | false |
String.next_eq_posGT | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p ≠ s.endPos}, p.next h = s.posGT p.offset ⋯ | null | true |
_private.Mathlib.CategoryTheory.Sites.Over.0.CategoryTheory.instIsCocontinuousOverLeftIteratedSliceBackwardOver._proof_1 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(f : CategoryTheory.Over X), f.iteratedSliceBackward.IsCocontinuous (J.over f.left) ((J.over X).over f) | null | false |
_private.Init.Prelude.0.Lean.Syntax.getHeadInfo?.loop.match_1 | Init.Prelude | (motive : Option Lean.SourceInfo → Sort u_1) →
(x : Option Lean.SourceInfo) → ((info : Lean.SourceInfo) → motive (some info)) → (Unit → motive none) → motive x | null | false |
AList.empty_union | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {s : AList β}, ∅ ∪ s = s | null | true |
List.Perm.swap' | Init.Data.List.Perm | ∀ {α : Type u_1} (x y : α) {l₁ l₂ : List α}, l₁.Perm l₂ → (y :: x :: l₁).Perm (x :: y :: l₂) | null | true |
Metric.closure_eq_iInter_cthickening' | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (E : Set α) (s : Set ℝ),
(∀ (ε : ℝ), 0 < ε → (s ∩ Set.Ioc 0 ε).Nonempty) → closure E = ⋂ δ ∈ s, Metric.cthickening δ E | The closure of a set equals the intersection of its closed thickenings of positive radii
accumulating at zero. | true |
Mathlib.Tactic.CategoryTheory.Map.mapCompSimp | Mathlib.Tactic.CategoryTheory.Map | Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | `simp only` with `Functor.map_comp` and `Functor.map_id` on a single expression
(used on each side via `simpEq`). | true |
Module.rank_def | Mathlib.LinearAlgebra.Dimension.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Module.rank R M = ⨆ ι, Cardinal.mk ↑↑ι | null | true |
_private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.comm_ring_aux₁._proof_11 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : Fact (Nat.Prime p)] (x : WittVector p (MvPolynomial R ℚ)) (m : ℕ),
WittVector.ghostFun✝ (x ^ m) = WittVector.ghostFun✝ x ^ m | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Exp.0._aux_Mathlib_Analysis_Complex_UpperHalfPlane_Exp___unexpand_Function_Periodic_qParam_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Exp | Lean.PrettyPrinter.Unexpander | null | false |
GenContFract.convs_stable_of_terminated | Mathlib.Algebra.ContinuedFractions.TerminatedStable | ∀ {K : Type u_1} {g : GenContFract K} {n m : ℕ} [inst : DivisionRing K],
n ≤ m → g.TerminatedAt n → g.convs m = g.convs n | null | true |
Set.powersetCard.eq_empty_iff | Mathlib.Data.Set.PowersetCard | ∀ {α : Type u_1} {n : ℕ} [Finite α], Set.powersetCard α n = ∅ ↔ Nat.card α < n | null | true |
WeakPseudoEMetricSpace.ext_iff | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_2} [inst : TopologicalSpace α] {m m' : WeakPseudoEMetricSpace α}, m = m' ↔ m.toEDist = m'.toEDist | null | true |
Std.DTreeMap.Internal.Unit.RcoSliceData.mk | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Std.Rco α → Std.DTreeMap.Internal.Unit.RcoSliceData α | null | true |
GradedMonoid.fst_pow | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (x : GradedMonoid A) (n : ℕ),
(x ^ n).fst = n • x.fst | null | true |
CategoryTheory.Join.inlCompFromSum_inv_app | Mathlib.CategoryTheory.Join.Sum | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : C),
(CategoryTheory.Join.inlCompFromSum C D).inv.app X = CategoryTheory.CategoryStruct.id (CategoryTheory.Join.left X) | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_zero_iff_of_nonneg_ae._simp_1_3 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {p : ℝ}, (ENNReal.ofReal p = 0) = (p ≤ 0) | null | false |
Interval.addCommMonoid.eq_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α],
Interval.addCommMonoid =
{ toZero := instZeroInterval, toAdd := instAddInterval, add_assoc := ⋯, zero_add := ⋯, add_zero := ⋯,
nsmul := nsmulRecAuto, nsmul_zero := ⋯, nsmul_succ := ⋯, add_comm := ⋯ } | null | true |
CategoryTheory.Limits.FormalCoproduct.fromIncl_comp_coproductIsoSelf_inv_assoc | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Limits.FormalCoproduct C) (i : X.I)
{Z : CategoryTheory.Limits.FormalCoproduct C} (h : ∐ X.toFun ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl i (CategoryTheory.CategoryStruct.id (X.obj ... | null | true |
CategoryTheory.Limits.hasColimitsOfShape_of_initialSeg | Mathlib.CategoryTheory.Limits.Shapes.Preorder.HasIterationOfShape | ∀ {J : Type w} [inst : LinearOrder J] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[CategoryTheory.Limits.HasIterationOfShape J C] [SuccOrder J] [WellFoundedLT J] {α : Type u_1}
[inst_5 : PartialOrder α] (f : α ≤i J) [Nonempty α], CategoryTheory.Limits.HasColimitsOfShape α C | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLTLTIsoLT_inv_hom_id_app_eTruncLT_obj | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
Lean.LocalDecl.cdecl | Lean.LocalContext | ℕ → Lean.FVarId → Lean.Name → Lean.Expr → Lean.BinderInfo → Lean.LocalDeclKind → Lean.LocalDecl | A local variable without any value.
`Lean.LocalContext.mkBinding` creates lambdas or foralls from `cdecl`s. | true |
MeasureTheory.Measure.haar._proof_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [Group G] [inst : TopologicalSpace G] [LocallyCompactSpace G],
Nonempty (TopologicalSpace.PositiveCompacts G) | null | false |
derivationToSquareZeroOfLift._proof_3 | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) [inst_5 : Algebra A B] [IsScalarTower R A B],
IsScalarTower R A (B ⧸ I) | null | false |
List.Forall._f | Mathlib.Data.List.Defs | {α : Type u_1} → (α → Prop) → (x : List α) → List.below x → Prop | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Orthogonal.0.Submodule.map_orthogonal._simp_1_7 | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} {x : M}, (x ∈ p ⊓ q) = (x ∈ p ∧ x ∈ q) | null | false |
Cardinal.lift_iSup_le_iff._simp_1 | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι : Type v} {f : ι → Cardinal.{w}},
BddAbove (Set.range f) →
∀ {t : Cardinal.{max u w}}, (Cardinal.lift.{u, w} (iSup f) ≤ t) = ∀ (i : ι), Cardinal.lift.{u, w} (f i) ≤ t | null | false |
OrderedFinpartition.extendMiddle._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (k m : Fin c.length),
StrictMono
(if h : m = k then
have this := ⋯;
(fun i => Fin.cases 0 (Fin.succ ∘ c.emb k) i) ∘ Fin.cast this
else
have this := ⋯;
Fin.succ ∘ c.emb m ∘ Fin.cast this) | null | false |
String.Slice.Subslice.extendLeft_self._proof_1 | Init.Data.String.Subslice | ∀ {s : String.Slice} {sl : s.Subslice}, sl.startInclusive ≤ sl.startInclusive | null | false |
String.validateUTF8 | Init.Data.String.Extra | ByteArray → Bool | Checks whether an array of bytes is a valid UTF-8 encoding of a string.
| true |
_private.Lean.Elab.Util.0.Lean.Elab.liftMacroM.match_3 | Lean.Elab.Util | (motive : Lean.Name × String → Sort u_1) →
(x : Lean.Name × String) → ((clsName : Lean.Name) → (msg : String) → motive (clsName, msg)) → motive x | null | false |
Complex.ofReal_cot | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), ↑(Real.cot x) = Complex.cot ↑x | null | true |
CategoryTheory.Pseudofunctor.DescentData.Hom.ext_iff | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C}
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentData f} {x y : D₁.Hom D₂}, x = y ↔ x.hom = y.hom | null | true |
Std.Internal.List.getValueCast?._sunfold | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [inst : BEq α] → [LawfulBEq α] → (a : α) → List ((a : α) × β a) → Option (β a) | null | false |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.natDegree_basis.match_1_2 | Mathlib.LinearAlgebra.Lagrange | ∀ {ι : Type u_1} {s : Finset ι} {i : ι} (j : ι) (motive : j ≠ i ∧ j ∈ s → Prop) (x : j ≠ i ∧ j ∈ s),
(∀ (hij₁ : j ≠ i) (hj : j ∈ s), motive ⋯) → motive x | null | false |
_private.Init.PropLemmas.0.nonempty_prop.match_1_1 | Init.PropLemmas | ∀ {p : Prop} (motive : Nonempty p → Prop) (x : Nonempty p), (∀ (h : p), motive ⋯) → motive x | null | false |
AlgebraicClosure.instCommRing._aux_30 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | (k : Type u_1) → [inst : Field k] → AlgebraicClosure k → AlgebraicClosure k | null | false |
DistribLattice.instIsModularLattice | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : DistribLattice α], IsModularLattice α | null | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.splitter | Mathlib.ModelTheory.Encoding | {L : FirstOrder.Language} →
{α : Type u_3} →
(motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) →
(x : ℕ) →
(x_1 : L.BoundedFormula α x) →
((n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum) →
((x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.... | null | true |
String.splits_startPos_iff._simp_1 | Init.Data.String.Lemmas.Splits | ∀ {t₁ t₂ s : String}, s.startPos.Splits t₁ t₂ = (t₁ = "" ∧ t₂ = s) | null | false |
Graph.toSimpleGraph._proof_2 | Mathlib.Combinatorics.Graph.Simple | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (u v : ↑G.vertexSet), u ≠ v ∧ G.Adj ↑u ↑v → v ≠ u ∧ G.Adj ↑v ↑u | null | false |
CategoryTheory.GradedObject.instFiniteElemProdNatOfPredEqHAddFstSnd | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ (n : ℕ), Finite ↑{i | i.1 + i.2.1 + i.2.2 = n} | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceFrom_lt_sliceFrom_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | null | false |
_private.Mathlib.Tactic.IntervalCases.0.Mathlib.Tactic.IntervalCases.natMethods.match_4 | Mathlib.Tactic.IntervalCases | (e : Q(ℕ)) →
(motive : ℤ × (e' : Q(ℕ)) × Q(«$e» = «$e'») → Sort u_1) →
(x : ℤ × (e' : Q(ℕ)) × Q(«$e» = «$e'»)) →
((z : ℤ) → (e_1 : Q(ℕ)) → (p : Q(«$e» = «$e_1»)) → motive (z, ⟨e_1, p⟩)) → motive x | null | false |
Primrec.ofNat | Mathlib.Computability.Primrec.Basic | ∀ (α : Type u_4) [inst : Denumerable α], Primrec (Denumerable.ofNat α) | null | true |
_private.Lean.Meta.Tactic.Util.0.Lean.Meta.saturate.go.match_1 | Lean.Meta.Tactic.Util | (motive : Option (List Lean.MVarId) → Sort u_1) →
(__do_lift : Option (List Lean.MVarId)) →
(Unit → motive none) → ((mvarIds : List Lean.MVarId) → motive (some mvarIds)) → motive __do_lift | null | false |
CategoryTheory.PreOneHypercover.toPullback_fst | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) {i₁ i₂ : E.I₀}
[inst_1 : CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)] (k : E.I₁ i₁ i₂),
CategoryTheory.CategoryStruct.comp (E.toPullback k) (CategoryTheory.Limits.pullback.fst (E.f i₁) (E.f i₂)) = E.p₁ k | null | true |
rpow_mul_exp_neg_mul_rpow_isLittleO_exp_neg | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | ∀ (s : ℝ) {b p : ℝ},
1 < p → 0 < b → (fun x => x ^ s * Real.exp (-b * x ^ p)) =o[Filter.atTop] fun x => Real.exp (-(1 / 2) * x) | null | true |
DoResultPRBC.break.noConfusion | Init.Core | {α β σ : Type u} → {P : Sort u_1} → {a a' : σ} → DoResultPRBC.break a = DoResultPRBC.break a' → (a ≍ a' → P) → P | null | false |
CategoryTheory.NatTrans.CommShift | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F₁ F₂ : CategoryTheory.Functor C D} →
(F₁ ⟶ F₂) →
(A : Type u_5) →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheor... | If `τ : F₁ ⟶ F₂` is a natural transformation between two functors
which commute with a shift by an additive monoid `A`, this typeclass
asserts a compatibility of `τ` with these shifts. | true |
Monoid.PushoutI.NormalWord.Pair.mk._flat_ctor | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
{d : Monoid.PushoutI.NormalWord.Transversal φ} →
{i : ι} →
G i →
(tail : Monoid.CoprodI.Word G... | null | false |
Batteries.CodeAction.holeKindToHoleString | Batteries.CodeAction.Misc | Lean.Name → String → String | Constructs a hole with a kind matching the provided hole elaborator. | true |
WittVector.frobeniusRotationCoeff | Mathlib.RingTheory.WittVector.FrobeniusFractionField | (p : ℕ) →
[hp : Fact (Nat.Prime p)] →
{k : Type u_1} →
[inst : Field k] →
[CharP k p] → [IsAlgClosed k] → {a₁ a₂ : WittVector p k} → a₁.coeff 0 ≠ 0 → a₂.coeff 0 ≠ 0 → ℕ → k | Recursively defines the sequence of coefficients for `WittVector.frobeniusRotation`. | true |
Lean.Core.Context.Cold.currMacroScope._default | Lean.CoreM | ℕ | null | false |
Std.Sat.AIG.Cache.WF.below.rec | Std.Sat.AIG.Basic | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α]
{motive :
(a : Array (Std.Sat.AIG.Decl α)) → (a_1 : Std.HashMap (Std.Sat.AIG.Decl α) ℕ) → Std.Sat.AIG.Cache.WF a a_1 → Prop}
{motive_1 :
{a : Array (Std.Sat.AIG.Decl α)} →
{a_1 : Std.HashMap (Std.Sat.AIG.Decl α) ℕ} →
(t : Std.Sat.AIG.Ca... | null | false |
CategoryTheory.LocalizerMorphism.IsLeftDerivabilityStructure | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Basic | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} → CategoryTheory.LocalizerMorphism W₁ W₂ → Prop | A localizer morphism `Φ : LocalizerMorphism W₁ W₂` is a left derivability
structure if it has left resolutions and the 2-square where the top and bottom functors
are localization functors for `W₁` and `W₂` is Guitart exact. | true |
_private.Aesop.Forward.State.0.Aesop.instBEqPatSubstSource.beq._sparseCasesOn_1 | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Zero.0.LinearMap.charpoly_eq_X_pow_iff._proof_1_2 | Mathlib.LinearAlgebra.Eigenspace.Zero | 3 ≠ 0 | null | false |
MeasureTheory.StronglyMeasurable.real_toNNReal | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {x : MeasurableSpace α} {f : α → ℝ},
MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => (f x).toNNReal | null | true |
_private.Mathlib.Data.List.Intervals.0.List.Ico.mem._proof_1_2 | Mathlib.Data.List.Intervals | ∀ {n m l : ℕ}, n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m | null | false |
ContinuousOpenMap.coe_id | Mathlib.Topology.Hom.Open | ∀ (α : Type u_2) [inst : TopologicalSpace α], ⇑(ContinuousOpenMap.id α) = id | null | true |
PrincipalSeg.image_Iio | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder β] [inst_1 : PartialOrder α] (f : α <i β) (a : α),
⇑f.toRelEmbedding '' Set.Iio a = Set.Iio (f.toRelEmbedding a) | null | true |
_private.Init.Omega.Int.0.Lean.Omega.Int.ofNat_min._simp_1_1 | Init.Omega.Int | ∀ {m n : ℕ}, (↑m ≤ ↑n) = (m ≤ n) | null | false |
KaehlerDifferential.endEquiv._proof_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
SMulCommClass S S Ω[S⁄R] | null | false |
ByteArray.set!.match_1 | Init.Data.ByteArray.Basic | (motive : ByteArray → ℕ → UInt8 → Sort u_1) →
(x : ByteArray) →
(x_1 : ℕ) →
(x_2 : UInt8) → ((bs : Array UInt8) → (i : ℕ) → (b : UInt8) → motive { data := bs } i b) → motive x x_1 x_2 | null | false |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocs.match_1 | Lean.Linter.MissingDocs | (motive : Option Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Option Lean.Linter.MissingDocs.Handler) →
((h : Lean.Linter.MissingDocs.Handler) → motive (some h)) →
((x : Option Lean.Linter.MissingDocs.Handler) → motive x) → motive x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_map_equiv._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
BitVec.DivModState.Lawful.hw | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {args : BitVec.DivModArgs w} {qr : BitVec.DivModState w} {h : BitVec.DivModState.Lawful args qr}, 0 < w | A lawful DivModState implies `w > 0`. | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_inst | Lean.Meta.IndPredBelow | SizeOf Lean.Meta.IndPredBelow.Context✝ | null | false |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.serreDerivativeOne_E2_slash._proof_1_2 | Mathlib.NumberTheory.ModularForms.RamanujanFormula | (11 + 1).AtLeastTwo | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.