name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.J.snd._proof_1 | Mathlib.CategoryTheory.Presentable.Comma | ∀ {C₁ : Type u_3} {C₂ : Type u_4} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C₁]
[inst_1 : CategoryTheory.Category.{u_2, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} (κ : Cardinal.{u_7}) [inst_3 : Fact κ.IsRegular]
(f... | null | false |
Std.Time.TimeZone.ZoneRules.mk | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.LocalTimeType →
Array Std.Time.TimeZone.Transition → Option Std.Time.TimeZone.RecurringRule → Std.Time.TimeZone.ZoneRules | null | true |
FintypeCat.uSwitch._proof_1 | Mathlib.CategoryTheory.FintypeCat | ∀ (X : FintypeCat), Finite (ULift.{u_1, 0} (Fin (Fintype.card X.obj))) | null | false |
ContinuousOn.integrableOn_uIcc | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {E : Type u_6} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure X} [OpensMeasurableSpace X] {f : X → E} {a b : X}
[MeasureTheory.IsFiniteMeasureOnCompacts μ] [inst_5 : LinearOrder X] [CompactIccSpace X] [T2Space X],
ContinuousOn f... | null | true |
MeasureTheory.Measure.IsHaarMeasure.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_3} →
[inst : Group G] →
[inst_1 : TopologicalSpace G] →
[inst_2 : MeasurableSpace G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsHaarMeasure → Sort u} →
(t : μ.IsHaarMeasure) →
([toIsFiniteMeasureOnCompacts : MeasureTheory.IsFiniteMeasureOnCompacts... | null | false |
CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) →
[in... | The colimit of `F.flip ⋙ colim` is isomorphic to the colimit of `F ⋙ colim`. | true |
VAddCon.instVAddQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} → (M : Type u_3) → [inst : VAdd S M] → (c : VAddCon S M) → VAdd S (VAddCon.Quotient M c) | null | true |
CategoryTheory.Sieve.sieveOfUliftSubfunctor._proof_3 | Mathlib.CategoryTheory.Sites.Sieves.Presheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C}
{R : CategoryTheory.Functor Cᵒᵖ (Type (max u_3 u_1))} (f : R ⟶ CategoryTheory.uliftYoneda.{u_3, u_1, u_2}.obj X)
{Y Z : C} {f_1 : Y ⟶ X},
(∃ t, (CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op Y))) t = { down := f_1 }) →
∀ (g : Z ⟶... | null | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift._proof_2 | Mathlib.CategoryTheory.Localization.Prod | ∀ {C₁ : Type u_3} {C₂ : Type u_2} [inst : CategoryTheory.Category.{u_6, u_3} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} E]
(F : CategoryTheory.Functor (C₁ × C₂)... | null | false |
Nat.reduceGcd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | null | true |
BitVec.msb_sshiftRight | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, (x.sshiftRight n).msb = x.msb | The msb after arithmetic shifting right equals the original msb. | true |
lt_csSup_of_lt | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a b : α}, BddAbove s → a ∈ s → b < a → b < sSup s | `b < sSup s` when there is an element `a` in `s` with `b < a`, when `s` is bounded above.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness above for one direction, nonemptiness and linear
order for the other one), so we formulate separately t... | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.ω_pow_formula._simp_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (a : ℤ) (b : ℕ), (↑a = 0) = (↑b ∣ a) | null | false |
instContinuousConstSMulForall | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {ι : Type u_4} {γ : ι → Type u_5} [inst : (i : ι) → TopologicalSpace (γ i)]
[inst_1 : (i : ι) → SMul M (γ i)] [∀ (i : ι), ContinuousConstSMul M (γ i)], ContinuousConstSMul M ((i : ι) → γ i) | null | true |
QuadraticMap.Isometry.tmul._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | (1 + 1).AtLeastTwo | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._unsafe_rec | 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 |
Monotone.pairwise_disjoint_on_Ico_pred | Mathlib.Order.SuccPred.IntervalSucc | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PredOrder α] [inst_2 : Preorder β] {f : α → β},
Monotone f → Pairwise (Function.onFun Disjoint fun n => Set.Ico (f (Order.pred n)) (f n)) | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `Set.Ico (f Order.pred n) (f n)` are pairwise disjoint. | true |
Zsqrtd.re_neg | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (z : ℤ√d), (-z).re = -z.re | null | true |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_ite._simp_1_8 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {f : Filter α} {a : α}, (f ≤ pure a) = ({a} ∈ f) | null | false |
CategoryTheory.MonoidalClosed.closed | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
[self : CategoryTheory.MonoidalClosed C] → (X : C) → CategoryTheory.Closed X | null | true |
MonadWithReaderOf.recOn | Init.Prelude | {ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadWithReaderOf ρ m → Sort u_1} →
(t : MonadWithReaderOf ρ m) →
((withReader : {α : Type u} → (ρ → ρ) → m α → m α) → motive { withReader := withReader }) → motive t | null | false |
ProofWidgets.MarkdownDisplay.instToJsonProps.toJson | ProofWidgets.Component.Basic | ProofWidgets.MarkdownDisplay.Props → Lean.Json | null | true |
Lean.Meta.Sym.SharedExprs.ctorIdx | Lean.Meta.Sym.SymM | Lean.Meta.Sym.SharedExprs → ℕ | null | false |
Lean.Parser.ParserAttributeHook.rec | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) →
(t : Lean.Parser.ParserAttributeHook) → motive t | null | false |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat_i₃ | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (pq : ℕ × ℕ) (hr : 2 ≤ r),
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat.i₃ r pq hr = WithBotTop.coe (-↑pq.2 + r - 1) | null | true |
Prod.snd | Init.Prelude | {α : Type u} → {β : Type v} → α × β → β | The second element of a pair. | true |
Std.Do.Spec.forIn'_roc | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LE α] [inst_3 : DecidableLE α] [inst_4 : LT α] [inst_5 : Std.PRange.UpwardEnumerable α]
[inst_6 : Std.Rxc.IsAlwaysFinite α] [inst_7 : Std.PRange.LawfulUpwardEnumerable α]
[inst_8 : Std.PRange.L... | null | true |
instTrivialStarNNReal | Mathlib.Basic.NNReal.Star | TrivialStar NNReal | null | true |
IsLocallyConstant.one | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : One Y], IsLocallyConstant 1 | null | true |
List.Vector.tail.match_1 | Mathlib.Data.Vector.Defs | {α : Type u_1} →
{n : ℕ} →
(motive : List.Vector α n → Sort u_2) →
(x : List.Vector α n) →
((h : [].length = n) → motive ⟨[], h⟩) →
((head : α) → (v : List α) → (h : (head :: v).length = n) → motive ⟨head :: v, h⟩) → motive x | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.map_on.match_1_1 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} (a b : α) (motive : a ∈ l ∧ b ∈ l ∧ a ≠ b → Prop) (x : a ∈ l ∧ b ∈ l ∧ a ≠ b),
(∀ (ma : a ∈ l) (mb : b ∈ l) (n : a ≠ b), motive ⋯) → motive x | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift.0.Std.IterM.length_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3)
(h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
... | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.congrHash.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
AddChar.add_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : CommMonoid M] (ψ φ : AddChar A M) (a : A),
(ψ + φ) a = ψ a * φ a | null | true |
Matrix.toBlocks₁₂.eq_1 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_11} (M : Matrix (n ⊕ o) (l ⊕ m) α),
M.toBlocks₁₂ = Matrix.of fun i j => M (Sum.inl i) (Sum.inr j) | null | true |
MvPowerSeries.HasSubst.truncTotal | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {τ : Type u_4} {S : Type u_5} [inst : CommRing S] {a : σ → MvPowerSeries τ S} {x : σ → ℕ}
[inst_1 : Finite τ],
MvPowerSeries.HasSubst a → MvPowerSeries.HasSubst fun i => ↑((MvPowerSeries.truncTotal (x i)) (a i)) | null | true |
CommGrpCat.mk.noConfusion | Mathlib.Algebra.Category.Grp.Basic | {P : Sort u_1} →
{carrier : Type u} →
{str : CommGroup carrier} →
{carrier' : Type u} →
{str' : CommGroup carrier'} →
{ carrier := carrier, str := str } = { carrier := carrier', str := str' } →
(carrier = carrier' → str ≍ str' → P) → P | null | false |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_iff_coborder_mem_nhds._proof_1_2 | Mathlib.Topology.LocallyClosed | 9 ≠ 0 | null | false |
Matrix.blockDiagonal_transpose | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_11} [inst : DecidableEq o] [inst_1 : Zero α]
(M : o → Matrix m n α), (Matrix.blockDiagonal M).transpose = Matrix.blockDiagonal fun k => (M k).transpose | null | true |
AddSubgroup.leftCosetEquivAddSubgroup._proof_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (g : α) (x : ↥s), ∃ a ∈ ↑s, g +ᵥ a = g + ↑x | null | false |
_private.Mathlib.Topology.Order.0.IndiscreteTopology.isClosed_iff._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
CategoryTheory.TransfiniteCompositionOfShape.map._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {J : Type u_5} [inst_2 : LinearOrder J] [inst_3 : OrderBot J]
{X Y : C} {f : X ⟶ Y} [inst_4 : SuccOrder J] [inst_5 : WellFoundedLT J]
(c : CategoryTheory.TransfiniteCompositionOfShape J f)... | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.leading_parser._regBuiltin.Lean.Parser.Term.withAnonymousAntiquot.parenthesizer_19 | Lean.Parser.Term | IO Unit | null | false |
_private.Init.Data.UInt.Package.0.instLinearOrderPackageUInt8._proof_3 | Init.Data.UInt.Package | ∀ (a : UInt8), a ≤ a | null | false |
_private.Mathlib.Tactic.Linter.UnusedInstancesInType.0.Mathlib.Linter.UnusedInstancesInType.InstanceOfConcern.idx | Mathlib.Tactic.Linter.UnusedInstancesInType | Mathlib.Linter.UnusedInstancesInType.InstanceOfConcern✝ → ℕ | The index of the binder that this instance came from. The first binder is `0`, and we do not
increment this index when seeing through `let`s. | true |
CategoryTheory.MonObj.instMonoOne | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {D : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} D] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D]
(M : D) [inst_2 : CategoryTheory.MonObj M], CategoryTheory.Mono CategoryTheory.MonObj.one | null | true |
SimpleGraph.ConnectedComponent.ind | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {β : G.ConnectedComponent → Prop},
(∀ (v : V), β (G.connectedComponentMk v)) → ∀ (c : G.ConnectedComponent), β c | null | true |
CategoryTheory.hasLeftDualUnit | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.HasLeftDual (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
WithZero.instMonad._aux_3 | Mathlib.Algebra.Group.WithOne.Defs | {α β : Type u_1} → α → WithZero β → WithZero α | null | false |
AlgebraicGeometry.Proj.openCoverOfMapIrrelevantEqTop | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | {σ : Type u_1} →
{A : Type u} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
{X : AlgebraicGeometry.Scheme} →
(f : A →+* ↑(X.presheaf.obj (Opposite.op ⊤))) →
... | Given a graded ring `A` and a map `f : A →+* Γ(X, ⊤)` such that the image of the
irrelevant ideal under `f` generates the whole ring, the set of `D(f(r))` for homogeneous `r`
of positive degree forms an open cover on `X`. | true |
sSupHom.comp._proof_1 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
(f : sSupHom β γ) (g : sSupHom α β) (s : Set α), (⇑f ∘ ⇑g) (sSup s) = sSup (⇑f ∘ ⇑g '' s) | null | false |
_private.Lean.Server.AsyncList.0.Lean.AsyncList.waitUntil.match_5 | Lean.Server.AsyncList | {α : Type u_2} →
{ε : Type u_1} →
(motive : Lean.AsyncList ε α → Sort u_3) →
(x : Lean.AsyncList ε α) →
((hd : α) → (tl : Lean.AsyncList ε α) → motive (Lean.AsyncList.cons hd tl)) →
(Unit → motive Lean.AsyncList.nil) →
((tl : Lean.Server.ServerTask (Except ε (Lean.AsyncList ε α... | null | false |
Set.self_mem_ordConnectedComponent._simp_1 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {x : α}, (x ∈ s.ordConnectedComponent x) = (x ∈ s) | null | false |
_private.Lean.Parser.Basic.0.Lean.Parser.longestMatchFnAux.parse._sunfold | Lean.Parser.Basic | Option Lean.Syntax → ℕ → ℕ → String.Pos.Raw → ℕ → List (Lean.Parser.Parser × ℕ) → Lean.Parser.ParserFn | null | false |
CategoryTheory.Cat.isTerminalOfUniqueOfIsDiscrete._proof_1 | Mathlib.CategoryTheory.Category.Cat.Terminal | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] [inst_1 : Unique T] [CategoryTheory.IsDiscrete T]
(x : CategoryTheory.Cat) (x_1 : x ⟶ ↧T), x_1 = ((CategoryTheory.Functor.const ↑x).obj default).toCatHom | null | false |
Batteries.HashMap.insert | Batteries.Data.HashMap.Basic | {α : Type u_1} →
{x : BEq α} → {x_1 : Hashable α} → {β : Type u_2} → Batteries.HashMap α β → α → β → Batteries.HashMap α β | Inserts key-value pair `a, b` into the map.
If an element equal to `a` is already in the map, it is replaced by `b`.
```
def hashMap := ofList [("one", 1), ("two", 2)]
hashMap.insert "three" 3 = {"one" => 1, "two" => 2, "three" => 3}
hashMap.insert "two" 0 = {"one" => 1, "two" => 0}
```
| true |
_private.Mathlib.RingTheory.TensorProduct.DirectLimitFG.0.TensorProduct.exists_of_fg.match_1_1 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (u : TensorProduct R M N)
(motive :
(∃ i x,
(Module.DirectLimit.of R { P // P.FG } (fun P => TensorProduct R (↥↑P) N)
(fu... | null | false |
Module.IsPrincipal.of_surjective | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂),
Function.Surjective ⇑f → ∀ [Module.IsPrincipal R M], Module.IsPrincipal R M₂ | null | true |
Subgroup.commutator_top_left_eq_bot_iff_le_center | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, ⁅⊤, H⁆ = ⊥ ↔ H ≤ Subgroup.center G | null | true |
uniformity_multiplicative | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α],
uniformity (Multiplicative α) = Filter.map (Prod.map ⇑Multiplicative.ofAdd ⇑Multiplicative.ofAdd) (uniformity α) | null | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : Turing.PartrecToTM2.Λ' → Sort u_1) (k : Turing.PartrecToTM2.K')
(s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ') (q : Turing.PartrecToTM2.Λ')
(h_1 :
(Q : Turing.PartrecToTM2.Λ') →
(p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q :... | null | true |
AddSemiconjBy.neg_neg_symm | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a x y : G}, AddSemiconjBy a y x → AddSemiconjBy (-a) (-x) (-y) | **Alias** of the reverse direction of `AddSemiconjBy.neg_neg_symm_iff`. | true |
Homeomorph.neg.eq_1 | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ (G : Type u_4) [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [inst_2 : ContinuousNeg G],
Homeomorph.neg G = { toEquiv := Equiv.neg G, continuous_toFun := ⋯, continuous_invFun := ⋯ } | null | true |
CategoryTheory.InducedCategory.homEquiv | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (X ⟶ Y) ≃ (F X ⟶ F Y) | Morphisms in `InducedCategory D F` identify to morphisms in `D`. | true |
_private.Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic.0.quadraticChar_card_sqrts._simp_1_1 | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀], (a ^ 2 = 0) = (a = 0) | null | false |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.AlgebraicTopology.DoldKan.PInfty_comp_map_mono_eq_zero._proof_1_7 | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | ∀ (m k : ℕ) (i : { len := m } ⟶ { len := m + k + 1 + 1 }), CategoryTheory.Epi i → False | null | false |
Units.mul_le_of_le_mul_inv | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulRightMono M] {a b : M} (u : Mˣ), a ≤ b * ↑u⁻¹ → a * ↑u ≤ b | **Alias** of the forward direction of `Units.le_mul_inv_iff`. | true |
SelbergSieve.level | Mathlib.NumberTheory.SelbergSieve | SelbergSieve → ℝ | The `level` of the sieve controls how many terms we include in the inclusion-exclusion type
sum. A higher level will yield a tighter bound for the main term, but will also increase the
size of the error term. | true |
Std.Time.Modifier.b.elim | Std.Time.Format.Modifier | {motive : Std.Time.Modifier → Sort u} →
(t : Std.Time.Modifier) →
t.ctorIdx = 17 → ((presentation : Std.Time.Text) → motive (Std.Time.Modifier.b presentation)) → motive t | null | false |
Lean.Meta.Grind.CasesTypes.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (casesMap : Lean.PHashMap Lean.Name Bool), sizeOf { casesMap := casesMap } = 1 + sizeOf casesMap | null | true |
_private.Mathlib.Analysis.BoxIntegral.UnitPartition.0.BoxIntegral.unitPartition.tendsto_card_div_pow₄ | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (s : Set (ι → ℝ)) [inst : Fintype ι],
Bornology.IsBounded s →
(∀ ⦃x y : ℝ⦄, 0 < x → x ≤ y → x • s ⊆ y • s) →
∀ᶠ (x : ℝ) in Filter.atTop,
↑(Nat.card ↑(s ∩ x⁻¹ • ↑(Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))) / x ^ Fintype.card ι ≤
↑(Nat.card ↑(s ∩ (↑⌈x⌉₊)⁻¹ • ↑(Submod... | null | true |
Equiv.Perm.support_swap_mul_swap | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {x y z : α},
[x, y, z].Nodup → (Equiv.swap x y * Equiv.swap y z).support = {x, y, z} | null | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.visitForall._sparseCasesOn_5 | Lean.Compiler.LCNF.Types | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.pow_lt_pow_iff_left._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, (b < a) = ¬a ≤ b | null | false |
AnalyticWithinAt.im_ofReal | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {f : ℂ → ℂ} {s : Set ℝ} {x : ℝ},
AnalyticWithinAt ℂ f (Complex.ofReal '' s) ↑x → AnalyticWithinAt ℝ (fun x => (f ↑x).im) s x | null | true |
SimpleGraph.Iso.connectedComponentEquiv_symm | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G ≃g G'),
φ.symm.connectedComponentEquiv = φ.connectedComponentEquiv.symm | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.destruct | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Option
(ℝ ×
Tactic.ComputeAsymptotics.MultiseriesExpansion basis_tl ×
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries ba... | Destruct a multiseries into a triple `(exp, coef, tl)`, where `exp` is the leading exponent,
`coef` is the leading coefficient, and `tl` is the tail. | true |
InnerProductSpace.gramSchmidtNormed_orthonormal' | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] (f : ι → E),
Orthonormal 𝕜 fun i => InnerProductSpace.gramSchmidtNormed 𝕜 f ↑i | **Gram-Schmidt Orthonormalization**:
`gramSchmidtNormed` produces an orthonormal system of vectors after removing the vectors which
become zero in the process. | true |
Lean.Linter.LintEntry.mk._flat_ctor | Lean.Linter.PersistentLintLog | Lean.Name → Lean.SerialMessage → Option Lean.Position → String → Lean.Linter.LintEntry | null | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Quasispectrum.0.quasispectrum.algebraMap_mem_iff._simp_1_1 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (S : Type u_1) {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : A} {r : R},
((algebraMap R S) r ∈ spectrum S a) = (r ∈ spectrum R a) | null | false |
Std.TreeMap.ofList | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} → List (α × β) → (cmp : autoParam (α → α → Ordering) Std.TreeMap.ofList._auto_1) → Std.TreeMap α β cmp | Transforms a list of mappings into a tree map. | true |
Mathlib.Meta.NormNum.NormNums.mk.sizeOf_spec | Mathlib.Tactic.NormNum.Core | ∀ (tree : Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt) (erased : Lean.PHashSet Lean.Name),
sizeOf { tree := tree, erased := erased } = 1 + sizeOf tree + sizeOf erased | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.count_le_one_of_centralizer_le_alternating._simp_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_2} [inst : Add α] [inst_1 : Mul α] {a : α} [LeftDistribClass α], Even a → ∀ (b : α), Even (b * a) = True | null | false |
Array.findSomeM?._sparseCasesOn_1.else_eq | Init.Data.List.ToArray | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Array.findSomeM?._sparseCasesOn_1 t some «else» = «else» h | null | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.lt_length_drop._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {k n m : ℕ}, (k + n < k + m) = (n < m) | null | false |
Nat.lcm_lcm_self_right_right | Init.Data.Nat.Lcm | ∀ (m n : ℕ), m.lcm (n.lcm m) = m.lcm n | null | true |
AddMonoidHom.continuous_of_isBounded_nhds_zero | Mathlib.Analysis.Normed.Module.Basic | ∀ {G : Type u_6} {H : Type u_7} [inst : SeminormedAddCommGroup G] [inst_1 : SeminormedAddCommGroup H] [NormedSpace ℝ H]
{s : Set G} (f : G →+ H), s ∈ nhds 0 → Bornology.IsBounded (⇑f '' s) → Continuous ⇑f | A group homomorphism from a normed group to a real normed space,
bounded on a neighborhood of `0`, must be continuous. | true |
Std.DTreeMap.Const.isEmpty_insertMany_list | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)}, (Std.DTreeMap.Const.insertMany t l).isEmpty = (t.isEmpty && l.isEmpty) | null | true |
PartialEquiv.refl_prod_refl | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2}, (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β) | null | true |
prod_mk_prod | Mathlib.Algebra.BigOperators.Pi | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] (s : Finset ι) (f : ι → M)
(g : ι → N), (∏ x ∈ s, f x, ∏ x ∈ s, g x) = ∏ x ∈ s, (f x, g x) | null | true |
CategoryTheory.MorphismProperty.IsStableUnderFiniteCoproducts.rec | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{motive : W.IsStableUnderFiniteCoproducts → Sort u_1} →
((isStableUnderCoproductsOfShape : ∀ (J : Type) [Finite J], W.IsStableUnderCoproductsOfShape J) → motive ⋯) →
(t : W.IsStableUnderFin... | null | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.derivedSeries_le_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
FiniteGaloisIntermediateField.instMax._proof_3 | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L₁ L₂ : FiniteGaloisIntermediateField k K), IsGalois k ↥(L₁.toIntermediateField ⊔ L₂.toIntermediateField) | null | false |
Int16.le_antisymm | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a ≤ b → b ≤ a → a = b | null | true |
ProfiniteAddGrp.Hom.ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {x y : A.Hom B}, x.hom' = y.hom' → x = y | null | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.even_interleave.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} (s₁' s₁ : Stream' α) (motive : (∃ s₂, s₁' = (s₁ ⋈ s₂).even) → Prop) (x : ∃ s₂, s₁' = (s₁ ⋈ s₂).even),
(∀ (s₂ : Stream' α) (h₁ : s₁' = (s₁ ⋈ s₂).even), motive ⋯) → motive x | null | false |
CategoryTheory.OverPresheafAux.OverArrows.map₂.congr_simp | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A}
{X Y : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A}
(u u_1 : CategoryTheory.OverPresheafAux.OverArrows η t),
u = u_1 →
∀ (f f_1 : X ⟶ Y) (e_f : f = f_1) (hst : Cat... | null | true |
Types.subobjectEquivSet | Mathlib.CategoryTheory.Subobject.Types | (α : Type u) → CategoryTheory.Subobject α ≃o Set α | For `α : Type u`, `Subobject α` is order isomorphic to `Set α`.
| true |
RBTree.RBMap.instStreamStream_1 | Batteries.Recycling.RBTree.Basic | {α : Type u} → {β : Type v} → Std.Stream (RBTree.RBMap.Values.Stream α β) β | null | true |
Algebra.basicOpen_subset_etaleLocus_iff_etale | Mathlib.RingTheory.Etale.Locus | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[Algebra.FinitePresentation R A] {f : A},
↑(PrimeSpectrum.basicOpen f) ⊆ Algebra.etaleLocus R A ↔ Algebra.Etale R (Localization.Away f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.