name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimpleGraph.exists_egirth_eq_length | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α}, (∃ a w, w.IsCycle ∧ G.egirth = ↑w.length) ↔ ¬G.IsAcyclic | null | true |
Lean.Compiler.LCNF.FloatLetIn.instReprDecision.repr | Lean.Compiler.LCNF.FloatLetIn | Lean.Compiler.LCNF.FloatLetIn.Decision → ℕ → Std.Format | null | true |
CategoryTheory.TwistShiftData.mk | Mathlib.CategoryTheory.Shift.Twist | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type w} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
(z : A → A → (CategoryTheory.CatCenter C)ˣ) →
autoParam (z 0 0 = 1) CategoryTheory.TwistShiftData.z_zero_zero._autoParam →
a... | null | true |
ImportGraph.Widget.CopyDisplay.iconOnly.elim | ImportGraph.Widget.Copy | {motive : ImportGraph.Widget.CopyDisplay → Sort u} →
(t : ImportGraph.Widget.CopyDisplay) → t.ctorIdx = 1 → motive ImportGraph.Widget.CopyDisplay.iconOnly → motive t | null | false |
UpperHalfPlane.tendsto_atImInfty_of_hasSum_qExpansion | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ} {c : ℕ → ℂ},
0 < h →
(∀ (τ : UpperHalfPlane), HasSum (fun m => c m • Function.Periodic.qParam h ↑τ ^ m) (f τ)) →
Filter.Tendsto f UpperHalfPlane.atImInfty (nhds (c 0)) | A function on the upper half plane that is given everywhere by a convergent `q`-expansion with
non-negative exponents, `f τ = ∑' m, c m * 𝕢 h τ ^ m`, tends to the constant term of its
`q`-expansion at `i∞`. | true |
Lean.Meta.Grind.CasesEntry.rec | Lean.Meta.Tactic.Grind.Cases | {motive : Lean.Meta.Grind.CasesEntry → Sort u} →
((declName : Lean.Name) → (eager : Bool) → motive { declName := declName, eager := eager }) →
(t : Lean.Meta.Grind.CasesEntry) → motive t | null | false |
RingHom.isUnit_eqLocusS_mk_iff | Mathlib.Algebra.Ring.Subring.Units | ∀ {R : Type u_1} {T : Type u_2} [inst : Semiring T] [inst_1 : Semiring R] (f g : R →+* T) {r : R} (hr : f r = g r),
IsUnit ⟨r, hr⟩ ↔ IsUnit r | null | true |
Module.finrank | Mathlib.LinearAlgebra.Dimension.Finrank | (R : Type u_1) → (M : Type u_2) → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [Module R M] → ℕ | The rank of a module as a natural number.
For a finite-dimensional vector space `V` over a field `k`, `Module.finrank k V` is equal to
the dimension of `V` over `k`.
For a general module `M` over a ring `R`, `Module.finrank R M` is defined to be the supremum of the
cardinalities of the `R`-linearly independent subset... | true |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace.IsUnramified.isUnmixed_conjugate._simp_1_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_1} [inst : Field K] {φ : K →+* ℂ},
NumberField.ComplexEmbedding.IsReal φ = (NumberField.InfinitePlace.mk φ).IsReal | null | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.isPreconnected_Icc.match_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {L : TopologicalSpace.Compacts α} (M : TopologicalSpace.Compacts α)
(motive : M ∈ {K | (↑K).Nonempty ∧ ↑K ⊆ ↑L} → Prop) (x : M ∈ {K | (↑K).Nonempty ∧ ↑K ⊆ ↑L}),
(∀ (left : (↑M).Nonempty) (hM : ↑M ⊆ ↑L), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.fiberwiseColimitLimitIso_inv_app | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
{J : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} J] {F : CategoryTheory.Functor C CategoryTheory.Cat}
(K : CategoryTheory.Functor J (CategoryTheory.Functor (CategoryTheory.Grothendieck F) ... | null | true |
Mathlib.Tactic.Sat.Parser.parseLRAT | Mathlib.Tactic.Sat.FromLRAT | Std.Internal.Parsec.String.Parser (Array Mathlib.Tactic.Sat.LRATStep) | Parse an LRAT file into a list of steps. | true |
PosSMulMono.rec | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulMono α β → Sort u} →
((smul_le_smul_of_nonneg_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b₂ : β⦄, b₁ ≤ b₂ → a • b₁ ≤ a • b₂) → motive ⋯)... | null | false |
UInt32.ofBitVec.inj | Init.Core | ∀ {toBitVec toBitVec_1 : BitVec 32}, { toBitVec := toBitVec } = { toBitVec := toBitVec_1 } → toBitVec = toBitVec_1 | null | true |
Std.DTreeMap.Internal.Impl.WF.interSmallerFn | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] [BEq α] (m₁ m₂ : Std.DTreeMap.Internal.Impl α β)
(hm₂ : m₂.WF) (k : α), (↑(m₁.interSmallerFn ⟨m₂, ⋯⟩ k)).WF | null | true |
Lean.Meta.SolveByElim.ApplyRulesConfig.transparency._default | Lean.Meta.Tactic.SolveByElim | Lean.Meta.TransparencyMode | null | false |
OrderDual.normedCommGroup | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_3} → [NormedCommGroup E] → NormedCommGroup Eᵒᵈ | null | true |
isSublattice_empty._simp_1 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : Lattice α], IsSublattice ∅ = True | null | false |
SimpleGraph.Finsubgraph.coe_top | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} [inst : Finite V], ↑⊤ = ⊤ | null | true |
Aesop.SearchM.run | Aesop.Search.SearchM | {Q : Type} →
[inst : Aesop.Queue Q] →
{α : Type} →
Aesop.LocalRuleSet →
Aesop.Options' →
Lean.Meta.Simp.Config →
Option Lean.Term → Lean.MVarId → Aesop.SearchM Q α → Aesop.BaseM (α × Aesop.SearchM.State Q × Aesop.Tree) | null | true |
Metric.nhds_basis_eball | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} {x : α} [inst : PseudoEMetricSpace α], (nhds x).HasBasis (fun ε => 0 < ε) (Metric.eball x) | null | true |
_private.Mathlib.Analysis.BoxIntegral.Integrability.0.BoxIntegral.hasIntegralIndicatorConst._simp_1_2 | Mathlib.Analysis.BoxIntegral.Integrability | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | null | false |
Topology.CWComplex.map_zero_eq_self_iff | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {D : Set X} (C : Set X) [inst : Topology.RelCWComplex C D]
{x z : Topology.RelCWComplex.cell C 0},
↑(Topology.RelCWComplex.map 0 x) ![] = ↑(Topology.RelCWComplex.map 0 z) ![] ↔ x = z | **Alias** of `Topology.RelCWComplex.map_zero_eq_self_iff`. | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.exists_le_iSup_basicOpen_and_smul_eq_smul_and_eq_const._simp_1_7 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a ^ n * a = a ^ (n + 1) | null | false |
Ordinal._aux_Mathlib_SetTheory_Ordinal_Veblen___unexpand_Ordinal_gamma_1 | Mathlib.SetTheory.Ordinal.Veblen | Lean.PrettyPrinter.Unexpander | null | false |
Set.enumerate_inj | Mathlib.Data.Set.Enumerate | ∀ {α : Type u_1} (sel : Set α → Option α) {n₁ n₂ : ℕ} {a : α} {s : Set α},
(∀ (s : Set α) (a : α), sel s = some a → a ∈ s) →
Set.enumerate sel s n₁ = some a → Set.enumerate sel s n₂ = some a → n₁ = n₂ | null | true |
CategoryTheory.Pseudofunctor.mapAdjunction | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{a b : B} →
{f : a ⟶ b} →
{g : b ⟶ a} →
(F : CategoryTheory.Pseudofunctor B C) →
CategoryTheory.Bicategory.Adjunction f g → CategoryTheo... | A pseudofunctor carries an adjunction `f ⊣ g` to an adjunction `F.map f ⊣ F.map g`. | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.lt_endPos_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String} (p : s.Pos), (p = s.endPos) = (s.endPos ≤ p) | null | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.head_drop._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), (xs.head h = a) = (xs.head? = some a) | null | false |
RBTree.RBNode.isRed | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode α → RBTree.RBColor | Returns `red` if the node is red, otherwise `black`. (Nil nodes are treated as `black`.) | true |
Finsupp.subtypeDomain_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {p : α → Prop} {a : Subtype p} {v : α →₀ M},
(Finsupp.subtypeDomain p v) a = v ↑a | null | true |
_private.Batteries.Tactic.GeneralizeProofs.0.Batteries.Tactic.GeneralizeProofs.instEvalExprConfig | Batteries.Tactic.GeneralizeProofs | Lean.Elab.ConfigEval.EvalExpr Batteries.Tactic.GeneralizeProofs.Config | null | true |
SimpleGraph.Preconnected.map | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {H : SimpleGraph V'} (f : G →g H),
Function.Surjective ⇑f → G.Preconnected → H.Preconnected | null | true |
CategoryTheory.Functor.WellOrderInductionData.sectionsMk.congr_simp | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
(d d_1 : F.WellOrderInductionData),
d = d_1 →
∀ [inst_2 : OrderBot J] [inst_3 : WellFoundedLT J] (val₀ val₀_1 : F.obj (Opposite.op ⊥)),
val₀ = val₀_1 → d.sectionsMk val₀ = d_1.sectionsMk val₀_1 | null | true |
Ring.KrullDimLE.mk₀ | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} [inst : CommSemiring R], (∀ (I : Ideal R), I.IsPrime → I.IsMaximal) → Ring.KrullDimLE 0 R | null | true |
_private.Lean.Meta.GetUnfoldableConst.0.Lean.Meta.getUnfoldableConst?._sparseCasesOn_4 | Lean.Meta.GetUnfoldableConst | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
LinearMap.BilinForm.iIsOrtho.not_isOrtho_basis_self_of_nondegenerate | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {n : Type w}
[Nontrivial R] {B : LinearMap.BilinForm R M} {v : Module.Basis n R M},
B.iIsOrtho ⇑v → B.Nondegenerate → ∀ (i : n), (B (v i)) (v i) ≠ 0 | An orthogonal basis with respect to a nondegenerate bilinear form has no self-orthogonal
elements. | true |
AlgebraicGeometry.Scheme.Modules.instModuleCarrierCarrierObjOppositeOpensCarrierCarrierCommRingCatSpecAbPresheafOp._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {M : (AlgebraicGeometry.Spec R).Modules} {U : (AlgebraicGeometry.Spec R).Opens} (x y : ↑R)
(b : ↑(M.presheaf.obj (Opposite.op U))), (x * y) • b = x • y • b | null | false |
Mathlib.Tactic.LibraryRewrite.Kind.fromCache.sizeOf_spec | Mathlib.Tactic.Widget.LibraryRewrite | sizeOf Mathlib.Tactic.LibraryRewrite.Kind.fromCache = 1 | null | true |
CircleDeg1Lift.sup_apply | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f g : CircleDeg1Lift) (x : ℝ), (f ⊔ g) x = max (f x) (g x) | null | true |
Finset.sum_dite_of_true | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} {s : Finset ι} [inst : AddCommMonoid M] {p : ι → Prop} [inst_1 : DecidablePred p]
(h : ∀ i ∈ s, p i) (f : (i : ι) → p i → M) (g : (i : ι) → ¬p i → M),
(∑ i ∈ s, if hi : p i then f i hi else g i hi) = ∑ i, f ↑i ⋯ | null | true |
LineDeriv.iteratedLineDerivOp_zero | Mathlib.Analysis.Distribution.DerivNotation | ∀ {V : Type u_3} {E : Type u_4} [inst : LineDeriv V E E] {n : ℕ} (m : Fin n → V) [inst_1 : AddCommGroup V]
[inst_2 : AddCommGroup E] [LineDerivAdd V E E], LineDeriv.iteratedLineDerivOp m 0 = 0 | null | true |
WeakDual.instBornology | Mathlib.Analysis.Normed.Module.WeakDual | {𝕜 : Type u_1} →
{E : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Bornology (WeakDual 𝕜 E) | The bornology on `WeakDual 𝕜 F` is the norm bornology inherited from `StrongDual 𝕜 F`.
Note: This is a pragmatic choice. To be precise, the bornology of a weak topology should be
the von Neumann bornology (pointwise boundedness). However, in the normed setting,
`IsBounded` is most useful when referring to the operat... | true |
Mathlib.Tactic.ClickSuggestions.State.solvedSuggestions | Mathlib.Tactic.ClickSuggestions.Util | Mathlib.Tactic.ClickSuggestions.State → Array ProofWidgets.Html | The suggestions that close the goal. | true |
CategoryTheory.instIsConnectedComponent | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] (j : CategoryTheory.ConnectedComponents J),
CategoryTheory.IsConnected j.Component | Each connected component of the category is connected. | true |
Lean.Elab.Tactic.Context.mk.sizeOf_spec | Lean.Elab.Tactic.Basic | ∀ (elaborator : Lean.Name) (recover : Bool),
sizeOf { elaborator := elaborator, recover := recover } = 1 + sizeOf elaborator + sizeOf recover | null | true |
MultipliableLocallyUniformlyOn.exists_multipliableUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {x : β} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] [LocallyCompactSpace β],
MultipliableLocallyUniformlyOn f s → s ∈ nhds x → ∃ t ∈ nhdsWithin x s, MultipliableUniformlyOn f t | null | true |
Sym.fill._proof_1 | Mathlib.Data.Sym.Basic | ∀ {n : ℕ} (i : Fin (n + 1)), n - ↑i + ↑i = n | null | false |
Ideal.span_singleton_eq_bot | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {x : α}, Ideal.span {x} = ⊥ ↔ x = 0 | null | true |
CategoryTheory.powZero | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{B : C} →
[CategoryTheory.BraidedCategory C] →
{I : C} →
CategoryTheory.Limits.IsInitial I →
[inst_3 : CategoryTheory.MonoidalClosed C] → I ⟹ B ≅ Cat... | If an initial object `0` exists in a CCC then `0^B ≅ 1` for any `B`. | true |
_private.Lean.Expr.0.Lean.Expr.updateLambda!Impl | Lean.Expr | Lean.Expr → Lean.BinderInfo → Lean.Expr → Lean.Expr → Lean.Expr | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.two_mul_angle_incenter._simp_1_4 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Lean.Elab.InfoTree.Util.0.Lean.Elab.InfoTree.hoverableInfoAtM?.match_3 | Lean.Elab.InfoTree.Util | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((r : Lean.Syntax.Range) → motive (some r)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | null | false |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.fst_inv_eq_snd_inv._simp_1_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.ofSlice_next._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
Std.Internal.List.eraseKey_cons_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [ReflBEq α] {l : List ((a : α) × β a)} {k : α} {v : β k},
Std.Internal.List.eraseKey k (⟨k, v⟩ :: l) = l | null | true |
Option.getD_choice | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {a : α}, (Option.choice α).getD a = (Option.choice α).get ⋯ | null | true |
Batteries.AssocList.empty_eq | Batteries.Data.AssocList.Lemmas | ∀ {α : Type u_1} {β : Type u_2}, ∅ = Batteries.AssocList.nil | null | true |
MvPolynomial.commAlgEquiv_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u_2} {S₁ : Type u_3} {S₂ : Type u_4} [inst : CommSemiring R] (i : S₁),
(MvPolynomial.commAlgEquiv R S₁ S₂) (MvPolynomial.X i) = MvPolynomial.C (MvPolynomial.X i) | null | true |
Action.FunctorCategoryEquivalence.functorMonoidal._proof_8 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V],
autoParam
(∀ (X Y : Action V G),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ Action.FunctorCategoryEquivalence.functor X ... | null | false |
AffineIsometry.ext | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_4} {P : Type u_7} {P₂ : Type u_8} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMe... | null | true |
Perfect.casesOn | Mathlib.Topology.Perfect | {α : Type u_1} →
[inst : TopologicalSpace α] →
{C : Set α} →
{motive : Perfect C → Sort u} →
(t : Perfect C) → ((closed : IsClosed C) → (acc : Preperfect C) → motive ⋯) → motive t | null | false |
Rat.cast_comm | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_2} [inst : DivisionRing α] (r : ℚ) (a : α), ↑r * a = a * ↑r | null | true |
OrderHom.compₘ | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] → [inst_1 : Preorder β] → [inst_2 : Preorder γ] → (β →o γ) →o (α →o β) →o α →o γ | The composition of two bundled monotone functions, a fully bundled version. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceNatAdd.declare_176._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.1282248690._hygCtx._hyg.21 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
List.suffix_cons_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂ | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_14 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (tail : List α) {n s : ℕ},
n - 1 + 1 ≤ (List.idxsOf x tail (s + 1)).length → n - 1 < (List.idxsOf x tail (s + 1)).length | null | false |
Std.DTreeMap.eraseMany._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {ρ : Type u_3} [inst : ForIn Id ρ α]
(t : Std.DTreeMap α β cmp) (l : ρ), (↑(t.inner.eraseMany l ⋯)).WF | null | false |
_private.Mathlib.RingTheory.Invariant.Galois.0.Ideal.IsFractionRing.normal._simp_1_4 | Mathlib.RingTheory.Invariant.Galois | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
{x_2 : NonAssocSemiring γ} {δ : Type u_5} {x_3 : NonAssocSemiring δ} (f : α →+* β) (g : β →+* γ) (h : γ →+* δ),
h.comp (g.comp f) = (h.comp g).comp f | null | false |
Quiver.casesOn | Mathlib.Combinatorics.Quiver.Basic | {V : Type u} →
{motive : Quiver V → Sort u_1} → (t : Quiver V) → ((Hom : V → V → Type v) → motive { Hom := Hom }) → motive t | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.instIsOrderedRing | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, IsOrderedRing X.IdealSheafData | null | true |
Multiset.filter_subset | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α), Multiset.filter p s ⊆ s | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.brecOn_1.eq | Batteries.Data.MLList.Basic | ∀ {m : Type u → Type u} {α : Type u} {motive_1 : MLList.MLListImpl✝ m α → Sort u_1}
{motive_2 : Thunk (MLList.MLListImpl✝ m α) → Sort u_1} (t : Thunk (MLList.MLListImpl✝ m α))
(F_1 : (t : MLList.MLListImpl✝ m α) → MLList.MLListImpl.below✝ t → motive_1 t)
(F_2 : (t : Thunk (MLList.MLListImpl✝ m α)) → MLList.MLList... | null | true |
CountableSupClosed.mk._flat_ctor | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} [inst : LE α] {s : Set α},
(∀ t ⊆ s, t.Nonempty → t.Countable → ∀ (x : α), IsLUB t x → x ∈ s) → CountableSupClosed s | null | false |
_private.Mathlib.Data.Nat.PSub.0.Nat.sub_eq_psub.match_1_1 | Mathlib.Data.Nat.PSub | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
CategoryTheory.FunctorToTypes.binaryProductCone_pt_obj | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C),
(CategoryTheory.FunctorToTypes.binaryProductCone F G).pt.obj a = (F.obj a × G.obj a) | null | true |
CommRingCat.KaehlerDifferential.map.congr_simp | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {A B A' B' : CommRingCat} {f : A ⟶ B} {f' : A' ⟶ B'} {g g_1 : A ⟶ A'} (e_g : g = g_1) {g' : B ⟶ B'}
(fac : CategoryTheory.CategoryStruct.comp g f' = CategoryTheory.CategoryStruct.comp f g'),
CommRingCat.KaehlerDifferential.map fac = CommRingCat.KaehlerDifferential.map ⋯ | null | true |
MonCat.free._proof_2 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X Y Z : Type u_1} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
MonCat.ofHom (FreeMonoid.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp x x_1))) =
CategoryTheory.CategoryStruct.comp (MonCat.ofHom (FreeMonoid.map ⇑(CategoryTheory.ConcreteCategory.hom x)))
(MonCat.ofHom (FreeMonoid.map ⇑(Catego... | null | false |
Lean.Lsp.RegistrationParams.mk.noConfusion | Lean.Data.Lsp.Client | {P : Sort u} →
{registrations registrations' : Array Lean.Lsp.Registration} →
{ registrations := registrations } = { registrations := registrations' } → (registrations = registrations' → P) → P | null | false |
_private.Mathlib.LinearAlgebra.Transvection.Generation.0.LinearEquiv.sup_span_singleton_lt_top._proof_1_2 | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {K : Type u_1} [inst : DivisionRing K] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{W : Submodule K V},
1 < Module.finrank K (V ⧸ W) →
Module.finrank K (V ⧸ W) + Module.finrank K ↥W = Module.finrank K V →
Module.finrank K V ≤ Module.finrank K ↥W + 1 → False | null | false |
StarMonoidHom.ofClass._proof_2 | Mathlib.Algebra.Star.MonoidHom | ∀ {F : Type u_2} {A : Type u_3} {B : Type u_1} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : FunLike F A B]
[MonoidHomClass F A B] (f : F) (x y : A), f (x * y) = f x * f y | null | false |
List.flatten_replicate_replicate | Init.Data.List.Lemmas | ∀ {n m : ℕ} {α : Type u_1} {a : α}, (List.replicate n (List.replicate m a)).flatten = List.replicate (n * m) a | null | true |
Lean.MonadHashMapCacheAdapter.mk | Lean.Util.MonadCache | {α β : Type} →
{m : Type → Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
m (Std.HashMap α β) → ((Std.HashMap α β → Std.HashMap α β) → m Unit) → Lean.MonadHashMapCacheAdapter α β m | null | true |
ProbabilityTheory.Kernel.densityProcess | Mathlib.Probability.Kernel.Disintegration.Density | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{mα : MeasurableSpace α} →
{mβ : MeasurableSpace β} →
{mγ : MeasurableSpace γ} →
[MeasurableSpace.CountablyGenerated γ] →
ProbabilityTheory.Kernel α (γ × β) → ProbabilityTheory.Kernel α γ → ℕ → α → γ → Set β → ℝ | An `ℕ`-indexed martingale that is a density for `κ` with respect to `ν` on the sets in
`countablePartition γ n`. Used to define its limit `ProbabilityTheory.Kernel.density`, which is
a density for those kernels for all measurable sets. | true |
ClosureOperator.closure_sup_closure_right | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (x ⊔ c y) = c (x ⊔ y) | null | true |
CategoryTheory.ShortComplex.ShortExact.δ_comp_assoc | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (hS : S.ShortExact) (i j : ι)
(hij : c.Rel i j) {Z : C} (h : S.X₂.homology j ⟶ Z),
CategoryTheory.CategoryStruct.comp (h... | null | true |
Decidable.intro.sizeOf_spec | Init.SizeOf | ∀ {p : Prop} [inst : SizeOf p] (decide : Bool) (reflects_decide : decide.Reflects p),
sizeOf { decide := decide, reflects_decide := reflects_decide } = 1 + sizeOf decide + sizeOf reflects_decide | null | true |
Lean.Server.CodeActionResolveData.mk.sizeOf_spec | Lean.Server.CodeActions.Basic | ∀ (params : Lean.Lsp.CodeActionParams) (providerName : Lean.Name) (providerResultIndex : ℕ),
sizeOf { params := params, providerName := providerName, providerResultIndex := providerResultIndex } =
1 + sizeOf params + sizeOf providerName + sizeOf providerResultIndex | null | true |
MeasureTheory.condLExp_congr_ae_trim | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {Ω : Type u_1} {mΩ₀ mΩ : MeasurableSpace Ω} (hm : mΩ ≤ mΩ₀) {P : MeasureTheory.Measure Ω} {X Y : Ω → ENNReal},
X =ᵐ[P] Y → P⁻[X | mΩ] =ᵐ[P.trim hm] P⁻[Y | mΩ] | null | true |
List.forall_mem_ne' | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (∀ a' ∈ l, ¬a' = a) ↔ a ∉ l | null | true |
CategoryTheory.Functor.Monoidal.ε_η_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
(F : CategoryTheory.Functor C D) [self : F.Monoidal] {Z : D}
(h : CategoryTheory.MonoidalCategoryStruct.... | null | true |
biSup_inf_le_biSup_inf | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α) (s : Set β) (a : α),
⨆ i ∈ s, f i ⊓ a ≤ (⨆ i ∈ s, f i) ⊓ a | null | true |
Mathlib.Tactic.Linarith.Preprocessor.casesOn | Mathlib.Tactic.Linarith.Datatypes | {motive : Mathlib.Tactic.Linarith.Preprocessor → Sort u} →
(t : Mathlib.Tactic.Linarith.Preprocessor) →
((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) →
(transform : Lean.Expr → Lean.MetaM (List Lean.Expr)) →
motive { toPreprocessorBase := toPreprocessorBase, transform := trans... | null | false |
Ideal.mul_left_self_sup | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I J : Ideal R}, J * I ⊔ I = I | null | true |
Sigma.Lex.linearOrder._proof_1 | Mathlib.Order.Sigma | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)]
(a b : Σₗ (i : ι), α i), (if a ≤ b then a else b) = if a ≤ b then a else b | null | false |
Lean.Lsp.RefInfo.usages | Lean.Data.Lsp.Internal | Lean.Lsp.RefInfo → Array Lean.Lsp.RefInfo.Location | Usage sites of the reference. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_26 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : ℕ) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size ≤ { aig := aig_1, vec := expr }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExp... | null | false |
AbsolutelyMonotoneOn.contDiffOn | Mathlib.Analysis.Calculus.AbsolutelyMonotone | ∀ {f : ℝ → ℝ} {s : Set ℝ}, AbsolutelyMonotoneOn f s → ContDiffOn ℝ (↑⊤) f s | An absolutely monotone function on `s` is `C^∞` on `s`. | true |
DilationEquiv.symm_symm | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y),
e.symm.symm = e | null | true |
Std.Http.URI.Port._sizeOf_inst | Std.Http.Data.URI.Basic | SizeOf Std.Http.URI.Port | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.