name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MvPolynomial.coeffs_C | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq R] (r : R),
(MvPolynomial.C r).coeffs = if r = 0 then ∅ else {r} | null | true |
Nat.sqrt.lt_iter_succ_sq | Mathlib.Data.Nat.Sqrt | ∀ (n guess : ℕ), n < (guess + 1) * (guess + 1) → n < (Nat.sqrt.iter n guess + 1) * (Nat.sqrt.iter n guess + 1) | null | true |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.evalPushCast._regBuiltin.Lean.Elab.Tactic.NormCast.evalPushCast.declRange_3 | Lean.Elab.Tactic.NormCast | IO Unit | null | false |
Nat.ceil_int | Mathlib.Algebra.Order.Floor.Defs | Nat.ceil = Int.toNat | null | true |
AddAction.IsBlock.vadd_eq_or_disjoint | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {B : Set X},
AddAction.IsBlock G B → ∀ (g : G), g +ᵥ B = B ∨ Disjoint (g +ᵥ B) B | null | true |
_private.Init.Data.Range.Polymorphic.Int.0.Std.PRange.instLawfulUpwardEnumerableInt._proof_3 | Init.Data.Range.Polymorphic.Int | ∀ (n : ℕ) (a : ℤ), ¬a + ↑(n + 1) = a + ↑n + 1 → False | null | false |
Std.TreeMap.getElem!_erase_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited β]
{k : α}, (t.erase k)[k]! = default | null | true |
ExteriorAlgebra.map._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M), 0 (f.toFun x) = 0 (f.toFun x) | null | false |
Lean.Elab.Term.CoeExpansionTrace.mk._flat_ctor | Lean.Elab.Term.TermElabM | List Lean.Name → Lean.Elab.Term.CoeExpansionTrace | null | false |
WithOne.coe_inv._simp_2 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} [inst : Inv α] (a : α), (↑a)⁻¹ = ↑a⁻¹ | null | false |
hasSum_of_isLUB_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), 0 ≤ f i) → IsLUB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | null | true |
CategoryTheory.Limits.BinaryFan.rightUnitor | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} →
CategoryTheory.Limits.IsLimit s →
{t : CategoryTheory.Limits.BinaryFan X s.pt} → CategoryTheory.Limits.IsLimit t → (t.pt ≅ X) | Construct a right unitor from specified limit cones. | true |
IsLocalization.bot_lt_comap_prime | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[IsLocalization M S] [IsDomain R],
M ≤ nonZeroDivisors R → ∀ (p : Ideal S) [hpp : p.IsPrime], p ≠ ⊥ → ⊥ < Ideal.under R p | **Alias** of `IsLocalization.bot_lt_under_prime`. | true |
LinearMap.coe_toContinuousLinearMap_symm | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence.0.EisensteinSeries.eisensteinSeries_tendstoLocallyUniformly._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {p : Filter ι} [LocallyCompactSpace α],
TendstoLocallyUniformly F f p = ∀ (K : Set α), IsCompact K → TendstoUniformlyOn F f p K | null | false |
Lean.Meta.SplitKind.ctorIdx | Lean.Meta.Tactic.SplitIf | Lean.Meta.SplitKind → ℕ | null | false |
Submonoid.center.smulCommClass_left | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Monoid M], SMulCommClass (↥(Submonoid.center M)) M M | The center of a monoid acts commutatively on that monoid. | true |
Lean.Elab.Tactic.saveTacticInfoForToken | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM Unit | Save the current tactic state for a token `stx`.
This method is a no-op if `stx` has no position information.
We use this method to save the tactic state at punctuation such as `;`
| true |
HurwitzZeta.hasSum_hurwitzZeta_of_one_lt_re | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ {a : ℝ}, a ∈ Set.Icc 0 1 → ∀ {s : ℂ}, 1 < s.re → HasSum (fun n => 1 / (↑n + ↑a) ^ s) (HurwitzZeta.hurwitzZeta (↑a) s) | Formula for `hurwitzZeta s` as a Dirichlet series in the convergence range. We
restrict to `a ∈ Icc 0 1` to simplify the statement. | true |
Submonoid.rec | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : MulOneClass M] →
{motive : Submonoid M → Sort u} →
((toSubsemigroup : Subsemigroup M) →
(one_mem' : 1 ∈ toSubsemigroup.carrier) → motive { toSubsemigroup := toSubsemigroup, one_mem' := one_mem' }) →
(t : Submonoid M) → motive t | null | false |
Filter.hnot_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α}, ￢Filter.principal s = Filter.principal sᶜ | null | true |
Submodule.subtype_injective | Mathlib.Algebra.Module.Submodule.LinearMap | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M),
Function.Injective ⇑p.subtype | null | true |
Finset.tendsto_Ioc_atBot_prod_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [NoBotOrder α],
Filter.Tendsto (fun p => Finset.Ioc p.1 p.2) (Filter.atBot ×ˢ Filter.atTop) Filter.atTop | null | true |
_private.Mathlib.Logic.Basic.0.apply_ite_left._proof_1_1 | Mathlib.Logic.Basic | ∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : α → β → γ) (P : Prop) [inst : Decidable P] (x y : α) (z : β),
f (if P then x else y) z = if P then f x z else f y z | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_conj_iff._simp_1_2 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.leadingTerm_eq_zero_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {s : σ →₀ ℕ} {b : R}, ((MvPolynomial.monomial s) b = 0) = (b = 0) | null | false |
Lean.IR.FnBody.sset | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → ℕ → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FnBody → Lean.IR.FnBody | Store `y : ty` at Position `sizeof(void*)*i + offset` in `x`. `x` must be a Constructor object and `RC(x)` must be 1.
`ty` must not be `object`, `tobject`, `erased` nor `Usize`. | true |
instDecidableEqInt64 | Init.Data.SInt.Basic | DecidableEq Int64 | null | true |
CategoryTheory.Localization.homEquiv.congr_simp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
(W W_1 : CategoryTheory.MorphismProperty C) (e_W : W = W_1) (L₁ : CategoryTheory.Functor C D₁)
[inst_3 : L₁.IsLocalizatio... | null | true |
ContinuousMap.instPow._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Monoid β]
[ContinuousMul β] (f : C(α, β)) (n : ℕ), Continuous fun b => f b ^ n | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsColimitCokernelCofork_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hg₁ : S₁.g = 0)
(c₁ : CategoryTheory.Limits.CokernelCofork S₁.f) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hg₂ : S₂.g = 0)
(c₂ : CategoryTheor... | null | true |
_private.Init.Data.Range.Polymorphic.UpwardEnumerable.0.Std.PRange.UpwardEnumerable.succMany_succ_eq_succ_succMany._simp_1_1 | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany n (Std.PRange.succ a) = Std.PRange.succMany (n + 1) a | null | false |
ContinuousLinearMap.toSeminormedRing._proof_2 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (a b : E →L[𝕜] E), a + b = b + a | null | false |
finSigmaFinEquiv.match_1 | Mathlib.Algebra.BigOperators.Fin | (motive : (m : ℕ) → {n : Fin m → ℕ} → Sort u_1) →
(m : ℕ) → {n : Fin m → ℕ} → ((n : Fin 0 → ℕ) → motive 0) → ((m : ℕ) → (n : Fin m.succ → ℕ) → motive m.succ) → motive m | null | false |
IsAlgebraic.of_aeval_of_transcendental | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : A} {f : Polynomial R},
IsAlgebraic R ((Polynomial.aeval r) f) → Transcendental R f → IsAlgebraic R r | null | true |
Lean.Elab.Term.Do.extendUpdatedVars | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.VarSet → Lean.Elab.TermElabM Lean.Elab.Term.Do.CodeBlock | Extend the set of updated variables. It assumes `ws` is a super set of `c.uvars`.
We **cannot** simply update the field `c.uvars`, because `c` may have shadowed some variable in `ws`.
See discussion at `pullExitPoints`.
| true |
CategoryTheory.Limits.Multifork.isoOfι | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
{I : CategoryTheory.Limits.MulticospanIndex J C} →
(t : CategoryTheory.Limits.Multifork I) → t ≅ CategoryTheory.Limits.Multifork.ofι I t.pt t.ι ⋯ | Every multifork is isomorphic to one of the form `Multifork.ofι`. | true |
MeasurableSet.map_coe_volume | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} [inst : MeasureTheory.MeasureSpace α] {s : Set α},
MeasurableSet s → MeasureTheory.Measure.map Subtype.val MeasureTheory.volume = MeasureTheory.volume.restrict s | null | true |
Vector.eq_iff_flatten_eq | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xss xss' : Vector (Vector α n) m}, xss = xss' ↔ xss.flatten = xss'.flatten | Two vectors of constant length vectors are equal iff their flattens coincide. | true |
Lean.Elab.InfoTree._sizeOf_4 | Lean.Elab.InfoTree.Types | Array Lean.Elab.InfoTree → ℕ | null | false |
Set.smul_set_mono | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s t : Set β} {a : α}, s ⊆ t → a • s ⊆ a • t | null | true |
_private.Mathlib.Combinatorics.Digraph.Orientation.0.Digraph.toSimpleGraphStrict_bot.match_1_1 | Mathlib.Combinatorics.Digraph.Orientation | ∀ {V : Type u_1} (x x_1 : V) (motive : ⊥.toSimpleGraphStrict.Adj x x_1 → Prop) (x_2 : ⊥.toSimpleGraphStrict.Adj x x_1),
(∀ (left : x ≠ x_1) (h : ⊥.Adj x x_1 ∧ ⊥.Adj x_1 x), motive ⋯) → motive x_2 | null | false |
Units.divp_sub_divp | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : CommRing α] (a b : α) (u₁ u₂ : αˣ), a /ₚ u₁ - b /ₚ u₂ = (a * ↑u₂ - ↑u₁ * b) /ₚ (u₁ * u₂) | null | true |
Std.ExtDHashMap.not_mem_diff_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₁ → k ∉ m₁ \ m₂ | null | true |
Lean.Lsp.instToJsonTypeDefinitionParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.TypeDefinitionParams | null | true |
Lean.Parser.ParserModuleContext.mk.noConfusion | Lean.Parser.Types | {P : Sort u} →
{env : Lean.Environment} →
{options : Lean.Options} →
{currNamespace : Lean.Name} →
{openDecls : List Lean.OpenDecl} →
{env' : Lean.Environment} →
{options' : Lean.Options} →
{currNamespace' : Lean.Name} →
{openDecls' : List Lean.Ope... | null | false |
stableUnderGeneralization_empty | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], StableUnderGeneralization ∅ | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{d : ℤ} →
{p : Int.Linear.Poly} →
{h : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{d' : ℤ} →
{p' : Int.Linear.Poly} →
{h' : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{ d := d, p := p, h := h } = { d := d', p := p', h := h' } → (d = d' → p = p... | null | false |
LieAlgebra.SemiDirectSum.instLieRing._proof_2 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x + x_1, x_2⁆ = ⁅x, x_2⁆ + ⁅x_1, x_2⁆ | null | false |
Lean.Lsp.TextDocumentSyncOptions.mk.injEq | Lean.Data.Lsp.TextSync | ∀ (openClose : Bool) (change : Lean.Lsp.TextDocumentSyncKind) (willSave willSaveWaitUntil : Bool)
(save? : Option Lean.Lsp.SaveOptions) (openClose_1 : Bool) (change_1 : Lean.Lsp.TextDocumentSyncKind)
(willSave_1 willSaveWaitUntil_1 : Bool) (save?_1 : Option Lean.Lsp.SaveOptions),
({ openClose := openClose, change... | null | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.expandLinearCombo.match_12 | Mathlib.Tactic.LinearCombination | (motive : Mathlib.Tactic.LinearCombination.Expanded → Mathlib.Tactic.LinearCombination.Expanded → Sort u_1) →
(__do_lift __do_lift_1 : Mathlib.Tactic.LinearCombination.Expanded) →
((c₁ c₂ : Lean.Term) →
motive (Mathlib.Tactic.LinearCombination.Expanded.const c₁)
(Mathlib.Tactic.LinearCombination... | null | false |
ZeroHom.toFun_eq_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] (f : ZeroHom M N), f.toFun = ⇑f | null | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.normEq0.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{p : Lean.Grind.CommRing.Poly} →
{d : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c : Lean.Meta.Grind.Arith.CommRing.EqCnstr} →
{p' : Lean.Grind.CommRing.Poly} →
{d' : Lean.Meta.Grind.Arith.CommRing.PolyDerivation} →
{c' : Lean.Meta.Grind.Arith.CommRing.EqC... | null | false |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtOfIso'._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} (E : L.RightExtension F) {Y Y' : D} (e : Y ≅ Y')
(j : Categ... | null | false |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.IsUniformInducing.mk'._simp_1_2 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {f g : Filter α}, (f = g) = ∀ (s : Set α), s ∈ f ↔ s ∈ g | null | false |
Batteries.Tactic._aux_Batteries_Tactic_Unreachable___macroRules_Batteries_Tactic_unreachableConv_1 | Batteries.Tactic.Unreachable | Lean.Macro | null | false |
CategoryTheory.OverPresheafAux.YonedaCollection.map₂_id | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
{F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C},
CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F (CategoryTheory.CategoryStruct.id X) = id | null | true |
Stream'.Seq.zip_nil_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α}, s.zip Stream'.Seq.nil = Stream'.Seq.nil | null | true |
Mathlib.Meta.Positivity.Strictness.nonzero.elim | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
t.ctorIdx = 2 → ((pf : Q(«$e» ≠ 0)) → motiv... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.map_edgeFinset_induce._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
MonomialOrder.lex_le_iff | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {c d : σ →₀ ℕ},
MonomialOrder.lex.toSyn c ≤ MonomialOrder.lex.toSyn d ↔ toLex c ≤ toLex d | null | true |
Module.End.IsSemisimple.mul_of_commute | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f g : Module.End K M}
[FiniteDimensional K M] [PerfectField K], Commute f g → f.IsSemisimple → g.IsSemisimple → (f * g).IsSemisimple | null | true |
AlgHom.snd_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), (AlgHom.snd R B C).comp (f.prod g) = g | null | true |
List.length_eraseP_le | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.eraseP p l).length ≤ l.length | null | true |
Std.Internal.Do.assertGadget.eq_1 | Std.Internal.Do.Triple.Gadget | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.Internal.Do.Assertion Pred]
[inst_2 : Std.Internal.Do.Assertion EPred] [inst_3 : Std.Internal.Do.WPMonad m Pred EPred] (name : Lean.Name)
(as : Pred), Std.Internal.Do.assertGadget name as = pure PUnit.unit | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_one_two_three_iff._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Filter.filter_eq | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {f g : Filter α}, f.sets = g.sets → f = g | null | true |
_private.Mathlib.Data.Finset.Defs.0.Finset.instAsymmSSubset._proof_1 | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1}, Std.Asymm fun x1 x2 => x1 ⊂ x2 | null | false |
Finset.gcd_eq_of_dvd_sub | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommRing α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β} {f g : β → α}
{a : α}, (∀ x ∈ s, a ∣ f x - g x) → gcd a (s.gcd f) = gcd a (s.gcd g) | null | true |
Turing.PartrecToTM2.Γ'.consₗ.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Γ' → Sort u} →
(t : Turing.PartrecToTM2.Γ') → t.ctorIdx = 0 → motive Turing.PartrecToTM2.Γ'.consₗ → motive t | null | false |
CategoryTheory.MorphismProperty.FunctorsInverting.hom_ext | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{W : CategoryTheory.MorphismProperty C} {F₁ F₂ : W.FunctorsInverting D} {α β : F₁ ⟶ F₂}, α.hom.app = β.hom.app → α = β | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.insertListIfNew.eq_def | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l toInsert : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l toInsert =
match toInsert with
| [] => l
| ⟨k, v⟩ :: tl => Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) tl | null | true |
_private.Init.Data.List.Range.0.List.mem_range'._simp_1_7 | Init.Data.List.Range | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | null | false |
RBTree.RBSet.mem_iff_lowerBound? | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : RBTree.RBSet α cmp} [Std.TransCmp cmp],
x ∈ t ↔ ∃ y, t.lowerBound? x = some y ∧ cmp x y = Ordering.eq | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.finrank._proof_2 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {S : AlgebraicGeometry.Scheme} (s : ↥S),
AlgebraicGeometry.IsAffine (AlgebraicGeometry.Spec (S.affineOpenCover.X (S.affineOpenCover.idx s))) | null | false |
TypeVec.splitFun_inj | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} {f f' : α.drop.Arrow α'.drop}
{g g' : α.last → α'.last}, TypeVec.splitFun f g = TypeVec.splitFun f' g' → f = f' ∧ g = g' | null | true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : NonUnitalNonAssocSemiring R] (x x_1 x_2 : QuadraticAlgebra R a b),
(x + x_1) * x_2 = x * x_2 + x_1 * x_2 | null | false |
EmetricSpace.ofRiemannianMetric | Mathlib.Geometry.Manifold.Riemannian.Basic | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type u_2} →
[inst_2 : TopologicalSpace H] →
(I : ModelWithCorners ℝ E H) →
(M : Type u_3) →
[inst_3 : TopologicalSpace M] →
[inst_4 : ChartedSpace H M] →
... | **Alias** of `EMetricSpace.ofRiemannianMetric`.
---
The emetric space structure associated to a Riemannian metric on a manifold. Designed
so that the topology is defeq to the original one.
This should only be used when constructing data in specific situations. To develop the theory,
one should rather assume that the... | true |
AddSemigrp.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : AddSemigrp}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | null | true |
OrderMonoidHom.cancel_right | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] {g₁ g₂ : β →*o γ} {f : α →*o β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
WithTop.ofDual_le_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithTop αᵒᵈ}, WithTop.ofDual y ≤ WithTop.ofDual x ↔ x ≤ y | null | true |
Lean.Omega.Constraint.exact.eq_1 | Init.Omega.Constraint | ∀ (r : ℤ), Lean.Omega.Constraint.exact r = { lowerBound := some r, upperBound := some r } | null | true |
StarAddMonoid.recOn | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : AddMonoid R] →
{motive : StarAddMonoid R → Sort u_1} →
(t : StarAddMonoid R) →
([toInvolutiveStar : InvolutiveStar R] →
(star_add : ∀ (r s : R), star (r + s) = star r + star s) →
motive { toInvolutiveStar := toInvolutiveStar, star_add := star_add }) →... | null | false |
CategoryTheory.Limits.isoZeroOfMonoZero._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp 0 0) 0 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | null | false |
Std.ExtTreeMap.getD_ofList_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false → (Std.ExtTreeMap.ofList l cmp).getD k fallback = fallback | null | true |
CategoryTheory.Presheaf.isIso_of_isLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
{A : CategoryTheory.Functor C ℰ} [CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.HasPointwiseLeftKanExtension A]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) ℰ)
(... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.expOpenPartialHomeomorph._simp_1 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {z : ℂ}, (Complex.exp z ∈ Complex.slitPlane) = (toIocMod Real.two_pi_pos (-Real.pi) z.im ≠ Real.pi) | null | false |
Lean.Meta.NormCast.Label.toCtorIdx | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.Label → ℕ | null | false |
AddOpposite.instCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [CommSemigroup α] → CommSemigroup αᵃᵒᵖ | null | true |
lowerBounds_Icc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → lowerBounds (Set.Icc a b) = Set.Iic a | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁.match_1.eq_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (motive : Turing.TM1.Stmt Γ Λ σ → Sort u_4) (Q : Turing.TM1.Stmt Γ Λ σ)
(h_1 :
(Q : Turing.TM1.Stmt Γ Λ σ) →
(a : Turing.Dir) → (q : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.move a q → motive (Turing.TM1.Stmt.move a q))
(h_2 :
(Q : Turing.TM1.Stmt Γ Λ... | null | true |
HopfAlgCat.instMonoidalCategoryStruct._proof_2 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), SMulCommClass R R X.carrier | null | false |
spectrum.map_star | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] [inst_3 : InvolutiveStar R]
[inst_4 : StarRing A] [StarModule R A] (a : A), spectrum R (star a) = star (spectrum R a) | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_7 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {n : ℕ} ⦃x : ↥{0}ᶜ⦄, ¬↑x = 0 | null | false |
ExteriorAlgebra.induction | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{C : ExteriorAlgebra R M → Prop},
(∀ (r : R), C ((algebraMap R (ExteriorAlgebra R M)) r)) →
(∀ (x : M), C ((ExteriorAlgebra.ι R) x)) →
(∀ (a b : ExteriorAlgebra R M), C a → C b → C (a * b)) →
(∀ (a b ... | If `C` holds for the `algebraMap` of `r : R` into `ExteriorAlgebra R M`, the `ι` of `x : M`,
and is preserved under addition and multiplication, then it holds for all of `ExteriorAlgebra R M`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Operations.0.SimpleGraph.edgeSet_replaceVertex_of_not_adj._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u} (G : SimpleGraph V) {a b c : V}, (s(b, c) ∈ G.incidenceSet a) = (G.Adj b c ∧ (a = b ∨ a = c)) | null | false |
LightCondensed.lanPresheafIso | Mathlib.Condensed.Discrete.Colimit | {S : LightProfinite} →
{F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)} →
CategoryTheory.Limits.IsColimit (F.mapCocone (CategoryTheory.Limits.coconeRightOpOfCone S.asLimitCone)) →
((LightCondensed.lanPresheaf F).obj (Opposite.op S) ≅ F.obj (Opposite.op S)) | A presheaf, which takes a light profinite set written as a sequential limit to the corresponding
colimit, agrees with the left Kan extension of its restriction.
| true |
AlgebraicGeometry.instSubsingletonOverTerminalScheme | Mathlib.AlgebraicGeometry.Limits | ∀ {X : AlgebraicGeometry.Scheme}, Subsingleton (X.Over (⊤_ AlgebraicGeometry.Scheme)) | null | true |
CategoryTheory.Limits.opCoproductIsoProduct_hom_comp_π_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct Z] (i : α) {Z_1 : Cᵒᵖ} (h : Opposite.op (Z i) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opCoproductIsoProduct Z).hom
(CategoryTheory.CategoryStruct.comp (... | null | true |
CategoryTheory.BasedFunctor.isHomLift_iff | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴) {R S : 𝒮} {a b : 𝒳.obj} (f : R ⟶ S)
(φ : a ⟶ b), 𝒴.p.IsHomLift f (F.map φ) ↔ 𝒳.p.IsHomLift f φ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.