name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AffineMap.pi_apply | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V1 : Type u_3} {P1 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : AddTorsor V1 P1]
[inst_3 : Module k V1] {ι : Type u_9} {φv : ι → Type u_10} {φp : ι → Type u_11}
[inst_4 : (i : ι) → AddCommGroup (φv i)] [inst_5 : (i : ι) → Module k (φv i)]
[inst_6 : (i : ι) → AddTorsor (φv i) ... | null | true |
MeasureTheory.SimpleFunc.exists_upperSemicontinuous_le_lintegral_le | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] {μ : MeasureTheory.Measure α}
[μ.WeaklyRegular] (f : MeasureTheory.SimpleFunc α NNReal),
∫⁻ (x : α), ↑(f x) ∂μ ≠ ⊤ →
∀ {ε : ENNReal},
ε ≠ 0 → ∃ g, (∀ (x : α), g x ≤ f x) ∧ UpperSemicontinuous g ∧ ∫⁻ (x : α), ↑(f x) ∂μ... | Given a simple function `f` with values in `ℝ≥0`, there exists an upper semicontinuous
function `g ≤ f` with integral arbitrarily close to that of `f`. Formulation in terms of
`lintegral`.
Auxiliary lemma for Vitali-Carathéodory theorem `exists_lt_lower_semicontinuous_integral_lt`. | true |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.brecOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
((t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Ari... | null | false |
affineIndepOn_equiv | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} {ι' : Type u_5} (e : ι ≃ ι') {f : ι' → P} {s : Set ι},
AffineIndepOn k (f ∘ ⇑e) s ↔ AffineIndepOn k f (⇑e '' s) | null | true |
SubAddAction.SMulMemClass.subtype | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} →
{M : Type v} →
[inst : AddMonoid R] →
[inst_1 : AddAction R M] →
{A : Type u_1} → [inst_2 : SetLike A M] → [hA : VAddMemClass A R M] → (S' : A) → ↥S' →ₑ[id] M | The natural `AddActionHom` over `R` from a `SubAddAction` of `M` to `M`. | true |
Finsupp.lcoeFun | Mathlib.LinearAlgebra.Finsupp.Pi | {α : Type u_1} →
{M : Type u_2} →
{R : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (α →₀ M) →ₗ[R] α → M | Forget that a function is finitely supported.
This is the linear version of `Finsupp.toFun`. | true |
Turing.TM2to1.StAct.ctorElimType | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} → {motive : Turing.TM2to1.StAct K Γ σ k → Sort u} → ℕ → Sort (max 1 (imax (max (u_2 + 1) (u_4 + 1)) u)) | null | false |
_private.Mathlib.AlgebraicGeometry.Noetherian.0.AlgebraicGeometry.isNoetherian_Spec._simp_1_1 | Mathlib.AlgebraicGeometry.Noetherian | ∀ (X : AlgebraicGeometry.Scheme),
AlgebraicGeometry.IsNoetherian X = (AlgebraicGeometry.IsLocallyNoetherian X ∧ CompactSpace ↥X) | null | false |
Std.DTreeMap.Internal.RoiSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Roi α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | null | true |
CategoryTheory.Limits.pushout.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {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] {W : C} {k l : CategoryTheory.Limits.pushout f g ⟶ W},
k = l ↔
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g) k =
CategoryTheory.Catego... | null | true |
HomologicalComplex.Hom.isoOfComponents_hom_f | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : (i : ι) → C₁.X i ≅ C₂.X i)
(hf :
autoParam
(∀ (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp... | null | true |
Subsemigroup.comap_le_comap_iff_of_surjective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Surjective ⇑f → ∀ {S T : Subsemigroup N}, Subsemigroup.comap f S ≤ Subsemigroup.comap f T ↔ S ≤ T | null | true |
groupHomology.H0π.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
groupHomology.H0π A = CategoryTheory.CategoryStruct.comp (groupHomology.cyclesIso₀ A).inv (groupHomology.π A 0) | null | true |
HomotopyCategory.Plus.singleFunctors._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C],
(HomotopyCategory.plus C).ι.Full | null | false |
OrderMonoidWithZeroHom.ext_iff | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] {f g : α →*₀o β}, f = g ↔ ∀ (a : α), f a = g a | null | true |
toMeromorphicNFAt_eventuallyEq_nhds_congr | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 𝕜} {f g : 𝕜 → E},
f =ᶠ[nhdsWithin x {x}ᶜ] g → toMeromorphicNFAt f x =ᶠ[nhds x] toMeromorphicNFAt g x | null | true |
instIsPrincipalIdealRingOfIsSemisimpleRing | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] [IsSemisimpleRing R], IsPrincipalIdealRing R | null | true |
Std.TreeMap.Raw.instLawfulSingletonProd | Std.Data.TreeMap.Raw.Basic | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, LawfulSingleton (α × β) (Std.TreeMap.Raw α β cmp) | null | true |
isGreatest_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGreatest {a} a = True | null | false |
AddCancelMonoid.noConfusion | Mathlib.Algebra.Group.Monoid | {P : Sort u} →
{M : Type u_2} →
{t : AddCancelMonoid M} →
{M' : Type u_2} → {t' : AddCancelMonoid M'} → M = M' → t ≍ t' → AddCancelMonoid.noConfusionType P t t' | null | false |
Array.extract_append_right | Init.Data.Array.Extract | ∀ {α : Type u_1} {i : ℕ} {as bs : Array α}, (as ++ bs).extract as.size (as.size + i) = bs.extract 0 i | null | true |
Lean.Lsp.SymbolKind.number.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 15 → motive Lean.Lsp.SymbolKind.number → motive t | null | false |
WithAbs.ofAbs_pow | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (x : WithAbs v) (n : ℕ), (x ^ n).ofAbs = x.ofAbs ^ n | null | true |
Finset.PNat.coe_prod | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_4} (f : ι → ℕ+) (s : Finset ι), ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i) | null | true |
Set.insert_Ioc_right_eq_Ioc_add_one_of_not_isMax | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Add α] [SuccAddOrder α] {a b : α},
a ≤ b → ¬IsMax b → insert (b + 1) (Set.Ioc a b) = Set.Ioc a (b + 1) | null | true |
Lean.isAutoDeclOrPrivate_Internal | Lean.AutoDecl | Lean.Name → Lean.CoreM Bool | Returns true if `decl` is an automatically generated declaration.
Also returns true if `decl` is an internal name or created during macro
expansion.
| true |
Std.DHashMap.erase_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {k : α}, ∅.erase k = ∅ | null | true |
CategoryTheory.Pseudofunctor.casesOn | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.Pseudofunctor B C → Sort u} →
(t : CategoryTheory.Pseudofunctor B C) →
((toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C) →
... | null | false |
Polynomial.isNilpotent_aeval_sub_of_isNilpotent_sub | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Polynomial R)
{a b : S}, IsNilpotent (a - b) → IsNilpotent ((Polynomial.aeval a) P - (Polynomial.aeval b) P) | null | true |
Batteries.Tactic.GeneralizeProofs.Config.mk.inj | Batteries.Tactic.GeneralizeProofs | ∀ {maxDepth : ℕ} {abstract debug : Bool} {maxDepth_1 : ℕ} {abstract_1 debug_1 : Bool},
{ maxDepth := maxDepth, abstract := abstract, debug := debug } =
{ maxDepth := maxDepth_1, abstract := abstract_1, debug := debug_1 } →
maxDepth = maxDepth_1 ∧ abstract = abstract_1 ∧ debug = debug_1 | null | true |
CategoryTheory.Functor.IsCocartesian.toIsHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} 𝒮} {inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳}
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [self : p.IsCocartesian f φ],
p.IsHomLift f φ | null | true |
padicNorm.eq_zpow_of_nonzero | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ} {q : ℚ}, q ≠ 0 → padicNorm p q = ↑p ^ (-padicValRat p q) | Unfolds the definition of the `p`-adic norm of `q` when `q ≠ 0`. | true |
Std.DTreeMap.Internal.Impl.decidableEquiv | Std.Data.DTreeMap.Internal.Lemmas | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
[Std.LawfulEqOrd α] →
[inst_3 : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] →
(t₁ t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.WF → t₂.WF → Decidable (t₁.Equiv t₂) | Internal implementation detail | true |
CategoryTheory.Bicategory.RightLift.whiskerIdCancel._proof_2 | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t :
CategoryTheory.Bicategory.RightLift f (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id c) g))
{s : CategoryTheory.Bicategory.RightLift f g} (τ : s.whisker (CategoryTheory.CategoryStruct.id c) ⟶ t)... | null | false |
SemiRingCat.hasForgetToMonCat._proof_4 | Mathlib.Algebra.Category.Ring.Basic | { obj := fun R => ↧↑R, map := fun {X Y} f => MonCat.ofHom ↑(SemiRingCat.Hom.hom f),
map_id := SemiRingCat.hasForgetToMonCat._proof_1, map_comp := @SemiRingCat.hasForgetToMonCat._proof_2 }.comp
(CategoryTheory.forget MonCat) =
CategoryTheory.forget SemiRingCat | null | false |
rothNumberNat_spec | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ (n : ℕ), ∃ t ⊆ Finset.range n, t.card = rothNumberNat n ∧ ThreeAPFree ↑t | null | true |
Lean.Elab.Term.ElabElim.Context.mk.noConfusion | Lean.Elab.App | {P : Sort u} →
{elimInfo : Lean.Elab.Term.ElabElimInfo} →
{expectedType : Lean.Expr} →
{elimInfo' : Lean.Elab.Term.ElabElimInfo} →
{expectedType' : Lean.Expr} →
{ elimInfo := elimInfo, expectedType := expectedType } =
{ elimInfo := elimInfo', expectedType := expectedType' } →... | null | false |
_private.Lake.Build.Trace.0.Lake.Hash.fromJson?._sparseCasesOn_1 | Lake.Build.Trace | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((s : String) → motive_1 (Lean.Json.str s)) →
((n : Lean.JsonNumber) → motive_1 (Lean.Json.num n)) → (Nat.hasNotBit 12 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
List.Nodup.mem_diff_iff | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α} {a : α} [inst : BEq α] [LawfulBEq α], l₁.Nodup → (a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂) | **Alias** of `List.Nodup.mem_sdiff_iff`. | true |
_private.Batteries.Data.Char.Basic.0.Char.exists_eq_false_of_all_eq_false._proof_1_9 | Batteries.Data.Char.Basic | ∀ (x : Fin 1056768),
↑x + (Char.maxSurrogate + 1) < 55296 ∨ 57343 < ↑x + (Char.maxSurrogate + 1) ∧ ↑x + (Char.maxSurrogate + 1) < 1114112 | null | false |
unitsNonZeroDivisorsEquiv._proof_4 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀],
Function.RightInverse (fun u => { val := ⟨↑u, ⋯⟩, inv := ⟨↑u⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ })
(↑(Units.map (nonZeroDivisors M₀).subtype)).toFun | null | false |
CategoryTheory.ShortComplex.rightHomologyι_naturality' | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂)... | null | true |
Mathlib.Tactic.Order.OrderType.ctorIdx | Mathlib.Tactic.Order.Preprocessing | Mathlib.Tactic.Order.OrderType → ℕ | null | false |
List.zipWithM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (x : List α)
(x_1 : List β),
List.zipWithM' f x x_1 =
match x, x_1 with
| x :: xs, y :: ys => do
let z ← f x y
let zs ← List.zipWithM' f xs ys
pure (z :: zs)
| x, x_2 => pure [] | null | true |
Complex.ofRealCLM_norm | Mathlib.Analysis.Complex.OperatorNorm | ‖Complex.ofRealCLM‖ = 1 | null | true |
Nat.induct_roo_right | Init.Data.Range.Polymorphic.NatLemmas | ∀ (motive : ℕ → ℕ → Prop),
(∀ (a b : ℕ), b ≤ a + 1 → motive a b) →
(∀ (a b : ℕ), a + 1 ≤ b → motive a b → motive a (b + 1)) → ∀ (a b : ℕ), motive a b | Induction principle for proving properties of `Nat`-based ranges of the form `a<...b` by
varying the upper bound.
In the `base` case, one proves that for any `a : Nat` and `b : Nat` with
`b ≤ a + 1`, the statement holds for the empty range `a<...b`.
In the `step` case, one proves that for any `a : Nat` and `b : Nat`,... | true |
Profinite.NobelingProof.factors._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Span | ∀ {I : Type u_1} [inst : LinearOrder I], IsTrans I fun x1 x2 => x2 ≤ x1 | null | false |
WeierstrassCurve.natDegree_preΨ₄_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R), 2 ≠ 0 → 0 < W.preΨ₄.natDegree | null | true |
CategoryTheory.Preadditive.ofFullyFaithful._proof_1 | Mathlib.CategoryTheory.Preadditive.Transfer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Preadditive D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
F.map (CategoryTheory.CategoryStruct.comp (f + f') g... | null | false |
Homotopy.extend.homAux.eq_2 | Mathlib.Algebra.Homology.Embedding.ExtendHomotopy | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
{K L : HomologicalComplex C c} (φ : (i j : ι) → K.X i ⟶ L.X j) (i' : Option ι),
(i' = none → False) → Homotopy.extend.homAux φ... | null | true |
instNonUnitalNonAssocRingWithConvMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : WithConv (Matrix m n α)), 0 * a = 0 | null | false |
AddSubgroup.unop_bot | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G], ⊥.unop = ⊥ | null | true |
String.Pos.Raw.utf8SetAux.eq_1 | Init.Data.String.Basic | ∀ (c' : Char) (x x_1 : String.Pos.Raw), String.Pos.Raw.utf8SetAux c' [] x x_1 = [] | null | true |
CategoryTheory.Triangulated.someOctahedron | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | A choice of octahedron given by the octahedron axiom. | true |
Int.fdiv_eq_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ},
a.fdiv b =
a.tdiv b - if b ∣ a then 0 else if 0 ≤ a then if 0 ≤ b then 0 else 1 else if 0 ≤ b then b.sign else 1 + b.sign | null | true |
Nat.getElem!_toList_roo_eq_add | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n - (m + 1) → (m<...n).toList[i]! = m + 1 + i | null | true |
Convex.eq_1 | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (s : Set E), Convex 𝕜 s = ∀ ⦃x : E⦄, x ∈ s → StarConvex 𝕜 x s | null | true |
Polynomial.contract_C | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), Polynomial.contract p (Polynomial.C r) = Polynomial.C r | null | true |
MeasureTheory.VAddInvariantMeasure.casesOn | Mathlib.MeasureTheory.Group.Defs | {M : Type u_1} →
{α : Type u_2} →
[inst : VAdd M α] →
{x : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.VAddInvariantMeasure M α μ → Sort u} →
(t : MeasureTheory.VAddInvariantMeasure M α μ) →
((measure_preimage_vadd : ∀ (c : M) ⦃s :... | null | false |
LieAlgebra.lieCharacter_apply_lie' | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(χ : LieAlgebra.LieCharacter R L) (x y : L), ⁅χ x, χ y⁆ = 0 | null | true |
HSpace.prod._proof_10 | Mathlib.Topology.Homotopy.HSpaces | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : HSpace X]
[inst_3 : HSpace Y] (hG : Continuous fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))) (x : X × Y),
{ toFun := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)), continuous_toFu... | null | false |
quadraticChar_exists_neg_one | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F],
ringChar F ≠ 2 → ∃ a, (quadraticChar F) a = -1 | If `F` has odd characteristic, then `quadraticChar F` takes the value `-1`. | true |
Pi.eq_top_iff_refl_of_subsingleton | Mathlib.Order.PropInstances | ∀ {α : Type u_2} [Subsingleton α] {r : α → α → Prop}, r = ⊤ ↔ Std.Refl r | null | true |
CategoryTheory.ObjectProperty.prop_of_isColimit_cofan | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteCoproducts] {J : Type u_2} [Finite J] {f : J → C} {F : CategoryTheory.Limits.Cofan f}
(hF : CategoryTheory.Limits.IsColimit F), (∀ (j : J), P (f j)) → P F.pt | null | true |
Std.TreeMap.Raw.WF.emptyc | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.WF | null | true |
Finset.noncommSum_lemma | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid β] (s : Finset α) (f : α → β),
(↑s).Pairwise (Function.onFun AddCommute f) → {x | x ∈ Multiset.map f s.val}.Pairwise AddCommute | Proof used in definition of `Finset.noncommSum` | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (k : ℤ) (y? : Option Int.Internal.Linear.Var) (c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c) = 1 + sizeOf k + sizeOf y? + sizeOf c | null | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.saveBVar | Lean.Meta.Tactic.Grind.EMatchTheorem | ℕ → Lean.Meta.Grind.NormalizePattern.M✝ Unit | null | true |
Polynomial.separable_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], (Polynomial.cyclotomic n K).Separable | null | true |
Nat.bit_mod_two | Mathlib.Data.Nat.BinaryRec | ∀ (b : Bool) (n : ℕ), Nat.bit b n % 2 = b.toNat | null | true |
Squash.mk | Init.Core | {α : Sort u} → α → Squash α | Places a value into its squash type, in which it cannot be distinguished from any other.
| true |
continuous_finsum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M},
(∀ (i : ι), Continuous (f i)) →
(LocallyFinite fun i => Function.support (f i)) → Continuous fun x => ∑ᶠ (i : ι), f i x | null | true |
Mathlib.Tactic.ITauto.Context.format | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Std.Format | Debug printer for the context. | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.maxPowDvdDiv.match_1.eq_1 | Mathlib.Data.Nat.MaxPowDiv | ∀ (motive : ℕ × ℕ → Sort u_1) (e q : ℕ) (h_1 : (e q : ℕ) → motive (e, q)),
(match (e, q) with
| (e, q) => h_1 e q) =
h_1 e q | null | true |
ImportGraph.Shake.ConstLocation.ctorElimType | ImportGraph.Shake.DeclNeeds | {motive : ImportGraph.Shake.ConstLocation → Sort u} → ℕ → Sort (max 1 u) | null | false |
FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] {F : Type w} [inst_5 : AddCommGroup F]
[inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [IsTopologicalAddGroup F] [Contin... | Two finite-dimensional topological vector spaces over a complete normed field are continuously
linearly equivalent if they have the same (finite) dimension. | true |
Matrix.transposeᵣ.eq_2 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x n : ℕ) (A : Matrix (Fin x) (Fin (n + 1)) α),
A.transposeᵣ = Matrix.of (Matrix.vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ).transposeᵣ) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x < y) = (x.toInt < y.toInt) | null | false |
Lean.instInhabitedScopedEnvExtension.default | Lean.ScopedEnvExtension | {α β σ : Type} → [Inhabited α] → Lean.ScopedEnvExtension α β σ | null | true |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.solveMonoCall._sparseCasesOn_1 | Lean.Elab.Tactic.Monotonicity | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.Iterate.0.String.Slice.revBytes._proof_1 | Init.Data.String.Iterate | ∀ (s : String.Slice), s.endPos.offset ≤ s.rawEndPos | null | false |
MonadFinally | Init.Control.Except | (Type u → Type v) → Type (max (u + 1) v) | Monads that provide the ability to ensure an action happens, regardless of exceptions or other
failures.
`MonadFinally.tryFinally'` is used to desugar `try ... finally ...` syntax.
| true |
LinearAlgebra.FreeProduct.ι' | Mathlib.LinearAlgebra.FreeProduct.Basic | {I : Type u} →
[inst : DecidableEq I] →
(R : Type v) →
[inst_1 : CommSemiring R] →
(A : I → Type w) →
[inst_2 : (i : I) → Semiring (A i)] →
[inst_3 : (i : I) → Algebra R (A i)] → (DirectSum I fun i => A i) →ₗ[R] LinearAlgebra.FreeProduct R A | The canonical linear map from the direct sum of the `A i` to the free product | true |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(hc₁ : CategoryTheory.Limits.IsLimit c₁) (hf₂ : S₂.f = 0) (c₂ : CategoryTheory.Limits... | null | true |
Tactic.ComputeAsymptotics.Seq.dist_nil_cons | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (x : α) (s : Stream'.Seq α), dist Stream'.Seq.nil (Stream'.Seq.cons x s) = 1 | null | true |
Module.Grassmannian._sizeOf_1 | Mathlib.RingTheory.Grassmannian | {R : Type u} →
{inst : CommRing R} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → {k : ℕ} → [SizeOf R] → [SizeOf M] → Module.Grassmannian R M k → ℕ | null | false |
Lean.IR.CollectMaps.collectParams | Lean.Compiler.IR.EmitUtil | Array Lean.IR.Param → Lean.IR.CollectMaps.Collector | null | true |
Subsemiring.distribMulAction | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : Semiring R'] →
[inst_1 : AddMonoid α] → [DistribMulAction R' α] → (S : Subsemiring R') → DistribMulAction (↥S) α | The action by a subsemiring is the action by the underlying semiring. | true |
UniformSpace.ofCoreEq._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (u : UniformSpace.Core α) (t : TopologicalSpace α),
t = u.toTopologicalSpace → ∀ (x : α), nhds x = Filter.comap (Prod.mk x) u.uniformity | null | false |
CategoryTheory.faithful_linearYoneda | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C],
(CategoryTheory.linearYoneda R C).Faithful | null | true |
Prod.finite_iff | Mathlib.Basic.Finite.Prod | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β], Finite (α × β) ↔ Finite α ∧ Finite β | null | true |
Std.DTreeMap.Internal.Impl.erase._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l r : Std.DTreeMap.Internal.Impl α β)
(h : (Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Balanced) (l' : Std.DTreeMap.Internal.Impl α β)
(hl'₁ : l'.Balanced) (hl'₂ : l.size - 1 ≤ l'.size) (hl'₃ : l'.size ≤ l.size),
(Std.DTreeMap.Internal.Impl.ba... | null | false |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.QuickResult.casesOn | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | {motive : Lean.Meta.Grind.QuickResult✝ → Sort u} →
(t : Lean.Meta.Grind.QuickResult✝) →
motive Lean.Meta.Grind.QuickResult.no✝ →
motive Lean.Meta.Grind.QuickResult.proof✝ →
motive Lean.Meta.Grind.QuickResult.decidable✝ → motive Lean.Meta.Grind.QuickResult.undef✝ → motive t | null | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append_right._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, 0 < ys.size → ¬0 < xs.size + ys.size → False | null | false |
Lean.Widget.WidgetSource.rec | Lean.Widget.UserWidget | {motive : Lean.Widget.WidgetSource → Sort u} →
((sourcetext : String) → motive { sourcetext := sourcetext }) → (t : Lean.Widget.WidgetSource) → motive t | null | false |
MeasureTheory.LocallyIntegrable.exists_nat_integrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [SecondCountableTopology X],
MeasureTheory.LocallyIntegrable f μ →
∃ u, (∀ (n : ℕ), IsOpen (u n)) ∧ ⋃ n, u n = Set.univ ∧ ... | If a function is locally integrable in a second countable topological space,
then there exists a sequence of open sets covering the space on which it is integrable. | true |
ComplexShape.χ | Mathlib.Algebra.Homology.EulerCharacteristic | {ι : Type u_1} → (c : ComplexShape ι) → [c.EulerCharSigns] → ι → ℤˣ | The sign at index `i` for Euler characteristic computations. | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.rec | Mathlib.NumberTheory.LSeries.Nonvanishing | {N : ℕ} →
[inst : NeZero N] →
{motive : DirichletCharacter.BadChar✝ N → Sort u} →
((χ : DirichletCharacter ℂ N) →
(χ_ne : χ ≠ 1) →
(χ_sq : χ ^ 2 = 1) →
(hχ : DirichletCharacter.LFunction χ 1 = 0) → motive { χ := χ, χ_ne := χ_ne, χ_sq := χ_sq, hχ := hχ }) →
(t : Di... | null | false |
PositiveLinearMap.preGNS_norm_def | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : PartialOrder A] [inst_2 : Module ℂ A] [inst_3 : StarRing A]
[inst_4 : StarOrderedRing A] [inst_5 : SelfAdjointDecompose A] [inst_6 : StarModule ℂ A]
[inst_7 : IsScalarTower ℂ A A] (f : A →ₚ[ℂ] ℂ) (a : f.PreGNS), ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.