name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Sym.erase_mk._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] (m : Multiset α), m.card = n + 1 → ∀ a ∈ m, (m.erase a).card = n | null | false |
BddDistLat.Hom.noConfusion | Mathlib.Order.Category.BddDistLat | {P : Sort u_1} →
{X Y : BddDistLat} →
{t : X.Hom Y} →
{X' Y' : BddDistLat} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → BddDistLat.Hom.noConfusionType P t t' | null | false |
MonoidHom.noncommCoprod_apply' | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) (mn : M × N),
(f.noncommCoprod g comm) mn = g mn.2 * f mn.1 | Variant of `MonoidHom.noncommCoprod_apply` with the product written in the other direction. | true |
CategoryTheory.ObjectProperty.SerreClassLocalization.inverseImage_monomorphisms | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | null | true |
DoResultSBC.recOn | Init.Core | {α σ : Type u} →
{motive : DoResultSBC α σ → Sort u_1} →
(t : DoResultSBC α σ) →
((a : α) → (a_1 : σ) → motive (DoResultSBC.pureReturn a a_1)) →
((a : σ) → motive (DoResultSBC.break a)) → ((a : σ) → motive (DoResultSBC.continue a)) → motive t | null | false |
Fin.dfoldlM_succ | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Fin (n + 1 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin (n + 1)) → α i.castSucc → m (α i.succ)) (x : α 0),
Fin.dfoldlM (n + 1) α f x = do
let x ← f 0 x
Fin.dfoldlM n (α ∘ Fin.succ) (fun x1 x2 => f x1.succ x2) x | null | true |
Set.range_list_getI | Mathlib.Data.Set.List | ∀ {α : Type u_1} [inst : Inhabited α] (l : List α), Set.range l.getI = insert default {x | x ∈ l} | null | true |
CategoryTheory.Limits.prod.braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(P Q : C) →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q] →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P] → P ⨯ Q ≅ Q ⨯ P | The braiding isomorphism which swaps a binary product. | true |
_private.Init.Data.Vector.Lemmas.0.Vector.sum_reverse._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] [inst_1 : Zero α] {xs : Vector α n}, xs.sum = xs.toList.sum | null | false |
Lean.Syntax.Traverser._sizeOf_inst | Lean.Syntax | SizeOf Lean.Syntax.Traverser | null | false |
AddCommGroup.DirectLimit.map._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (G i)]
{f : (i j : ι) → i ≤ j → G i →+ G j} [inst_2 : DecidableEq ι] {G' : ι → Type u_2}
[inst_3 : (i : ι) → AddCommMonoid (G' i)] {f' : (i j : ι) → i ≤ j → G' i →+ G' j} (g : (i : ι) → G i →+ G' i),
(∀ (i j : ι) (h : i ≤ j)... | null | false |
HasSubset.Subset.diff_ssubset_of_nonempty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → s.Nonempty → t \ s ⊂ t | **Alias** of `LE.le.sdiff_ssubset_of_nonempty`. | true |
HahnSeries.SummableFamily.smul_apply | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
[inst_5 : VAdd Γ Γ'] [inst_6 : IsOrderedCancelVAdd Γ Γ'] {x : HahnSeries Γ R} {s : HahnSeries.SummableFam... | null | true |
CategoryTheory.evaluationAdjunctionLeft._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) {X : CategoryTheory.Functor C D}
{Y Y' : D} (f : ((CategoryTheory.evaluation C D).obj c).obj X ⟶ Y) (g : ... | null | false |
_private.Mathlib.Analysis.Analytic.Within.0.analyticOn_of_locally_analyticOn._simp_1_4 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Lean.LeanOptions.mk.noConfusion | Lean.Util.LeanOptions | {P : Sort u} →
{values values' : Lean.NameMap Lean.LeanOptionValue} →
{ values := values } = { values := values' } → (values = values' → P) → P | null | false |
NormedCommGroup.ofMulDist' | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} →
[inst : Norm E] →
[inst_1 : CommGroup E] →
[inst_2 : MetricSpace E] →
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist (z * x) (z * y) ≤ dist x y) → NormedCommGroup E | Construct a normed group from a multiplication-invariant pseudodistance. | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Preregular C]
[CategoryTheory.FinitaryExtensive C], CategoryTheory.Precoherent C | null | false |
Subgroup.instNormalSubtypeMemFocalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroupOf.Normal | Lemma: H* is a normal subgroup of H. | true |
FintypeCat.toLightProfinite | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.Functor FintypeCat LightProfinite | The natural functor from `Fintype` to `LightProfinite`, endowing a finite type with the
discrete topology. | true |
CochainComplex.mappingConeCompTriangleh_comm₁_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.u... | null | true |
LeanSearchClient.SearchServer.rec | LeanSearchClient.Syntax | {motive : LeanSearchClient.SearchServer → Sort u} →
((name url cmd : String) →
(query : String → ℕ → Lean.MetaM (Array LeanSearchClient.SearchResult)) →
(queryNum : Lean.CoreM ℕ) →
motive { name := name, url := url, cmd := cmd, query := query, queryNum := queryNum }) →
(t : LeanSearchClien... | null | false |
Algebra.IsEffective.of_section | Mathlib.RingTheory.TensorProduct.IncludeLeftSubRight | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S] (g : S →ₐ[R] R),
Algebra.IsEffective R S | `IsEffective` is true for any `R`-algebra `S` having an `R`-algebra section of
`Algebra.ofId _ _ : R →ₐ[R] S`. | true |
_private.Init.Data.List.ToArray.0.Break.runK.match_1.splitter | Init.Data.List.ToArray | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | null | true |
Matrix.liftLinear_comp_singleLinearMap | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} (S : Type u_6) {α : Type u_7} {β : Type u_8} [inst : DecidableEq m]
[inst_1 : DecidableEq n] [inst_2 : Fintype m] [inst_3 : Fintype n] [inst_4 : Semiring R] [inst_5 : Semiring S]
[inst_6 : AddCommMonoid α] [inst_7 : AddCommMonoid β] [inst_8 : Module R α] [inst_9 : Modu... | null | true |
ULift.recOn | Init.Prelude | {α : Type s} →
{motive : ULift.{r, s} α → Sort u} → (t : ULift.{r, s} α) → ((down : α) → motive { down := down }) → motive t | null | false |
ISize.toInt16_not | Init.Data.SInt.Bitwise | ∀ (a : ISize), (~~~a).toInt16 = ~~~a.toInt16 | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.map_parallel._proof_1_10 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) ⦃c1 c2 : Computation β⦄,
(∃ l S,
c1 = Computation.map f (Computation.corec Computation.parallel.aux1✝ (l, S)) ∧
c2 =
Computation.corec Computation.parallel.aux1✝
(List.map (Computation.map f) l, Stream'.WSeq.map (Computation.map f) S)) →
... | null | false |
LinOrd.ext | Mathlib.Order.Category.LinOrd | ∀ {X Y : LinOrd} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g | null | true |
AffineEquiv.instCoeOutEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | null | true |
CategoryTheory.Limits.DiagramOfCones.conePoints_map | 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)} (D : CategoryTheory.Limits.DiagramOfCones F) {X Y : J}
(f : X ⟶ Y... | null | true |
_private.Mathlib.CategoryTheory.SmallObject.Iteration.Basic.0.CategoryTheory.SmallObject.SuccStruct.Iteration.subsingleton._simp_5 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
CategoryTheory.DifferentialObject.instHasShift._proof_1 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddCommGroupWithOne S] (C : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (m₁ m₂ m₃ : S)
(X : CategoryTheory.DifferentialObject S C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.... | null | false |
MonCat.Colimits.instInhabitedColimitType | Mathlib.Algebra.Category.MonCat.Colimits | {J : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} J] →
(F : CategoryTheory.Functor J MonCat) → Inhabited (MonCat.Colimits.ColimitType F) | null | true |
List.Cursor.current.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (c : l.Cursor) (h : 0 < c.suffix.length), c.current h = c.suffix[0] | null | true |
LinearMap.exists_mem_center_apply_eq_smul_of_forall_notLinearIndependent | Mathlib.LinearAlgebra.Center | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [IsDomain R] [StrongRankCondition R] [inst_3 : AddCommGroup V]
[inst_4 : Module R V] [Module.Free R V] {f : V →ₗ[R] V},
Module.finrank R V ≠ 1 → (∀ (v : V), ¬LinearIndependent R ![v, f v]) → ∃ a, f = a • 1 | Over a domain `R`, an endomorphism `f` of a free module `V`
of rank ≠ 1 such that `f v` and `v` are collinear, for all `v : V`,
consists of homotheties with central ratio.
When `R` does not satisfy `StrongRankCondition`, use
`LinearMap.exists_mem_center_apply_eq_smul_of_basis`.
When `finrank R V = 1`, up to a linear ... | true |
CategoryTheory.Limits.Cofork.IsColimit.desc'.congr_simp | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g}
(hs hs_1 : CategoryTheory.Limits.IsColimit s),
hs = hs_1 →
∀ {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Lim... | null | true |
Polynomial.modByMonic_eq_sub_mul_div | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R), p %ₘ q = p - q * (p /ₘ q) | null | true |
Lean.Widget.MsgEmbed.brecOn_3.go | Lean.Widget.InteractiveDiagnostic | {motive_1 : Lean.Widget.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u} →
{motive... | null | true |
Prod.map_comp_map | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ζ : Type u_6} (f : α → β) (f' : γ → δ)
(g : β → ε) (g' : δ → ζ), Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f') | Composing a `Prod.map` with another `Prod.map` is equal to
a single `Prod.map` of composed functions.
| true |
SubAddAction.fixingAddSubgroupInsertEquiv._proof_6 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : AddGroup M] [inst_1 : AddAction M α] (a : α)
(s : Set ↥(SubAddAction.ofStabilizer M a)) (x : ↥(fixingAddSubgroup M (insert a (Subtype.val '' s)))),
(fun m => ⟨↑↑m, ⋯⟩) ((fun m => ⟨⟨↑m, ⋯⟩, ⋯⟩) x) = x | null | false |
Mathlib.instReprIneq | Mathlib.Data.Ineq | Repr Mathlib.Ineq | null | true |
CategoryTheory.InjectiveResolution.definition._proof_2._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Injective.ι Z)
((CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1) =
0 | null | false |
Shrink.instAdd | Mathlib.Algebra.Group.Shrink | {α : Type u_2} → [inst : Small.{v, u_2} α] → [Add α] → Add (Shrink.{v, u_2} α) | null | true |
Pi.commMonoidWithZero._proof_3 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → CommMonoidWithZero (α i)] (a : (i : ι) → α i), a * 0 = 0 | null | false |
Lean.Elab.InlayHintLabel | Lean.Elab.InfoTree.InlayHints | Type | null | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Iio_True._simp_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
ZeroHom.coe_copy | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {x : Zero M} {x_1 : Zero N} (f : ZeroHom M N) (f' : M → N) (h : f' = ⇑f),
⇑(f.copy f' h) = f' | null | true |
Real.fourier_continuousMultilinearMap_apply | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] [inst_6 : FiniteDimensional ℝ V]
{ι : Type u_4} [inst_7 : Fintype ι] {M : ι → Type u_5} [inst_8 : (i : ι) → N... | null | true |
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val : ℤ} →
{x n : Lean.Grind.Linarith.Var} →
{c' : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val' : ℤ} →
{x' n' : Lean.Grind.Linarith.Var} →
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.can... | null | false |
Set.iUnion_setOf | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} (P : ι → α → Prop), ⋃ i, {x | P i x} = {x | ∃ i, P i x} | **Alias** of `Set.iUnion_ofPred`. | true |
String.Slice.Pattern.ForwardSliceSearcher.startsWith | Init.Data.String.Pattern.String | String.Slice → String.Slice → Bool | null | true |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.bind.match_14 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {β : Type u_3} {m : α → Filter β} (x : Set β) (σ : Type u_2) (F : CFilter (Set α) σ)
(motive :
(∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ },
∀ x_1 ∈ t, x ∈ m x_1) →
Prop)
(x_1 :
∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets ... | null | false |
_private.Mathlib.LinearAlgebra.Span.Basic.0.LinearMap.submoduleOf_span_singleton_of_mem._simp_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
Affine.Simplex.Equilateral.angle_eq_pi_div_three | Mathlib.Geometry.Euclidean.Simplex | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} {s : Affine.Simplex ℝ P n},
s.Equilateral →
∀ {i₁ i₂ i₃ : Fin (n + 1)},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → EuclideanGeometry.angle (s.points i₁) (s.poin... | null | true |
summable_of_absolute_convergence_real | Mathlib.Analysis.Normed.Ring.InfiniteSum | ∀ {f : ℕ → ℝ}, (∃ r, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)) → Summable f | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.exact? | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Elab.ConfigEval.HandlerTrie✝ → Option Lean.Elab.ConfigEval.EvalConfigItemHandler | The `EvalConfigItemHandlerKind.exact` handler for this trie position's key. | true |
Nonneg.linearOrderedCommGroupWithZero._proof_2 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α],
autoParam (∀ (a : { x // 0 ≤ x }), a ^ 0 = 1) DivInvMonoid.zpow_zero'._autoParam | null | false |
Mathlib.Tactic.ClickSuggestions.Context | Mathlib.Tactic.ClickSuggestions.Util | Type | The information required for pasting a suggestion into the editor. | true |
LinearMap.BilinForm.tmul.eq_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₁ : Type uM₁} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R A] [inst_5 : Module R M₁]
[inst_6 : Module A M₁] [inst_7 : SMulCommClass R A M₁] [inst_8 : IsScalarTower R A M₁] [inst_9 : Modul... | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{lhs rhs : Lean.Expr} →
{configKey : UInt64} →
{lhs' rhs' : Lean.Expr} →
{configKey' : UInt64} →
{ lhs := lhs, rhs := rhs, configKey := configKey } = { lhs := lhs', rhs := rhs', configKey := configKey' } →
(lhs = lhs' → rhs = rhs' → configKey = configKey' → P) → ... | null | false |
List.Cursor.tail.congr_simp | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (s s_1 : l.Cursor) (e_s : s = s_1) (h : 0 < s.suffix.length), s.tail h = s_1.tail ⋯ | null | true |
CategoryTheory.Functor.isoCopyObj | Mathlib.CategoryTheory.NatIso | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → (obj : C → D) → (e : (X : C) → F.obj X ≅ obj X) → F ≅ F.copyObj obj e | The functor constructed with `copyObj` is isomorphic to the given functor. | true |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.elabSetLibrarySuggestions._regBuiltin.Lean.LibrarySuggestions.elabSetLibrarySuggestions_1 | Lean.LibrarySuggestions.Basic | IO Unit | null | false |
Finset.mulETransformLeft_inv | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommGroup α] (e : α) (x : Finset α × Finset α),
Finset.mulETransformLeft e⁻¹ x = (Finset.mulETransformRight e x.swap).swap | null | true |
Int.Internal.Linear.Expr.toPoly'.go.eq_5 | Init.Data.Int.Linear | ∀ (coeff k : ℤ) (a : Int.Internal.Linear.Expr),
Int.Internal.Linear.Expr.toPoly'.go coeff (Int.Internal.Linear.Expr.mulL k a) =
bif k == 0 then id else Int.Internal.Linear.Expr.toPoly'.go (coeff.mul k) a | null | true |
Fin.predAbove_le_predAbove | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} {p q : Fin n}, p ≤ q → ∀ {i j : Fin (n + 1)}, i ≤ j → p.predAbove i ≤ q.predAbove j | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_toArray._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Int.divisorsAntidiag.eq_2 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
(Int.negSucc n).divisorsAntidiag =
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
(n + 1).divisorsAntidiagonal).disjUnion
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
(n +... | null | true |
CategoryTheory.LocalizerMorphism.liftingLocalizedFunctor._aux_1 | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u_1} →
{C₂ : Type u_8} →
{D₁ : Type u_6} →
{D₂ : Type u_3} →
[inst : CategoryTheory.Category.{u_4, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] →
[inst_2 : CategoryTheory.Category.{u_5, u_6} D₁] →
[inst_3 : CategoryTheory.Category.{u_2, u... | null | false |
OrthonormalBasis.fromOrthogonalSpanSingleton._proof_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(n : ℕ) [Fact (Module.finrank 𝕜 E = n + 1)], FiniteDimensional 𝕜 E | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_40 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Besicovitch.BallPackage.ctorIdx | Mathlib.MeasureTheory.Covering.Besicovitch | {β : Type u_1} → {α : Type u_2} → Besicovitch.BallPackage β α → ℕ | null | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_17 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_3} {S : Type u_1} {A : Type u_2} [inst : Semifield R] [inst_1 : TopologicalSpace R] [inst_2 : Field S]
[inst_3 : TopologicalSpace S] [inst_4 : NonUnitalRing A] [inst_5 : Algebra R S] [inst_6 : Module R A]
[inst_7 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [IsScalarTower R S A] {a : A} {... | null | false |
isClosed_le_of_isClosed_nonneg | Mathlib.Analysis.Normed.Order.Lattice | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[ContinuousSub G], IsClosed {x | 0 ≤ x} → IsClosed {p | p.1 ≤ p.2} | null | true |
MeasureTheory.Lp.edist_toLp_zero | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f : α → E) (hf : MeasureTheory.MemLp f p μ),
edist (MeasureTheory.MemLp.toLp f hf) 0 = MeasureTheory.eLpNorm f p μ | null | true |
CategoryTheory.WideSubcategory.obj | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{_P : CategoryTheory.MorphismProperty C} → [inst_1 : _P.IsMultiplicative] → CategoryTheory.WideSubcategory _P → C | The category of which this is a wide subcategory | true |
nhdsSet_le_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {s t : Set X}, (nhdsSet s ≤ nhdsSet t) = (s ⊆ t) | null | false |
Lean.Server.StatefulRequestHandler.casesOn | Lean.Server.Requests | {motive : Lean.Server.StatefulRequestHandler → Sort u} →
(t : Lean.Server.StatefulRequestHandler) →
((fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(pureHandle : Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(handle... | null | false |
Sublattice.mem_mk._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {s : Set α} {a : α} (h_sup : SupClosed s) (h_inf : InfClosed s),
(a ∈ { carrier := s, supClosed' := h_sup, infClosed' := h_inf }) = (a ∈ s) | null | false |
Lean.Lsp.ResolveSupport | Lean.Data.Lsp.Basic | Type | null | true |
intervalIntegral.integral_derivWithin_Icc_of_contDiffOn_Icc | Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ} [CompleteSpace E],
ContDiffOn ℝ 1 f (Set.Icc a b) → a ≤ b → ∫ (x : ℝ) in a..b, derivWithin f (Set.Icc a b) x = f b - f a | Fundamental theorem of calculus-2: If `f : ℝ → E` is `C^1` on `[a, b]`,
then `∫ y in a..b, derivWithin f (Icc a b) y` equals `f b - f a`. | true |
GroupExtension.Equiv.trans_apply | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S')
{E'' : Type u_5} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S'') (a : E),... | null | true |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.vars | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Meta.Simp.Arith.Nat.ToLinear.State → Array Lean.Expr | null | true |
Part.elim_toOption | Mathlib.Data.Part | ∀ {α : Type u_4} {β : Type u_5} (a : Part α) [inst : Decidable a.Dom] (b : β) (f : α → β),
a.toOption.elim b f = if h : a.Dom then f (a.get h) else b | null | true |
SeminormFamily.basisSets_univ_mem | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι), Set.univ ∈ p.basisSets | null | true |
EuclideanSpace.nnnorm_single | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜),
‖EuclideanSpace.single i a‖₊ = ‖a‖₊ | null | true |
Std.DTreeMap.Internal.Impl.insertMany_eq_foldl_impl | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t₁ : Std.DTreeMap.Internal.Impl α β} (h₁ : t₁.Balanced)
{t₂ : Std.DTreeMap.Internal.Impl α β},
↑(t₁.insertMany t₂ h₁) =
Std.DTreeMap.Internal.Impl.foldl (fun acc k v => Std.DTreeMap.Internal.Impl.insert! k v acc) t₁ t₂ | null | true |
_private.Mathlib.Computability.Reduce.0.ManyOneEquiv.trans.match_1_1 | Mathlib.Computability.Reduce | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop} (motive : ManyOneEquiv p q → ManyOneEquiv q r → Prop)
(x : ManyOneEquiv p q) (x_1 : ManyOneEquiv q r),
(∀ (pq : p ≤₀ q) (qp : q ≤₀ p) (qr : q ≤₀ r) (... | null | false |
LowerSet.instSProd | Mathlib.Order.UpperLower.Prod | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → SProd (LowerSet α) (LowerSet β) (LowerSet (α × β)) | null | true |
Std.ExtHashMap.getKeyD_alter_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | null | true |
SemiNormedGrp.hom_id | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M : SemiNormedGrp}, SemiNormedGrp.Hom.hom (CategoryTheory.CategoryStruct.id M) = NormedAddGroupHom.id M.carrier | null | true |
MeasureTheory.Measure.IsAddLeftInvariant.comap | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] {H : Type u_3} [inst_3 : AddGroup H]
{mH : MeasurableSpace H} [MeasurableAdd H] (μ : MeasureTheory.Measure H) [μ.IsAddLeftInvariant] {f : G →+ H},
MeasurableEmbedding ⇑f → (MeasureTheory.Measure.comap (⇑f) μ).IsAddLeftInvariant | null | true |
Matrix.SpecialLinearGroup.instCoeInt | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → Coe (Matrix.SpecialLinearGroup n ℤ) (Matrix.SpecialLinearGroup n R) | Coercion of SL `n` `ℤ` to SL `n` `R` for a commutative ring `R`. | true |
List.getLast?_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {n : ℕ}, (List.replicate n a).getLast? = if n = 0 then none else some a | null | true |
neg_one_pow_eq_neg_one_iff_odd | Mathlib.Algebra.Ring.Parity | ∀ {R : Type u_4} [inst : Monoid R] [inst_1 : HasDistribNeg R] {n : ℕ}, -1 ≠ 1 → ((-1) ^ n = -1 ↔ Odd n) | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesProd.match_5 | Lean.Meta.MkIffOfInductiveProp | (motive : Array Lean.Meta.CasesSubgoal → Sort u_1) →
(__x : Array Lean.Meta.CasesSubgoal) →
((sg : Lean.Meta.CasesSubgoal) → motive #[sg]) → ((x : Array Lean.Meta.CasesSubgoal) → motive x) → motive __x | null | false |
unitsCentralizerEquiv._proof_8 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 x_2 : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ = ⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ | null | false |
_private.Mathlib.Combinatorics.Schnirelmann.0.add_eq_univ_of_one_le_schirelmannDensity_add_schnirelmannDensity.match_1_1.splitter | Mathlib.Combinatorics.Schnirelmann | (motive : ℕ ⊕ ℕ → Sort u_1) → (x : ℕ ⊕ ℕ) → ((x : ℕ) → motive (Sum.inl x)) → ((y : ℕ) → motive (Sum.inr y)) → motive x | null | true |
_private.Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic.0.ProfiniteAddGrp.Hom.mk.inj | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {hom' hom'_1 : ↑A.toProfinite.toTop →ₜ+ ↑B.toProfinite.toTop},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.