name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.TextDocumentSyncOptions.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncOptions → Sort u} →
((openClose : Bool) →
(change : Lean.Lsp.TextDocumentSyncKind) →
(willSave willSaveWaitUntil : Bool) →
(save? : Option Lean.Lsp.SaveOptions) →
motive
{ openClose := openClose, change := change, willSave := willSav... | null | false |
Ideal.Quotient.algebraMap_quotient_of_ramificationIdx_neZero | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
[inst_3 : NeZero (p.ramificationIdx P)] (x : R),
(algebraMap (R ⧸ p) (S ⧸ P)) ((Ideal.Quotient.mk p) x) = (Ideal.Quotient.mk P) ((algebraMap R S) x) | null | true |
Std.Internal.List.containsKey_iff_exists | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a l = true ↔ ∃ a' ∈ Std.Internal.List.keys l, (a == a') = true | null | true |
QuotientAddGroup.equivIcoMod._proof_2 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a : α) (b : α ⧸ AddSubgroup.zmultiples p), ⋯.lift b ∈ Set.Ico a (a + p) | null | false |
QuadraticModuleCat.instMonoidalCategory.tensorHom | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} →
[inst : CommRing R] →
[inst_1 : Invertible 2] →
{W X Y Z : QuadraticModuleCat R} →
(W ⟶ X) →
(Y ⟶ Z) →
(QuadraticModuleCat.instMonoidalCategory.tensorObj W Y ⟶
QuadraticModuleCat.instMonoidalCategory.tensorObj X Z) | Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`.
We want this up front so that we can re-use it to define `whiskerLeft` and `whiskerRight`. | true |
CategoryTheory.Equalizer.Sieve.SecondObj.ext | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C}
{S : CategoryTheory.Sieve X} (z₁ z₂ : CategoryTheory.Equalizer.Sieve.SecondObj P S),
(∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
(CategoryTheory.ConcreteCategory.hom
(Cate... | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.coeff_mul_prod_one_sub_of_lt_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
NumberField.Units.instFintypeSubtypeUnitsRingOfIntegersMemSubgroupTorsion._proof_1 | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Finite ↑↑(NumberField.Units.torsion K) | null | false |
ZFSet.instReflSubset | Mathlib.SetTheory.ZFC.Basic | Std.Refl fun x1 x2 => x1 ⊆ x2 | null | true |
_private.Mathlib.Topology.UniformSpace.Defs.0.isOpen_uniformity._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} {x : α} {s : Set β} {F : Filter (α × β)},
(s ∈ Filter.comap (Prod.mk x) F) = ({p | p.1 = x → p.2 ∈ s} ∈ F) | null | false |
Std.Rcc.isSome_succMany?_of_lt_length_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {i : ℕ}, i < r.toList.length → (Std.PRange.succMany? i r.lower).isSome = true | null | true |
Multiset.rel_zero_right._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {a : Multiset α}, Multiset.Rel r a 0 = (a = 0) | null | false |
Ideal.mulQuot | Mathlib.RingTheory.OrderOfVanishing.Basic | {R : Type u_1} → [inst : CommRing R] → (a : R) → (I : Ideal R) → R ⧸ I →ₗ[R] R ⧸ a • I | The map `R ⧸ I →ₗ[R] R ⧸ (a • I)` defined by multiplication by `a`
| true |
Filter.comap_lift_eq | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β},
Filter.comap m (f.lift g) = f.lift (Filter.comap m ∘ g) | null | true |
Filter.Germ.const_lt_iff | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : Preorder β] {x y : β}, ↑x < ↑y ↔ x < y | null | true |
FormalMultilinearSeries.rightInv._proof_16 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
_private.Batteries.Data.Array.Scan.0.Array.back?_scanr._simp_1_1 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} (xs : Array α), xs.back? = xs.toList.getLast? | null | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_pt | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)), (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).pt = c.pt | null | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeries._simp_1_1 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Lean.Grind.Linarith.Poly.NonnegCoeffs.brecOn | Init.Grind.Module.NatModuleNorm | ∀ {motive : (a : Lean.Grind.Linarith.Poly) → a.NonnegCoeffs → Prop} {a : Lean.Grind.Linarith.Poly} (t : a.NonnegCoeffs),
(∀ (a : Lean.Grind.Linarith.Poly) (t : a.NonnegCoeffs), Lean.Grind.Linarith.Poly.NonnegCoeffs.below t → motive a t) →
motive a t | null | true |
Lean.Meta.Sym.Arith.ClassifyResult.ctorElim | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.ClassifyResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Sym.Arith.ClassifyResult) →
ctorIdx = t.ctorIdx → Lean.Meta.Sym.Arith.ClassifyResult.ctorElimType ctorIdx → motive t | null | false |
SimpleGraph.Subgraph.Preconnected.casesOn | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | {V : Type u} →
{G : SimpleGraph V} →
{H : G.Subgraph} →
{motive : H.Preconnected → Sort u_1} → (t : H.Preconnected) → ((coe : H.coe.Preconnected) → motive ⋯) → motive t | null | false |
ContinuousLinearMap.isBigOTVS_fun_comp | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} (g : E →L[𝕜] F),
(fun x => g ... | null | true |
Lean.Meta.DefaultInstanceEntry.rec | Lean.Meta.Instances | {motive : Lean.Meta.DefaultInstanceEntry → Sort u} →
((className instanceName : Lean.Name) →
(priority : ℕ) → motive { className := className, instanceName := instanceName, priority := priority }) →
(t : Lean.Meta.DefaultInstanceEntry) → motive t | null | false |
MeasureTheory.lintegral_prod_mul | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → ENNReal} {g : β → ENNReal},
AEMeasurable f μ →
AEMeasurable g ν → ∫⁻ (z : α × β), f z.1 * g z.2 ∂μ.prod ν = (∫⁻ (x : α), f x ∂μ) ... | null | true |
Asymptotics.isBigO_const_mul_self | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] (c : R) (f : α → R) (l : Filter α),
(fun x => c * f x) =O[l] f | null | true |
_private.Mathlib.Algebra.Polynomial.Inductions.0.Polynomial.natDegree_divX_eq_natDegree_tsub_one._simp_1_2 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.divX = 0) = (p = Polynomial.C (p.coeff 0)) | null | false |
Batteries.Tactic.Lint.LintVerbosity._sizeOf_1 | Batteries.Tactic.Lint.Frontend | Batteries.Tactic.Lint.LintVerbosity → ℕ | null | false |
CategoryTheory.Lax.LaxTrans.LaxFunctor.bicategory_associator_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 x_2 : CategoryTheory.LaxFunctor B C} (x_3 : CategoryTheory.LaxFunctor B C) (η : x ⟶ x_1) (θ : x_1 ⟶ x_2)
(ι : x_2 ⟶ x_3) (a : B),
(CategoryTheory.Bicategory.associator η θ ι).inv.as.app a =
(Catego... | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW._simp_1_3 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_129 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
completeBipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Basic | (V : Type u_1) → (W : Type u_2) → SimpleGraph (V ⊕ W) | Two vertices are adjacent in the complete bipartite graph on two vertex types
if and only if they are not from the same side.
Any bipartite graph may be regarded as a subgraph of one of these. | true |
Int.neg_add_le_right_of_le_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, a ≤ b + c → -c + a ≤ b | null | true |
_private.Init.Data.Array.Basic.0.Array.mapM.map._unary._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_2} {β : Type u_1} (as : Array α) (i : ℕ) (bs : Array β),
i < as.size →
∀ (__do_lift : β),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i bs => as.size - i) ⟨i + 1, bs.push __do_lift⟩
⟨i, bs⟩ | null | false |
CategoryTheory.Bicategory.hom_inv_whiskerRight_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f g : a ⟶ b} (η : f ≅ g) (h : b ⟶ c) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) k ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.... | null | true |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.splitter | Init.Data.Option.Monadic | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((r : β) → motive (ForInStep.done r)) → ((r : β) → motive (ForInStep.yield r)) → motive __do_lift | null | true |
Aesop.PostponedSafeRule.ctorIdx | Aesop.Tree.UnsafeQueue | Aesop.PostponedSafeRule → ℕ | null | false |
Booleanisation.instBooleanAlgebra._proof_14 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x : Booleanisation α), ⊤ ≤ x ⊔ xᶜ | null | false |
_private.Mathlib.Topology.Order.LeftRightLim.0.tendsto_atTop_of_mapClusterPt._simp_1_1 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
Finset.convexHull_eq | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R] [IsStrictOrderedRing R] (s : Finset E),
(convexHull R) ↑s = {x | ∃ w, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x} | null | true |
Mathlib.Tactic.IntervalCases.Bound.lt.injEq | Mathlib.Tactic.IntervalCases | ∀ (n n_1 : ℤ), (Mathlib.Tactic.IntervalCases.Bound.lt n = Mathlib.Tactic.IntervalCases.Bound.lt n_1) = (n = n_1) | null | true |
Submodule.prodEquivOfIsCompl_symm_apply_right | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p q : Submodule R E)
(h : IsCompl p q) (x : ↥q), (p.prodEquivOfIsCompl q h).symm ↑x = (0, x) | null | true |
Mathlib.Tactic.Push.Head.noConfusionType | Mathlib.Tactic.Push.Attr | Sort u → Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Sort u | null | false |
biInf_sigma | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {β : Type u_4} [inst : CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i))
(f : Sigma α → β), ⨅ ij ∈ s.sigma t, f ij = ⨅ i ∈ s, ⨅ j ∈ t i, f ⟨i, j⟩ | null | true |
ArchimedeanClass.mem_closedBall_iff | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M] {a : M} {c : ArchimedeanClass M},
a ∈ ArchimedeanClass.cl... | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_isBasis_iff._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A] {s : Set A},
(AlgebraicIndependent.matroid R A).Indep s = AlgebraicIndepOn R id s | null | false |
CategoryTheory.Grothendieck.Hom.noConfusionType | Mathlib.CategoryTheory.Grothendieck | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C CategoryTheory.Cat} →
{X Y : CategoryTheory.Grothendieck F} →
X.Hom Y →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : Category... | null | false |
_private.Mathlib.Algebra.Homology.Homotopy.0.Homotopy.toShortComplex._abel_3 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} {f g : K ⟶ L} (ho : Homotopy f g) (i : ι),
f.f (c.prev i) =
CategoryTheory.CategoryStruct.comp (K.d (c.prev i) i) (ho.hom i (c.prev i)) +
... | null | false |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.Stable.exists_pow_smul_eq._proof_1_1 | Mathlib.RingTheory.Filtration | ∀ (n₀ n : ℕ), n₀ ≤ n₀ + n | null | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._proof_1 | Init.Data.Nat.Power2.Basic | ∀ power > 0, 0 < power * 2 | null | false |
Lean.Compiler.LCNF.Code.setTag.inj | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} {fvarId : Lean.FVarId} {cidx : ℕ} {k : Lean.Compiler.LCNF.Code pu}
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_13} {fvarId_1 : Lean.FVarId}
{cidx_1 : ℕ} {k_1 : Lean.Compiler.LCNF.Code pu}
{h_1 : autoParam (pu = Lean.Compiler.LCNF.Purity.im... | null | true |
WithZero.instCoeTC.eq_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u}, WithZero.instCoeTC = { coe := WithZero.coe } | null | true |
ContinuousMap.mem_nhds_iff | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{s : Set C(X, Y)},
s ∈ nhds f ↔
∃ S,
S.Finite ∧
(∀ (K : Set X) (U : Set Y), (K, U) ∈ S → IsCompact K ∧ IsOpen U ∧ Set.MapsTo (⇑f) K U) ∧
{g | ∀ (K : Set X) (U : Set Y), (K, U) ∈ S → Se... | null | true |
IsMulCommutative.instNonAssocCommSemiring._proof_1 | Mathlib.Algebra.Ring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : IsMulCommutative R] (a b : R), a * b = b * a | null | false |
sub_one_div_inv_le_two | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a : α},
2 ≤ a → (1 - 1 / a)⁻¹ ≤ 2 | An inequality involving `2`. | true |
MeasureTheory.eLpNorm_le_eLpNorm_mul_eLpNorm_of_nnnorm | Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {m : MeasurableSpace α} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.Measure α} {f : α → E} {g : α → F}
{p q r : ENNReal},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AE... | Hölder's inequality, as an inequality on the `ℒp` seminorm of an elementwise operation
`fun x => b (f x) (g x)`. | true |
AffineSubspace.mem_perpBisector_iff_inner_eq_inner | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ inner ℝ (c -ᵥ p₁) (p₂ -ᵥ p₁) = inner ℝ (c -ᵥ p₂) (p₁ -ᵥ p₂) | null | true |
Part.some_sdiff_some | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : α), Part.some a \ Part.some b = Part.some (a \ b) | null | true |
AlgCat.instMonoidalCategory.tensorHom._proof_1 | Mathlib.Algebra.Category.AlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] {W : AlgCat R}, IsScalarTower R R ↑W | null | false |
_private.Mathlib.Order.CountableDenseLinearOrder.0.Order.exists_orderEmbedding_insert._simp_1_3 | Mathlib.Order.CountableDenseLinearOrder | ∀ {α : Type u_1} (s : Finset α) (x : ↥s), (x ∈ s.attach) = True | null | false |
Sum.bnot_isRight | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (x : α ⊕ β), (!x.isRight) = x.isLeft | null | true |
Valuation.norm._proof_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀],
MonoidWithZeroHomClass (Valuation L Γ₀) L Γ₀ | null | false |
Std.DTreeMap.Raw.get!.congr_simp | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.LawfulEqCmp cmp]
(t t_1 : Std.DTreeMap.Raw α β cmp), t = t_1 → ∀ (a : α) [inst_1 : Inhabited (β a)], t.get! a = t_1.get! a | null | true |
NumberField.mixedEmbedding.fundamentalCone.hasDerivAt_expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] (w : NumberField.InfinitePlace K) (x : ℝ),
HasDerivAt (↑(NumberField.mixedEmbedding.fundamentalCone.expMap_single w))
(NumberField.mixedEmbedding.fundamentalCone.deriv_expMap_single w x) x | null | true |
Std.DHashMap.Raw.Const.get_map' | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → γ} {k : α} {h' : k ∈ Std.DHashMap.Raw.map f m}
(h : m.WF),
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.map f m) k h' = f (m.getKey k ⋯) ... | Variant of `get_map` that holds with `EquivBEq` (i.e. without `LawfulBEq`). | true |
List.getElem?_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (f : α → α) (a : α) (n i : ℕ), i < n → (List.iterate f a n)[i]? = some (f^[i] a) | null | true |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___macroRules__private_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral_0_term𝓟_1_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.Macro | null | false |
Finset.traverse.eq_1 | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} {F : Type u → Type u} [inst : Applicative F] [inst_1 : CommApplicative F] [inst_2 : DecidableEq β]
(f : α → F β) (s : Finset α), Finset.traverse f s = Multiset.toFinset <$> Multiset.traverse f s.val | null | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.sphere_prod._simp_1_5 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b = c) = (a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b) | null | false |
Batteries.Tactic.TransRelation.implies.elim | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} →
(t : Batteries.Tactic.TransRelation) →
t.ctorIdx = 1 →
((name : Lean.Name) → (bi : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name bi)) → motive t | null | false |
MeasureTheory.FiniteMeasure.instModuleNNReal | Mathlib.MeasureTheory.Measure.FiniteMeasure | {Ω : Type u_3} → [inst : MeasurableSpace Ω] → Module NNReal (MeasureTheory.FiniteMeasure Ω) | null | true |
CoeFun.recOn | Init.Coe | {α : Sort u} →
{γ : α → Sort v} →
{motive : CoeFun α γ → Sort u_1} → (t : CoeFun α γ) → ((coe : (f : α) → γ f) → motive { coe := coe }) → motive t | null | false |
Lean.Compiler.LCNF.Decl.isTemplateLike | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → Lean.CoreM Bool | Return `true` if `decl` is supposed to be inlined/specialized.
| true |
IsLocalExtr.comp_continuous | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} {δ : Type x} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β}
[inst_2 : TopologicalSpace δ] {g : δ → α} {b : δ}, IsLocalExtr f (g b) → ContinuousAt g b → IsLocalExtr (f ∘ g) b | null | true |
IncidenceAlgebra.lambda_apply | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_2) {α : Type u_5} [inst : Zero 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : DecidableRel fun x1 x2 => x1 ⩿ x2] (a b : α), (IncidenceAlgebra.lambda 𝕜) a b = if a ⩿ b then 1 else 0 | null | true |
_private.Lean.ToExpr.0.Lean.Name.toExprAux.isSimple._unsafe_rec | Lean.ToExpr | Lean.Name → ℕ → Bool | null | false |
Valuation.RankOne.toRankLeOne | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : Ring R} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} → {v : Valuation R Γ₀} → [self : v.RankOne] → v.RankLeOne | null | true |
Matroid.IsBasis.subset_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → X ⊆ M.closure I | null | true |
Ordinal.lt_add_iff | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, c ≠ 0 → (a < b + c ↔ ∃ d < c, a ≤ b + d) | null | true |
FreeMonoid.count_apply | Mathlib.Algebra.FreeMonoid.Count | ∀ {α : Type u_1} [inst : DecidableEq α] (x : α) (l : FreeAddMonoid α),
(FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x (FreeAddMonoid.toList l)) | null | true |
AddGroupWithOne.noConfusionType | Mathlib.Data.Int.Cast.Defs | Sort u_1 → {R : Type u} → AddGroupWithOne R → {R' : Type u} → AddGroupWithOne R' → Sort u_1 | null | false |
IsDiscrete.preimage' | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
IsDiscrete s → ContinuousOn f (f ⁻¹' s) → (∀ (x : Y), IsDiscrete (f ⁻¹' {x})) → IsDiscrete (f ⁻¹' s) | If `f` is continuous with discrete fibers, then the preimage of discrete sets are discrete. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.Data.Nat.GCD.Basic.0.Nat.coprime_iff_isRelPrime._simp_1_5 | Mathlib.Data.Nat.GCD.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsUnit x = (x ∣ 1) | null | false |
NonUnitalSubring.add_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x y : R}, x ∈ s → y ∈ s → x + y ∈ s | A non-unital subring is closed under addition. | true |
Complex.cosh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.cosh ↑x).im = 0 | null | true |
SSet.Truncated.HomotopyCategory₂._sizeOf_1 | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | {A : SSet.Truncated 2} → A.HomotopyCategory₂ → ℕ | null | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_4 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
⦃X Y : CategoryTheory.Arrow (CategoryTheory.Functor J C)⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.... | null | false |
Std.HashMap.getKey_eq_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α} {h' : a ∈ m}, m.getKey a h' = m.getKeyD a fallback | null | true |
Fin.orderPred_zero | Mathlib.Data.Fin.SuccPredOrder | ∀ (n : ℕ), Order.pred 0 = 0 | null | true |
SimpleGraph.IsClique.mono | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G H : SimpleGraph α} {s : Set α}, G ≤ H → G.IsClique s → H.IsClique s | null | true |
CoxeterMatrix.recOn | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
{motive : CoxeterMatrix B → Sort u} →
(t : CoxeterMatrix B) →
((M : Matrix B B ℕ) →
(isSymm : M.IsSymm) →
(diagonal : ∀ (i : B), M i i = 1) →
(off_diagonal : ∀ (i i' : B), i ≠ i' → M i i' ≠ 1) →
motive { M := M, isSymm := isSymm, diagonal ... | null | false |
CategoryTheory.Mat_.instPreadditive._proof_2 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N K : CategoryTheory.Mat_ C) (f : M ⟶ N) (g g' : N ⟶ K),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g' | null | false |
MonCat | Mathlib.Algebra.Category.MonCat.Basic | Type (u + 1) | The category of monoids and monoid morphisms. | true |
Topology.CWComplex.instRelCWComplex._proof_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C] (n : ℕ)
(i : Topology.CWComplex.cell C n),
∃ I,
Set.MapsTo (↑(Topology.CWComplex.map n i)) (Metric.sphere 0 1)
(∅ ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, ↑(Topology.CWComplex.map m j) '' Metric.closedBall 0 1) | null | false |
WithTopology.instSemilatticeSup | Mathlib.Topology.WithTopology | {X : Type u_1} → (t : TopologicalSpace X) → [SemilatticeSup X] → SemilatticeSup (WithTopology X t) | null | true |
Std.CloseableChannel.Flavors._sizeOf_1 | Std.Sync.Channel | {α : Type} → [SizeOf α] → Std.CloseableChannel.Flavors α → ℕ | null | false |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Defs___unexpand_Matrix_GeneralLinearGroup_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.isLUB_range_ωSup._simp_1_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Lean.Grind.CommRing.Poly.checkCoeffs._unsafe_rec | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Poly → Bool | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.