name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Util.UnusedBinders.0.Lean.Expr.hasUnusedForallBindersWhere._sparseCasesOn_1 | Lean.Util.UnusedBinders | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : B... | null | false |
mabs_eq_max_inv | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] {a : α}, |a|ₘ = max a a⁻¹ | null | true |
CategoryTheory.EffectiveEpi.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : CategoryTheory.EffectiveEpi f → Sort u} →
(t : CategoryTheory.EffectiveEpi f) →
((effectiveEpi : Nonempty (CategoryTheory.EffectiveEpiStruct f)) → motive ⋯) → motive t | null | false |
String.intercalate_cons_of_ne_nil | Init.Data.String.Lemmas.Intercalate | ∀ {s t : String} {l : List String}, l ≠ [] → s.intercalate (t :: l) = t ++ s ++ s.intercalate l | null | true |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_ge' | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [CompleteSpace E]
[l'.IsMeasurablyGenerated] [Filter.TendstoIxxClass Set.Ioc l l'],
StronglyMeasurableAtFilter f l' μ →
Fil... | **Fundamental theorem of calculus-1**, local version for any measure.
Let filters `l` and `l'` be related by `TendstoIxxClass Ioc`.
If `f` has a finite limit `c` at `l ⊓ ae μ`, where `μ` is a measure
finite at `l`, then `∫ x in u..v, f x ∂μ = -μ (Ioc v u) • c + o(μ(Ioc v u))` as both
`u` and `v` tend to `l` so that `v ... | true |
PowerBasis.ofAdjoinEqTop'.congr_simp | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : Algebra R S]
[inst_4 : IsIntegrallyClosed R] [inst_5 : IsDomain S] [inst_6 : Module.IsTorsionFree R S] {x x_1 : S} (e_x : x = x_1)
(hx : IsIntegral R x) (hx' : R[x] = ⊤), PowerBasis.ofAdjoinEqTop' hx hx' = Powe... | null | true |
AddSubgroup.one_le_sum_inv_index_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i +ᵥ ↑(H i) = Set.univ → 1 ≤ ∑ i ∈ s, (↑(H i).index)⁻¹ | null | true |
_private.Mathlib.Topology.Baire.Lemmas.0.Set.Finite.dense_sInter._simp_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {α : Type u_1} {P : α → Prop} {a : α} {s : Set α}, (∀ x ∈ insert a s, P x) = (P a ∧ ∀ x ∈ s, P x) | null | false |
CategoryTheory.Comon.tensorObj_comul | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A B : C) [inst_3 : CategoryTheory.ComonObj A]
[inst_4 : CategoryTheory.ComonObj B],
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(Ca... | The comultiplication on the tensor product of two comonoids is
the tensor product of the comultiplications followed by the tensor strength
(to shuffle the factors back into order).
| true |
Polynomial.degree.eq_1 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), p.degree = p.support.max | null | true |
Tactic.ComputeAsymptotics.BasisExtension.insert.sizeOf_spec | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis : Tactic.ComputeAsymptotics.Basis} (f : ℝ → ℝ) (ex : Tactic.ComputeAsymptotics.BasisExtension basis),
sizeOf (Tactic.ComputeAsymptotics.BasisExtension.insert f ex) = 1 + sizeOf basis + sizeOf ex | null | true |
Lean.Lsp.MarkupKind.ctorElim | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.MarkupKind → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Lsp.MarkupKind) → ctorIdx = t.ctorIdx → Lean.Lsp.MarkupKind.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.Limits.Types.wedgeIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Types.End | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J]
(F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max u_3 u_1))))
(s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.multicospanIndexEnd F).multicospan)
(j : CategoryTheory.Limits.WalkingMulticospan (CategoryTheory.Limits.multicospa... | null | false |
LieAlgebra.Orthogonal.indefiniteDiagonal_transform | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_2) (q : Type u_3) (R : Type u₂) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
(LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiagonal p q R *
LieAlgebra.Orthogonal.Pso p... | null | true |
Mathlib.Tactic.ClickSuggestions.GrwLemma.mk._flat_ctor | Mathlib.Tactic.ClickSuggestions.GRewrite | Mathlib.Tactic.ClickSuggestions.Premise → Bool → Lean.Name → Mathlib.Tactic.ClickSuggestions.GrwLemma | null | false |
Lean.Meta.DiscrTree.Key.proj.inj | Lean.Meta.DiscrTree.Types | ∀ {a : Lean.Name} {a_1 a_2 : ℕ} {a_3 : Lean.Name} {a_4 a_5 : ℕ},
Lean.Meta.DiscrTree.Key.proj a a_1 a_2 = Lean.Meta.DiscrTree.Key.proj a_3 a_4 a_5 → a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5 | null | true |
gcdMonoidOfLCM._proof_6 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (lcm : α → α → α), (∀ (a b : α), a ∣ lcm a b) → ∀ (x : α), lcm 0 x = 0 | null | false |
LinearEquiv.injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
... | null | true |
CategoryTheory.Bicategory.LeftLift.alongId | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a c : B} → (g : c ⟶ a) → CategoryTheory.Bicategory.LeftLift (CategoryTheory.CategoryStruct.id a) g | The left lift along the identity. | true |
Lean.FromJson.mk.noConfusion | Lean.Data.Json.FromToJson.Basic | {α : Type u} →
{P : Sort u_1} →
{fromJson? fromJson?' : Lean.Json → Except String α} →
{ fromJson? := fromJson? } = { fromJson? := fromJson?' } → (fromJson? ≍ fromJson?' → P) → P | null | false |
isSemilinearSet_iff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsSemilinearSet s ↔ ∃ S, (∀ t ∈ S, IsLinearSet t) ∧ s = ⋃₀ ↑S | An equivalent expression of `IsSemilinearSet` in terms of `Finset` instead of `Set.Finite`. | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.gt) → α × β | null | false |
_private.Std.Sat.AIG.CachedLemmas.0.Std.Sat.AIG.mkGateCached.go.match_1.splitter | Std.Sat.AIG.CachedLemmas | (motive : Option Bool → Option Bool → Sort u_1) →
(lhsVal rhsVal : Option Bool) →
((x : Option Bool) → motive (some false) x) →
((x : Option Bool) → (x = some false → False) → motive x (some false)) →
((x : Option Bool) → (x = some false → False) → motive (some true) x) →
((x : Option Bool... | null | true |
SimplexCategory.factorThruImage_eq | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ CategoryTheory.Limits.image φ} [CategoryTheory.Epi e]
{i : CategoryTheory.Limits.image φ ⟶ Δ''} [CategoryTheory.Mono i],
CategoryTheory.CategoryStruct.comp e i = φ → CategoryTheory.Limits.factorThruImage φ = e | null | true |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_span_pair._simp_1_3 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) | null | false |
Set.exists_mem_notMem_of_ncard_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
s.ncard < t.ncard → autoParam s.Finite Set.exists_mem_notMem_of_ncard_lt_ncard._auto_1 → ∃ e ∈ t, e ∉ s | null | true |
Finset.nonempty_Ioc._simp_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α], (Finset.Ioc a b).Nonempty = (a < b) | null | false |
Rat.intCast_div_eq_divInt | Mathlib.Data.Rat.Defs | ∀ (n d : ℤ), ↑n / ↑d = Rat.divInt n d | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Integrability.Basic.0.intervalIntegral.intervalIntegrable_inv_one_add_sq._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | null | false |
Module.End.isSemisimple_iff' | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, f.IsSemisimple ↔ ∀ (p : ↥f.invtSubmodule), ∃ q, IsCompl p q | A linear endomorphism is semisimple if every invariant submodule has in invariant complement.
See also `Module.End.isSemisimple_iff`. | true |
CategoryTheory.Functor.mapCochainComplexShiftIso._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive] (n : ℤ) (K : HomologicalComplex C (ComplexShape.up ℤ))
... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.sum_density_div_card_le_density_add_eps._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.MonoidalOpposite.mopMopEquivalence.eq_1 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.MonoidalOpposite.mopMopEquivalence C =
(CategoryTheory.MonoidalOpposite.unmopEquiv Cᴹᵒᵖ).trans (CategoryTheory.MonoidalOpposite.unmopEquiv C) | null | true |
TopCat.toSSetObj₁Equiv._proof_3 | Mathlib.Topology.Homotopy.TopCat.ZerothHomotopy | ContinuousMapClass (↑TopCat.I ≃ₜ ↑(stdSimplex ℝ (Fin 2))) ↑TopCat.I ↑(stdSimplex ℝ (Fin 2)) | null | false |
Action.forget_δ | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] (X Y : Action V G),
CategoryTheory.Functor.OplaxMonoidal.δ (Action.forget V G) X Y =
CategoryTheory.CategoryStruct.id ((Action.forget V G).obj (CategoryTheory.MonoidalCa... | null | true |
ContinuousMonoidHom.instCoeOutOfMonoidHomClassOfContinuousMapClass | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
{F : Type u_7} →
[inst_4 : FunLike F A B] → [MonoidHomClass F A B] → [ContinuousMapClass F A B] → CoeOut F (A →ₜ* B) | Any type satisfying `MonoidHomClass` and `ContinuousMapClass` can be cast into
`ContinuousMonoidHom` via `ContinuousMonoidHom.toContinuousMonoidHom`. | true |
CategoryTheory.MorphismProperty.Over.isoMk._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T} {X : T}
{A B : P.Over Q X} (f : A.left ≅ B.left),
CategoryTheory.CategoryStruct.comp f.hom B.hom = A.hom →
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id T).map f.hom) B.hom =
CategoryT... | null | false |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_4 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬(a_1 ≤ a ↔ Int.negSucc a ≤ Int.negSucc a_1) → False | null | false |
Std.TreeMap.getKeyD_minKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {km fallback : α},
t.minKey? = some km → t.getKeyD km fallback = km | null | true |
mul_finsum' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {R : Type u_7} [inst : NonUnitalNonAssocSemiring R] (f : α → R) (r : R),
Function.HasFiniteSupport f → r * ∑ᶠ (a : α), f a = ∑ᶠ (a : α), r * f a | For functions with finite support, multiplication commutes with finsums. See `mul_finsum` for a
statement assuming that `R` has no zero divisors.
| true |
ZMod.valMinAbs_natAbs_eq_min | Mathlib.Data.ZMod.ValMinAbs | ∀ {n : ℕ} [hpos : NeZero n] (a : ZMod n), a.valMinAbs.natAbs = min a.val (n - a.val) | null | true |
Std.Internal.UV.TCP.Socket.getSockName | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Std.Net.SocketAddress | Gets the local address of a bound TCP socket.
| true |
FinBddDistLat.inv_hom_apply | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (e : X ≅ Y) (x : ↑X.toDistLat),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
TrivSqZeroExt.range_inlAlgHom_sup_adjoin_range_inr | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {S : Type u_1} {R : Type u} {M : Type v} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] [inst_4 : Module S M] [inst_5 : Module R M] [inst_6 : Module Rᵐᵒᵖ M]
[inst_7 : SMulCommClass R Rᵐᵒᵖ M] [inst_8 : IsScalarTower S R M] [inst_9 : IsScalarTower S Rᵐᵒᵖ M],
(TrivS... | null | true |
Exists | Init.Core | {α : Sort u} → (α → Prop) → Prop | Existential quantification. If `p : α → Prop` is a predicate, then `∃ x : α, p x`
asserts that there is some `x` of type `α` such that `p x` holds.
To create an existential proof, use the `exists` tactic,
or the anonymous constructor notation `⟨x, h⟩`.
To unpack an existential, use `cases h` where `h` is a proof of `∃ ... | true |
Std.HashMap.isEmpty_inter_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m₂.isEmpty = true → (m₁ ∩ m₂).isEmpty = true | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.below | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.AC.EqCnstrProof → Sort u} → Lean.Meta.Grind.AC.EqCnstrProof → Sort (max 1 u) | null | false |
OrthonormalBasis.mkOfOrthogonalEqBot.congr_simp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] {v v_1 : ι → E} (e_v : v = v_1) (hon : Orthonormal 𝕜 v)
(hsp : (Submodule.span 𝕜 (Set.range v))ᗮ = ⊥),
OrthonormalBasis.mkOfOrthogonalEqBot hon hsp = Orthonor... | null | true |
Std.TreeMap.maxKeyD | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → α | Tries to retrieve the largest key in the tree map, returning `fallback` if the tree map is empty.
| true |
Lean.getAttrParamOptPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ | null | true |
FinTopCat.instCategory._aux_5 | Mathlib.Topology.Category.FinTopCat | {X Y Z : FinTopCat} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
Fin.finsetImage_val_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a : Fin n), Finset.image Fin.val (Finset.Iic a) = Finset.Iic ↑a | null | true |
CategoryTheory.Preadditive.mono_iff_injective | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : (CategoryTheory.forge... | null | true |
LinearEquiv.fixedReduce_mkQ | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_4} {V : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] (e : V ≃ₗ[R] V) (x : V),
e.fixedReduce ((↑e).fixedSubmodule.mkQ x) = (↑e).fixedSubmodule.mkQ (e x) | null | true |
SaturatedSubmonoid.toSubmonoid | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → [inst : MulOneClass M] → SaturatedSubmonoid M → Submonoid M | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern.match_3.eq_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) (it : Std.IterM Id (String.Slice.Pattern.SearchStep s))
(motive : Option (s.sliceTo it.internalState.currPos).Pos → Sort u_1) (pos : (s.sliceTo it.internalState.currPos).Pos)
(h_1 : (pos_1 : (s.sliceTo it.internalState.currPos).Pos) → some pos = some pos_1 → motive (some po... | null | true |
ArchimedeanClass.FiniteElement._proof_2 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsStrictOrderedRing K | null | false |
_private.Mathlib.AlgebraicTopology.ModelCategory.DerivabilityStructureFibrant.0.HomotopicalAlgebra.FibrantObject.instWeakEquivalenceWWeakEquivalences._simp_1 | Mathlib.AlgebraicTopology.ModelCategory.DerivabilityStructureFibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.WeakEquivalence f = HomotopicalAlgebra.weakEquivalences C f | null | false |
CategoryTheory.HasDetector.casesOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t | null | false |
PowerSeries.substInvOfIsUnit | Mathlib.RingTheory.PowerSeries.Substitution | {R : Type u_2} → [inst : CommRing R] → (P : PowerSeries R) → IsUnit ((PowerSeries.coeff 1) P) → PowerSeries R | Given a power series `P = u • X + O(X²)` with `u` is an unit in ring `R`,
this is the power series `Q` such that `P(Q(X)) = X`.
See `PowerSeries.subst_substInvOfIsUnit_right`.
See also `PowerSeries.substInv` for a variant using `Invertible`. | true |
FirstOrder.Language.BoundedFormula.IsQF.isPrenex | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {φ : L.BoundedFormula α n}, φ.IsQF → φ.IsPrenex | null | true |
QuaternionGroup.instGroup._proof_10 | Mathlib.GroupTheory.SpecificGroups.Quaternion | ∀ {n : ℕ} (a : QuaternionGroup n), a * 1 = a | null | false |
isIrreducible_iff_sInter | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsIrreducible s ↔ ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty | A set `s` is irreducible if and only if
for every finite collection of open sets all of whose members intersect `s`,
`s` also intersects the intersection of the entire collection
(i.e., there is an element of `s` contained in every member of the collection). | true |
deriv_const_add_id | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} (c : 𝕜), deriv (fun x => c + x) x = 1 | null | true |
Ideal.instIsLiesOverAlgebraFiber | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal (p.Fiber S)) [inst_4 : q.IsPrime], Localization.AtPrime.IsLiesOverAlgebra p q | If `q` is a prime ideal of `p.Fiber S`, then the localization `(p.Fiber S)_q` is an algebra
over the localization `R_p` since `p.Fiber S` is already an `R_p`-algebra. This `R_p`-algebra
structure on `(p.Fiber S)_q` agrees with the one coming from the fact that `q` lies over `p`. | true |
UniformContinuous.dist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => dist (f b) (g b) | null | true |
_private.Lean.Server.Requests.0.Lean.Server.RequestM.findCmdParsedSnap.containsHoverPos | Lean.Server.Requests | Lean.Server.FileWorker.EditableDocument → String.Pos.Raw → Lean.Language.Lean.CommandParsedSnapshot → Bool | null | true |
derivWithin_const_smul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} {R : Type u_2} [inst_3 : Monoid R]
[inst_4 : DistribMulAction R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F] (c : R),
DifferentiableWithinAt 𝕜 f s... | null | true |
TendstoLocallyUniformlyOn.comp | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β]
{F : ι → α → β} {f : α → β} {s : Set α} {p : Filter ι} [inst_2 : TopologicalSpace γ] {t : Set γ},
TendstoLocallyUniformlyOn F f p s →
∀ (g : γ → α), Set.MapsTo g t s → ContinuousOn g t → TendstoLo... | null | true |
AddEquiv.linearEquiv | Mathlib.Algebra.Module.TransferInstance | {α : Type u_2} →
{β : Type u_3} →
(A : Type u_4) →
[inst : Semiring A] →
[inst_1 : AddCommMonoid α] → [inst_2 : AddCommMonoid β] → [inst_3 : Module A β] → (e : α ≃+ β) → α ≃ₗ[A] β | When `α` is equipped with the `A`-module structure transferred via `e : α ≃+ β`,
this isomorphism is `A`-linear. | true |
Hyperreal.instField._proof_7 | Mathlib.Analysis.Real.Hyperreal | ∀ (a : ℝ*), a + 0 = a | null | false |
SSet.Truncated.ι0₂._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | { len := 2 }.len ≤ 2 | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_roc_add_succ_right_eq_push._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m ≤ m + n → False | null | false |
Lean.KeyedDeclsAttribute.AttributeEntry.ctorIdx | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.AttributeEntry γ → ℕ | null | false |
CategoryTheory.Pretriangulated.Opposite.rotateTriangleOpEquivalenceInverseObjRotateUnopIso._proof_4 | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(T : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
CategoryTheory.CategoryStruct.comp
(Opposite.unop ((Categor... | null | false |
_private.Mathlib.RingTheory.KrullDimension.Regular.0.ringKrullDim_quotient_span_singleton_succ_eq_ringKrullDim_of_mem_jacobson._simp_1_1 | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (r : R)
(N : Submodule R M), r • N = Ideal.span {r} • N | null | false |
finSuccEquiv'_ne_last_apply | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i j : Fin (n + 1)} (hi : i ≠ Fin.last n), j ≠ i → (finSuccEquiv' i) j = some ((i.castLT ⋯).predAbove j) | null | true |
List.sym._unary._proof_3 | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (n : ℕ) (x : α) (xs : List α),
(invImage (fun x => PSigma.casesOn x fun n a => (n, a)) Prod.instWellFoundedRelation).1 ⟨n + 1, xs⟩ ⟨n.succ, x :: xs⟩ | null | false |
Metric.Snowflaking.instT2Space | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : TopologicalSpace X] [T2Space X],
T2Space (Metric.Snowflaking X α hα₀ hα₁) | null | true |
LinearMap.BilinMap.tmul | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | {R : Type uR} →
{A : Type uA} →
{M₁ : Type uM₁} →
{M₂ : Type uM₂} →
{N₁ : Type uN₁} →
{N₂ : Type uN₂} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : AddCommMonoid M₂] →
... | The tensor product of two bilinear forms, a shorthand for dot notation. | true |
ENNReal.toNNReal_natCast_eq_toNNReal | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ), (↑n).toNNReal = (↑n).toNNReal | null | true |
Cardinal.lift_eq_zero | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{v}}, Cardinal.lift.{u, v} a = 0 ↔ a = 0 | null | true |
ContinuousMap.Homotopy.mk.inj | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {inst : TopologicalSpace X} {inst_1 : TopologicalSpace Y} {f₀ f₁ : C(X, Y)}
{toContinuousMap : C(↑unitInterval × X, Y)} {map_zero_left : ∀ (x : X), toContinuousMap.toFun (0, x) = f₀ x}
{map_one_left : ∀ (x : X), toContinuousMap.toFun (1, x) = f₁ x} {toContinuousMap_1 : C(↑unitInterval × ... | null | true |
Lean.Omega.Coeffs.isZero | Init.Omega.Coeffs | Lean.Omega.Coeffs → Prop | Are the coefficients all zero? | true |
ChainComplex.cycles₀Iso._proof_3 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | IsRightCancelAdd ℕ | null | false |
CartanMatrix.E₆.eq_1 | Mathlib.LinearAlgebra.Matrix.Cartan | CartanMatrix.E₆ =
!![2, 0, -1, 0, 0, 0;
0, 2, 0, -1, 0, 0;
-1, 0, 2, -1, 0, 0;
0, -1, -1, 2, -1, 0;
0, 0, 0, -1, 2, -1;
0, 0, 0, 0, -1, 2] | null | true |
AddCircle.EndpointIdent.recOn | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : AddCommGroup 𝕜] →
[inst_1 : LinearOrder 𝕜] →
[inst_2 : IsOrderedAddMonoid 𝕜] →
{p a : 𝕜} →
[hp : Fact (0 < p)] →
{motive : (a_1 a_2 : ↑(Set.Icc a (a + p))) → AddCircle.EndpointIdent p a a_1 a_2 → Sort u} →
{a_1 a_2 : ↑(Set.Icc a (a + ... | null | false |
Lean.Meta.Grind.Arith.Cutsat.State.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive : Lean.Meta.Grind.Arith.Cutsat.State → Sort u} →
((vars : Lean.PArray Lean.Expr) →
(varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Int.Linear.Var) →
(vars' : Lean.PArray Lean.Expr) →
(varMap' : Lean.PHashMap Lean.Meta.Sym.ExprPtr Int.Linear.Var) →
(natToIntMap : Lean.PHashMap... | null | false |
BitVec.twoPow_mul_eq_shiftLeft | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w) (i : ℕ), BitVec.twoPow w i * x = x <<< i | null | true |
Aesop.IndexMatchLocation.none.elim | Aesop.Index.Basic | {motive : Aesop.IndexMatchLocation → Sort u} →
(t : Aesop.IndexMatchLocation) → t.ctorIdx = 0 → motive Aesop.IndexMatchLocation.none → motive t | null | false |
CategoryTheory.Coyoneda.isIso | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
[CategoryTheory.IsIso (CategoryTheory.coyoneda.map f)], CategoryTheory.IsIso f | If `coyoneda.map f` is an isomorphism, so was `f`.
| true |
EmbeddingLike.map_eq_one_iff._simp_2 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {M : Type u_4} {N : Type u_5} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[EmbeddingLike F M N] [OneHomClass F M N] {f : F} {x : M}, (f x = 1) = (x = 1) | null | false |
AddEquiv.toNatLinearEquiv_trans | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_5} {M₂ : Type u_7} {M₃ : Type u_8} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] (e : M ≃+ M₂) (e₂ : M₂ ≃+ M₃),
(e.trans e₂).toNatLinearEquiv = e.toNatLinearEquiv ≪≫ₗ e₂.toNatLinearEquiv | null | true |
CategoryTheory.ComposableArrows.threeδ₃Toδ₂.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ f₃_1 : k ⟶ l)
(e_f₃ : f₃ = f₃_1) (f₂₃ : j ⟶ l) (h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃),
CategoryTheory.ComposableArrows.threeδ₃Toδ₂ f₁ f₂ f₃ f₂₃ h₂₃ =
CategoryTheory.ComposableArrows.threeδ₃Toδ₂ f... | null | true |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.«term_<;>_» | Mathlib.Tactic.Tauto | Lean.TrailingParserDescr | Simulates the `<;>` tactic combinator.
First runs `tac1` and then runs `tac2` on all newly-generated subgoals.
| true |
Colex.instIsRightCancelAdd | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [IsRightCancelAdd α], IsRightCancelAdd (Colex α) | null | true |
CategoryTheory.Adjunction.homEquiv_naturality_left_square_assoc._to_dual_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) {X' X : C} {Y Y' : D} (f : X ⟶ X')
(g : Y' ⟶ F.obj X) (h : Y ⟶ F.obj X') (k : Y' ⟶ Y),
CategoryTheory.CategoryStru... | null | false |
Unitization.inrRangeEquiv._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : StarAddMonoid R] [inst_2 : NonUnitalSemiring A]
[inst_3 : Star A] [inst_4 : Module R A], NonUnitalAlgHomClass (A →⋆ₙₐ[R] Unitization R A) R A (Unitization R A) | null | false |
Right.inv_le_self | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : Preorder α] [MulRightMono α] {a : α}, 1 ≤ a → a⁻¹ ≤ a | null | true |
CategoryTheory.NatTrans.mapElements_obj | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} (φ : F ⟶ G)
(x : F.Elements),
(CategoryTheory.NatTrans.mapElements φ).obj x =
match x with
| ⟨X, x⟩ => ⟨X, (CategoryTheory.ConcreteCategory.hom (φ.app X)) x⟩ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.