name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TensorProduct.LieModule.map._proof_1 | Mathlib.Algebra.Lie.TensorProduct | ∀ {R : Type u_3} [inst : CommRing R] {L : Type u_6} {M : Type u_5} {N : Type u_4} {P : Type u_1} {Q : Type u_2}
[inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M]
[inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N]
[in... | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isValidForSlice | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice},
pat.isEmpty = false →
∀ {pos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat.copy.toByteArray s.copy.toByteArray
pat.utf8ByteSize pos.byteIdx →
String.Pos.Raw.IsValidForSlice s (pos.unoffsetBy pat.rawEndPos) → String.Pos.Raw.Is... | null | true |
FreeGroup.mulEquivIntOfUnique._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} [inst : Unique α] (x : Multiplicative ℤ),
(⇑Multiplicative.ofAdd ∘ ⇑FreeGroup.equivIntOfUnique) ((⇑FreeGroup.equivIntOfUnique.symm ∘ ⇑Multiplicative.toAdd) x) =
x | null | false |
CategoryTheory.FreeBicategory.homCategory' | Mathlib.CategoryTheory.Bicategory.Coherence | {B : Type u} →
[inst : Quiver B] → (a b : B) → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.FreeBicategory.Hom a b) | Category structure on `Hom a b`. In this file, we will use `Hom a b` for `a b : B`
(precisely, `FreeBicategory.Hom a b`) instead of the definitionally equal expression
`a ⟶ b` for `a b : FreeBicategory B`. The main reason is that we have to annoyingly write
`@Quiver.Hom (FreeBicategory B) _ a b` to get the latter expre... | true |
UInt32.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a * b = { toBitVec := a.toBitVec * b.toBitVec } | null | true |
List.findIdx_map | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} (xs : List α) (f : α → β) (p : β → Bool),
List.findIdx p (List.map f xs) = List.findIdx (p ∘ f) xs | null | true |
ZeroHom.mk.noConfusion | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
{inst : Zero M} →
{inst_1 : Zero N} →
{P : Sort u} →
{toFun : M → N} →
{map_zero' : toFun 0 = 0} →
{toFun' : M → N} →
{map_zero'' : toFun' 0 = 0} →
{ toFun := toFun, map_zero' := map_zero' } = {... | null | false |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x < y) = (x.toInt < y.toInt) | null | false |
Lean.Meta.LazyDiscrTree.InitEntry._sizeOf_1 | Lean.Meta.LazyDiscrTree | {α : Type} → [SizeOf α] → Lean.Meta.LazyDiscrTree.InitEntry α → ℕ | null | false |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.findAux.match_1.splitter | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) →
(motive : Batteries.UnionFind.FindAux self.size → Sort u_1) →
(x : Batteries.UnionFind.FindAux self.size) →
((arr₁ : Array Batteries.UFNode) →
(root : Fin self.size) → (H : arr₁.size = self.size) → motive { s := arr₁, root := root, size_eq := H }) →
motive x | null | true |
Lean.MonadStateCacheT | Lean.Util.MonadCache | (α : Type) → Type → (Type → Type) → [BEq α] → [Hashable α] → Type → Type | null | true |
MulHom.coe_ofDense | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y), ⇑(MulHom.ofDense f hs hmul) = f | null | true |
CategoryTheory.Arrow.w_mk_assoc | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y X' Y' : T} {f : X ⟶ Y} {g : X' ⟶ Y'}
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {Z : T} (h : Y' ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.left sq) (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.Ca... | null | true |
CategoryTheory.WithInitial.equivComma._proof_12 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
{X Y : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := Ca... | null | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.data_extract._proof_1_4 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {b e : ℕ}, ¬b ≤ e → ¬min e a.data.size ≤ b → False | null | false |
RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic.870781102._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Basic | Subtype (Eq @RatFunc.definition✝) | null | false |
Submonoid.mem_divPairs | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {f : ⊤.LocalizationMap G} {s : Submonoid G}
{x : M × M}, x ∈ Submonoid.divPairs f s ↔ f x.1 / f x.2 ∈ s | null | true |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_free_of_surjective._simp_1_7 | Mathlib.Algebra.Module.FinitePresentation | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{M' : Type u_8} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (v : α → M) (l : α →₀ R),
(Finsupp.linearCombination R (⇑f ∘ v)) l = f ((Finsupp.linearCombination R v) l) | null | false |
Aesop.RuleBuilderOptions.indexingMode? | Aesop.Builder.Basic | Aesop.RuleBuilderOptions → Option Aesop.IndexingMode | null | true |
_private.Lean.Level.0.Lean.Level.normLtAux._unary._proof_3 | Lean.Level | ∀ (l₁ : Lean.Level) (k₁ : ℕ) (l₂ : Lean.Level) (k₂ : ℕ),
(invImage
(fun x =>
PSigma.casesOn x fun a a_1 => PSigma.casesOn a_1 fun a_2 a_3 => PSigma.casesOn a_3 fun a_4 a_5 => (a, a_4))
Prod.instWellFoundedRelation).1
⟨l₁, ⟨k₁, ⟨l₂, k₂ + 1⟩⟩⟩ ⟨l₁, ⟨k₁, ⟨l₂.succ, k₂⟩⟩⟩ | null | false |
MeasureTheory.FiniteMeasure.coeFn_def | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω), ⇑μ = fun s => (↑μ s).toNNReal | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.exists_presentation_of_basis_cotangent._simp_1_3 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
Units.inv_mul_of_eq | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u = a → ↑u⁻¹ * a = 1 | null | true |
Nonneg.mk_smul | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : SMul R S] (a : R) (ha : 0 ≤ a)
(x : S), ⟨a, ha⟩ • x = a • x | null | true |
Set.preimage_singleton_eq_empty | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {y : β}, f ⁻¹' {y} = ∅ ↔ y ∉ Set.range f | null | true |
Set.isSimpleOrder_Iic_iff_isAtom | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a | null | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
{X₁ X₂ X₃ Y₁ Y₂ Y₃ : P.FullSubcategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃... | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.killCompl_X._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ↪ β) (a : α) (m : M),
(fun₀ | f a => m) = Finsupp.embDomain f fun₀ | a => m | null | false |
Quotient.finChoice._proof_2 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (x x_1 : { l // ∀ (i : ι), i ∈ l }),
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 ↔
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 | null | false |
Std.Http.Protocol.H1.Config.maxChunkLineLength._default | Std.Http.Protocol.H1.Config | ℕ | null | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobian._simp_1_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m n : ℕ), (f.sylvester g m n).det = f.resultant g m n | null | false |
RBTree.RBNode.balLeft.match_4.congr_eq_1 | BatteriesRecycling.RBTree.WF | ∀ {α : Type u_1} (motive : RBTree.RBNode α → Sort u_2) (l : RBTree.RBNode α)
(h_1 : (a : RBTree.RBNode α) → (x : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node RBTree.RBColor.red a x b))
(h_2 : (l : RBTree.RBNode α) → motive l) (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α),
l = RBTree.RBNode.node R... | null | true |
GrpWithZero.carrier | Mathlib.Algebra.Category.GrpWithZero | GrpWithZero → Type u_1 | The underlying group with zero. | true |
Std.Do.SPred.exists.match_1 | Std.Do.SPred.SPred | {α : Sort u_3} →
(motive : (σs : List (Type u_1)) → (α → Std.Do.SPred σs) → Sort u_2) →
(σs : List (Type u_1)) →
(P : α → Std.Do.SPred σs) →
((P : α → Std.Do.SPred []) → motive [] P) →
((σ : Type u_1) → (tail : List (Type u_1)) → (P : α → Std.Do.SPred (σ :: tail)) → motive (σ :: tail) P) →... | null | false |
IsPrimitiveRoot.toRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | {M : Type u_1} → [inst : CommMonoid M] → {μ : M} → {n : ℕ} → [NeZero n] → IsPrimitiveRoot μ n → ↥(rootsOfUnity n M) | Turn a primitive root μ into a member of the `rootsOfUnity` subgroup. | true |
Lean.Elab.Tactic.Conv.PatternMatchState.rec | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((subgoals : Array (ℕ × Lean.MVarId)) →
(idx : ℕ) →
(remaining : List (ℕ × ℕ)) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs s... | null | false |
OrderMonoidHom.inrₗ | Mathlib.Algebra.Order.Monoid.Lex | (α : Type u_1) →
(β : Type u_2) →
[inst : Monoid α] → [inst_1 : PartialOrder α] → [inst_2 : Monoid β] → [inst_3 : Preorder β] → β →*o Lex (α × β) | Given ordered monoids M, N, the natural inclusion ordered homomorphism from N to the
lexicographic M ×ₗ N. | true |
selfAdjoint.instField._proof_12 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : ℤ), ↑↑x = ↑↑x | null | false |
WithBot.map_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {β : Type u_1} (f : α → β), WithBot.map f 0 = ↑(f 0) | null | true |
Mathlib.Meta.NormNum.not_isSquare_of_isNNRat_rat_of_num | Mathlib.Tactic.NormNum.IsSquare | ∀ (a : ℚ) (n d : ℕ), ¬IsSquare n → n.Coprime d → Mathlib.Meta.NormNum.IsNNRat a n d → ¬IsSquare a | null | true |
DFinsupp.lsum_single | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} (S : Type u_4) {M : ι → Type u_5} {N : Type u_6} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : AddCommMonoid N]
[inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Semiring S] [inst_7 : Module S N]
[inst_8 : SMulComm... | While `simp` can prove this, it is often convenient to avoid unfolding `lsum` into `sumAddHom`
with `DFinsupp.lsum_apply_apply`. | true |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType | Lean.Meta.Tactic.Grind.AC.Util | Sort u →
{m : Type → Type} →
Lean.Meta.Grind.AC.MonadGetStruct m → {m' : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m' → Sort u | null | false |
_private.Init.Meta.Defs.0.Lean.Name.replacePrefix.match_1 | Init.Meta.Defs | (motive : Lean.Name → Lean.Name → Lean.Name → Sort u_1) →
(x x_1 x_2 : Lean.Name) →
((newP : Lean.Name) → motive Lean.Name.anonymous Lean.Name.anonymous newP) →
((x x_3 : Lean.Name) → motive Lean.Name.anonymous x x_3) →
((n p : Lean.Name) →
(s : String) →
(h : n = p.str s) ... | null | false |
ZeroHom.instModule._proof_1 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r • 0 = 0 | null | false |
Lean.Expr.replace | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | null | true |
Lean.instToJsonPrintImportResult.toJson | Lean.Elab.ParseImportsFast | Lean.PrintImportResult → Lean.Json | null | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.map_add_toList_rcc._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {n k : ℤ}, ¬n + 1 + k = n + k + 1 → False | null | false |
SemiNormedGrp.of.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier] (carrier_1 : Type u)
(str_1 : SeminormedAddCommGroup carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
ConvexOn.lt_left_of_right_lt' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : Module 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s ... | null | true |
MonoidAlgebra.mapAlgHom_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (f : A →ₐ[R] B)
(x : MonoidAlgebra A M) (m : M), ((MonoidAlgebra.mapAlgHom M f) x) m = f (x m) | null | true |
Except.ctorIdx | Init.Prelude | {ε : Type u} → {α : Type v} → Except ε α → ℕ | null | false |
Finset.Ioo_subset_Ioi_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ioo a b ⊆ Finset.Ioi a | null | true |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
AlgebraicGeometry.Scheme.basicOpen_le | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U | null | true |
_private.Lean.Exception.0.Lean.initFn._@.Lean.Exception.2633972168._hygCtx._hyg.2 | Lean.Exception | IO Lean.InternalExceptionId | null | false |
CategoryTheory.Precoverage.mem_coverings_of_isIso | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S ⟶ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f ∈ J.coverings T | **Alias** of `CategoryTheory.Precoverage.HasIsos.mem_coverings_of_isIso`. | true |
Lean.Elab.Attribute.name | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Name | null | true |
Primrec.PrimrecBounded | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → {β : Type u_2} → [Primcodable α] → [Primcodable β] → (α → β) → Prop | A function is `PrimrecBounded` if its size is bounded by a primitive recursive function | true |
Order.Ideal.toLowerSet_injective | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet | null | true |
SimpleGraph.cliqueFinset_eq_empty_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : DecidableRel G.Adj] {n : ℕ},
G.cliqueFinset n = ∅ ↔ G.CliqueFree n | null | true |
LieAlgebra.IsExtension.range_eq_top | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N →ₗ⁅R⁆ L) {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], p.range = ⊤ | null | true |
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Over.Hom.left ε) Y.hom = X.hom | null | false |
Finset.Colex.toColex_sdiff_lt_toColex_sdiff' | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α} [inst_1 : DecidableEq α],
toColex (s \ t) < toColex (t \ s) ↔ toColex s < toColex t | null | true |
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | Lean.Parser.ParserAliasValue → Lean.Parser.ParserResolution | Reference to a parser alias. Note that as aliases are built-in, a corresponding declaration may
not be in the environment (yet).
| true |
HasSubset.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{t : HasSubset α} → {α' : Type u} → {t' : HasSubset α'} → α = α' → t ≍ t' → HasSubset.noConfusionType P t t' | null | false |
Std.DHashMap.Internal.Raw₀.Const.any_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β) {p : α → β → Bool},
((Std.DHashMap.Raw.Const.toList ↑m).any fun x => p x.1 x.2) = (↑m).any p | null | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) → ((pre : Lean.Name) → motive (pre.str "inj")) → ((x : Lean.Name) → motive x) → motive declName | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu | null | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C ⊕ C') | A sum of discrete categories is discrete. | true |
CuspFormClass.rec | Mathlib.NumberTheory.ModularForms.Basic | {F : Type u_2} →
{Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
[inst : FunLike F UpperHalfPlane ℂ] →
{motive : CuspFormClass F Γ k → Sort u} →
([toSlashInvariantFormClass : SlashInvariantFormClass F Γ k] →
(holo : ∀ (f : F), MDiff ⇑f) →
(zero_at_cusps : ∀ (f : F) ... | null | false |
Nat.primorial_dvd_lcmUpto | Mathlib.NumberTheory.Chebyshev | ∀ (n : ℕ), primorial n ∣ n.lcmUpto | null | true |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), b ≤ a → (a - b).toNat = a.toNat - b.toNat | null | true |
Lean.Compiler.CSimp.replaceConstant | Lean.Compiler.CSimpAttr | Lean.Environment → Lean.Expr → Lean.CoreM Lean.Expr | If `e` (as a whole) matches a `[csimp]` theorem, returns the replacement expression, or else `e`.
| true |
Turing.TM1to1.trCfg.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (enc : Γ → List.Vector Bool n) [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (l : Option Λ) (v : σ) (T : Turing.Tape Γ),
Turing.TM1to1.trCfg enc enc0 { l := l, var := v, Tape := T } =
{ l := Option.map Turing.TM1to1.Λ'.normal l, ... | null | true |
GroupExtension.Splitting.conjAct | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → S.Splitting → G →* MulAut N | `G` acts on `N` by conjugation. | true |
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin (as.size + 1)) (hi : Fin as.size),
↑lo ≤ ↑hi → ¬(↑lo + ↑hi) / 2 < as.size → False | null | false |
PNat.XgcdType.flip_b | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.b = u.a | null | true |
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanIleanInfoParams → Sort u} →
(t : Lean.Lsp.LeanIleanInfoParams) →
((version : ℕ) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) → motive { version := version, references := references, decls := decls }) →
motive t | null | false |
Std.HashMap.Raw.getElem_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h : m.WF) {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | ∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), m₁.grevlex m₂ = m₁.grevlex_k m₂ | null | false |
Complex.isOpen_im_lt_EReal | Mathlib.Analysis.Complex.HalfPlane | ∀ (x : EReal), IsOpen {z | ↑z.im < x} | An open lower half-plane (with boundary imaginary part given by an `EReal`) is an open set
in the complex plane. | true |
CategoryTheory.Bundled.mk.noConfusion | Mathlib.CategoryTheory.ConcreteCategory.Bundled | {c : Type u → Type v} →
{P : Sort u_1} →
{α : Type u} →
{str : autoParam (c α) CategoryTheory.Bundled.str._autoParam} →
{α' : Type u} →
{str' : autoParam (c α') CategoryTheory.Bundled.str._autoParam} →
{ α := α, str := str } = { α := α', str := str' } → (α = α' → str ≍ str' → P... | null | false |
Std.ExtDTreeMap.size_le_size_erase | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, t.size ≤ (t.erase k).size + 1 | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._auto_1),
⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩ | null | false |
riemannZeta.eq_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | riemannZeta = HurwitzZeta.hurwitzZetaEven 0 | null | true |
CategoryTheory.ProjectivePresentation.noConfusionType | Mathlib.CategoryTheory.Preadditive.Projective.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
CategoryTheory.ProjectivePresentation X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{X' : C'} → CategoryTheory.ProjectivePresentation X' → Sort u_1 | null | false |
RatFunc.irreducible_minpolyX | Mathlib.FieldTheory.RatFunc.IntermediateField | ∀ {K : Type u_1} [inst : Field K] (f : RatFunc K), (¬∃ c, f = RatFunc.C c) → Irreducible (f.minpolyX ↥K⟮f⟯) | null | true |
WeakSpace.instModule' | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | {𝕜 : Type u_2} →
{𝕝 : Type u_3} →
{E : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
... | null | true |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
Filter.comk.congr_simp | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (p p_1 : Set α → Prop) (e_p : p = p_1) (he : p ∅) (hmono : ∀ (t : Set α), p t → ∀ s ⊆ t, p s)
(hunion : ∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)), Filter.comk p he hmono hunion = Filter.comk p_1 ⋯ ⋯ ⋯ | null | true |
CategoryTheory.Pretriangulated.Triangle.epi₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | null | true |
CategoryTheory.Subfunctor.range | Mathlib.CategoryTheory.Subfunctor.Image | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F F' : CategoryTheory.Functor C (Type w)} → (F' ⟶ F) → CategoryTheory.Subfunctor F | The range of a morphism of type-valued functors, as a subfunctor of the target. | true |
QuaternionAlgebra.equivProd | Mathlib.Algebra.Quaternion | {R : Type u_1} → (c₁ c₂ c₃ : R) → QuaternionAlgebra R c₁ c₂ c₃ ≃ R × R × R × R | The equivalence between a quaternion algebra over `R` and `R × R × R × R`. | true |
AddSemigroupIdeal.fg_iff | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Add M] {I : AddSemigroupIdeal M}, I.FG ↔ ∃ s, I = AddSemigroupIdeal.closure ↑s | null | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.matchesAt_iff_matchesAt_decide._simp_1_2 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt p pos pos' =
String.Slice.Pattern.Model.IsLongestMatchAt (fun x => decide (p x)) pos pos' | null | false |
Vector.set_mk._proof_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n) {i : ℕ} {x : α} (w : i < n), (xs.set i x ⋯).size = n | null | false |
Std.ExtTreeMap.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp}, t.isEmpty = (t.size == 0) | null | true |
NormedAddGroupHom.incl._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] (s : AddSubgroup V), ∃ C, ∀ (v : ↥s), ‖↑v‖ ≤ C * ‖v‖ | null | false |
Part.Mem | Mathlib.Data.Part | {α : Type u_1} → Part α → α → Prop | `a ∈ o` means that `o` is defined and equal to `a` | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.