name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.IR.Decl.uniqueIds | Lean.Compiler.IR.NormIds | Lean.IR.Decl → Bool | Return true if variable, parameter and join point ids are unique | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_3 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {x y : ℝ}, 0 ≤ x → y ≠ 0 → (x ^ y = 0) = (x = 0) | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.get.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(k : α) →
(motive : (t : Std.DTreeMap.Internal.Impl α β) → k ∈ t → Sort u_3) →
(t : Std.DTreeMap.Internal.Impl α β) →
(hlk : k ∈ t) →
((size : ℕ) →
(k' : α) →
(v' : β k') ... | null | true |
TrivSqZeroExt.mul_left_eq_one | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M] [inst_3 : Module R M]
(r : R) (x : TrivSqZeroExt R M),
r * x.fst = 1 → (TrivSqZeroExt.inl r + TrivSqZeroExt.inr (-(MulOpposite.op r • r • x.snd))) * x = 1 | null | true |
Erased.mk._proof_1 | Init.Data.Erased | ∀ {α : Sort u_1} (a : α), ∃ a_1, (fun x => a_1 = x) = fun b => a = b | null | false |
TendstoLocallyUniformlyOn.fun_mul₀ | Mathlib.Topology.MetricSpace.Algebra | ∀ {X : Type u_3} {M : Type u_4} {ι : Type u_5} [inst : TopologicalSpace X] [inst_1 : PseudoMetricSpace M]
[inst_2 : Zero M] [inst_3 : Mul M] [IsBoundedSMul M M] {s : Set X} {F G : ι → X → M} {f g : X → M} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
ContinuousOn ... | Eta-expanded form of `TendstoLocallyUniformlyOn.mul₀` | true |
Monoid.Coprod.mk_surjective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], Function.Surjective ⇑Monoid.Coprod.mk | null | true |
_private.Mathlib.Tactic.NormNum.BigOperators.0.Mathlib.Meta.Nat.unifyZeroOrSucc.match_1 | Mathlib.Tactic.NormNum.BigOperators | (motive : Option Lean.Expr → Sort u_1) →
(__x : Option Lean.Expr) → ((n'_val : Q(ℕ)) → motive (some n'_val)) → ((x : Option Lean.Expr) → motive x) → motive __x | null | false |
monotone_Iic | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} [inst : Preorder α], Monotone Set.Iic | null | true |
Mathlib.Tactic.Sat.LRATStep.noConfusionType | Mathlib.Tactic.Sat.FromLRAT | Sort u → Mathlib.Tactic.Sat.LRATStep → Mathlib.Tactic.Sat.LRATStep → Sort u | null | false |
Lean.Linter.MissingDocs.addBuiltinHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.Linter.MissingDocs.Handler → IO Unit | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.141571828._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
Multiset.toFinset_range | Mathlib.Data.Finset.Range | ∀ (n : ℕ), (Multiset.range n).toFinset = Finset.range n | null | true |
WittVector.mapFun.add | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Fact (Nat.Prime p)]
(f : R →+* S) (x y : WittVector p R),
WittVector.mapFun (⇑f) (x + y) = WittVector.mapFun (⇑f) x + WittVector.mapFun (⇑f) y | null | true |
SimpleGraph.Walk.reverseAux._sunfold | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {V : Type u} → {G : SimpleGraph V} → {u v w : V} → G.Walk u v → G.Walk u w → G.Walk v w | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Log.Basic.0.Mathlib.Meta.Positivity.evalLogNatLit._proof_6 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (inst : Q(DivisionRing ℝ)), «$inst» =Q Real.instDivisionRing | null | false |
SubMulAction.instTop | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : SMul R M] → Top (SubMulAction R M) | null | true |
eq_or_eq_inv_of_mabs_eq | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] {a b : α}, |a|ₘ = b → a = b ∨ a = b⁻¹ | null | true |
Multiset.nat_divisors_prod | Mathlib.Data.Finset.NatDivisors | ∀ (s : Multiset ℕ), s.prod.divisors = (Multiset.map Nat.divisors s).prod | null | true |
SimpleGraph.Finsubgraph.instHNot._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] (G' : G.Finsubgraph), (￢↑G').verts.Finite | null | false |
Nat.add_modEq_left_iff._simp_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a + b ≡ a [MOD n]) = (n ∣ b) | null | false |
frontier_Ico | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[NoMinOrder α] {a b : α}, a < b → frontier (Set.Ico a b) = {a, b} | null | true |
CategoryTheory.colimitCompWhiskeringRightIsoColimitComp | Mathlib.CategoryTheory.Limits.Preserves.FunctorCategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{J : Type u_4} →
[inst_3 : CategoryTheory.Category.{v_4, u_4} J] ... | Whiskering right and then taking a colimit is the same as taking the colimit and applying the
functor. | true |
Lean.Compiler.LCNF.Renaming | Lean.Compiler.LCNF.Renaming | Type | A mapping from free variable id to binder name.
| true |
CategoryTheory.Precoverage.ZeroHypercover.Small.mk | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C}
{E : J.ZeroHypercover S}, (∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) → E.Small | null | true |
Pi.normedAddGroup._proof_2 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NormedAddGroup (G i)] (x y : (i : ι) → G i),
dist x y = ‖-x + y‖ | null | false |
Bool.coe_sort_true | Mathlib.Data.Bool.Basic | (true = true) = True | null | true |
CategoryTheory.Preadditive.RightFreyd.homotopyOfEq._proof_1 | Mathlib.CategoryTheory.Preadditive.FreydCategory.RightFreyd | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{u v : CategoryTheory.Arrow V} (f g : u ⟶ v),
(CategoryTheory.Preadditive.RightFreyd.quotient V).map f = (CategoryTheory.Preadditive.RightFreyd.quotient V).map g →
CategoryTheory.Arrow.rightHomotopic V f g | null | false |
Continuous.rightOrdContinuous | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] {f : α → β} [inst_4 : TopologicalSpace β] [OrderTopology β],
Continuous f → Monotone f → RightOrdContinuous f | A monotone continuous function is right-continuous in the order-theoretic sense. | true |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic.0.inhomogeneousCochains.d._simp_2 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z | null | false |
PowerBasis.quotientEquivQuotientMinpolyMap.eq_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (pb : PowerBasis R S)
(I : Ideal R),
pb.quotientEquivQuotientMinpolyMap I =
(AlgEquiv.ofRingEquiv ⋯).trans (AdjoinRoot.quotEquivQuotMap (minpoly R pb.gen) I) | null | true |
ContDiff.differentiable_one | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
ContDiff 𝕜 1 f → Differentiable 𝕜 f | null | true |
Group.zpow._inherited_default | Mathlib.Algebra.Group.Defs | {G : Type u_2} → G → (G → G → G) → (G → G) → ℤ → G → G | null | false |
Lean.withTraceNode' | Lean.Util.Trace | {α : Type} →
{m : Type → Type} →
[Monad m] →
[Lean.MonadTrace m] →
[Lean.MonadRef m] →
[Lean.AddMessageContext m] →
[Lean.MonadOptions m] →
[Lean.MonadAlwaysExcept Lean.Exception m] →
[MonadLiftT BaseIO m] →
Lean.Name → m (α × Lea... | A version of `Lean.withTraceNode` which allows generating the message within the computation. | true |
ArithmeticFunction.instModule_1._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(r : ArithmeticFunction R), r • 0 = 0 | null | false |
VectorAllP | Mathlib.Data.Vector3 | {α : Type u_1} → {n : ℕ} → (α → Prop) → Vector3 α n → Prop | `VectorAllP p v` is equivalent to `∀ i, p (v i)`, but unfolds directly to a conjunction,
i.e. `VectorAllP p [0, 1, 2] = p 0 ∧ p 1 ∧ p 2`. | true |
MulMemClass.mul_left_mem_add_closure | Mathlib.Algebra.Ring.Submonoid.Basic | ∀ {M : Type u_1} {R : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : SetLike M R] [MulMemClass M R] {S : M}
{a b : R}, a ∈ S → b ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S | The product of an element of `S` and an element of the additive closure of a multiplicative
submonoid `S` is contained in the additive closure of `S`. | true |
MLList.ofList._unsafe_rec | Batteries.Data.MLList.Basic | {α : Type u_1} → {m : Type u_1 → Type u_1} → List α → MLList m α | null | false |
IsTopologicalAddGroup.toHSpace._proof_6 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousAdd M],
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.id M).prodMk (ContinuousMap.const M 0)) =
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousM... | null | false |
Set.encard_le_encard_diff_add_encard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s t : Set α), s.encard ≤ (s \ t).encard + t.encard | **Alias** of `Set.encard_le_encard_sdiff_add_encard`. | true |
UInt8.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 8)), { toBitVec := { toFin := n } } = UInt8.ofFin n | null | true |
LaurentPolynomial.smeval_T_pow | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : MulActionWithZero R S]
[inst_3 : Monoid S] (n : ℤ) (x : Sˣ), (LaurentPolynomial.T n).smeval x = ↑(x ^ n) | null | true |
Lean.Parser.Term.binop_lazy.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
ProfiniteGrp.toLimit._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}), CompactSpace ↑P.1.toTop | null | false |
CategoryTheory.Limits.IsImage.ofIsoI._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
{F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) {I' : C} (e : F.I ≅ I')
(F' : CategoryTheory.Limits.MonoFactorisation f),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.co... | null | false |
Finset.sumLexLift_inl_inl | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
(f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₁)
(b : β₁), Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inl a) (Sum.inl b) = Finset.map Function.Embedding.inl (... | null | true |
Std.Iter.foldl_toArray | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id] {f : γ → β → γ} {init : γ} {it : Std.Iter β},
Array.foldl f init it.toArray = Std.Iter.fold f init it | null | true |
Mathlib.Tactic.Translate.Reorder._sizeOf_inst | Mathlib.Tactic.Translate.Reorder | SizeOf Mathlib.Tactic.Translate.Reorder | null | false |
Lean.MetavarContext.addExprMVarDecl | Lean.MetavarContext | Lean.MetavarContext →
Lean.MVarId →
Lean.Name →
Lean.LocalContext →
Lean.LocalInstances →
Lean.Expr → optParam Lean.MetavarKind Lean.MetavarKind.natural → optParam ℕ 0 → Lean.MetavarContext | Low level API for adding/declaring metavariable declarations.
It is used to implement actions in the monads `MetaM`, `ElabM` and `TacticM`.
It should not be used directly since the argument `(mvarId : MVarId)` is assumed to be "unique". | true |
dualTensorHomEquivOfBasis._proof_3 | Mathlib.LinearAlgebra.Contraction | ∀ {ι : Type u_4} {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Fintype ι]
(b : Module.Basis ι R M),
(∑ i, (TensorProduct.mk R (Module.Dual R M) N) (b.dualBasi... | null | false |
Nat.sub_max_sub_left | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max (a - b) (a - c) = a - min b c | null | true |
UInt64.toUInt8_eq | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a.toUInt8 = b.toUInt8 ↔ a % 256 = b % 256 | null | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_eq_of_lt_fuel._simp_1_4 | Init.Data.Nat.ToString | ∀ {a b : ℕ}, (a / b = 0) = (b = 0 ∨ a < b) | null | false |
Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited α],
t.WF → ∀ {k : α} {f : β → β}, compare (Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey! t.maxKey! = Ordering.eq | null | true |
Cardinal.lift_inj._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{u}}, (Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b) = (a = b) | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_60 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (cond ifTrue ifFalse : Std.Sat.AIG.Fanin),
ifTrue.gate < upper →
∀ (fstate : Std.Sat.AIG.toCNF.State✝ aig),
ifTrue.gate < (Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ fstate)).size | null | false |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (f : (↑R)ᵒᵖ), (CategoryTheory.inducedFunctor PrimeSpectrum.basicOpen).obj (Opposite.unop f) ≤ ⊤ | null | false |
Subtype.exists | Init.Data.Subtype.Basic | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) ↔ ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | true |
BoxIntegral.unitPartition.prepartition._proof_1 | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] (B x : BoxIntegral.Box ι),
x ∈ Finset.image (fun ν => BoxIntegral.unitPartition.box n ν) (BoxIntegral.unitPartition.admissibleIndex n B) → x ≤ B | null | false |
supClosure._proof_1 | Mathlib.Order.SupClosed | ∀ {α : Type u_1} [inst : SemilatticeSup α] (s : Set α), ∀ a ∈ s, ↑{a} ⊆ s ∧ {a}.sup' ⋯ id = a | null | false |
DistribLattice.noConfusionType | Mathlib.Order.Defs.Lattice | Sort u → {α : Type u_1} → DistribLattice α → {α' : Type u_1} → DistribLattice α' → Sort u | null | false |
_private.Mathlib.Algebra.Module.Submodule.RestrictScalars.0.Submodule.codisjoint_restrictScalars_iff._simp_1_1 | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b = (a ⊔ b = ⊤) | null | false |
Real.tendsto_integral_gaussian_smul' | Mathlib.Analysis.Fourier.Inversion | ∀ {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace ℂ E] {f : V → E} [CompleteSpace E],
MeasureTheory.Integrable f MeasureTheory.vo... | null | true |
AffineBasis.instAddAction | Mathlib.LinearAlgebra.AffineSpace.Basis | {ι : Type u_1} →
{k : Type u_5} →
{V : Type u_6} →
{P : Type u_7} →
[inst : AddCommGroup V] →
[inst_1 : AddTorsor V P] → [inst_2 : Ring k] → [inst_3 : Module k V] → AddAction V (AffineBasis ι k P) | null | true |
Ideal.finsuppTotal | Mathlib.RingTheory.Ideal.Operations | (ι : Type u_1) →
(M : Type u_2) →
[inst : AddCommGroup M] →
{R : Type u_3} → [inst_1 : CommRing R] → [inst_2 : Module R M] → (I : Ideal R) → (ι → M) → (ι →₀ ↥I) →ₗ[R] M | A variant of `Finsupp.linearCombination` that takes in vectors valued in `I`. | true |
Lean.PersistentEnvExtensionDescrCore.ctorIdx | Lean.Environment | {α β σ : Type} → Lean.PersistentEnvExtensionDescrCore α β σ → ℕ | null | false |
Int64.toBitVec_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, Int64.minValue.toInt ≤ n → n ≤ Int64.maxValue.toInt → (Int64.ofIntClamp n).toBitVec = BitVec.ofInt 64 n | null | true |
Std.Internal.List.getEntry?_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {f : (a : α) × β a → Bool} {l : List ((a : α) × β a)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getEntry? k (List.filter f l) = Option.filter f (Std.Internal.List.getEntry? k l) | null | true |
String.Slice.Pattern.Model.isLongestRevMatchAt_cast_iff._simp_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s t : String.Slice} (hst : s.copy = t.copy)
{startPos endPos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat (startPos.cast hst) (endPos.cast hst) =
String.Slice.Pattern.Model.IsLongestRevMatchAt pat startPos endPos | null | false |
PerfectRing.comp_lift_apply | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing K] [inst_1 : CommRing L] [inst_2 : CommRing M]
(i : K →+* L) (f : L →+* M) (p : ℕ) [inst_3 : ExpChar M p] [inst_4 : ExpChar K p] [inst_5 : PerfectRing M p]
[inst_6 : IsPRadical i p] [inst_7 : ExpChar L p] (x : L), (PerfectRing.lift i (f.comp i) p) x = ... | null | true |
WeierstrassCurve.Projective.dblXYZ_Y | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P : Fin 3 → R), W'.dblXYZ P 1 = W'.dblY P | null | true |
Set.Nonempty.star | Mathlib.Algebra.Star.Pointwise | ∀ {α : Type u_1} [inst : InvolutiveStar α] {s : Set α}, s.Nonempty → (star s).Nonempty | null | true |
_private.Std.Time.Format.Modifier.0.Std.Time.parseText | Std.Time.Format.Modifier | (Std.Time.Text → Std.Time.Modifier) → String → Std.Internal.Parsec.String.Parser Std.Time.Modifier | null | true |
_private.Mathlib.Lean.Elab.InfoTree.0.Lean.Elab.InfoTree.findSomeM?.match_1 | Mathlib.Lean.Elab.InfoTree | (motive : Option Lean.Elab.ContextInfo → Sort u_1) →
(ctx? : Option Lean.Elab.ContextInfo) →
(Unit → motive none) → ((ctx : Lean.Elab.ContextInfo) → motive (some ctx)) → motive ctx? | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.instance.parenthesizer_321 | Lean.Parser.Command | IO Unit | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.GaussNorm.0.MvPowerSeries.Finset.Nonempty.map_sum_le_sup'_map._simp_1_4 | Mathlib.RingTheory.MvPowerSeries.GaussNorm | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Lean.DefinitionVal.mk.sizeOf_spec | Lean.Declaration | ∀ (toConstantVal : Lean.ConstantVal) (value : Lean.Expr) (hints : Lean.ReducibilityHints)
(safety : Lean.DefinitionSafety) (all : List Lean.Name),
sizeOf { toConstantVal := toConstantVal, value := value, hints := hints, safety := safety, all := all } =
1 + sizeOf toConstantVal + sizeOf value + sizeOf hints + si... | null | true |
Lean.Grind.CommRing.SPolResult.casesOn | Lean.Meta.Sym.Arith.Poly | {motive : Lean.Grind.CommRing.SPolResult → Sort u} →
(t : Lean.Grind.CommRing.SPolResult) →
((spol : Lean.Grind.CommRing.Poly) →
(k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) → motive { spol := spol, k₁ := k₁, m₁ := m₁, k₂ := k₂, ... | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.minEntry?.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : Type u_2} →
(motive : (Std.DTreeMap.Internal.Impl α fun x => β) → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β) →
(r : Std.D... | null | true |
Set.Nontrivial.eq_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} (s : Set α), s.Nontrivial = ∃ x ∈ s, ∃ y ∈ s, x ≠ y | null | true |
continuousOn_cfcₙ_setProd_nhdsSet | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {𝕜 : Type u_2} {A : Type u_3} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : StarRing A]
[inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A] [ContinuousStar A]
[inst_7 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] [CompleteSpace A] ... | null | true |
_private.Mathlib.CategoryTheory.Preadditive.OfBiproducts.0.CategoryTheory.SemiadditiveOfBinaryBiproducts.«term_+ᵣ_» | Mathlib.CategoryTheory.Preadditive.OfBiproducts | Lean.TrailingParserDescr | null | true |
ContinuousGeneratedByCat.toGeneratedByTopCat_obj | Mathlib.Topology.Convenient.Category | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] (X_1 : ContinuousGeneratedByCat X),
ContinuousGeneratedByCat.toGeneratedByTopCat.obj X_1 =
{ obj := ↧(Topology.WithGeneratedByTopology X ↑X_1), property := ⋯ } | null | true |
String.apply_skipSuffixWhile_prop._proof_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String} {h : s.skipSuffixWhile P ≠ s.startPos},
(s.skipSuffixWhile P).prev h ≠ s.endPos | null | false |
Matroid.map_isLoop_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {e : α} {f : α → β} {hf : Set.InjOn f M.E},
autoParam (e ∈ M.E) Matroid.map_isLoop_iff._auto_1 → ((M.map f hf).IsLoop (f e) ↔ M.IsLoop e) | null | true |
PiLp.nnnorm_ofLp | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] (f : PiLp ⊤ β),
‖f.ofLp‖₊ = ‖f‖₊ | null | true |
Valued.toNormedField.norm_le_iff | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [val : Valued L Γ₀]
[hv : Valued.v.RankOne] {x x' : L}, ‖x‖ ≤ ‖x'‖ ↔ Valued.v x ≤ Valued.v x' | null | true |
Matrix.«_aux_Mathlib_Data_Matrix_Mul___macroRules_Matrix_term_ᵥ*__1» | Mathlib.Data.Matrix.Mul | Lean.Macro | null | false |
Topology._aux_Mathlib_Topology_Defs_Basic___macroRules_Topology_Continuous_of_1 | Mathlib.Topology.Defs.Basic | Lean.Macro | null | false |
FirstOrder.Ring.compatibleRingOfRingStructure._proof_6 | Mathlib.ModelTheory.Algebra.Ring.Basic | ∀ (R : Type u_1) [inst : FirstOrder.Language.ring.Structure R] (x : Fin 0 → R),
FirstOrder.Language.Structure.funMap FirstOrder.Ring.zeroFunc x = 0 | null | false |
CategoryTheory.Functor.natTransEquiv_symm_apply_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} (f : F ⟶ G) (x : C),
(CategoryTheory.Functor.natTransEquiv.symm f).app x =
TypeCat.ofHom fun x_1 => CategoryTheory.Functor.HomObj.ofNatTrans f | null | true |
Lattice.ofIsLUBofIsGLB | Mathlib.Order.Bounds.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(sup inf : α → α → α) → (∀ (a b : α), IsLUB {a, b} (sup a b)) → (∀ (a b : α), IsGLB {a, b} (inf a b)) → Lattice α | An alternative constructor for `Lattice` using `IsLUB` and `IsGLB`. | true |
Std.DTreeMap.Raw.Const.getEntryGED | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → {β : Type v} → Std.DTreeMap.Raw α (fun x => β) cmp → α → α × β → α × β | Tries to retrieve the key-value pair with the smallest key that is greater than or equal to the
given key, returning `fallback` if no such pair exists.
| true |
CategoryTheory.SpectralSequence.mk.injEq | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_2}
{c : ℤ → ComplexShape κ} {r₀ : ℤ}
(page : (r : ℤ) → autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_1 → HomologicalComplex C (c r))
(iso :
(r r' : ℤ) →
(pq : κ) →
(hrr' : au... | null | true |
CategoryTheory.Limits.preservesBinaryBiproducts_of_preservesBinaryProducts | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms]
[CategoryTheory.Limits.PreservesLimitsOfShape (C... | A functor between preadditive categories that preserves (zero morphisms and) binary products
preserves binary biproducts. | true |
List.mergeSort_pair | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} (a b : α), [a, b].mergeSort le = if le a b = true then [a, b] else [b, a] | null | true |
Lean.Lsp.DiagnosticSeverity.warning | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticSeverity | null | true |
ContinuousAlternatingMap.add_apply | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f g : M [⋀^ι]→L[R] N) [inst_7 : ContinuousAdd N] (v : ι → M), (f + g) v = f... | null | true |
Metric.PiNatEmbed.toPiNat.sizeOf_spec | Mathlib.Topology.MetricSpace.PiNat | ∀ {ι : Type u_2} {X : Type u_5} {Y : ι → Type u_6} {f : (i : ι) → X → Y i} [inst : SizeOf ι] [inst_1 : SizeOf X]
[inst_2 : (a : ι) → SizeOf (Y a)] (ofPiNat : X), sizeOf { ofPiNat := ofPiNat } = 1 + sizeOf ofPiNat | null | true |
Lean.QuotKind | Lean.Declaration | Type | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.