name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NonUnitalStarSubalgebra.centralizer_univ | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] [inst_4 : IsScalarTower R A A] [inst_5 : SMulCommClass R A A],
NonUnitalStarSubalgebra.centralizer R Set.univ = NonUnitalStarSubalgebra.center R A | null | true |
Lean.Elab.Tactic.Do.SplitInfo.dite | Lean.Elab.Tactic.Do.VCGen.Split | Lean.Expr → Lean.Elab.Tactic.Do.SplitInfo | null | true |
Quiver.Path.length_comp._f | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b : V} (p : Quiver.Path a b) (x : V) (x_1 : Quiver.Path b x)
(f : Quiver.Path.below x_1), (p.comp x_1).length = p.length + x_1.length | null | false |
ModuleCat.lsmul_eq_smul_id | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {S : Type u} [inst : CommRing S] (M : ModuleCat S) (s : S),
ModuleCat.ofHom ((LinearMap.lsmul S ↑M) s) = s • CategoryTheory.CategoryStruct.id M | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestAtomic | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.Elab.Tactic.TacticM (Lean.TSyntax `tactic) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.mem_range_left._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {n d : ℕ} (s : (SSet.stdSimplex.obj { len := n }).obj (Opposite.op { len := d })) (i : Fin (n + 1)),
(s ∈ (SSet.horn n i).obj (Opposite.op { len := d })) = ∃ j, ∃ (_ : j ≠ i), j ∉ Set.range ⇑s | null | false |
Std.DTreeMap.Internal.Impl.insert.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v v_1 : β k),
v = v_1 →
∀ (t : Std.DTreeMap.Internal.Impl α β) (hl : t.Balanced),
Std.DTreeMap.Internal.Impl.insert k v t hl = Std.DTreeMap.Internal.Impl.insert k v_1 t hl | null | true |
RBTree.RBNode.Path.listL.eq_def | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} (x : RBTree.RBNode.Path α),
x.listL =
match x with
| RBTree.RBNode.Path.root => []
| RBTree.RBNode.Path.left c parent v r => parent.listL
| RBTree.RBNode.Path.right c l v parent => parent.listL ++ (l.toList ++ [v]) | null | true |
HNNExtension.NormalWord.cons_toList | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(u : ℤˣ) (w : HNNExtension.NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u'),
(HNNExtension.NormalWord.cons g u w h... | null | true |
Vector.ofFn_succ' | Init.Data.Vector.OfFn | ∀ {n : ℕ} {α : Type u_1} {f : Fin (n + 1) → α}, Vector.ofFn f = Vector.cast ⋯ (#v[f 0] ++ Vector.ofFn fun i => f i.succ) | null | true |
NumberField.mixedEmbedding.commMap._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] (m : ℝ) (x : (K →+* ℂ) → ℂ),
(fun w => ((m • x) (↑w).embedding).re, fun w => (m • x) (↑w).embedding) =
(RingHom.id ℝ) m • (fun w => (x (↑w).embedding).re, fun w => x (↑w).embedding) | null | false |
Set.iInter₂_vadd_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : VAdd α β] (s : (i : ι) → κ i → Set α)
(t : Set β), (⋂ i, ⋂ j, s i j) +ᵥ t ⊆ ⋂ i, ⋂ j, s i j +ᵥ t | null | true |
Polynomial.eq_zero_of_dvd_of_degree_lt | Mathlib.Algebra.Polynomial.Degree.Domain | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R}, p ∣ q → q.degree < p.degree → q = 0 | null | true |
Bialgebra.TensorProduct.coalgebra_rid_eq_algebra_rid_apply | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R S A]
(x : TensorProduct R A R), (Coalgebra.TensorProduct.rid R S A) x = (Algebra.TensorProduct.rid R... | null | true |
FinEnum.instUInt32 | Mathlib.Data.FinEnum | FinEnum UInt32 | null | true |
CStarMatrix.instNonUnitalCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] {n : Type u_2}
[inst_3 : Fintype n] (x : ℂ) (y z : CStarMatrix n n A), (x • y) • z = x • y • z | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.String.0.String.Slice.startsWith_slice_iff._simp_1_7 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ <+: l₂) = ∃ l₃, l₁ ++ l₃ = l₂ | null | false |
Polynomial.derivative_ofNat | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) [inst_1 : n.AtLeastTwo], Polynomial.derivative (OfNat.ofNat n) = 0 | null | true |
Lean.Lsp.CodeActionContext.mk._flat_ctor | Lean.Data.Lsp.CodeActions | Array Lean.Lsp.Diagnostic →
Option (Array Lean.Lsp.CodeActionKind) → Option Lean.Lsp.CodeActionTriggerKind → Lean.Lsp.CodeActionContext | null | false |
_private.Lean.Meta.Tactic.Apply.0.Lean.MVarId.iffOfEq._sparseCasesOn_1 | Lean.Meta.Tactic.Apply | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.Cofork.unop.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {f g : X ⟶ Y}
(c : CategoryTheory.Limits.Cofork f g),
c.unop =
((CategoryTheory.Limits.Cocone.precompose (CategoryTheory.Limits.opParallelPairIso f.unop g.unop).hom).obj
(CategoryTheory.Limits.Cocone.whisker CategoryTheory.Limits.wa... | null | true |
LightDiagram'._sizeOf_inst | Mathlib.Topology.Category.LightProfinite.Basic | SizeOf LightDiagram' | null | false |
_private.Mathlib.Topology.LocallyFinite.0.locallyFinite_option._simp_1_1 | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] [Finite ι] (f : ι → Set X), LocallyFinite f = True | null | false |
RootPairing.Equiv.mul_eq_comp | 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] {P : RootPairing ι R M N} (x y : P.Equiv P),
x * y = x.comp y | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftLeftZeroExtend._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} (n : ℕ), ¬x.toNat < 2 ^ w → False | null | false |
instCommRingFreeCommRing._proof_36 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1), autoParam (∀ (a b : FreeCommRing α), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd.0.EulerSine.integral_sin_mul_sin_mul_cos_pow_eq._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd | (1 + 1).AtLeastTwo | null | false |
SemiSimplexCategory.smallCategory._proof_2 | Mathlib.AlgebraicTopology.SimplexCategory.SemiSimplexCategory | ∀ {X Y : SemiSimplexCategory} (f : X.Hom Y), RelEmbedding.trans f (RelEmbedding.refl fun x1 x2 => x1 ≤ x2) = f | null | false |
Setoid.gi._proof_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (x : α → α → Prop) (s : Setoid α), Relation.EqvGen.setoid x ≤ s ↔ x ≤ ⇑s | null | false |
SetSemiring.instAddCommMonoid._proof_1 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (x : SetSemiring α), nsmulRec 0 x = 0 | null | false |
RootPairing.Equiv.mk'._proof_7 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_4} {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N), P.flip.IsPerfPair | null | false |
SSet.Truncated.Edge.CompStruct.comp_unique | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | ∀ {A : SSet.Truncated 2} [A.Quasicategory₂]
{x y z : A.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Quasicategory₂._proof_1 })}
{f f' : SSet.Truncated.Edge x y} {g g' : SSet.Truncated.Edge y z} {h h' : SSet.Truncated.Edge x z}
(s : f.CompStruct g h) (s' : f'.CompStruct g' h'),
SSet.Truncat... | Given `CompStruct f g h` and `CompStruct f' g' h'` with the same vertices and edges such
that `f` ≃ `f'` and `g` ≃ `g'`, then the long diagonal edges `h` and `h'` are also homotopic.
| true |
ClopenUpperSet.coe_toUpperSet | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] (s : ClopenUpperSet α), ↑s.toUpperSet = ↑s | null | true |
Aesop.SimpResult.ctorElim | Aesop.Search.Expansion.Simp | {motive : Aesop.SimpResult → Sort u} →
(ctorIdx : ℕ) → (t : Aesop.SimpResult) → ctorIdx = t.ctorIdx → Aesop.SimpResult.ctorElimType ctorIdx → motive t | null | false |
HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.BifibrantObject C) (x_2 x_3 : x ⟶ x_1),
HomotopicalAlgebra.BifibrantObject.homRel C x_2 x_3 →
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.comp HomotopicalAlgebra.Cofi... | null | false |
instReprExcept | Init.Data.ToString.Basic | {ε : Type u_1} → {α : Type u_2} → [Repr ε] → [Repr α] → Repr (Except ε α) | null | true |
Std.Internal.Do.WPMonad.liftWith_OptionT_wp._simp_1 | Std.Internal.Do.WP.Lemmas | ∀ {Pred : Type u} {EPred : Type u_1} {m : Type u → Type v} [inst : Monad m] [inst_1 : Std.Internal.Do.Assertion Pred]
[inst_2 : Std.Internal.Do.Assertion EPred] [inst_3 : Std.Internal.Do.WPMonad m Pred EPred] {α : Type u}
{post : α → Pred} {epost : EPost.cons✝ Pred EPred} (f : ({β : Type u} → OptionT m β → m (Optio... | null | false |
_private.Mathlib.Analysis.Normed.Module.MultipliableUniformlyOn.0.Summable.hasProdUniformlyOn_one_add._simp_1_1 | Mathlib.Analysis.Normed.Module.MultipliableUniformlyOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = TendstoUniformlyOn (fun x1 x2 => ∏ i ∈ x1, f i x2) g Filter.atTop s | null | false |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.replaceLhs? | Lean.Meta.Tactic.Grind.MatchCond | Lean.Expr → Lean.Expr → Option Lean.Expr → Option Lean.Expr | Replaces the left-hand side of an equality (or heterogeneous equality) `e` with `lhsNew`.
| true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.getKey._proof_3 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m : Std.ExtDHashMap α β) (a : α) (h : a ∈ m) (m_1 m' : Std.DHashMap α β) (x_2 : m = Std.ExtDHashMap.mk m_1),
m = Std.ExtDHashMap.mk m' → ∀ (h_1 : m_1.Equiv m'), m_1.getKey a ⋯ = m'.getKey a ⋯ | null | false |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda._sparseCasesOn_1 | Mathlib.Tactic.Translate.Core | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
RestrictedProduct.instPow.eq_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)],
RestrictedProduct.instPow R = { pow := fun x n => ⟨fun i => x i ^ n, ⋯⟩ } | null | true |
Filter.Tendsto.atBot_mul_atBot₀ | Mathlib.Order.Filter.AtTopBot.Ring | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {l : Filter β}
{f g : β → α},
Filter.Tendsto f l Filter.atBot → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x * g x) l Filter.atTop | null | true |
Batteries.Tactic.Lint.instReprLintVerbosity | Batteries.Tactic.Lint.Frontend | Repr Batteries.Tactic.Lint.LintVerbosity | null | true |
Lean.Grind.CommRing.denoteInt | Init.Grind.Ring.CommSolver | {α : Type u_1} → [Lean.Grind.Ring α] → ℤ → α | null | true |
Lean.Meta.Sym.Arith.instInhabitedCommRing.default | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.CommRing | null | true |
Affine.Simplex.map_mkOfPoint | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {V₂ : Type u_3} {P : Type u_5} {P₂ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V]
[inst_2 : AddCommGroup V₂] [inst_3 : Module k V] [inst_4 : Module k V₂] [inst_5 : AddTorsor V P]
[inst_6 : AddTorsor V₂ P₂] (f : P →ᵃ[k] P₂) (hf : Function.Injective ⇑f) (p : P),
(Affine.Simple... | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.spanFinset_eq_zero._simp_1_7 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
NumberField.InfinitePlace.IsUnramified.comap | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] (K : Type u_2) [inst_1 : Field K] {F : Type u_3} [inst_2 : Field F]
[inst_3 : Algebra k K] [inst_4 : Algebra k F] [inst_5 : Algebra K F] [IsScalarTower k K F]
{w : NumberField.InfinitePlace F},
NumberField.InfinitePlace.IsUnramified k w → NumberField.InfinitePlace.IsUnramified k ... | null | true |
CategoryTheory.TwoSquare.op | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | The opposite of a `2`-square. | true |
Subgroup.mem_sup_of_normal_left | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] {s t : Subgroup G} [hs : s.Normal] {x : G}, x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | true |
Subgroup.le_comap_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (H : Subgroup G),
H ≤ Subgroup.comap f (Subgroup.map f H) | null | true |
ContinuousMap.ctorIdx | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} → {Y : Type u_2} → {inst : TopologicalSpace X} → {inst_1 : TopologicalSpace Y} → C(X, Y) → ℕ | null | false |
CategoryTheory.Localization.SmallShiftedHom.shift | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{W : CategoryTheory.MorphismProperty C} →
{M : Type w'} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
[W.IsCompatibleWithShift M] →
{X Y : C} →
{a : M} →
... | Given `f : SmallShiftedHom.{w} W X Y a`, this is the element in
`SmallHom.{w} W (X⟦n⟧) (Y⟦a'⟧)` that is obtained by shifting by `n`
when `a + n = a'`. | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.mk.inj | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} {inst : Preorder ι} {c : ℤ → ComplexShape κ} {r₀ : ℤ} {deg : κ → ℤ}
{i₀ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_1 → ι}
{i₁ i₂ : κ → ι}
{i₃ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.Spectr... | null | true |
ContinuousAlternatingMap._sizeOf_1 | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
{ι : Type u_4} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : Module R M} →
{inst_3 : TopologicalSpace M} →
{inst_4 : AddCommMonoid N} →
{inst_5 : Module R N} →
... | null | false |
dist_prod_prod_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {E : Type u_5} [inst : SeminormedCommGroup E] (s : Finset ι) (f a : ι → E),
dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b) | null | true |
Real.partialOrder._proof_3 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a ≤ b → b ≤ c → a ≤ c | null | false |
LocallyConstant.constₐ_apply_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_6) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (y : Y) (a : X), ((LocallyConstant.constₐ R) y) a = y | null | true |
lp.inftyStarRing._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NonUnitalNormedRing (B i)] [inst_1 : (i : I) → StarRing (B i)]
[inst_2 : ∀ (i : I), NormedStarGroup (B i)] (_f _g : ↥(lp B ⊤)), star (_f * _g) = star _g * star _f | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sumZeroes_T_of_not_dvd._simp_1_12 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
dotProductBilin._proof_5 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_2} (R : Type u_3) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Fintype m] (x : R) (x_1 x_2 x_3 : m → A),
x • x_1 ⬝ᵥ (x_2 + x_3) = x • x_1 ⬝ᵥ x_2 + x • x_1 ⬝ᵥ x_3 | null | false |
_private.Mathlib.Tactic.Linter.TextBased.UnicodeLinter.0.Mathlib.Linter.TextBased.UnicodeLinter.ASCII.allowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Bool | Allowed (by the linter) ASCII characters | true |
instNonemptyTypeName | Init.Dynamic | ∀ {α : Type u_1}, Nonempty (TypeName α) | null | true |
ArchimedeanClass.instSMulNat._proof_1 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (x y : R),
ArchimedeanClass.mk x = ArchimedeanClass.mk y → ArchimedeanClass.mk (x ^ n) = ArchimedeanClass.mk (y ^ n) | null | false |
CategoryTheory.yonedaGrpObjRepresentableBy | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(G : C) →
[inst_2 : CategoryTheory.GrpObj G] →
((CategoryTheory.yonedaGrpObj G).comp (CategoryTheory.forget GrpCat)).RepresentableBy G | If `G` is a monoid object, then `Hom(-, G)` as a presheaf of monoids is represented by `G`. | true |
CategoryTheory.Limits.pushout.inl_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Epi g],
CategoryTheory.Epi (CategoryTheory.Limits.pushout.inl f g) | The pushout of an epimorphism is an epimorphism | true |
CategoryTheory.Functor.OplaxRightLinear.rec | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Mo... | null | false |
CategoryTheory.Abelian.SpectralObject.fromOpcycles._proof_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | false |
_private.Init.Data.List.ToArray.0.List.zipWithAll_go_toArray._proof_1_7 | Init.Data.List.ToArray | ∀ {α : Type u_1} {β : Type u_2} (as : List α) (bs : List β) (i : ℕ),
max as.length bs.length ≤ i → ¬bs.length ≤ i → False | null | false |
mem_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {t : Set α} {a : α} {s : Set α},
t ∈ nhdsWithin a s ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t | null | true |
Concept.casesOn | Mathlib.Order.Concept | {α : Type u_2} →
{β : Type u_3} →
{r : α → β → Prop} →
{motive : Concept α β r → Sort u} →
(t : Concept α β r) →
((extent : Set α) →
(intent : Set β) →
(upperPolar_extent : upperPolar r extent = intent) →
(lowerPolar_intent : lowerPolar r int... | null | false |
AlgebraicGeometry.Proj.toLocallyRingedSpace | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → AlgebraicGeometry.LocallyRingedSpace | `Proj` of a graded ring as a `LocallyRingedSpace` | true |
EuclideanSpace.equiv | Mathlib.Analysis.InnerProductSpace.PiL2 | (ι : Type u_1) → (𝕜 : Type u_3) → [inst : RCLike 𝕜] → EuclideanSpace 𝕜 ι ≃L[𝕜] ι → 𝕜 | A shorthand for `PiLp.continuousLinearEquiv`. | true |
_private.Init.Data.PLift.0.instDecidableEqPLift.decEq.match_1 | Init.Data.PLift | {α : Sort u_1} →
(motive : PLift α → PLift α → Sort u_2) →
(x x_1 : PLift α) → ((a b : α) → motive { down := a } { down := b }) → motive x x_1 | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.not_isG2_iff_isNotG2._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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] (P : RootPairing ι R M N)
[inst_5 : P.IsCrystallographic] [P.IsReduced] [P.IsIrreducible],
P.IsNotG2 = ∀ (i j : ι), P.pairingIn ℤ i j ∈ ... | null | false |
Lean.warnIfUsesSorry | Lean.AddDecl | Lean.Declaration → Lean.CoreM Unit | If the `warn.sorry` option is set to true and there are no errors in the log already,
logs a warning if the declaration uses `sorry`.
| true |
PFunctor.Approx.CofixA.noConfusion | Mathlib.Data.PFunctor.Univariate.M | {P : Sort u} →
{F : PFunctor.{uA, uB}} →
{a : ℕ} →
{t : PFunctor.Approx.CofixA F a} →
{F' : PFunctor.{uA, uB}} →
{a' : ℕ} →
{t' : PFunctor.Approx.CofixA F' a'} →
F = F' → a = a' → t ≍ t' → PFunctor.Approx.CofixA.noConfusionType P t t' | null | false |
List.take_succ_cons | Init.Data.List.Basic | ∀ {α : Type u} {a : α} {as : List α} {i : ℕ}, List.take (i + 1) (a :: as) = a :: List.take i as | null | true |
CategoryTheory.ComposableArrows.Precomp.map_zero_one'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ}, 0 + 1 < n + 1 + 1 | null | false |
cauchy_davenport_mul_of_linearOrder_isCancelMul | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : Mul α] [IsCancelMul α] [MulLeftMono α] [MulRightMono α]
{s t : Finset α}, s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | The **Cauchy-Davenport Theorem** for linearly ordered cancellative semigroups. The size of
`s * t` is lower-bounded by `|s| + |t| - 1`. | true |
Lean.Compiler.LCNF.Code.del.elim | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
t.ctorIdx = 13 →
((fvarId : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive_4 (Lean.Compiler.LCNF.... | null | false |
Lean.KVMap.Value.ctorIdx | Lean.Data.KVMap | {α : Type} → Lean.KVMap.Value α → ℕ | null | false |
PartialEquiv.toEquiv.match_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (motive : ↑e.source → Prop) (x : ↑e.source),
(∀ (val : α) (hx : val ∈ e.source), motive ⟨val, hx⟩) → motive x | null | false |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion._aux_Mathlib_Topology_UniformSpace_AbstractCompletion___macroRules__private_Mathlib_Topology_UniformSpace_AbstractCompletion_0_AbstractCompletion_termι_1 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.Macro | null | false |
List.findFinIdx?.go.match_1 | Init.Data.List.Basic | {α : Type u_1} →
(l : List α) →
(motive : (x : List α) → (x_1 : ℕ) → x.length + x_1 = l.length → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
(x_2 : x.length + x_1 = l.length) →
((x : ℕ) → (x_3 : [].length + x = l.length) → motive [] x x_3) →
((a : α) → (l_1 : List α) →... | null | false |
GrpCat.of.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ (M : Type u) [inst : Group M], GrpCat.of M = { carrier := M, str := inst } | null | true |
isClosed_empty._simp_1 | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ = True | null | false |
CategoryTheory.equivToOverUnit._proof_8 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit... | null | false |
Module.Invertible.rTensor_bijective_iff | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} (M : Type v) {N : Type u_1} {P : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] [Module.Invertible R M] {f : N →ₗ[R] P},
Function.Bijective ⇑(LinearMap.rTensor M f) ... | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.netMaxcard_infinite_iff._simp_1_3 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
CategoryTheory.Limits.colimitConstInitial._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasInitial C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.initial.to (CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj... | null | false |
_private.Init.Data.String.OrderInstances.0.String.Pos.instToIntCoOfNatIntHAddCastUtf8ByteSize._proof_2 | Init.Data.String.OrderInstances | ∀ {s : String} (p : s.Pos), p.offset.byteIdx ≤ s.utf8ByteSize → ¬↑p.offset.byteIdx < ↑s.utf8ByteSize + 1 → False | null | false |
Finset.sum_range_succ'._f | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] (f : ℕ → M) (x : ℕ) (f_1 : Nat.below x),
∑ k ∈ Finset.range (x + 1), f k = ∑ k ∈ Finset.range x, f (k + 1) + f 0 | null | false |
Matrix.toLinearEquivRight'OfInv | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
[inst : Semiring R] →
{m : Type u_3} →
{n : Type u_4} →
[inst_1 : Fintype m] →
[inst_2 : DecidableEq m] →
[inst_3 : Fintype n] →
[inst_4 : DecidableEq n] →
{M : Matrix m n R} → {M' : Matrix n m R} → M * M' = 1 → M' * M = 1 → (n → R... | If `M` and `M'` are each other's inverse matrices, they provide an equivalence between `n → A`
and `m → A` corresponding to `M.vecMul` and `M'.vecMul`. | true |
EReal.coe_ennreal_ne_zero | Mathlib.Data.EReal.Basic | ∀ {x : ENNReal}, ↑x ≠ 0 ↔ x ≠ 0 | null | true |
Std.DHashMap.get!_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
[inst_1 : Inhabited (β k)] {f : β k → β k}, (m.modify k f).get! k = (Option.map f (m.get? k)).get! | null | true |
smul_eq_self_of_preimage_zpow_eq_self | Mathlib.Dynamics.FixedPoints.Prufer | ∀ {G : Type u_1} [inst : CommGroup G] {n : ℤ} {s : Set G},
(fun x => x ^ n) ⁻¹' s = s → ∀ {g : G} {j : ℕ}, g ^ n ^ j = 1 → g • s = s | Let `n : ℤ` and `s` a subset of a commutative group `G` that is invariant under preimage for
the map `x ↦ x^n`. Then `s` is invariant under the pointwise action of the subgroup of elements
`g : G` such that `g^(n^j) = 1` for some `j : ℕ`. (This subgroup is called the Prüfer subgroup when
`G` is the `Circle` and `n` is ... | true |
Vector.range'_inj._simp_1 | Init.Data.Vector.Range | ∀ {s n s' : ℕ}, (Vector.range' s n = Vector.range' s' n) = (n = 0 ∨ s = s') | null | false |
_private.Mathlib.Data.List.Lookmap.0.List.lookmap_congr.match_1_1 | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} {f g : α → Option α} (motive : (x : List α) → (∀ a ∈ x, f a = g a) → Prop) (x : List α)
(x_1 : ∀ a ∈ x, f a = g a),
(∀ (x : ∀ a ∈ [], f a = g a), motive [] x) →
(∀ (a : α) (l : List α) (H : ∀ a_1 ∈ a :: l, f a_1 = g a_1), motive (a :: l) H) → motive x x_1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.