name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get? (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)) k =
if k ∈ t ∨ l.contains k = true then so... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.two_nsmul_eq_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {ψ θ : Real.Angle}, (2 • ψ = 2 • θ) = (ψ = θ ∨ ψ = θ + ↑Real.pi) | null | false |
Part.Fix.approx._unsafe_rec | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMap_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
FiniteDimensional.of_locallyCompactSpace | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {E : Type u_5} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [T2Space E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[WeaklyLocallyCompactSpace E], FiniteDimensional 𝕜 E | **Riesz's theorem**: a locally compact topological vector space is finite-dimensional. | true |
ProjectiveSpectrum.ctorIdx | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
{inst : CommRing A} →
{inst_1 : SetLike σ A} →
{inst_2 : AddSubmonoidClass σ A} → {𝒜 : ℕ → σ} → {inst_3 : GradedRing 𝒜} → ProjectiveSpectrum 𝒜 → ℕ | null | false |
MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {t : Set ↑s},
MeasureTheory.NullMeasurableSet s μ → MeasurableSet t → MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ | null | true |
Ideal.uniqueUnits | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Unique (Ideal R)ˣ | null | true |
rTensor.inverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
Complex.range_sin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Set.range Complex.sin = Set.univ | null | true |
instAssociativeMinOnOfIsLinearPreorder | Init.Data.Order.MinMaxOn | ∀ {β : Type u_1} {α : Sort u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β},
Std.Associative (minOn f) | null | true |
TopologicalSpace.NonemptyCompacts.instPartialOrder | Mathlib.Topology.Sets.Compacts | {α : Type u_1} → [inst : TopologicalSpace α] → PartialOrder (TopologicalSpace.NonemptyCompacts α) | null | true |
Lean.Expr.fvar.inj | Lean.Expr | ∀ {fvarId fvarId_1 : Lean.FVarId}, Lean.Expr.fvar fvarId = Lean.Expr.fvar fvarId_1 → fvarId = fvarId_1 | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.mk.noConfusion | Std.Http.Data.Body.Stream | {P : Sort u} →
{pendingProducer : Option Std.Http.Body.Channel.Producer✝} →
{pendingConsumer : Option Std.Http.Body.Channel.Consumer✝} →
{interestWaiter : Option (Std.Async.Waiter Bool)} →
{closed : Bool} →
{knownSize : Option Std.Http.Body.Length} →
{pendingIncompleteChunk : O... | null | false |
AddOpposite.instDecidableEq | Mathlib.Algebra.Opposites | {α : Type u_1} → [DecidableEq α] → DecidableEq αᵃᵒᵖ | null | true |
OpenNormalAddSubgroup.toFiniteIndexNormalAddSubgroup._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [CompactSpace G] [ContinuousAdd G]
(H : OpenNormalAddSubgroup G), (↑H.toOpenAddSubgroup).FiniteIndex | null | false |
Lean.Grind.AC.Context.vars | Init.Grind.AC | {α : Sort u} → Lean.Grind.AC.Context α → Lean.RArray (PLift α) | null | true |
ContinuousMap.instRing._proof_8 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : Ring β] [IsTopologicalRing β], ContinuousNeg β | null | false |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass._proof_6 | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | null | false |
Filter.EventuallyEq.mapClusterPt_iff | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {F : Filter α} {u : α → X} {x : X} {v : α → X},
u =ᶠ[F] v → (MapClusterPt x F u ↔ MapClusterPt x F v) | null | true |
sbtw_const_vsub_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P), Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z | null | true |
CategoryTheory.WithTerminal.comp.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C) (_X : C),
CategoryTheory.WithTerminal.comp =
match (motive := (x x_1 x_2 : CategoryTheory.WithTerminal C) → x.Hom x_1 → x_1.Hom x_2 → x.Hom x_2)
CategoryTheory.WithTerminal.of _X, x, CategoryTheory.WithTerminal.star... | null | true |
CategoryTheory.sum.inrCompInrCompInverseAssociator_hom_app_down | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : E),
((CategoryTheory.sum.inrCompInrCompInverseAssociator C D E).hom.app X).down =
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateDelImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((fvarId : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.Code.del fvarId k h)) →
... | null | false |
Lean.Parser.Tactic.Grind.finishTrace | Init.Grind.Interactive | Lean.ParserDescr | `finish?` tries to close the current goal using `grind`'s default strategy and suggests a tactic script. | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentInv._proof_2 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.Presentation... | null | false |
CategoryTheory.Limits.pasteVertIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
{t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | Given
```
Y₃ - i₃ -> X₃
| |
g₂ f₂
∨ ∨
Y₂ - i₂ -> X₂
| |
g₁ f₁
∨ ∨
Y₁ - i₁ -> X₁
```
The big square is a pushout if both the small squares are.
| true |
CategoryTheory.MonoidalClosed.curry.eq_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.Sections | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry = ⇑((CategoryTheory.ihom.adjunction A).homEquiv Y X) | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalClear._regBuiltin.Lean.Elab.Tactic.evalClear.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkGrindEqnParams | Lean.Elab.Tactic.Try | Array Lean.Name → Lean.MetaM (Array (Lean.TSyntax `Lean.Parser.Tactic.grindParam)) | Given a set of declaration names, returns `grind` parameters of the form `= <declName>` | true |
Subtype.restrict_def | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop), Subtype.restrict p f = f ∘ fun a => ↑a | null | true |
String.Pos.ofToSlice_comp_toSlice | Init.Data.String.Basic | ∀ {s : String}, String.Pos.ofToSlice ∘ String.Pos.toSlice = id | null | true |
Prod.mk_dvd_mk._simp_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Semigroup G₁] [inst_1 : Semigroup G₂] {x₁ y₁ : G₁} {x₂ y₂ : G₂},
((x₁, x₂) ∣ (y₁, y₂)) = (x₁ ∣ y₁ ∧ x₂ ∣ y₂) | null | false |
Lean.Server.Completion.EligibleDecl.recOn | Lean.Server.Completion.EligibleHeaderDecls | {motive : Lean.Server.Completion.EligibleDecl → Sort u} →
(t : Lean.Server.Completion.EligibleDecl) →
((info : Lean.ConstantInfo) →
(kind : Lean.MetaM Lean.Lsp.CompletionItemKind) →
(tags : Lean.MetaM (Array Lean.Lsp.CompletionItemTag)) →
motive { info := info, kind := kind, tags := ... | null | false |
Coalgebra.Quotient.instQuotientSubmodule._proof_6 | Mathlib.RingTheory.Coalgebra.Quotient | ∀ {R : Type u_1} {C : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup C] [inst_2 : Module R C] (I : Submodule R C),
SMulCommClass R R (TensorProduct R (C ⧸ I) R) | null | false |
Vector.zip_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} {n : ℕ},
(Vector.replicate n a).zip (Vector.replicate n b) = Vector.replicate n (a, b) | null | true |
RelEmbedding.mul_apply | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (e₁ e₂ : r ↪r r) (x : α), (e₁ * e₂) x = e₁ (e₂ x) | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) ⦃X_1 Y_1 : CategoryTheory.Over Y⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(({ obj := fun Z => CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X Z... | null | false |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instBEqInsertReplaceEdit.beq.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InsertReplaceEdit → Lean.Lsp.InsertReplaceEdit → Sort u_1) →
(x x_1 : Lean.Lsp.InsertReplaceEdit) →
((a : String) →
(a_1 a_2 : Lean.Lsp.Range) →
(b : String) →
(b_1 b_2 : Lean.Lsp.Range) →
motive { newText := a, insert := a_1, replace := a_2 } { newTe... | null | false |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.definition._simp_6._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.1878421158._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_incenter_eq._proof_1_1 | Mathlib.Geometry.Euclidean.Angle.Incenter | NeZero (1 + 1) | null | false |
ContinuousMap.HomotopicRel.equivalence | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X},
Equivalence fun f g => f.HomotopicRel g S | null | true |
CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f | null | true |
_private.Mathlib.Topology.Separation.Regular.0.regularSpace_TFAE.match_1_7 | Mathlib.Topology.Separation.Regular | ∀ (X : Type u_1) [inst : TopologicalSpace X]
(motive : (∀ (x : X), (nhds x).lift' closure = nhds x) → (x : X) → (x_1 : Set X) → x_1 ∈ nhds x → Prop)
(x : ∀ (x : X), (nhds x).lift' closure = nhds x) (x_1 : X) (x_2 : Set X) (x_3 : x_2 ∈ nhds x_1),
(∀ (H : ∀ (x : X), (nhds x).lift' closure = nhds x) (a : X) (s : Set... | null | false |
Int.natCast_le_zero._simp_1 | Init.Data.Int.LemmasAux | ∀ {n : ℕ}, (↑n ≤ 0) = (n = 0) | null | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.correspondence._simp_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (x ≤ y) = (↑x ≤ ↑y) | null | false |
SimpleGraph.Subgraph.IsMatching | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → {G : SimpleGraph V} → G.Subgraph → Prop | The subgraph `M` of `G` is a matching if every vertex of `M` is incident to exactly one edge in `M`.
We say that the vertices in `M.support` are *matched* or *saturated*.
| true |
Finset.one_le_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι} [MulLeftMono N],
(∀ i ∈ s, 1 ≤ f i) → 1 ≤ ∏ i ∈ s, f i | **Alias** of `Finset.one_le_prod`. | true |
Partition.Rel.trans | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x y z : α} {u : Set α} {P : Partition u}, P.Rel x y → P.Rel y z → P.Rel x z | null | true |
Std.Time.WallTime.addSeconds | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Second.Offset → Std.Time.WallTime | Adds a `Second.Offset` to the given `WallTime`.
| true |
FiniteAddGrp.instConcreteCategoryAddMonoidHomCarrierToAddGrp._aux_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | {X Y : FiniteAddGrp.{u_1}} → (X ⟶ Y) → ↑X.toAddGrp →+ ↑Y.toAddGrp | null | false |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_left | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → c * a ≤ c * b | null | true |
CategoryTheory.ComposableArrows.Precomp.map._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1), ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩ → i ≤ j | null | false |
Finset.le_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeSup α] {s : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : OrderTop α],
a ≤ s.truncatedSup a | null | true |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.«_aux_Mathlib_Topology_Homotopy_Product___macroRules__private_Mathlib_Topology_Homotopy_Product_0_Path_Homotopic_term_⬝__1» | Mathlib.Topology.Homotopy.Product | Lean.Macro | null | false |
contDiffOn_of_analyticOn_of_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞}, AnalyticOn 𝕜 f s → ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → C... | null | true |
RootPairing.Hom.mk.injEq | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.nonsingular_some._simp_1_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
CochainComplex.HomComplex.coboundaries.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
CochainComplex.HomComplex.coboundaries K L n =
{ carrier := {α | ∃ m, ∃ (_ : m + 1 = n), ∃ β, CochainComplex.HomComplex.δ m n β = ↑α}, add_mem' := ⋯,
zero_mem' := ⋯, neg_mem... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.quot._regBuiltin.Lean.Parser.Command.quot.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
FreeAddGroup.reduceCyclically.reduce_flatten_replicate_succ | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α],
FreeAddGroup.IsReduced L →
∀ (n : ℕ),
FreeAddGroup.reduce (List.replicate (n + 1) L).flatten =
FreeAddGroup.reduceCyclically.conjugator L ++
(List.replicate (n + 1) (FreeAddGroup.reduceCyclically L)).flatten ++
FreeAd... | null | true |
SubMulAction.algebraMap_mem | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
(algebraMap R A) r ∈ 1 | null | true |
IsCauSeq | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_3} →
[inst : Field α] →
[inst_1 : LinearOrder α] → [IsStrictOrderedRing α] → {β : Type u_4} → [Ring β] → (β → α) → (ℕ → β) → Prop | A sequence is Cauchy if the distance between its entries tends to zero. | true |
contDiffPointwiseHolderAt_iff | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k : ℕ) (α : ↑unitInterval) (f : E → F) (a : E),
ContDiffPointwiseHolderAt k α f a ↔
ContDiffAt ℝ (↑k) f a ∧ (fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.next_eq_iff.match_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} (motive : (p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q') → Prop)
(x : p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q'),
(∀ (h₁ : p < q) (h₂ : ∀ (q' : s.Pos), p < q' → q ≤ q'), motive ⋯) → motive x | null | false |
Set.singleton_union | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, {a} ∪ s = insert a s | null | true |
Trunc.nonempty | Mathlib.Data.Quot | ∀ {α : Sort u_1} (q : Trunc α), Nonempty α | null | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.type?._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.le_prod_iff._simp_1_1 | Mathlib.Order.Sublattice | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
fderivWithin_csinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x | null | true |
Finsupp.equivFunOnFinite | Mathlib.Data.Finsupp.Defs | {α : Type u_1} → {M : Type u_4} → [inst : Zero M] → [Finite α] → (α →₀ M) ≃ (α → M) | Given `Finite α`, `equivFunOnFinite` is the `Equiv` between `α →₀ β` and `α → β`.
(All functions on a finite type are finitely supported.) | true |
Lean.Elab.ConfigEval.foldConfigM._unsafe_rec | Lean.Elab.ConfigEval.Basic | {α : Type} →
{m : Type → Type} →
[Monad m] →
[Lean.MonadRef m] → α → Lean.Syntax → (α → Lean.Elab.ConfigEval.ConfigItem → m α) → (α → Lean.Syntax → m α) → m α | null | false |
SimpleGraph.ConnectedComponent.map_mk | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G →g G') (v : V),
SimpleGraph.ConnectedComponent.map φ (G.connectedComponentMk v) = G'.connectedComponentMk (φ v) | null | true |
Set.bounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x1 x2 => x1 ≤ x2) s | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mctxBefore | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.TacticData✝ → Lean.MetavarContext | MetavarContext before the tactic | true |
LinearGrowth.linearGrowthInf_iInf | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {ι : Type u_1} [Finite ι] (u : ι → ℕ → EReal),
LinearGrowth.linearGrowthInf (⨅ i, u i) = ⨅ i, LinearGrowth.linearGrowthInf (u i) | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj.match_1.eq_2 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : AugmentedSimplexCategory → AugmentedSimplexCategory → Sort u_1) (x : AugmentedSimplexCategory)
(h_1 : (m n : SimplexCategory) → motive (CategoryTheory.WithInitial.of m) (CategoryTheory.WithInitial.of n))
(h_2 : (x : AugmentedSimplexCategory) → motive CategoryTheory.WithInitial.star x)
(h_3 : (x : Augm... | null | true |
Array.instOrientedOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.OrientedOrd α], Std.OrientedOrd (Array α) | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity.mkProof.match_1 | Lean.Meta.CongrTheorems | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 snd : Lean.Expr) → motive (some (fst, lhs, fst_1, snd))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
Std.Internal.List.length_le_length_insertListConst | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)},
l.length ≤ (Std.Internal.List.insertListConst l toInsert).length | null | true |
Path.target' | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (self : Path x y), self.toFun 1 = y | The end point of a `Path`. | true |
LinearMap.toMatrixRight'_id | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} [inst_1 : Fintype m] [inst_2 : DecidableEq m],
LinearMap.toMatrixRight' LinearMap.id = 1 | null | true |
Even.pow_nonneg | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Even n → ∀ (a : R), 0 ≤ a ^ n | null | true |
differentiableAt_of_isInvertible_fderiv | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, (fderiv 𝕜 f x).IsInvertible → DifferentiableAt 𝕜 f ... | null | true |
Algebra.IsSeparablyGenerated | Mathlib.FieldTheory.TranscendentalSeparable | (k : Type u_1) → (K : Type u_2) → [inst : Field k] → [inst_1 : Field K] → [Algebra k K] → Prop | A field extension is separably generated if there exists a transcendence basis such that
the extension above it is separable. | true |
Std.DHashMap.Internal.Raw₀.equiv_iff_toList_perm_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m₁ m₂ : Std.DHashMap.Raw α β), m₁.Equiv m₂ ↔ m₁.toList.Perm m₂.toList | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n s : ℕ},
n + 1 ≤ (List.findIdxs p (head :: tail) s).length → n < (List.findIdxs p (head :: tail) s).length | null | false |
Polynomial.MonicDegreeEq.degree | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] [Nontrivial R] (p : Polynomial.MonicDegreeEq R n), (↑p).degree = ↑n | null | true |
selfAdjoint.instNNRatCast._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (q : ℚ≥0), IsSelfAdjoint ↑q | null | false |
Array.count_eq_zero_of_not_mem | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, a ∉ xs → Array.count a xs = 0 | null | true |
Lean.Server.RequestCancellationToken._sizeOf_inst | Lean.Server.RequestCancellation | SizeOf Lean.Server.RequestCancellationToken | null | false |
Set.countable_iUnion_iff._simp_1 | Mathlib.Data.Set.Countable | ∀ {α : Type u} {ι : Sort x} [Countable ι] {t : ι → Set α}, (⋃ i, t i).Countable = ∀ (i : ι), (t i).Countable | null | false |
DirectLimit.instGroup._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → Group (G i)] ... | null | false |
MeasureTheory.Lp._proof_4 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
Nat.ceilRoot_eq_zero | Mathlib.Data.Nat.Factorization.Root | ∀ {a n : ℕ}, n.ceilRoot a = 0 ↔ n = 0 ∨ a = 0 | null | true |
HahnModule.instAddCommGroup._proof_12 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V]
(a b : HahnModule Γ R V), a + b = b + a | null | false |
AddSubgroupClass.subtype_injective | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_4} (H : S) [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G],
Function.Injective ⇑↑H | null | true |
FiberwiseLinear.openPartialHomeomorph._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_3} {B : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {U : Set B} (φ : B → F ≃L[𝕜] F),
∀ _x ∈ U ×ˢ Set.univ, (_x.1, (φ _x.1).symm _x.2) ∈ U ×ˢ Set.univ | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.elim_nhds_subcover._simp_1_5 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
ValuativeRel.supp._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : ValuativeRel R] {a b : R},
a ∈ {x | x ≤ᵥ 0} → b ∈ {x | x ≤ᵥ 0} → a + b ≤ᵥ 0 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.