name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CauSeq.Completion.Cauchy.divisionRing._proof_5 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (n : ℕ) (a : CauSeq.Completion.Cauchy abv),
a ^ ↑n.succ = a ^ ↑n * a | null | false |
TypeCat.symmetric_of_symmetricRelation | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {X R : Type w} {p₁ p₂ : R ⟶ X} (e : CategoryTheory.SymmetricRelation p₁ p₂), Std.Symm (TypeCat.Rel.ofPair p₁ p₂) | **Alias** of `TypeCat.symm_of_symmetricRelation`.
---
An internal symmetric relation in the category of types gives rise to a standard symmetric
relation. | true |
SchwartzMap.smulLeftCLM_compL_smulLeftCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] {g₁ g₂ : E → 𝕜},
Function.HasTemperateGrowth g₁ →
... | null | true |
_private.Init.Data.Array.Sort.Basic.0.Array.MergeSort.Internal.merge._proof_2 | Init.Data.Array.Sort.Basic | ∀ {α : Type u_1} (xs ys : Subarray α), 1 < Std.Slice.size ys → ¬0 < Std.Slice.size ys - 1 → False | null | false |
Lean.Meta.Grind.Arith.Linear.LinearM.Context._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | SizeOf Lean.Meta.Grind.Arith.Linear.LinearM.Context | null | false |
RpcEncodablePacket._sizeOf_inst._@.Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1 | Mathlib.Tactic.Widget.SelectPanelUtils | SizeOf RpcEncodablePacket✝ | null | false |
List.destutter'_eq_self_iff._simp_1 | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (l : List α) (R : α → α → Prop) [inst : DecidableRel R] (a : α),
(List.destutter' R a l = a :: l) = List.IsChain R (a :: l) | null | false |
LinearEquiv.isPositive_symm_iff._simp_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E ≃ₗ[𝕜] E}, (↑T.symm).IsPositive = (↑T).IsPositive | null | false |
_private.Lean.Elab.SetOption.0.Lean.Elab.elabSetOption.setOption | Lean.Elab.SetOption | {m : Type → Type} →
[Monad m] →
[Lean.MonadOptions m] →
[Lean.MonadError m] → Lean.Name → Lean.OptionDecl → Lean.DataValue → m (Lean.Options × Lean.OptionDecl) | null | true |
_private.Init.Data.List.Pairwise.0.List.pairwise_and_iff.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {S : α → α → Prop}
(motive : List.Pairwise R l ∧ List.Pairwise S l → Prop) (x : List.Pairwise R l ∧ List.Pairwise S l),
(∀ (hR : List.Pairwise R l) (hS : List.Pairwise S l), motive ⋯) → motive x | null | false |
Std.DTreeMap.Raw.Const.get!_insert_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {k : α} {v : β}, Std.DTreeMap.Raw.Const.get! (t.insert k v) k = v | null | true |
Turing.TM1to1.trTape_mk' | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {n : ℕ} {enc : Γ → List.Vector Bool n} [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (L R : Turing.ListBlank Γ),
Turing.TM1to1.trTape enc0 (Turing.Tape.mk' L R) = Turing.TM1to1.trTape' enc0 L R | null | true |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isIsotypic_iff_isFullyInvariant_imp_bot_or_top.match_1_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(motive : (∃ m ≤ N, IsSimpleModule R ↥m) → Prop) (x : ∃ m ≤ N, IsSimpleModule R ↥m),
(∀ (S : Submodule R M) (le : S ≤ N) (right : IsSimpleModule R ↥S), motive ⋯) → motive x | null | false |
CompactlySupportedContinuousMap.instMulActionWithZeroOfContinuousConstSMul | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : Zero β] →
{R : Type u_5} →
[inst_3 : MonoidWithZero R] →
[inst_4 : MulActionWithZero R β] →
[ContinuousConstSMul R β] → MulActionWithZero R (C... | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderColimitsOfShape.inverseImage | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {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] (J : Type u') [inst_2 : CategoryTheory.Category.{v', u'} J]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) [P.IsClosedUnderColimitsOfShape J]
[CategoryTheory.Limits... | null | true |
Subring.coe_pow._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : Ring R] (s : Subring R) (x : ↥s) (n : ℕ), ↑x ^ n = ↑(x ^ n) | null | false |
RelIso.symm_symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s), e.symm.symm = e | null | true |
Std.ExtTreeSet.get!_empty | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α] {a : α}, ∅.get! a = default | null | true |
Lean.Meta.Sym.Simp.instInhabitedResult | Lean.Meta.Sym.Simp.SimpM | Inhabited Lean.Meta.Sym.Simp.Result | null | true |
Polynomial.rootsExpandToRoots._proof_2 | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R] (x x_1 : ↥((Polynomial.expand R p) f).roots.toFinset), ⟨↑x ^ p, ⋯⟩ = ⟨↑x_1 ^ p, ⋯⟩ → x = x_1 | null | false |
Finset.cons | Mathlib.Data.Finset.Insert | {α : Type u_1} → (a : α) → (s : Finset α) → a ∉ s → Finset α | `cons a s h` is the set `{a} ∪ s` containing `a` and the elements of `s`. It is the same as
`insert a s` when it is defined, but unlike `insert a s` it does not require `DecidableEq α`,
and the union is guaranteed to be disjoint. | true |
Std.DTreeMap.Internal.Unit.RocSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} [inst : Ord α] [inst_1 : SizeOf α] (treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit)
(range : Std.Roc α), sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | null | true |
Lean.Grind.Ring.zsmul_natCast_eq_nsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (n : ℕ) (a : α), ↑n • a = n • a | Scalar multiplication by natural numbers is consistent with scalar multiplication by integers. | true |
Lean.Elab.Do.DoElemContKind.duplicable | Lean.Elab.Do.Basic | Lean.Elab.Do.DoElemContKind | null | true |
PartialEquiv.prod._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {δ : Type u_4} (e : PartialEquiv α β) (e' : PartialEquiv γ δ),
∀ p ∈ e.target ×ˢ e'.target, (↑e.symm p.1, ↑e'.symm p.2) ∈ e.source ×ˢ e'.source | null | false |
_private.Mathlib.CategoryTheory.IsoCat.0.CategoryTheory.Functor.strictInv._proof_3 | Mathlib.CategoryTheory.IsoCat | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] (F : CategoryTheory.Functor C D) [inst_2 : F.IsIso] (X : D),
F.preimage
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (Cate... | null | false |
ByteArray.utf8Decode?.go | Init.Data.String.Basic | (b : ByteArray) → (i : ℕ) → Array Char → i ≤ b.size → Option (Array Char) | null | true |
Fin.orderSucc_eq | Mathlib.Order.SuccPred.Fin | ∀ {n : ℕ}, Order.succ = fun i => Fin.lastCases (Fin.last n) Fin.succ i | null | true |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.qNF.mkAddProof._unary._proof_2 | Mathlib.Tactic.Module | ∀ {u v : Lean.Level} {M : Q(Type v)} {R : Q(Type u)} (a₁ : Q(«$R»)) (x₁ : Q(«$M»)) (k₁ : ℕ)
(t₁ : List ((Q(«$R») × Q(«$M»)) × ℕ)) (a₂ : Q(«$R»)) (x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((Q(«$R») × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun l₁ l₂ => (l₁, l₂)) Prod.instWellFoundedRelation).1 ⟨t₁, ((a₂, x₂), ... | null | false |
UniqueProds.instMulOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Mul G] [h : UniqueProds G], UniqueProds Gᵐᵒᵖ | null | true |
MulAction.toPermHom | Mathlib.Algebra.Group.Action.End | (G : Type u_1) → (α : Type u_4) → [inst : Group G] → [MulAction G α] → G →* Equiv.Perm α | Given an action of a group `G` on a set `α`, each `g : G` defines a permutation of `α`. | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.StartsWithResult | Lean.Meta.Tactic.Grind.AC.Seq | Type | Result type for `s₁.startsWith s₂`
| true |
Std.ExtTreeMap.instMembershipOfTransCmp | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Membership α (Std.ExtTreeMap α β cmp) | null | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.parseRequestLine.match_1 | Std.Http.Protocol.H1.Parser | (motive : Std.Http.RequestTarget × ℕ × ℕ → Sort u_1) →
(x : Std.Http.RequestTarget × ℕ × ℕ) →
((uri : Std.Http.RequestTarget) → (major minor : ℕ) → motive (uri, major, minor)) → motive x | null | false |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocContext.close._proof_2 | Lean.DocString.Extension | ∀ (ctx : Lean.VersoModuleDocs.DocContext✝),
¬(Lean.VersoModuleDocs.DocContext.context✝ ctx).size = 0 → 0 < (Lean.VersoModuleDocs.DocContext.context✝ ctx).size | null | false |
LinearEquiv.det | Mathlib.LinearAlgebra.Determinant | {R : Type u_1} →
[inst : CommRing R] → {M : Type u_2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (M ≃ₗ[R] M) →* Rˣ | On a `LinearEquiv`, the domain of `LinearMap.det` can be promoted to `Rˣ`. | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.log_riemannZeta_eq_neg_log_sub_add_ofReal._proof_1_2 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℝ}, s > 1 → (riemannZeta ↑s).re = (s - 1)⁻¹ * (riemannZeta₁ ↑s).re → ¬(s - 1)⁻¹ = 0 | null | false |
SemiNormedGrp.of.sizeOf_spec | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier], sizeOf ↧carrier = 1 + sizeOf carrier + sizeOf str | null | true |
IsOrderedCancelAddMonoid.of_add_lt_add_left | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : LinearOrder α],
(∀ (a b c : α), b < c → a + b < a + c) → IsOrderedCancelAddMonoid α | null | true |
Matrix.isSymm_one | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α], Matrix.IsSymm 1 | null | true |
IsField.toField._proof_2 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Ring R] (h : IsField R) (a b : R), a * b = b * a | null | false |
CategoryTheory.MorphismProperty.monotone_paths | Mathlib.CategoryTheory.PathCategory.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C], Monotone CategoryTheory.MorphismProperty.paths | If `W` and `W'` are morphism properties on `C` such that `W ≤ W'`, then `W.paths ≤ W'.paths`. | true |
CategoryTheory.SimplicialObject.augmentedCechNerve_map_left_app | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
{X Y : CategoryTheory.Arrow C} (F : X ⟶ Y) (n : SimplexCategoryᵒᵖ),
(CategoryTheory.SimplicialObject.augmentedCechNer... | null | true |
compl_unique | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ⊓ b = ⊥ → a ⊔ b = ⊤ → aᶜ = b | null | true |
StructureGroupoid.LocalInvariantProp.liftPropOn_congr | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {G : StructureGroupoid H} {G' : StructureGroupoid H'}
{P : (H → H') → Se... | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.forallTelescopeReducingAux | Lean.Meta.Basic | {α : Type} → Lean.Expr → Option ℕ → (Array Lean.Expr → Lean.Expr → Lean.MetaM α) → Bool → Bool → Lean.MetaM α | null | true |
AddMonoidAlgebra.bialgEquivOfSubsingleton.eq_1 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} (M : Type u_8) [inst : CommSemiring R] [inst_1 : AddMonoid M] [inst_2 : Subsingleton M],
AddMonoidAlgebra.bialgEquivOfSubsingleton M =
{ toCoalgHom := (Bialgebra.counitBialgHom R (AddMonoidAlgebra R M)).toCoalgHom,
invFun := ⇑(algebraMap R (AddMonoidAlgebra R M)), left_inv := ⋯, right_inv :... | null | true |
Set.biUnionEqSigmaOfDisjoint._proof_1 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s : Set ι} {f : ι → Set α}, ⋃ x ∈ s, f x = ⋃ x, f ↑x | null | false |
LinearMap.compl₁₂.eq_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {Mₗ : Type u_6} {N : Type u_7}
{Pₗ : Type u_9} {Qₗ : Type u_10} {Qₗ' : Type u_11} [inst_2 : AddCommMonoid Mₗ] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid Pₗ] [inst_5 : AddCommMonoid Qₗ] [inst_6 : AddCommMonoid Qₗ'] [inst_7 : Module... | null | true |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.findSyntheticFieldCompletion? | Lean.Server.Completion.SyntheticCompletion | Lean.FileMap →
String.Pos.Raw → Lean.Syntax → Lean.Elab.InfoTree → Option Lean.Server.Completion.ContextualizedCompletionInfo | null | true |
Complex.exists_continuousOn_pow_eq | Mathlib.Analysis.Complex.BranchLogRoot | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyPathConnectedSpace X] {U : Set X},
IsSimplyConnected U →
IsOpen U →
∀ {g : X → ℂ}, ContinuousOn g U → 0 ∉ g '' U → ∀ {n : ℕ}, n ≠ 0 → ∃ f, ContinuousOn f U ∧ ∀ (x : X), f x ^ n = g x | If `g : X → ℂ` defined on a locally path connected space
is continuous on an open simply connected set `U` and `0 ∉ g '' U`,
then for any `n ≠ 0`, there exists a continuous branch of `ⁿ√g` on `U`.
More precisely, there exists a function `f : X → ℂ` continuous on `U`
such that `(f x) ^ n = g x` for all `x`. | true |
Lean.Lsp.DocumentChange.create.injEq | Lean.Data.Lsp.Basic | ∀ (a a_1 : Lean.Lsp.CreateFile), (Lean.Lsp.DocumentChange.create a = Lean.Lsp.DocumentChange.create a_1) = (a = a_1) | null | true |
CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.coequalizerCoconeIsColimit | Mathlib.CategoryTheory.Limits.Constructions.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[inst_2 : CategoryTheory.Limits.HasPushouts C] →
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C) →
CategoryTheory.Limits.IsColimit
(Categ... | Show the equalizing cocone is a colimit | true |
Std.TreeMap.getKeyD_eq_of_contains | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
{k fallback : α}, t.contains k = true → t.getKeyD k fallback = k | null | true |
TopologicalSpace.Closeds.isUniformEmbedding_coe | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], IsUniformEmbedding SetLike.coe | null | true |
Filter.bliminf_eq_liminf_subtype | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop},
Filter.bliminf u f p = Filter.liminf (u ∘ Subtype.val) (Filter.comap Subtype.val f) | null | true |
Lean.PrettyPrinter.OneLine.State._sizeOf_1 | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.OneLine.State → ℕ | null | false |
AddOpposite.instAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α],
AddOpposite.instAddCommMonoid = { toAddMonoid := AddOpposite.instAddMonoid, add_comm := ⋯ } | null | true |
FirstOrder.Field.FieldAxiom.toSentence._proof_3 | Mathlib.ModelTheory.Algebra.Field.Basic | NeZero (0 + 1 + 1) | null | false |
Subsemiring.instSMulWithZeroSubtypeMem | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : NonAssocSemiring R'] →
{S' : Type u_5} →
[inst_1 : SetLike S' R'] →
[inst_2 : SubsemiringClass S' R'] → (s : S') → [inst_3 : Zero α] → [SMulWithZero R' α] → SMulWithZero (↥s) α | null | true |
_private.Mathlib.Algebra.Group.Units.Defs.0.AddUnits.isAddUnit_add_addUnits.match_1_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] (a : M) (u : AddUnits M) (motive : IsAddUnit (a + ↑u) → Prop)
(x : IsAddUnit (a + ↑u)), (∀ (v : AddUnits M) (hv : ↑v = a + ↑u), motive ⋯) → motive x | null | false |
ImportGraph.Lake.computeInputHash | ImportGraph.WorkspaceModel.Summary.Cache | String → Option Lake.ToolchainVer → System.FilePath → System.FilePath → Array System.FilePath → IO Lake.Hash | Internal helper shared by cache validation and the workspace-summary executable.
Hashes the toolchain identity and workspace configuration files. | true |
instAddCommGroupPadic._proof_14 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (a : ℚ_[p]), -a + a = 0 | null | false |
StieltjesFunction.mono' | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (self : StieltjesFunction R), Monotone ↑self | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty.0.SimplexCategory.Truncated.morphismProperty_eq_top._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ}, ∀ n < d, n ≤ d | null | false |
CategoryTheory.yonedaMonObjIsoOfRepresentableBy._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ MonCat) (α : (F.comp (CategoryTheory.forget MonCat)).RepresentableBy X)
{X_1 Y : Cᵒᵖ} (φ : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yone... | null | false |
SkewPolynomial.erase_monomial | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] {n : ℕ} {a : R}, SkewPolynomial.erase n ((SkewPolynomial.monomial n) a) = 0 | null | true |
_private.Mathlib.NumberTheory.DiophantineApproximation.Basic.0.Real.aux₁._proof_1_8 | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ {v : ℤ}, 2 ≤ v → v = 1 → False | null | false |
ContinuousAt.snd' | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : Y → Z} {x : X} {y : Y}, ContinuousAt f y → ContinuousAt (fun x => f x.2) (x, y) | Precomposing `f` with `Prod.snd` is continuous at `(x, y)` | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minEntry?_insertEntry._simp_1_5 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) | null | false |
irreducible_pow_sup_of_ge | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {T : Type u_4} [inst : CommRing T] [IsDedekindDomain T] {I J : Ideal T},
I ≠ ⊥ → Irreducible J → ∀ (n : ℕ), emultiplicity J I ≤ ↑n → J ^ n ⊔ I = J ^ multiplicity J I | **Alias** of `Ideal.irreducible_pow_sup_of_ge`. | true |
circleAverage_log_norm_sub_const₂ | Mathlib.Analysis.SpecialFunctions.Integrals.PosLog | ∀ {a : ℂ}, 1 < ‖a‖ → Real.circleAverage (fun x => Real.log ‖x - a‖) 0 1 = Real.log ‖a‖ | If `a : ℂ` has norm greater than one, then `circleAverage (log ‖· - a‖) 0 1` equals `log ‖a‖`.
| true |
RegularWreathProduct | Mathlib.GroupTheory.RegularWreathProduct | Type u_1 → Type u_2 → Type (max u_1 u_2) | The regular wreath product of groups `Q` and `D`. It is the product `(Q → D) × Q` with the group
operation `⟨a₁, a₂⟩ * ⟨b₁, b₂⟩ = ⟨a₁ * (fun x ↦ b₁ (a₂⁻¹ * x)), a₂ * b₂⟩`. | true |
MeasurableSet.setOf_infinite | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [Countable α], MeasurableSet {s | s.Infinite} | **Alias** of `MeasurableSet.setOfPred_infinite`. | true |
SetRel.finiteDimensional_iff | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (r : SetRel α α), r.FiniteDimensional ↔ ∃ x, ∀ (y : RelSeries r), y.length ≤ x.length | null | true |
Multiset.countP_False | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s : Multiset α}, Multiset.countP (fun x => False) s = 0 | null | true |
Lean.RecursorVal.mk._flat_ctor | Lean.Declaration | Lean.Name →
List Lean.Name → Lean.Expr → List Lean.Name → ℕ → ℕ → ℕ → ℕ → List Lean.RecursorRule → Bool → Bool → Lean.RecursorVal | null | false |
Lean.RecursorRule.mk.injEq | Lean.Declaration | ∀ (ctor : Lean.Name) (nfields : ℕ) (rhs : Lean.Expr) (ctor_1 : Lean.Name) (nfields_1 : ℕ) (rhs_1 : Lean.Expr),
({ ctor := ctor, nfields := nfields, rhs := rhs } = { ctor := ctor_1, nfields := nfields_1, rhs := rhs_1 }) =
(ctor = ctor_1 ∧ nfields = nfields_1 ∧ rhs = rhs_1) | null | true |
AdicCompletion.instAlgebra._proof_6 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (I : Ideal R) [inst_2 : Algebra S R]
(x y : S),
⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) (x * y), ⋯⟩ =
⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) x, ⋯⟩ * ⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) y, ⋯⟩ | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertIfNew._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (t : Std.DTreeMap.Internal.Impl α β), ¬t.size ≤ t.size → False | null | false |
Lean.Meta.getLitValueModulus? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option ℕ) | Returns the modulus of the wrapping numeric type `α` (`n` for `Fin n`, `2^w` for the
fixed-width types) if it is known. `USize`/`ISize` are not included: their widths are
platform-dependent.
| true |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.ctorIdx | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} →
{inst : CategoryTheory.Category.{v, u} J} →
{F : CategoryTheory.Functor J (Type w₀)} → {c : F.CoconeTypes} → c.IsColimitCore → ℕ | null | false |
CategoryTheory.ChosenPullbacksAlong.isoInv_pullback_obj_right_as | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y X : C} (f : Y ≅ X) (Z : CategoryTheory.Over Y),
((CategoryTheory.ChosenPullbacksAlong.pullback f.inv).obj Z).right.as = PUnit.unit | null | true |
List.get_permutations'Aux | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (s : List α) (x : α) (n : ℕ) (hn : n < (List.permutations'Aux x s).length),
(List.permutations'Aux x s).get ⟨n, hn⟩ = s.insertIdx n x | null | true |
Ideal.pow_multiset_sum_mem_span_pow | Mathlib.RingTheory.Ideal.Basic | ∀ {α : Type u_2} [inst : CommSemiring α] [inst_1 : DecidableEq α] (s : Multiset α) (n : ℕ),
s.sum ^ (s.card * n + 1) ∈ Ideal.span ↑(Multiset.map (fun x => x ^ (n + 1)) s).toFinset | null | true |
CochainComplex.HomComplex.instAddCommGroupCohomologyClass._proof_18 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
autoParam (∀ (a b : CochainComplex.HomComplex.CohomologyClass K L n), a - b = a + -b)
SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
conditionallyCompleteLatticeOfLatticeOfsSup._proof_2 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : Lattice α] (a b : α), ∃ x, x ∈ lowerBounds {a, b} | null | false |
NormalSpace.of_paracompactSpace_r1Space | Mathlib.Topology.Compactness.Paracompact | ∀ {X : Type v} [inst : TopologicalSpace X] [R1Space X] [ParacompactSpace X], NormalSpace X | **Dieudonné's theorem**: a paracompact R₁ space is normal.
Formalization is based on the proof
at [ncatlab](https://ncatlab.org/nlab/show/paracompact+Hausdorff+spaces+are+normal). | true |
AffineMap.pi | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_2} →
{V1 : Type u_3} →
{P1 : Type u_4} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : AddTorsor V1 P1] →
[inst_3 : Module k V1] →
{ι : Type u_9} →
{φv : ι → Type u_10} →
{φp : ι → Type u_11} →
... | `pi` construction for affine maps. From a family of affine maps it produces an affine
map into a family of affine spaces.
This is the affine version of `LinearMap.pi`.
| true |
Submonoid.mem_op._simp_2 | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {x : Mᵐᵒᵖ} {S : Submonoid M}, (x ∈ S.op) = (MulOpposite.unop x ∈ S) | null | false |
_private.Mathlib.Algebra.Homology.SpectralSequence.Basic.0.CategoryTheory.SpectralSequence._proof_9 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.SpectralSequence._auto_3 →
autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_5 → r₀ ≤ r' | null | false |
Std.ExtTreeMap.minKey_insert_of_isEmpty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → (t.insert k v).minKey ⋯ = k | null | true |
convexHullAddMonoidHom._proof_1 | Mathlib.Analysis.Convex.Combination | ∀ (R : Type u_2) (E : Type u_1) [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R], (convexHull R) 0 = 0 | null | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.forIn'_eq_match_step.match_3.splitter | Init.Data.Iterators.Lemmas.Consumers.Loop | {α β : Type u_1} →
[inst : Std.Iterator α Id β] →
{it : Std.Iter β} →
(motive : it.Step → Sort u_2) →
(x : it.Step) →
((it' : Std.Iter β) →
(out : β) →
(h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩) →
... | null | true |
Sublattice.mem_iInf | Mathlib.Order.Sublattice | ∀ {ι : Sort u_1} {α : Type u_2} [inst : Lattice α] {a : α} {f : ι → Sublattice α}, a ∈ ⨅ i, f i ↔ ∀ (i : ι), a ∈ f i | null | true |
LinearMap.sub_mem_ker_iff | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {x y : M}, x - y ∈ f.ker ↔ f x = f y | null | true |
MultilinearMap.dfinsuppFamily_compLinearMap_lsingle | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type uι} {κ : ι → Type uκ} {R : Type uR} {M : (i : ι) → κ i → Type uM} {N : ((i : ι) → κ i) → Type uN}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : κ i) ... | null | true |
Submodule.Quotient.module'._proof_2 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (P : Submodule R M)
(x x_1 : M), Submodule.Quotient.mk (x + x_1) = Submodule.Quotient.mk x + Submodule.Quotient.mk x_1 | null | false |
_private.Mathlib.Analysis.Normed.Algebra.Exponential.0.NormedSpace.star_exp._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star x ^ n = star (x ^ n) | null | false |
Mathlib.Tactic.BicategoryCoherence.assoc_liftHom₂ | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] [inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g]
[inst_3 : Mathlib.Tactic.BicategoryCoherence.LiftHom h] (η : f ⟶ g) (θ : g ⟶ h) (ι : h ⟶ i)
[Mathlib.Tactic.BicategoryCohe... | Auxiliary simp lemma for the `coherence` tactic:
this move brackets to the left in order to expose a maximal prefix
built out of unitors and associators.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.