name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.trace_fin_one | Mathlib.LinearAlgebra.Matrix.Trace | ∀ {R : Type u_6} [inst : AddCommMonoid R] (A : Matrix (Fin 1) (Fin 1) R), A.trace = A 0 0 | null | true |
Complex.norm_ratCast | Mathlib.Analysis.Complex.Norm | ∀ (q : ℚ), ‖↑q‖ = |↑q| | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.interSmallerFn.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l sofar : List ((a : α) × β a)) (k : α),
Std.Internal.List.interSmallerFn l sofar k =
match Std.Internal.List.getEntry? k l with
| some kv' => Std.Internal.List.insertEntry kv'.fst kv'.snd sofar
| none => sofar | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Real.rpow_def_of_nonneg._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | null | false |
IsOpenMap.functor._proof_2 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom f))
{X_1 Y_1 Z : TopologicalSpace.Opens ↑X} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
IsOpenMap.functorMap ⋯ ⋯ ⋯ =
CategoryTheory.CategoryStruct.comp (IsOpenMap.functorMap ⋯ ⋯ ⋯) (IsOpenMap.functorMap ⋯ ⋯ ⋯) | null | false |
CategoryTheory.Mat_.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Preadditive C] → (M N : CategoryTheory.Mat_ C) → AddCommGroup (M ⟶ N) | null | true |
Lean.Elab.PartialTermInfo.casesOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.PartialTermInfo → Sort u} →
(t : Lean.Elab.PartialTermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
motive { toElabInfo := toElabInfo, lctx := lctx, expectedType? := expectedType? }) →
motive t | null | false |
Subgroup.subgroupOf_map_powMonoidHom_eq_range | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {M : Type u_5} [inst : CommGroup M] (S : Subgroup M) (n : ℕ),
(Subgroup.map (powMonoidHom n) S).subgroupOf S = (powMonoidHom n).range | null | true |
_private.Init.Data.List.MinMax.0.List.max?_attach._simp_1_4 | Init.Data.List.MinMax | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
_private.Lean.Compiler.LCNF.Specialize.0.PSigma.casesOn._arg_pusher | Lean.Compiler.LCNF.Specialize | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
IsDedekindDomain.HeightOneSpectrum.equivPrimesOver | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {A : Type u_4} →
[inst : CommRing A] →
{p : Ideal A} →
[hpm : p.IsMaximal] →
(B : Type u_5) →
[inst_1 : CommRing B] →
[IsDedekindDomain B] →
[inst_3 : Algebra A B] →
[IsDomain A] →
[Module.IsTorsionFree A B] →
... | The bijection between the elements of the height one prime spectrum of `B` that divide the lift
of the maximal ideal `p` in `B` and the primes over `p` in `B`.
| true |
_private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.sum_Ico_eq_card_lt | Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas | ∀ {p q : ℕ},
∑ a ∈ Finset.Ico 1 (p / 2).succ, a * q / p =
{x ∈ Finset.Ico 1 (p / 2).succ ×ˢ Finset.Ico 1 (q / 2).succ | x.2 * p ≤ x.1 * q}.card | The given sum is the number of integer points in the triangle formed by the diagonal of the
rectangle `(0, p/2) × (0, q/2)`. | true |
LawfulMonadStateOf.set_bind_modifyGet_bind | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α β : Type u_1} (s : σ) (f : σ → α × σ) (mx : α → m β),
(do
set s
let x ← modifyGet f
mx x) =
do
set (f s).2
mx (f s).1 | null | true |
TopologicalSpace.Opens.toTopCat_map | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat) {U V : TopologicalSpace.Opens ↑X} {f : U ⟶ V} {x : ↑X} {h : x ∈ U},
(CategoryTheory.ConcreteCategory.hom ((TopologicalSpace.Opens.toTopCat X).map f)) ⟨x, h⟩ = ⟨x, ⋯⟩ | null | true |
Mathlib.Tactic.Ring.natCast_mul | Mathlib.Tactic.Ring.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {b₁ b₃ : R} {a₁ a₃ : ℕ} (a₂ : ℕ),
↑a₁ = b₁ → ↑a₃ = b₃ → ↑(a₁ ^ a₂ * a₃) = b₁ ^ a₂ * b₃ | null | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.Balanced.append.match_1_7 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {n : ℕ} (b c a : RBTree.RBNode α) (x : α) (b_1 : RBTree.RBNode α)
(motive :
(w : RBTree.RBColor) →
(RBTree.RBNode.node RBTree.RBColor.red a x b_1).Balanced w n → (b.append c).Balanced w n → Prop)
(w : RBTree.RBColor) (x_1 : (RBTree.RBNode.node RBTree.RBColor.red a x b_1).Balanced w n)
(... | null | false |
AlgebraicGeometry.Scheme.Cover.exists_lift_trans_eq | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀}
(x : ↥(CategoryTheory.Limits.pullback (𝒰.f... | null | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_3 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type u_2))}
(hF : ∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.ma... | null | false |
PointedCone.maxTensorProduct._proof_2 | Mathlib.Geometry.Convex.Cone.TensorProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
DivInvMonoid.div._default | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
(one : G) →
(mul : G → G → G) →
(∀ (a b c : G), a * b * c = a * (b * c)) →
(∀ (a : G), 1 * a = a) →
(∀ (a : G), a * 1 = a) →
(npow : ℕ → G → G) →
(∀ (x : G), x ^ 0 = 1) → (∀ (n : ℕ) (x : G), x ^ (n + 1) = x ^ n * x) → (G → G) → G → G → G | null | false |
Subsemigroup.unop_eq_bot._simp_2 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S : Subsemigroup Mᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) | null | false |
_private.Mathlib.Tactic.Determinant.Bird.Meta.0.Mathlib.Tactic.Determinant.reifyBirdDet.match_119 | Mathlib.Tactic.Determinant.Bird.Meta | (fst : Lean.Level) →
(α :
have u := fst;
Q(Type u)) →
(motive : Option Q(CommRing «$α») → Sort u_1) →
(__x : Option Q(CommRing «$α»)) →
((rα : Q(CommRing «$α»)) → motive (some rα)) → ((x : Option Q(CommRing «$α»)) → motive x) → motive __x | null | false |
LightProfinite.«termℕ∪{∞}» | Mathlib.Topology.Category.LightProfinite.Sequence | Lean.ParserDescr | The one point compactification of the natural numbers as a light profinite set. | true |
CategoryTheory.Functor.sheafPushforwardContinuousIso_hom | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F F' : CategoryTheory.Functor C D} (e : F ≅ F') (A : Type u) [inst_2 : CategoryTheory.Category.{t, u} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [i... | null | true |
Std.TreeMap.getKey!_eq_get!_getKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{a : α}, t.getKey! a = (t.getKey? a).get! | null | true |
Lean.Meta.CaseValuesSubgoal.mk.injEq | Lean.Meta.Match.CaseValues | ∀ (mvarId : Lean.MVarId) (newHs : Array Lean.FVarId) (subst : Lean.Meta.FVarSubst) (mvarId_1 : Lean.MVarId)
(newHs_1 : Array Lean.FVarId) (subst_1 : Lean.Meta.FVarSubst),
({ mvarId := mvarId, newHs := newHs, subst := subst } = { mvarId := mvarId_1, newHs := newHs_1, subst := subst_1 }) =
(mvarId = mvarId_1 ∧ ne... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α] {k : α}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
(Std.Internal.List.minKey? l = some k) =
(Std.Internal.List.getKey? k l = some k ∧
∀ (k' : α), Std.Internal.List.containsKey ... | null | false |
MeasureTheory.Egorov.tendstoUniformlyOn_diff_iUnionNotConvergentSeq | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} [inst : PseudoEMetricSpace β]
{μ : MeasureTheory.Measure α} {s : Set α} {ε : ENNReal} {f : ι → α → β} {g : α → β} [inst_1 : SemilatticeSup ι]
[inst_2 : Nonempty ι] [inst_3 : Countable ι] (hε : 0 < ε) (hf : ∀ (n : ι), Measurable fun a => edist (f... | **Alias** of `MeasureTheory.Egorov.tendstoUniformlyOn_sdiff_iUnionNotConvergentSeq`. | true |
PosNum.cmp_swap | Mathlib.Data.Num.Lemmas | ∀ (m n : PosNum), (m.cmp n).swap = n.cmp m | null | true |
AddEquiv.ext_int | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_4} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f 1 = g 1 → f = g | Two additive monoid isomorphisms `f`, `g` from `ℤ` to an additive monoid are equal
if `f 1 = g 1`. | true |
Cardinal.preAleph_of_omega0_sq_le | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u_1}}, Ordinal.omega0 ^ 2 ≤ o → Cardinal.preAleph o = Cardinal.aleph o | null | true |
Lean.Lsp.DocumentColorOptions.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toWorkDoneProgressOptions toWorkDoneProgressOptions_1 : Lean.Lsp.WorkDoneProgressOptions},
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions } =
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions_1 } →
toWorkDoneProgressOptions = toWorkDoneProgressOptions_1 | null | true |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk.noConfusion | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} →
{t : D ⟶ (CategoryTheory.Functor.const I).obj S} →
{f : X ⟶ S} →
{P : Sort u_1} →
{c : CategoryTheory.Limits.Con... | null | false |
Polygon.HasNondegenerateVertices.hasNondegenerateEdges | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} {n : ℕ} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] [inst_4 : NeZero n] [Nontrivial R] {poly : Polygon P n},
Polygon.HasNondegenerateVertices R poly → poly.HasNondegenerateEdges | Polygons with nondegenerate vertices also have nondegenerate edges. | true |
Subarray.foldrM | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → {m : Type v → Type w} → [Monad m] → (α → β → m β) → β → Subarray α → m β | Folds a monadic operation from right to left over the elements in a subarray.
An accumulator of type `β` is constructed by starting with `init` and monadically combining each
element of the subarray with the current accumulator value in turn, moving from the end to the
start. The monad in question may permit early ter... | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.g'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {cc : CategoryTheory.Limits.CokernelCofork S.f}
(hcc : CategoryTheory.Limits.IsColimit cc),
hcc.desc (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯) =
CategoryTheory.CategoryStruct... | null | true |
Filter.EventuallyEq.star | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {R : Type u_2} [inst : Star R] {f g : α → R} {l : Filter α}, f =ᶠ[l] g → star f =ᶠ[l] star g | null | true |
Nat.primeCounting.eq_1 | Mathlib.NumberTheory.PrimeCounting | ∀ (n : ℕ), n.primeCounting = (n + 1).primeCounting' | null | true |
exists_compact_superset | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [WeaklyLocallyCompactSpace X] {K : Set X},
IsCompact K → ∃ K', IsCompact K' ∧ K ⊆ interior K' | In a weakly locally compact space,
every compact set is contained in the interior of a compact set. | true |
MulAction.instDecidablePredMemSubmonoidStabilizerSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : Monoid M] →
[inst_1 : MulAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ MulAction.stabilizerSubmonoid M a | null | true |
Lean.Elab.Term.Do.Var | Lean.Elab.Do.Legacy | Type | null | true |
AffineEquiv.list_sbtw_map_iff | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : PartialOrder R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] {l : List P} (f : P ≃ᵃ[R] P'),
List.Sbtw R ... | null | true |
_private.Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization.0.HomogeneousLocalization.Away.isLocalization_mul._simp_1_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
(Localization.r S) x y = ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1) | null | false |
DirectSum | Mathlib.Algebra.DirectSum.Basic | (ι : Type v) → (β : ι → Type w) → [(i : ι) → AddCommMonoid (β i)] → Type (max w v) | `DirectSum ι β` is the direct sum of a family of additive commutative monoids `β i`.
Note: `open DirectSum` will enable the notation `⨁ i, β i` for `DirectSum ι β`. | true |
CategoryTheory.SplitMono.comp.eq_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z Y X : C} {g : Z ⟶ Y} {f : Y ⟶ X}
(seg : CategoryTheory.SplitMono g) (sef : CategoryTheory.SplitMono f),
seg.comp sef = { retraction := CategoryTheory.CategoryStruct.comp sef.retraction seg.retraction, id := ⋯ } | null | true |
AddSubgroup.Normal.pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
(AddSubgroup.pathComponentZero G).Normal | The path component of zero in an additive topological group is normal. | true |
CompleteLatticeHom.toBoundedLatticeHom._proof_4 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : CompleteLatticeHom α β)
(a b : α),
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | null | false |
_private.Mathlib.Basic.ENNReal.Basic.0.Mathlib.Meta.Positivity.evalENNRealtoReal._sparseCasesOn_1 | Mathlib.Basic.ENNReal.Basic | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
BitVec.ushiftRight_eq' | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y = x >>> y.toNat | null | true |
LinearEquiv.rTensor_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [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] (f : N ≃ₗ[R] P) (m : M) (p : P), (LinearEquiv.rTensor M f).symm (p ⊗ₜ[R] m) = f.sym... | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.dimension_level_one._proof_1_11 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ (k : ℕ), 1 + ↑((k - 12) / 12) = ↑((k - 12) / 12 + 1) | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.toSet_iSup._simp_1_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
(f : CategoryTheory.Arrow C), (f ∈ P.toSet) = P f.hom | null | false |
Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM | Lean.PrettyPrinter.Delaborator.Basic | MonadReaderOf Lean.SubExpr Lean.PrettyPrinter.Delaborator.DelabM | null | true |
Submonoid.disjoint_def' | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] {p₁ p₂ : Submonoid M},
Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 | null | true |
Turing.ToPartrec.stepNormal.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Code),
Turing.ToPartrec.stepNormal x =
match (motive := Turing.ToPartrec.Code → Turing.ToPartrec.Cont → List ℕ → Turing.ToPartrec.Cfg) x with
| Turing.ToPartrec.Code.zero' => fun k v => Turing.ToPartrec.Cfg.ret k (0 :: v)
| Turing.ToPartrec.Code.succ => fun k v => Turing.ToPartrec.... | null | true |
Ordinal.isInitialIso_symm_apply_coe | Mathlib.SetTheory.Cardinal.Aleph | ∀ (x : Cardinal.{u_1}), ↑((RelIso.symm Ordinal.isInitialIso) x) = x.ord | null | true |
ClopenUpperSet.instSetLike._proof_1 | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] (s t : ClopenUpperSet α),
(fun s => s.carrier) s = (fun s => s.carrier) t → s = t | null | false |
UInt16.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt16), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec | null | true |
Lean.instReprExpr.repr._unsafe_rec | Lean.Expr | Lean.Expr → ℕ → Std.Format | null | false |
LinearMap.isPairSelfAdjointSubmodule._proof_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup M₂] [inst_4 : Module R M₂] (B F : M →ₗ[R] M →ₗ[R] M₂), B.IsAdjointPair F 0 0 | null | false |
Matrix.SpecialLinearGroup.instCoeFun | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → CoeFun (Matrix.SpecialLinearGroup n R) fun x => n → n → R | This instance is here for convenience, but is literally the same as the coercion from
`hasCoeToMatrix`. | true |
SaturatedAddSubmonoid.instCompleteLattice._proof_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M] (a b : SaturatedAddSubmonoid M), b ≤ SemilatticeSup.sup a b | null | false |
birkhoffAverage_neg | Mathlib.Dynamics.BirkhoffSum.Average | ∀ {R : Type u_1} {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] {f : α → α} {g : α → M}, birkhoffAverage R f (-g) = -birkhoffAverage R f g | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Real.abs_sin_eq_one_iff._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {x : ℝ} (n : ℤ), Real.pi / 2 + ↑n * (2 * Real.pi) = x → Real.pi / 2 + IntCast.intCast (2 * n) * Real.pi = x | null | false |
WithZero.lift'_zero | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulZeroOneClass β] (f : α →* β),
(WithZero.lift' f) 0 = 0 | null | true |
MeasureTheory.lpNorm_const_smul | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} [inst : NormedAddCommGroup E] {𝕜 : Type u_3}
[inst_1 : NormedField 𝕜] [inst_2 : Module 𝕜 E] [NormSMulClass 𝕜 E] (c : 𝕜) (f : α → E) (μ : MeasureTheory.Measure α),
MeasureTheory.lpNorm (c • f) p μ = ↑‖c‖₊ * MeasureTheory.lpNorm f p μ | null | true |
CategoryTheory.Functor.Monoidal.whiskerRight_δ_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D) {Z : D}
(h :
CategoryTheory... | null | true |
IsLocalization.ringEquivOfRingEquiv_symm | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {T : Submonoid P}
{Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q] {j : R ≃+*... | null | true |
compl_strictAnti | Mathlib.Order.Hom.Set | ∀ (α : Type u_1) [inst : BooleanAlgebra α], StrictAnti compl | null | true |
CategoryTheory.Sieve.BindStruct | Mathlib.CategoryTheory.Sites.Sieves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) → {Z : C} → (Z ⟶ X) → Type (max u₁ v₁) | Structure which contains the data and properties for a morphism `h` satisfying
`Sieve.bind S R h`. | true |
Nat.toArray_ric_eq_toArray_rcc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = (0...=n).toArray | null | true |
Int.add_assoc | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), a + b + c = a + (b + c) | null | true |
IdealFilter.gabrielComposition | Mathlib.RingTheory.IdealFilter.Basic | {A : Type u_1} → [inst : Ring A] → IdealFilter A → IdealFilter A → IdealFilter A | The Gabriel composition of ideal filters `F` and `G`.
See [nLab: Gabriel composition](https://ncatlab.org/nlab/show/Gabriel+composition+of+filters). | true |
CategoryTheory.OplaxFunctor.PseudoCore.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(mapIdIso : (a : B) → F.map (CategoryTheory.CategoryStruct.id a) ≅ CategoryTheory.CategoryStruct.id (F.obj a))
(mapCompIso :
{... | null | true |
YoungDiagram.transpose_transpose | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram), μ.transpose.transpose = μ | null | true |
continuousAt_extChartAt_symm | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] (x : M),
ContinuousAt (↑(extChartAt I... | null | true |
NonUnitalRingHom.fst_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.fst S T).comp (f.prod g) = f | null | true |
WeierstrassCurve.Jacobian.map_add | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} {K : Type v} [inst : Field F] [inst_1 : Field K] {W : WeierstrassCurve.Jacobian F} (f : F →+* K)
{P Q : Fin 3 → F}, W.Nonsingular P → W.Nonsingular Q → (W.map f).add (⇑f ∘ P) (⇑f ∘ Q) = ⇑f ∘ W.add P Q | null | true |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_dvd_eq._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] {z : ℤ} {a : α}, (⌈a⌉ ≤ z) = (a ≤ ↑z) | null | false |
Finset.prod_extend_by_one | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : CommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → M),
(∏ i ∈ s, if i ∈ s then f i else 1) = ∏ i ∈ s, f i | null | true |
RBTree.RBNode.find?.eq_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (cut : α → Ordering) (c : RBTree.RBColor) (l : RBTree.RBNode α) (v : α) (r : RBTree.RBNode α),
RBTree.RBNode.find? cut (RBTree.RBNode.node c l v r) =
match cut v with
| Ordering.lt => RBTree.RBNode.find? cut l
| Ordering.gt => RBTree.RBNode.find? cut r
| Ordering.eq => some v | null | true |
IsCompactOperator.antilipschitz_of_not_hasEigenvalue | Mathlib.Analysis.Normed.Operator.Compact.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜},
IsCompactOperator ⇑T → μ ≠ 0 → ¬Module.End.HasEigenvalue (↑T) μ → ∃ K, AntilipschitzWith K ⇑(T - μ • 1) | If `T : X →L[𝕜] X` is a compact operator on a Banach space `X`, and `μ ≠ 0` is not an
eigenvalue of `T`, then `T - μ • 1` is antilipschitz with positive constant.
That is, `T - μ • 1` is bounded below as an operator.
This is a useful step in the proof of the Fredholm alternative for compact operators. | true |
Std.Do.PredTrans.pushOption.match_1 | Std.Do.PredTrans | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | null | false |
StrongDual.extendRCLikeₗᵢ_symm_apply | Mathlib.Analysis.Normed.Module.RCLike.Extend | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F]
[inst_3 : NormedSpace ℝ F] [inst_4 : IsScalarTower ℝ 𝕜 F] (f : StrongDual 𝕜 F),
StrongDual.extendRCLikeₗᵢ.symm f = RCLike.reCLM ∘SL ContinuousLinearMap.restrictScalars ℝ f | null | true |
CategoryTheory.typesGrothendieckTopology._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (x : Type u_1),
∀ x_1 ∈ {S | ∀ (x_2 : x), S.arrows (TypeCat.ofHom fun x => x_2)},
∀ (x_2 : CategoryTheory.Sieve x),
(∀ ⦃Y : Type u_1⦄ ⦃f : Y ⟶ x⦄,
x_1.arrows f → CategoryTheory.Sieve.pullback f x_2 ∈ {S | ∀ (x : Y), S.arrows (TypeCat.ofHom fun x_3 => x)}) →
∀ (x_3 : x),
(Catego... | null | false |
Isometry.of_dist_eq | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
(∀ (x y : α), dist (f x) (f y) = dist x y) → Isometry f | A map that preserves distances is an isometry | true |
AddSubmonoid.coe_finsetSum | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {ι : Type u_3} {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M) (f : ι → ↥S) (s : Finset ι),
↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i) | null | true |
WeierstrassCurve.Jacobian.toAffine | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → WeierstrassCurve.Jacobian R → WeierstrassCurve.Affine R | The conversion from a Weierstrass curve in Jacobian coordinates to affine coordinates. | true |
Metric.mem_ball_self | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, 0 < ε → x ∈ Metric.ball x ε | null | true |
CategoryTheory.Grothendieck.final_pre | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D CategoryTheory.Cat) (G : CategoryTheory.Functor C D) [hG : G.Final],
(CategoryTheory.Grothendieck.pre F G).Final | null | true |
CategoryTheory.Limits.CategoricalPullback.toCatCommSqOver_obj_snd_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X]
(J : C... | null | true |
SymbolicDynamics.FullShift.fullShift.eq_1 | Mathlib.Dynamics.SymbolicDynamics.Basic | ∀ (A : Type u_1) (G : Type u_2) [inst : TopologicalSpace A] [inst_1 : AddMonoid G],
SymbolicDynamics.FullShift.fullShift A G = { carrier := Set.univ, isClosed := ⋯, mapsTo := ⋯ } | null | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceFin._proof_1 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (l : ℕ) (u : ℤ × ℤ) {i j j' : ℤ × Fin l},
i.1 + u.1 = j.1 ∧ ↑↑i.2 + u.2 = ↑↑j.2 → i.1 + u.1 = j'.1 ∧ ↑↑i.2 + u.2 = ↑↑j'.2 → j.1 = j'.1 | null | false |
_private.Init.Data.Option.Basic.0.Option.instLawfulBEq.match_1 | Init.Data.Option.Basic | ∀ (α : Type u_1) [inst : BEq α] (motive : (x y : Option α) → {h : (x == y) = true} → Prop) (x y : Option α)
{h : (x == y) = true},
(∀ (x y : α) (h : (some x == some y) = true), motive (some x) (some y)) →
(∀ (h : (none == none) = true), motive none none) → motive x y | null | false |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.nonempty_type_iff_nonempty.match_1_3 | Mathlib.SetTheory.ZFC.PSet | ∀ {x : PSet.{u_1}} (motive : x.Nonempty → Prop) (x_1 : x.Nonempty),
(∀ (w : PSet.{u_1}) (j : x.Type) (h : w.Equiv (x.Func j)), motive ⋯) → motive x_1 | null | false |
_private.Lean.Server.Completion.CompletionUtils.0.Lean.Server.Completion.minimizeGlobalIdentifierInContext.shortenInOpenNamespace | Lean.Server.Completion.CompletionUtils | Lean.Name → Lean.Name → Lean.Name | null | true |
ContDiffAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℝ n f x → f x ≠ 0 → ContDiffAt ℝ n (fun x => Real.log (f x)) x | null | true |
Representation.equivOfIso._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{u_1, u_2, u_3} k G} (i : A ≅ B)
(m : k) (x : ↑A), (Rep.Hom.hom i.hom).toFun (m • x) = (RingHom.id k) m • (Rep.Hom.hom i.hom).toFun x | null | false |
MeasureTheory.Lp.constₗ_apply | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3) [inst_2 : NormedRing 𝕜]
[inst_3 : Module 𝕜 E] [inst_4 : IsBoundedSMul 𝕜 E] (a : E),
(MeasureTheory.Lp.constₗ p μ 𝕜) a = (... | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.psum_eq_mul_esymm_sub_sum._proof_1_5 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (k : ℕ), 0 < k → (0, k).1 + (0, k).2 = k ∧ (0, k).1 < k ∧ ¬0 < (0, k).1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.