name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lake.instReprBuildTrace | Lake.Build.Trace | Repr Lake.BuildTrace | null | true |
Function.HasTemperateGrowth.id' | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], Function.HasTemperateGrowth fun x => x | null | true |
SimplexCategoryGenRel.faces | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | CategoryTheory.MorphismProperty SimplexCategoryGenRel | A morphism is called a face if it is a `δ i` for some `i : Fin (n + 2)`. | true |
CategoryTheory.equivYoneda'._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (S : CategoryTheory.Sheaf CategoryTheory.typesGrothendieckTopology (Type u_1)),
CategoryTheory.CategoryStruct.comp { hom := (CategoryTheory.equivYoneda S.obj ⋯).inv }
{ hom := (CategoryTheory.equivYoneda S.obj ⋯).hom } =
CategoryTheory.CategoryStruct.id (CategoryTheory.yoneda'.obj (S.obj.obj (Opposite.op ... | null | false |
Std.TreeMap.Raw.WF.insert | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {a : α} {b : β},
t.WF → (t.insert a b).WF | null | true |
ProbabilityTheory.IsAEKolmogorovProcess.aemeasurable_edist | Mathlib.Probability.Process.Kolmogorov | ∀ {T : Type u_1} {Ω : Type u_2} {E : Type u_3} [inst : PseudoEMetricSpace T] {mΩ : MeasurableSpace Ω}
[inst_1 : PseudoEMetricSpace E] {p q : ℝ} {M : NNReal} {P : MeasureTheory.Measure Ω} {X : T → Ω → E},
ProbabilityTheory.IsAEKolmogorovProcess X P p q M → ∀ {s t : T}, AEMeasurable (fun ω => edist (X s ω) (X t ω)) P | null | true |
CommRing.Pic.mapAlgebra._proof_4 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_2) [inst : CommSemiring R] (A : Type u_1) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(M : CommRing.Pic R), Module.Invertible A (TensorProduct R A M.AsModule) | null | false |
Algebra.Presentation.reindex._proof_1 | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_4} {σ : Type u_5} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.Presentation R S ι σ) {ι' : Type u_2} {σ' : Type u_6} (e : ι' ≃ ι) (f : σ' ≃ σ),
Ideal.span (Set.range (⇑(MvPolynomial.rename ⇑e.symm) ∘ P.relation ∘ ⇑f)) = (P.reindex e).ker | null | false |
ContDiffWithinAt.derivWithin | Mathlib.Analysis.Calculus.ContDiff.Deriv | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {m n : WithTop ℕ∞} {f : 𝕜 → F} {s : Set 𝕜} {x : 𝕜},
ContDiffWithinAt 𝕜 n f s x → UniqueDiffOn 𝕜 s → m + 1 ≤ n → x ∈ s → ContDiffWithinAt 𝕜 m (derivWithin f s) s x | null | true |
CategoryTheory.PreGaloisCategory.IsFundamentalGroup.mk._flat_ctor | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {F : CategoryTheory.Functor C FintypeCat}
[inst_1 : CategoryTheory.GaloisCategory C] {G : Type u_1} [inst_2 : Group G]
[inst_3 : (X : C) → MulAction G (F.obj X).obj] [inst_4 : TopologicalSpace G] [inst_5 : IsTopologicalGroup G]
[inst_6 : CompactSpace G],... | null | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.associativity'Iso | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | (X Y Z : SSet.Truncated 2) →
(CategoryTheory.prod.associativity X.HomotopyCategory Y.HomotopyCategory Z.HomotopyCategory).inverse.comp
(((SSet.Truncated.HomotopyCategory.BinaryProduct.inverse X Y).prod
(CategoryTheory.Functor.id Z.HomotopyCategory)).comp
((SSet.Truncated.HomotopyCategory.Bin... | Auxiliary definition for `associativityIso`. | true |
HasSum.add | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α} {a b : α}
{L : SummationFilter β} [ContinuousAdd α], HasSum f a L → HasSum g b L → HasSum (fun b => f b + g b) (a + b) L | null | true |
_private.Lean.Environment.0.Lean.ImportedModule.mk.sizeOf_spec | Lean.Environment | ∀ (toEffectiveImport : Lean.EffectiveImport) (parts irParts : Array (Lean.ModuleData × Lean.CompactedRegion))
(needsIRTrans : Bool),
sizeOf { toEffectiveImport := toEffectiveImport, parts := parts, irParts := irParts, needsIRTrans := needsIRTrans } =
1 + sizeOf toEffectiveImport + sizeOf parts + sizeOf irParts ... | null | true |
CategoryTheory.Limits.CokernelCofork.IsColimit.desc'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {s : CategoryTheory.Limits.CokernelCofork f} (hs : CategoryTheory.Limits.IsColimit s) {W : C}
(k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = 0),
CategoryTheory.Catego... | null | false |
DFinsupp.prod_ne_zero_iff | Mathlib.Data.DFinsupp.BigOperators | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : CommMonoidWithZero γ] [Nontrivial γ] [NoZeroDivisors γ] [inst_5 : (i : ι) → DecidableEq (β i)]
{f : Π₀ (i : ι), β i} {g : (i : ι) → β i → γ}, f.prod g ≠ 0 ↔ ∀ i ∈ f.support, g i (f i) ≠ 0 | null | true |
TensorProduct.instRepr.match_3 | Mathlib.LinearAlgebra.TensorProduct.Defs | (motive : List Std.Format → Sort u_1) →
(parts : List Std.Format) →
(Unit → motive []) →
((part : Std.Format) → motive [part]) → ((parts : List Std.Format) → motive parts) → motive parts | null | false |
dotProduct_one | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_3} {α : Type v} [inst : Fintype n] [inst_1 : MulOneClass α] [inst_2 : AddCommMonoid α] (v : n → α),
v ⬝ᵥ 1 = ∑ i, v i | null | true |
ContinuousOpenMap._sizeOf_1 | Mathlib.Topology.Hom.Open | {α : Type u_6} →
{β : Type u_7} → {inst : TopologicalSpace α} → {inst_1 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → (α →CO β) → ℕ | null | false |
Matrix.IsFiniteCartan.transpose | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {M : Matrix ι ι ℤ},
M.IsFiniteCartan → M.transpose.IsFiniteCartan | null | true |
Array.pmap_push._proof_2 | Init.Data.Array.Attach | ∀ {α : Type u_1} {P : α → Prop} (a : α) (xs : Array α), (∀ b ∈ xs.push a, P b) → ∀ a ∈ xs, P a | null | false |
CategoryTheory.Square.toArrowArrowFunctor_obj_hom_right | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
(CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.right = sq.f₃₄ | null | true |
CochainComplex.isGE_iff | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : CochainComplex C ℤ) (n : ℤ), K.IsGE n ↔ ∀ i < n, HomologicalComplex.ExactAt K i | null | true |
StarSubalgebra.ofClass._proof_2 | Mathlib.Algebra.Star.Subalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [SubsemiringClass S A] (s : S), 1 ∈ s | null | false |
AlgebraicGeometry.reduce_to_affine_nbhd | Mathlib.AlgebraicGeometry.Properties | ∀ (P : (X : AlgebraicGeometry.Scheme) → ↥X → Prop),
(∀ (R : CommRingCat) (x : ↥(AlgebraicGeometry.Spec R)), P (AlgebraicGeometry.Spec R) x) →
(∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] (x : ↥X), P X x → P Y (f x)) →
∀ (X : AlgebraicGeometry.Scheme) (x : ↥X), P X x | null | true |
indicator_enorm_le_enorm_self | Mathlib.Analysis.Normed.Group.Indicator | ∀ {α : Type u_1} {ε : Type u_2} [inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε] {s : Set α} (f : α → ε)
(a : α), s.indicator (fun a => ‖f a‖ₑ) a ≤ ‖f a‖ₑ | null | true |
TopologicalSpace.NoetherianSpace.exists_isOpen_nonempty_subset_irreducibleComponent | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α],
∀ Z ∈ irreducibleComponents α, ∃ o, IsOpen o ∧ o.Nonempty ∧ o ⊆ Z | [Stacks Tag 0052](https://stacks.math.columbia.edu/tag/0052) ((3)) | true |
Std.DTreeMap.Internal.Impl.BalancedAtRoot.erase_left | Std.Data.DTreeMap.Internal.Balancing | ∀ {l l' r : ℕ},
Std.DTreeMap.Internal.Impl.BalancedAtRoot l r →
l - 1 ≤ l' → l' ≤ l → Std.DTreeMap.Internal.Impl.BalanceLErasePrecond r l' | null | true |
_private.Mathlib.SetTheory.Cardinal.Order.0.Cardinal.lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le._simp_1_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
Subsingleton.uniqueTopologicalSpace | Mathlib.Topology.Order | {α : Type u} → [Subsingleton α] → Unique (TopologicalSpace α) | null | true |
Ordinal.instOrderBot | Mathlib.SetTheory.Ordinal.Basic | OrderBot Ordinal.{u_1} | null | true |
Rat.div_def' | Mathlib.Data.Rat.Defs | ∀ (q r : ℚ), q / r = Rat.divInt (q.num * ↑r.den) (↑q.den * r.num) | null | true |
Subgroup.zpow.eq_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.zpow = { pow := fun a n => ⟨↑a ^ n, ⋯⟩ } | null | true |
Lean.Grind.CommRing.denoteInt.eq_1 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (k : ℤ),
Lean.Grind.CommRing.denoteInt k = Bool.rec (OfNat.ofNat k.natAbs) (-OfNat.ofNat k.natAbs) (k.blt' 0) | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError._sizeOf_inst | Mathlib.Tactic.Linter.TextBased | SizeOf Mathlib.Linter.TextBased.StyleError✝ | null | false |
List.maxOn?_eq_ite | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β}
{xs : List α}, List.maxOn? f xs = if h : xs ≠ [] then some (List.maxOn f xs h) else none | null | true |
AddHom.mulOp._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] (f : Mᵐᵒᵖ →ₙ+ Nᵐᵒᵖ) (x y : M),
MulOpposite.unop ((⇑f ∘ MulOpposite.op) (x + y)) =
MulOpposite.unop
{ unop' := (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) x + (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) y } | null | false |
LSeries_eq_mul_integral' | Mathlib.NumberTheory.LSeries.SumCoeff | ∀ (f : ℕ → ℂ) {r : ℝ},
0 ≤ r →
∀ {s : ℂ},
r < s.re →
((fun n => ∑ k ∈ Finset.Icc 1 n, ‖f k‖) =O[Filter.atTop] fun n => ↑n ^ r) →
LSeries f s = s * ∫ (t : ℝ) in Set.Ioi 1, (∑ k ∈ Finset.Icc 1 ⌊t⌋₊, f k) * ↑t ^ (-(s + 1)) | A version of `LSeries_eq_mul_integral` where we use the stronger condition that the partial sums
`∑ k ∈ Icc 1 n, ‖f k‖` are `O(n ^ r)` to deduce the integral representation. | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction.match_3 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {d₁ d₂ : Dᵒᵖ} {c₁ c₂ c₃ c₄ : Cᵒᵖ}
(motive : (d₁ ⟶ d₂) → (c₁ ⟶ c₂) → (c₃ ⟶ c₄) → Prop) (x : d₁ ⟶ d₂) (x_1 : c₁ ⟶ c₂) (x_2 : c₃ ⟶ c₄),
(∀ (f : Opposite.unop d₂ ⟶ Opposite.unop d₁) (g : Oppos... | null | false |
Int.Internal.Linear.Poly.add.injEq | Init.Data.Int.Linear | ∀ (k : ℤ) (v : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly) (k_1 : ℤ) (v_1 : Int.Internal.Linear.Var)
(p_1 : Int.Internal.Linear.Poly),
(Int.Internal.Linear.Poly.add k v p = Int.Internal.Linear.Poly.add k_1 v_1 p_1) = (k = k_1 ∧ v = v_1 ∧ p = p_1) | null | true |
SimpleGraph.vertexCoverNum_ne_top_of_finite_edgeSet | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {G : SimpleGraph V}, G.edgeSet.Finite → G.vertexCoverNum ≠ ⊤ | null | true |
CategoryTheory.Functor.LeftExtension.coconeAtFunctor._proof_3 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_2} {D : Type u_6} {H : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] [inst_2 : CategoryTheory.Category.{u_3, u_4} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (Y : D) {X Y_1 Z : L.LeftExtension F} (f : X ⟶ Y_1)
(g : Y_... | null | false |
CategoryTheory.«term_⟶[_]_» | Mathlib.CategoryTheory.Enriched.Basic | Lean.TrailingParserDescr | `X ⟶[V] Y` is the `V` object of morphisms from `X` to `Y`. | true |
WithZero.decidableLE.match_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_1} →
(motive : WithZero α → WithZero α → Sort u_2) →
(x x_1 : WithZero α) →
((x : WithZero α) → motive none x) →
((a : α) → motive (some a) none) → ((a b : α) → motive (some a) (some b)) → motive x x_1 | null | false |
CategoryTheory.Limits.Cone.postcomposeId._proof_4 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F : CategoryTheory.Functor J C} {X Y : CategoryTheory.Limits.Cone F}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.Cone.postcompose (CategoryTheory.Categor... | null | false |
CategoryTheory.MonoOver.mapComp._proof_2 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] (g_1 : CategoryTheory.MonoOver X),
CategoryTheory.Mono (CategoryTheory.CategoryStruct.comp g_1.arrow (CategoryTheory.CategoryStruct.comp f g)) | null | false |
InfiniteDimensionalOrder | Mathlib.Order.RelSeries | (γ : Type u_3) → [Preorder γ] → Prop | A type is infinite dimensional if it has `LTSeries` of at least arbitrary length | true |
Set.op_smul_set_smul_eq_smul_smul_set | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : SMul αᵐᵒᵖ β] [inst_1 : SMul β γ] [inst_2 : SMul α γ] (a : α)
(s : Set β) (t : Set γ),
(∀ (a : α) (b : β) (c : γ), (MulOpposite.op a • b) • c = b • a • c) → (MulOpposite.op a • s) • t = s • a • t | null | true |
Float32.Model.valid | Init.Data.Float.Model.Float32 | ∀ (self : Float32.Model), Float.Model.Format.binary32.Valid self.toBits.toBitVec | The underlying bit pattern is valid according to the IEEE `binary32` format. | true |
Array.swap_comm | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ} (hi : i < xs.size) (hj : j < xs.size), xs.swap i j hi hj = xs.swap j i hj hi | null | true |
_private.Init.System.IO.0.IO.appDir._sparseCasesOn_1 | Init.System.IO | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
instRegularSpaceForall | Mathlib.Topology.Separation.Regular | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), RegularSpace (X i)],
RegularSpace ((i : ι) → X i) | null | true |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory._proof_8 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b c d : CategoryTheory.OplaxFunctor B C} (f : a ⟶ b) (g : b ⟶ c) {h h' : c ⟶ d} (η : h ⟶ h'),
CategoryTheory.Oplax.OplaxTrans.whiskerLeft (CategoryTheory.CategoryStruct.comp f g) η =
CategoryTheory.Cat... | null | false |
Std.DTreeMap.Internal.Impl.mem_alter_of_not_compare_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)},
¬compare k k' = Ordering.eq → (k' ∈ (Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl ↔ k' ∈ t) | null | true |
Pi.instBooleanAlgebra._proof_12 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → BooleanAlgebra (α i)] (x x_1 : (i : ι) → α i), x ⇨ x_1 = x_1 ⊔ xᶜ | null | false |
rootsOfUnityEquivNthRoots | Mathlib.RingTheory.RootsOfUnity.Basic | (R : Type u_4) →
(k : ℕ) →
[NeZero k] →
[inst : CommRing R] → [inst_1 : IsDomain R] → ↥(rootsOfUnity k R) ≃ { x // x ∈ Polynomial.nthRoots k 1 } | Equivalence between the `k`-th roots of unity in `R` and the `k`-th roots of `1`.
This is implemented as equivalence of subtypes,
because `rootsOfUnity` is a subgroup of the group of units,
whereas `nthRoots` is a multiset. | true |
Fin.covBy_iff | Mathlib.Order.SuccPred.Nat | ∀ {n : ℕ} {a b : Fin n}, a ⋖ b ↔ ↑a ⋖ ↑b | null | true |
Lean.instBEqConstantVal.beq | Lean.Declaration | Lean.ConstantVal → Lean.ConstantVal → Bool | null | true |
_private.Mathlib.GroupTheory.Perm.MaximalSubgroups.0.Equiv.Perm.ofSubtype_mem_stabilizer._simp_1_1 | Mathlib.GroupTheory.Perm.MaximalSubgroups | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x | null | false |
Bornology.IsBounded.add | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddGroup E] {s t : Set E},
Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s + t) | null | true |
FDRep.forget₂_ρ | Mathlib.RepresentationTheory.FDRep | ∀ {R : Type u} {G : Type v} [inst : CommRing R] [inst_1 : Monoid G] (V : FDRep R G),
((CategoryTheory.forget₂ (FDRep R G) (Rep.{u, u, v} R G)).obj V).ρ = V.ρ | null | true |
NNReal.instFloorSemiring._aux_1 | Mathlib.Basic.NNReal.Basic | NNReal → ℕ | null | false |
Lean.Widget.RpcEncodablePacket.mk.«_@».Lean.Widget.InteractiveGoal.2553565095._hygCtx._hyg.1.noConfusion | Lean.Widget.InteractiveGoal | {P : Sort u} →
{hyps type ctx range term hyps' type' ctx' range' term' : Lean.Json} →
{ hyps := hyps, type := type, ctx := ctx, range := range, term := term } =
{ hyps := hyps', type := type', ctx := ctx', range := range', term := term' } →
(hyps = hyps' → type = type' → ctx = ctx' → range = range' ... | null | false |
HasFPowerSeriesOnBall.tendsto_partialSum_prod | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal} {y : E},
HasFPowerSeriesOnBall f p x r ... | If a function admits a power series on a ball, then the partial sums
`p.partialSum n z` converges to `f (x + y)` as `n → ∞` and `z → y`. | true |
Subalgebra.finiteDimensional_toSubmodule | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Ring E] [inst_2 : Algebra F E] {S : Subalgebra F E},
FiniteDimensional F ↥(Subalgebra.toSubmodule S) ↔ FiniteDimensional F ↥S | A `Subalgebra` is `FiniteDimensional` iff it is `FiniteDimensional` as a submodule. | true |
dist_birkhoffAverage_birkhoffAverage | Mathlib.Dynamics.BirkhoffSum.NormedSpace | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] (𝕜 : Type u_3) [inst_1 : RCLike 𝕜]
[inst_2 : NormedSpace 𝕜 E] (f : α → α) (g : α → E) (n : ℕ) (x y : α),
dist (birkhoffAverage 𝕜 f g n x) (birkhoffAverage 𝕜 f g n y) = dist (birkhoffSum f g n x) (birkhoffSum f g n y) / ↑n | null | true |
PartialFun.Iso.mk._proof_1 | Mathlib.CategoryTheory.Category.PartialFun | ∀ {α β : PartialFun} (e : α ≃ β), ↑(⇑e.symm ∘ ⇑e) = CategoryTheory.CategoryStruct.id α | null | false |
intervalIntegral.intervalIntegrable_deriv_of_nonneg | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {g' g : ℝ → ℝ} {a b : ℝ},
ContinuousOn g (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt g (g' x) x) →
(∀ x ∈ Set.Ioo (min a b) (max a b), 0 ≤ g' x) → IntervalIntegrable g' MeasureTheory.volume a b | When the derivative of a function is nonnegative, then it is automatically integrable,
interval version. | true |
MeasureTheory.Measure.haarScalarFactor.congr_simp | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (μ' μ'_1 : MeasureTheory.Measure G) (e_μ' : μ' = μ'_1)
(μ μ_1 : MeasureTheory.Measure G) (e_μ : μ = μ_1) [inst_5 : μ.IsHaarMeasure]
[inst_6 : MeasureTheory.IsFiniteM... | null | true |
CategoryTheory.DifferentialObject.d | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
(self : CategoryTheory.DifferentialObject S C) → self.obj ⟶ (CategoryTheory... | The differential of a differential object. | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
MulOpposite.unop_neg | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Neg α] (x : αᵐᵒᵖ), MulOpposite.unop (-x) = -MulOpposite.unop x | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
ContinuousOn.div_const | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [SeparatelyContinuousMul G₀]
{f : α → G₀} {s : Set α} [inst_3 : TopologicalSpace α],
ContinuousOn f s → ∀ (y : G₀), ContinuousOn (fun x => f x / y) s | null | true |
List.eraseP_eq_nil_iff._simp_1 | Init.Data.List.Erase | ∀ {α : Type u_1} {xs : List α} {p : α → Bool}, (List.eraseP p xs = []) = (xs = [] ∨ ∃ x, p x = true ∧ xs = [x]) | null | false |
Mathlib.Tactic.Echelon.BareissResult.recOn | Mathlib.Tactic.Echelon.Bareiss | {u : Lean.Level} →
{m n : ℕ} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{A : Q(Matrix (Fin «$m») (Fin «$n») «$α»)} →
{motive : Mathlib.Tactic.Echelon.BareissResult rα A → Sort u} →
(t : Mathlib.Tactic.Echelon.BareissResult rα A) →
((cert : Mathlib.Tactic.Echelo... | null | false |
IsUniformGroup.isTopologicalGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α], IsTopologicalGroup α | null | true |
DirectLimit.map₀MonoidHom.eq_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
(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 : Nonempty ι]
[inst_5 : (... | null | true |
AdjoinRoot.Minpoly.coe_toAdjoin | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S},
⇑(AdjoinRoot.Minpoly.toAdjoin R x) = ⇑(AdjoinRoot.liftAlgHom (minpoly R x) (Algebra.ofId R ↥R[x]) ⟨x, ⋯⟩ ⋯) | null | true |
Lean.Grind.UInt16.toNat_eq_toBitVec_toNat | Init.Grind.Homo.UInt16 | ∀ (x : UInt16), x.toNat = x.toBitVec.toNat | null | true |
AddMonoidAlgebra.map_surjective | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+ S),
Function.Surjective ⇑f → Function.Surjective (AddMonoidAlgebra.map f) | `AddMonoidAlgebra.map` of an surjective function is surjective. | true |
Finset.biUnion_empty | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {t : α → Finset β} [inst : DecidableEq β], ∅.biUnion t = ∅ | null | true |
CategoryTheory.InducedCategory.Hom | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → CategoryTheory.InducedCategory D F → CategoryTheory.InducedCategory D F → Type v | The type of morphisms in `InducedCategory D F` between `X` and `Y`
is a 1-field structure which identifies to `F X ⟶ F Y`. | true |
WittVector.mapFun.zsmul | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Fact (Nat.Prime p)]
(f : R →+* S) (z : ℤ) (x : WittVector p R), WittVector.mapFun (⇑f) (z • x) = z • WittVector.mapFun (⇑f) x | null | true |
AlgebraicGeometry.Scheme.Modules.smul_restrictAppIso_inv_apply | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f] (M : Y.Modules)
(U : X.Opens) (r : ↑(Y.presheaf.obj (Opposite.op ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U))))
(x : ↑(M.presheaf.obj (Opposite.op ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U)))),
(Catego... | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂Cohomological._proof_2 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (pq : ℤ × ℤ), 2 ≤ r → WithBotTop.coe (pq.2 - r + 2) ≤ WithBotTop.coe pq.2 | null | false |
AlgHom.linearMapMk_toAddHom | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), { toAddHom := ↑f, map_smul' := ⋯ } = f.toLinearMap | null | true |
CauSeq.exists_gt | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f : CauSeq α abs),
∃ a, f < CauSeq.const abs a | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_le_size._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var | ∀ {w : ℕ} (a : ℕ)
(_x : (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) ×' (curr : ℕ) ×' (_ : aig.RefVec curr) ×' curr ≤ w),
_x.1.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go _x.1 w a _x.2.1 _x.2.2.1 ⋯).aig.decls.size | null | false |
Order.not_isPredPrelimit_iff_pred_eq | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : PredOrder α],
¬Order.IsPredPrelimit a ↔ ∃ b, ¬IsMin b ∧ Order.pred b = a | null | true |
RingCon.instDistribMulActionQuotientOfIsScalarTower._proof_1 | Mathlib.RingTheory.Congruence.Basic | ∀ {α : Type u_2} {R : Type u_1} [inst : Monoid α] [inst_1 : NonAssocSemiring R] [inst_2 : DistribMulAction α R]
[inst_3 : IsScalarTower α R R] (c : RingCon R) (x : α), x • 0 = 0 | null | false |
Lean.Meta.SorryLabelView.module? | Lean.Meta.Sorry | Lean.Meta.SorryLabelView → Option Lean.DeclarationLocation | Records the origin module name, logical source position, and LSP range for the `sorry`.
The logical source position is used when displaying the sorry when the `pp.sorrySource` option is true,
and the LSP range is used for "go to definition" in the Infoview.
| true |
AddMonoidAlgebra.map | Mathlib.Algebra.MonoidAlgebra.MapDomain | {R : Type u_3} →
{S : Type u_4} →
{M : Type u_6} →
[inst : Semiring R] → [inst_1 : Semiring S] → (R →+ S) → AddMonoidAlgebra R M → AddMonoidAlgebra S M | Given a map `f : R →+ S`, return the corresponding map `R[M] → S[M]` obtained by mapping
each coefficient along `f`. | true |
NumberField.IdeleClassGroup.ofCompletion_apply | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : NumberField.InfinitePlace K) (x : v.Completionˣ),
(NumberField.IdeleClassGroup.ofCompletion R K v) x = ↑((NumberField.IdeleGroup.ofCompletion R K v) x) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int8.le_of_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
Invertible.casesOn | Mathlib.Algebra.Group.Invertible.Defs | {α : Type u} →
[inst : Mul α] →
[inst_1 : One α] →
{a : α} →
{motive : Invertible a → Sort u_1} →
(t : Invertible a) →
((invOf : α) →
(invOf_mul_self : invOf * a = 1) →
(mul_invOf_self : a * invOf = 1) →
motive { invOf := in... | null | false |
CategoryTheory.CommaMorphism.recOn | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B T} →
... | null | false |
Lean.Compiler.LCNF.instHashableDecl.hash | Lean.Compiler.LCNF.DeclHash | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → UInt64 | null | true |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_10 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 < as.size | null | false |
Int64.instRxcHasSize | Init.Data.Range.Polymorphic.SInt | Std.Rxc.HasSize Int64 | null | true |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_7 | Mathlib.Data.List.Sublists | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.