name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Indistinguishable | Mathlib.Probability.Process.Indistinguishable | {ι : Type u_1} →
{Ω : Type u_2} →
{E : Type u_3} → {mΩ : MeasurableSpace Ω} → MeasureTheory.Measure Ω → (ι → Ω → E) → (ι → Ω → E) → Prop | Two processes are indistinguishable if almost surely they agree everywhere. | true |
HomotopicalAlgebra.PrepathObject.RightHomotopy.op._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {P : HomotopicalAlgebra.PrepathObject Y}
{f g : X ⟶ Y} (h : P.RightHomotopy f g), CategoryTheory.CategoryStruct.comp P.op.i₁ h.h.op = g.op | null | false |
Stream'.Seq.ofList._proof_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (l : List α) {n : ℕ}, (fun x => l[x]?) n = none → (fun x => l[x]?) (n + 1) = none | null | false |
AddCommGrpCat.limitCone._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections],
Small.{u_1, max u_1 u_2}
↑((F.comp (CategoryTheory.forget₂ AddCommGrpCat AddGrpCat)).comp (CategoryTheory.forget AddGrp... | null | false |
borel_anti | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1}, Antitone (@borel α) | null | true |
Std.DTreeMap.Internal.Impl.maxEntry.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.In... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux.isCompatible_α._proof_1_5 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {n : ℕ} {i : Fin n} (k : Fin (n + 2)), i.succ.succ ≤ k → i.succ.succ < k → i.succ.succ.succ < k.succ | null | false |
Std.TreeMap.instSliceableRioSlice | Std.Data.TreeMap.Slice | {α : Type u} →
{β : Type v} →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.instSliceableRioSlice._auto_1) →
Std.Rio.Sliceable (Std.TreeMap α β cmp) α (Std.DTreeMap.Internal.Const.RioSlice α β) | null | true |
HurwitzZeta.sinKernel.eq_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (x : ℝ), HurwitzZeta.sinKernel a x = ⋯.lift a | null | true |
UInt64.instLawfulOrderOrd | Init.Data.Ord.UInt | Std.LawfulOrderOrd UInt64 | null | true |
CategoryTheory.WithInitial.mkCommaObject_right_map | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) {X Y : C} (f : X ⟶ Y),
(CategoryTheory.WithInitial.mkCommaObject F).right.map f = F.map (CategoryTheory.WithInitial.incl.map f) | null | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctor_obj | 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} {S' : C} {p : S' ⟶ S} {ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j : ι') → ... | null | true |
SimpleGraph.Subgraph.topIso._proof_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : ↑⊤.verts), ⟨↑x, ⋯⟩ = x | null | false |
BotHom.instDistribLattice._proof_4 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : DistribLattice β] [inst_2 : OrderBot β] (x x_1 : BotHom α β),
⇑(x ⊓ x_1) = ⇑(x ⊓ x_1) | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.toOption.eq_3 | Init.Data.String.Pattern.String | ∀ {s : String.Slice} (needle : String.Slice) (table : Vector ℕ needle.utf8ByteSize)
(ht : table = String.Slice.Pattern.ForwardSliceSearcher.buildTable needle) (stackPos needlePos : String.Pos.Raw)
(hn : needlePos < needle.rawEndPos),
String.Slice.Pattern.ForwardSliceSearcher.toOption✝
(String.Slice.Pattern.... | null | true |
ProbabilityTheory.variance_sub_const | Mathlib.Probability.Moments.Variance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[MeasureTheory.IsProbabilityMeasure μ],
MeasureTheory.AEStronglyMeasurable X μ →
∀ (c : ℝ), ProbabilityTheory.variance (fun ω => X ω - c) μ = ProbabilityTheory.variance X μ | null | true |
Mathlib.Tactic.Ring.Common.Cache.ctorIdx | Mathlib.Tactic.Ring.Common | {u : Lean.Level} → {α : Q(Type u)} → {sα : Q(CommSemiring «$α»)} → Mathlib.Tactic.Ring.Common.Cache sα → ℕ | null | false |
_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instBEqAuxDeclCacheKey.beq._proof_2 | Lean.Compiler.LCNF.AuxDeclCache | ∀ (a b : Lean.Compiler.LCNF.Purity) (h : (a == b) = true), ⋯ ≍ ⋯ | null | false |
_private.Init.Data.Option.Instances.0.Option.eq_none_of_isNone.match_1_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} (motive : (x : Option α) → x.isNone = true → Prop) (x : Option α) (x_1 : x.isNone = true),
(∀ (x : none.isNone = true), motive none x) → motive x x_1 | null | false |
Order.IsIdeal.Directed | Mathlib.Order.Ideal | ∀ {P : Type u_2} [inst : LE P] {I : Set P}, Order.IsIdeal I → DirectedOn (fun x1 x2 => x1 ≤ x2) I | The ideal is upward directed. | true |
CategoryTheory.Pretriangulated.productTriangle.π_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | null | true |
SimpleGraph.Subgraph.instFinite | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} [Finite V], Finite G.Subgraph | null | true |
CategoryTheory.Limits.Pi.map_π | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : (b : β) → f b ⟶ g b)
(b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.map p) (CategoryTheory.Limits.Pi.π g b) =
... | null | true |
MeasureTheory.AEEqFun.mul_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Mul γ] [inst_3 : ContinuousMul γ] (f g : α →ₘ[μ] γ), (f * g).toGerm = f.toGerm * g.toGerm | null | true |
MvPolynomial.coeff_linearCombination_X_pow | Mathlib.Algebra.MvPolynomial.Coeff | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] (a : σ →₀ R) (s : σ →₀ ℕ) (n : ℕ),
((Finsupp.linearCombination R MvPolynomial.X) a ^ n).coeff s =
if (s.sum fun x m => m) = n then ↑s.multinomial * s.prod fun r m => a r ^ m else 0 | null | true |
UpperSet.Ici_ne_top._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (UpperSet.Ici a = ⊤) = False | null | false |
CategoryTheory.ObjectProperty.fullMonoidalClosedSubcategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : P.IsMonoidalClosed] (X : P.FullSubcategory) ⦃X_1 Y : P.FullSubcategory⦄ (f : X_1 ⟶ Y),
Cate... | null | false |
_private.Lean.IdentifierSuggestion.0.Lean.throwUnknownNameWithSuggestions.match_1 | Lean.IdentifierSuggestion | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((prefixName : Lean.Name) → motive (some prefixName)) → motive x | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.exactlyChars.go._unary._proof_1 | Std.Time.Format.Basic | ∀ (size : ℕ) (acc : String) (count : ℕ),
¬count ≥ size →
∀ (res : Char),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun acc count => size - count)
⟨acc.push res, count.succ⟩ ⟨acc, count⟩ | null | false |
SupHom.subtypeVal | Mathlib.Order.Hom.Lattice | {β : Type u_3} →
[inst : SemilatticeSup β] → {P : β → Prop} → (Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) → SupHom { x // P x } β | `Subtype.val` as a `SupHom`. | true |
CStarMatrix.of_add_of | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Add A] (f g : Matrix m n A),
CStarMatrix.ofMatrix f + CStarMatrix.ofMatrix g = CStarMatrix.ofMatrix (f + g) | null | true |
Lean.Expr.hasLooseBVarInExplicitDomain | Lean.Expr | Lean.Expr → ℕ → Bool → Bool | Returns true if `e` contains the loose bound variable `bvarIdx` in an explicit parameter,
or in the range if `considerRange == true`.
Additionally, if the bound variable appears in an implicit parameter,
it transitively looks for that implicit parameter.
| true |
CategoryTheory.Adjunction.homEquiv_naturality_right_square | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X)
(g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y'),
CategoryTheory.CategoryStru... | null | true |
LinearEquiv.coe_injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {modM : Module R M} {modM₂ : Module S M₂} {σ : R →+* S}
{σ' : S →+* R} [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ], Function.Injective DFu... | null | true |
Mathlib.Tactic.Group.group | Mathlib.Tactic.Group | Lean.ParserDescr | `group` normalizes expressions in multiplicative groups that occur in the goal. `group` does not
assume commutativity, instead using only the group axioms without any information about which group
is manipulated. If the goal is an equality, and after normalization the two sides are equal, `group`
closes the goal.
For ... | true |
Std.Rxi.HasSize.casesOn | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
(t : Std.Rxi.HasSize α) → ((size : α → ℕ) → motive { size := size }) → motive t | null | false |
_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM.match_1 | Lean.Util.ReplaceLevel | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.la... | null | false |
SeparationQuotient.instRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
Congr!.plausiblyEqualTypes._unsafe_rec | Mathlib.Tactic.CongrExclamation | Lean.Expr → Lean.Expr → optParam ℕ 5 → Lean.MetaM Bool | null | false |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{l : List ((a : α) × β a)}, (↑(t.insertMany l ⋯)).isEmpty = (t.isEmpty && l.isEmpty) | null | true |
MeasurableEq.mk | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet (Set.diagonal α) → MeasurableEq α | null | true |
instComplSubtypeProdAndEqHMulFstSndOfNatHAdd | Mathlib.Algebra.Order.Ring.Idempotent | {R : Type u_1} → [inst : CommMonoid R] → [inst_1 : AddCommMonoid R] → Compl { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 } | null | true |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b : α), a + b = a - -b | null | false |
Plausible.InjectiveFunction.instArbitraryInt | Mathlib.Testing.Plausible.Functions | Plausible.Arbitrary (Plausible.InjectiveFunction ℤ) | null | true |
HomotopicalAlgebra.CategoryWithCofibrations.recOn | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : HomotopicalAlgebra.CategoryWithCofibrations C → Sort u_1} →
(t : HomotopicalAlgebra.CategoryWithCofibrations C) →
((cofibrations : CategoryTheory.MorphismProperty C) → motive { cofibrations := cofibrations }) → motive t | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.restrict_lintegral._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (x : α),
(f x ∈ f.range) = True | null | false |
_private.Mathlib.Order.Setoid.Partition.0.IndexedPartition.proj_fiber._simp_1_1 | Mathlib.Order.Setoid.Partition | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
LieAlgebra.isNilpotent_ad_of_mem_rootSpace | Mathlib.Algebra.Lie.Weights.Chain | ∀ {L : Type u_2} [inst : LieRing L] {K : Type u_4} [inst_1 : Field K] [CharZero K] [inst_3 : LieAlgebra K L]
(H : LieSubalgebra K L) [inst_4 : LieRing.IsNilpotent ↥H] [LieModule.IsTriangularizable K (↥H) L]
[FiniteDimensional K L] {x : L} {χ : ↥H → K},
χ ≠ 0 → x ∈ LieAlgebra.rootSpace H χ → IsNilpotent ((LieAlgeb... | null | true |
Nat.isLeast_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (Set.ofPred p).Infinite → ∀ (n : ℕ), IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n) | null | true |
CliffordAlgebra.reverseOp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (m : M),
CliffordAlgebra.reverseOp ((CliffordAlgebra.ι Q) m) = MulOpposite.op ((CliffordAlgebra.ι Q) m) | null | true |
Std.Time.Modifier.s.noConfusion | Std.Time.Format.Modifier | {P : Sort u} →
{presentation presentation' : Std.Time.Number} →
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation' → (presentation = presentation' → P) → P | null | false |
Lean.Meta.Grind.mkExtension._auto_1 | Lean.Meta.Tactic.Grind.Extension | Lean.Syntax | null | false |
Lean.ScopedEnvExtension.ScopedEntries.casesOn | Lean.ScopedEnvExtension | {β : Type} →
{motive : Lean.ScopedEnvExtension.ScopedEntries β → Sort u} →
(t : Lean.ScopedEnvExtension.ScopedEntries β) →
((map : Lean.SMap Lean.Name (Lean.PArray β)) → motive { map := map }) → motive t | null | false |
NonUnitalSubsemiring.instSetLike | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → SetLike (NonUnitalSubsemiring R) R | null | true |
_private.ImportGraph.Shake.DeclNeeds.0.ImportGraph.Shake.instOrdComptimeDependency.ord.match_1 | ImportGraph.Shake.DeclNeeds | (motive : ImportGraph.Shake.ComptimeDependency → ImportGraph.Shake.ComptimeDependency → Sort u_1) →
(x x_1 : ImportGraph.Shake.ComptimeDependency) →
((a : Lean.IndirectModUse) →
(a_1 : Array Lean.Name) →
(b : Lean.IndirectModUse) →
(b_1 : Array Lean.Name) →
motive (Impo... | null | false |
_private.Mathlib.CategoryTheory.Generator.Preadditive.0.CategoryTheory.Preadditive.isSeparating_iff._simp_1_1 | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Lean.Server.handleCodeActionResolve | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeAction → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Lsp.CodeAction) | Handler for `"codeAction/resolve"`.
[reference](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#codeAction_resolve)
| true |
PartialHomeomorph.eq_symm_apply | Mathlib.Topology.PartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialHomeomorph X Y)
{x : X} {y : Y}, x ∈ e.source → y ∈ e.target → (x = ↑e.symm y ↔ ↑e x = y) | null | true |
Subgroup.isMulFG_top_iff | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_1} [inst : Group G], IsMulFG ↥⊤ ↔ IsMulFG G | null | true |
Lean.Elab.Term.elabWithoutExpectedTypeAttr | Lean.Elab.App | Lean.TagAttribute | Instructs the elaborator to elaborate applications of the given declaration without an expected
type. This may prevent the elaborator from incorrectly inferring implicit arguments.
| true |
PseudoMetricSpace.noConfusionType | Mathlib.Topology.MetricSpace.Pseudo.Defs | Sort u_1 → {α : Type u} → PseudoMetricSpace α → {α' : Type u} → PseudoMetricSpace α' → Sort u_1 | null | false |
Real.tendsto_rightDeriv_mul_log_atTop | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | Filter.Tendsto (fun x => derivWithin (fun x => x * Real.log x) (Set.Ioi x) x) Filter.atTop Filter.atTop | null | true |
Array.prod_reverse_nat | Init.Data.Array.Nat | ∀ (xs : Array ℕ), xs.reverse.prod = xs.prod | null | true |
Lean.Kernel.Exception.toMessageData | Lean.Message | Lean.Kernel.Exception → Lean.Options → Lean.MessageData | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k k' fallback : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).getKeyD k' fallback =
if compare k k' = Ordering.eq then if ... | null | true |
Lean.Lsp.instFromJsonPartialResultParams | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.PartialResultParams | null | true |
isOpen_sum_iff | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s) | null | true |
instAssociativeXor_mathlib | Mathlib.Data.LawfulXor.Basic | ∀ {α : Type u_1} [inst : XorOp α] [inst_1 : Zero α] [LawfulXor α], Std.Associative XorOp.xor | null | true |
UniformSpace.Completion.uniformSpace._proof_4 | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α)))
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α))) | null | false |
Monoid.toMulAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_1) [inst : Monoid M] (a : M), 1 * a = a | null | false |
Batteries.BinaryHeap.singleton_wf._simp_1 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} [inst : Ord α] {x : α}, (Batteries.BinaryHeap.singleton x).WF = True | null | false |
subsingleton_iff_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroOneClass M₀], 0 = 1 ↔ Subsingleton M₀ | In a monoid with zero, zero equals one if and only if all elements of that semiring
are equal. | true |
Lean.instEmptyCollectionPrefixTree | Lean.Data.PrefixTree | {α : Type u_1} → {β : Type u_2} → {p : α → α → Ordering} → EmptyCollection (Lean.PrefixTree α β p) | null | true |
Equiv.removeNone_aux_none | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α}, e (some x) = none → some (e.removeNoneAux x) = e none | **Alias** of `Equiv.removeNoneAux_none`. | true |
Int32.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n ≤ 2147483647 → (OfNat.ofNat n).toISize = OfNat.ofNat n | null | true |
MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
{f : α → F} {C : NNReal}, (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ C) → MeasureTheory.eLpNormEssSup f μ ≤ ↑C | null | true |
ZeroLEOneClass.rec | Mathlib.Algebra.Order.ZeroLEOne | {α : Type u_2} →
[inst : Zero α] →
[inst_1 : One α] →
[inst_2 : LE α] →
{motive : ZeroLEOneClass α → Sort u} → ((zero_le_one : 0 ≤ 1) → motive ⋯) → (t : ZeroLEOneClass α) → motive t | null | false |
UpperHalfPlane.IsZeroAtImInfty.petersson_isZeroAtImInfty_left | Mathlib.NumberTheory.ModularForms.Petersson | ∀ {F : Type u_1} {F' : Type u_2} [inst : FunLike F UpperHalfPlane ℂ] [inst_1 : FunLike F' UpperHalfPlane ℂ] (k : ℤ)
(Γ : Subgroup (GL (Fin 2) ℝ)) [Fact (IsCusp OnePoint.infty Γ)] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ]
[ModularFormClass F Γ k] [ModularFormClass F' Γ k] {f : F},
UpperHalfPlane.IsZeroAtImInfty... | null | true |
List.Vector.instLawfulTraversableFlipNat | Mathlib.Data.Vector.Basic | ∀ {n : ℕ}, LawfulTraversable (flip List.Vector n) | null | true |
SymbolicDynamics.FullShift.Pattern.rec | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{G : Type u_2} →
[inst : Inhabited A] →
{motive : SymbolicDynamics.FullShift.Pattern A G → Sort u} →
((config : G → A) →
(support : Finset G) →
(condition : ∀ g ∉ support, config g = default) →
motive { config := config, support := support, ... | null | false |
AddSubmonoid.instInfSet._proof_2 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (s : Set (AddSubmonoid M)) {a b : M},
a ∈ ⋂ t ∈ s, ↑t → b ∈ ⋂ t ∈ s, ↑t → a + b ∈ ⋂ x ∈ s, ↑x | null | false |
PFunctor.Approx.Agree.continu | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : PFunctor.Approx.CofixA F 0) (y : PFunctor.Approx.CofixA F 1), PFunctor.Approx.Agree x y | null | true |
SlashInvariantForm.constℝ._proof_1 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetPlusMinusOne] (x : ℝ),
∀ g ∈ Γ,
∀ (τ : UpperHalfPlane),
SlashAction.map 0 g (Function.const UpperHalfPlane ↑x) τ = Function.const UpperHalfPlane (↑x) τ | null | false |
Eq.mpr_prop | Init.SimpLemmas | ∀ {p q : Prop}, p = q → q → p | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.congr._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
_private.Mathlib.Data.QPF.Multivariate.Basic.0.MvQPF.mem_supp._proof_1_1 | Mathlib.Data.QPF.Multivariate.Basic | ∀ {n : ℕ} {F : TypeVec.{u_1} n → Type u_2} [q : MvQPF F] {α : TypeVec.{u_1} n} (x : F α) (i : Fin2 n) (u : α i),
(∀ (a : (MvQPF.P F).A) (f : ((MvQPF.P F).B a).Arrow α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ) →
∀ ⦃P : (i : Fin2 n) → α i → Prop⦄, MvFunctor.LiftP P x → P i u | null | false |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_6 | Mathlib.Algebra.Lie.CartanExists | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) | null | false |
Lean.Meta.SynthInstance.Waiter.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.Waiter → Sort u} →
(t : Lean.Meta.SynthInstance.Waiter) →
((a : Lean.Meta.SynthInstance.ConsumerNode) → motive (Lean.Meta.SynthInstance.Waiter.consumerNode a)) →
motive Lean.Meta.SynthInstance.Waiter.root → motive t | null | false |
Mathlib.Tactic.Matrix.DotProductEq.mk._flat_ctor | Mathlib.Tactic.Matrix.MulExpand | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{aα : Q(Add «$α»)} →
{mα : Q(Mul «$α»)} →
(n : Q(ℕ)) →
(l₁ l₂ : Q(List «$α»)) →
(expr : Q(«$α»)) →
Q(Mathlib.Tactic.Matrix.ListMatrix.dotProduct «$n» «$l₁» «$l₂» = «$expr») →
... | null | false |
LieIdeal.lcs | Mathlib.Algebra.Lie.Nilpotent | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
LieIdeal R L →
(M : Type u_3) →
[inst_3 : AddCommGroup M] → [inst_4 : Module R M] → [inst_5 : LieRingModule L M] → ℕ → LieSubmodule R L M | Given a Lie module `M` over a Lie algebra `L` together with an ideal `I` of `L`, this is the
lower central series of `M` as an `I`-module. The advantage of using this definition instead of
`LieModule.lowerCentralSeries R I M` is that its terms are Lie submodules of `M` as an
`L`-module, rather than just as an `I`-modul... | true |
ExteriorAlgebra.ι | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | (R : Type u1) →
[inst : CommRing R] → {M : Type u2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M →ₗ[R] ExteriorAlgebra R M | The canonical linear map `M →ₗ[R] ExteriorAlgebra R M`.
| true |
AddSubmonoid.leftNeg | Mathlib.GroupTheory.Submonoid.Inverses | {M : Type u_1} → [inst : AddMonoid M] → AddSubmonoid M → AddSubmonoid M | `S.leftNeg` is the additive submonoid containing all the left additive inverses of `S`. | true |
CategoryTheory.Bicategory.Adj.Hom.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {l : a ⟶ b} {r : b ⟶ a}
{adj : CategoryTheory.Bicategory.Adjunction l r} {l_1 : a ⟶ b} {r_1 : b ⟶ a}
{adj_1 : CategoryTheory.Bicategory.Adjunction l_1 r_1},
{ l := l, r := r, adj := adj } = { l := l_1, r := r_1, adj := adj_1 } → l = l_1 ∧ r = r_1 ∧ adj... | null | true |
Matrix.projVandermonde_map | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} {R' : Type u_3} [inst_1 : CommRing R'] (φ : R →+* R') (v w : Fin n → R),
(Matrix.projVandermonde (fun i => φ (v i)) fun i => φ (w i)) = φ.mapMatrix (Matrix.projVandermonde v w) | null | true |
CategoryTheory.Subobject.isoOfEqMk_inv | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f),
(X.isoOfEqMk f h).inv = CategoryTheory.Subobject.ofMkLE f X ⋯ | null | true |
Finset.noncommProd_singleton | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (a : α) (f : α → β), {a}.noncommProd f ⋯ = f a | null | true |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.symm_mem_dilatransvections_iff._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
CategoryTheory.SimplicialObject.σ_δ₀Iter_assoc | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject C) (i : ℕ) {n m : ℕ}
(j : Fin (m + 1)) (hi : autoParam (n + (i + 1) = m + 1) CategoryTheory.SimplicialObject.σ_δ₀Iter._auto_1),
autoParam (↑j ≤ i) CategoryTheory.SimplicialObject.σ_δ₀Iter._auto_3 →
∀ {Z : C} (h :... | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr_v_descCochain_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ (p q : ℤ), p + 1 = q → p = q + -1 | null | false |
String.Pos.instLinearOrderPackage._proof_9 | Init.Data.String.OrderInstances | ∀ {s : String},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Max.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊔ b = if b ≤ a then a else b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.