name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Affine.Simplex.abs_inner_vsub_altitudeFoot_lt_mul | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) [inst_4 : n.AtLeastTwo] {i j : Fin (n + 1)},
i ≠ j → |inner ℝ (s.points i -ᵥ s.altitudeFoot i) (s.points j -ᵥ s.altitudeFoot j)| <... | The inner product of two distinct altitudes has absolute value strictly less than the product of
their lengths.
Equivalently, neither vector is a multiple of the other; the angle between them is not 0 or π. | true |
Filter.eventually_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α},
(∀ᶠ (x : α) in f ⊓ Filter.principal s, p x) ↔ ∀ᶠ (x : α) in f, x ∈ s → p x | null | true |
Ideal.Quotient.factor | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u} →
[inst : Ring R] → {S T : Ideal R} → [inst_1 : S.IsTwoSided] → [inst_2 : T.IsTwoSided] → S ≤ T → R ⧸ S →+* R ⧸ T | The ring homomorphism from the quotient by a smaller ideal to the quotient by a larger ideal.
This is the `Ideal.Quotient` version of `Quot.Factor`
When the two ideals are of the form `I^m` and `I^n` and `n ≤ m`,
please refer to the dedicated version `Ideal.Quotient.factorPow`. | true |
Computation.liftRel_think_right | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β),
Computation.LiftRel R ca cb.think ↔ Computation.LiftRel R ca cb | null | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.Valid.prevn.match_1_1 | Batteries.Data.String.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
CategoryTheory.Limits.kernelIsKernel._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) [inst_2 : CategoryTheory.Limits.HasKernel f],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.parallelPa... | null | false |
ExceptT.ext_iff | Init.Control.Lawful.Instances | ∀ {ε : Type u_1} {m : Type u_1 → Type u_2} {α : Type u_1} {x y : ExceptT ε m α}, x = y ↔ x.run = y.run | null | true |
instSymmAnd_mathlib | Mathlib.Basic.Logic.Basic | Std.Symm And | null | true |
Lean.Meta.Grind.AC.ACM.Context.opId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Meta.Grind.AC.ACM.Context → ℕ | null | true |
HomotopyCategory.Plus.quasiIso_eq_subcategoryAcyclic_trW | Mathlib.Algebra.Homology.DerivedCategory.Plus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C],
HomotopyCategory.Plus.quasiIso C = (HomotopyCategory.Plus.subcategoryAcyclic C).trW | null | true |
_private.Mathlib.Order.Lex.0.instNontrivialColex._proof_1 | Mathlib.Order.Lex | ∀ (α : Type u_1) [Nontrivial α], Nontrivial (Colex α) | null | false |
Std.IsLinearOrder.toIsLinearPreorder | Init.Data.Order.Classes | ∀ {α : Type u} [inst : LE α] [self : Std.IsLinearOrder α], Std.IsLinearPreorder α | null | true |
Polynomial.SplittingField.instField._proof_9 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), a ≠ 0 → a * a⁻¹ = 1 | null | false |
TensorProduct.rightComm._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_3) (N : Type u_2) (P : Type u_4) [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], SMulCommClass R R (TensorProduct R (TensorProduct R M P) N) | null | false |
AddGrpCat.FilteredColimits.G.mk | Mathlib.Algebra.Category.Grp.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[inst_1 : CategoryTheory.IsFiltered J] →
(F : CategoryTheory.Functor J AddGrpCat) → (j : J) × ↑(F.obj j) → ↑(AddGrpCat.FilteredColimits.G F) | The canonical projection into the colimit, as a quotient type. | true |
DivisionMonoid.noConfusion | Mathlib.Algebra.Group.DivInvMonoid | {P : Sort u} →
{G : Type u_2} →
{t : DivisionMonoid G} →
{G' : Type u_2} → {t' : DivisionMonoid G'} → G = G' → t ≍ t' → DivisionMonoid.noConfusionType P t t' | null | false |
Lean.Lsp.RpcReleaseParams.mk.sizeOf_spec | Lean.Data.Lsp.Extra | ∀ (uri : Lean.Lsp.DocumentUri) (sessionId : UInt64) (refs : Array Lean.Json),
sizeOf { uri := uri, sessionId := sessionId, refs := refs } = 1 + sizeOf uri + sizeOf sessionId + sizeOf refs | null | true |
Std.Sat.AIG.mkAtomCached_eval_eq_mkAtom_eval | Std.Sat.AIG.CachedLemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {assign : α → Bool} {var : α} {aig : Std.Sat.AIG α},
⟦assign, aig.mkAtomCached var⟧ = ⟦assign, aig.mkAtom var⟧ | The central equality theorem between `mkAtomCached` and `mkAtom`.
| true |
Std.DTreeMap.Internal.Impl.entryAtIdx?.match_3 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → ℕ → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : ℕ) →
((x : ℕ) → motive Std.DTreeMap.Internal.Impl.leaf x) →
((size : ℕ) →
(k : α) →
(v : β k) →
... | null | false |
CategoryTheory.OrthogonalReflection.instSmallLMultispanShape | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C)
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂]
[inst_3 : CategoryTheory.Limi... | null | true |
Lean.Elab.DerivingClassView.mk.sizeOf_spec | Lean.Elab.Deriving.Basic | ∀ (ref : Lean.Syntax) (hasExpose : Bool) (cls : Lean.Term),
sizeOf { ref := ref, hasExpose := hasExpose, cls := cls } = 1 + sizeOf ref + sizeOf hasExpose + sizeOf cls | null | true |
RestrictedProduct.mapAlongRingHom._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι₁ : Type u_4} {ι₂ : Type u_3} (R₁ : ι₁ → Type u_1) (R₂ : ι₂ → Type u_2) (f : ι₂ → ι₁)
[inst : (i : ι₁) → Ring (R₁ i)] [inst_1 : (i : ι₂) → Ring (R₂ i)] (j : ι₂),
AddMonoidHomClass (R₁ (f j) →+* R₂ j) (R₁ (f j)) (R₂ j) | null | false |
Std.ExtDTreeMap.inter | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp | Computes the union of the given tree maps. If a key appears in both maps, the entry contained in
the second argument will appear in the result.
This function always merges the smaller map into the larger map.
| true |
CategoryTheory.Limits.map_lift_equalizerComparison._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_4} {X Y : C} [inst : CategoryTheory.Category.{u_3, u_4} C] (f g : X ⟶ Y) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D) {Z : C} {h : Z ⟶ X},
CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g →
CategoryTheory.CategoryStr... | null | false |
List.prefix_concat_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α} {a : α}, l₁ <+: l₂ ++ [a] ↔ l₁ = l₂ ++ [a] ∨ l₁ <+: l₂ | null | true |
AlgebraicGeometry.Scheme.Pullback.gluing.match_1 | Mathlib.AlgebraicGeometry.Pullbacks | {X : AlgebraicGeometry.Scheme} →
(𝒰 : X.OpenCover) → (motive : 𝒰.I₀ × 𝒰.I₀ → Sort u_2) → (x : 𝒰.I₀ × 𝒰.I₀) → ((i j : 𝒰.I₀) → motive (i, j)) → motive x | null | false |
CategoryTheory.Pi.eval | Mathlib.CategoryTheory.Pi.Basic | {I : Type w₀} →
(C : I → Type u₁) →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] → (i : I) → CategoryTheory.Functor ((i : I) → C i) (C i) | The evaluation functor at `i : I`, sending an `I`-indexed family of objects to the object over `i`.
| true |
IO.FS.SystemTime.sec | Init.System.IO | IO.FS.SystemTime → ℤ | The number of whole seconds. | true |
CategoryTheory.SemiadditiveOfBinaryBiproducts.addCommMonoidHomOfHasBinaryBiproducts._proof_1 | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (X Y : C) (x : X ⟶ Y), 0 • x = 0 | null | false |
Int.reduceAbs | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | Lean.Meta.Simp.DSimproc | null | true |
Continuous.matrix_submatrix | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {l : Type u_3} {m : Type u_4} {n : Type u_5} {p : Type u_6} {R : Type u_8} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace R] {A : X → Matrix l n R},
Continuous A → ∀ (e₁ : m → l) (e₂ : p → n), Continuous fun x => (A x).submatrix e₁ e₂ | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let_tmp._regBuiltin.Lean.Parser.Term.let_tmp.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
Std.DTreeMap.Raw.minKey!_insert_le_minKey! | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF → t.isEmpty = false → ∀ {k : α} {v : β k}, (cmp (t.insert k v).minKey! t.minKey!).isLE = true | null | true |
Irrational.mul_ratCast | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ {q : ℚ}, q ≠ 0 → Irrational (x * ↑q) | null | true |
Std.Time.DateTime.withSeconds | Std.Time.DateTime | Std.Time.DateTime → Std.Time.Second.Ordinal true → Std.Time.DateTime | Creates a new `DateTime` by adjusting the `second` component.
| true |
ProbabilityTheory.tendsto_stieltjesOfMeasurableRat_atBot | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : Measurable f) (a : α),
Filter.Tendsto (↑(ProbabilityTheory.stieltjesOfMeasurableRat f hf a)) Filter.atBot (nhds 0) | null | true |
Finset.zero_mem_sub_iff._simp_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddGroup α] {s t : Finset α}, (0 ∈ s - t) = ¬Disjoint s t | null | false |
AddMonoid.instIsAddFGSubtypeMemAddSubmonoidMrangeAddMonoidHom | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} {M' : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass M'] (f : M →+ M') [IsAddFG M],
IsAddFG ↥(AddMonoidHom.mrange f) | null | true |
_private.Lean.Data.Trie.0.Lean.Data.Trie.find?.loop | Lean.Data.Trie | {α : Type} → String → ℕ → Lean.Data.Trie α → Option α | null | true |
AlgebraicGeometry.Etale.instSmooth | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Etale f], AlgebraicGeometry.Smooth f | null | true |
Int.ModEq.listSum_map | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {l : List α} {f g : α → ℤ},
(∀ x ∈ l, f x ≡ g x [ZMOD n]) → (List.map f l).sum ≡ (List.map g l).sum [ZMOD n] | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.isNilpotent_e._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {α : Sort u_1} (P Q : Prop) [inst : Decidable P] (a b : α) [inst_1 : Decidable Q],
(if P then if Q then a else b else b) = if P ∧ Q then a else b | null | false |
HurwitzZeta.hasSum_nat_cosKernel₀ | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : ℝ) {t : ℝ},
0 < t →
HasSum (fun n => 2 * Real.cos (2 * Real.pi * a * (↑n + 1)) * Real.exp (-Real.pi * (↑n + 1) ^ 2 * t))
(HurwitzZeta.cosKernel (↑a) t - 1) | null | true |
SeparationQuotient.outCLM_uniformContinuous | Mathlib.Topology.Algebra.SeparationQuotient.Section | ∀ (K : Type u_1) (E : Type u_2) [inst : DivisionRing K] [inst_1 : AddCommGroup E] [inst_2 : Module K E]
[inst_3 : UniformSpace E] [inst_4 : IsUniformAddGroup E] [inst_5 : ContinuousConstSMul K E],
UniformContinuous ⇑(SeparationQuotient.outCLM K E) | null | true |
CategoryTheory.ObjectProperty.isColocal | Mathlib.CategoryTheory.Localization.Bousfield | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.ObjectProperty C → CategoryTheory.MorphismProperty C | Given `P : ObjectProperty C`, this is the class of morphisms `g : Y ⟶ Z`
such that for all `X : C` such that `P X`, the postcomposition with `g` induces
a bijection `(X ⟶ Y) ≃ (X ⟶ Z)`. (One of the applications of this notion
is the right Bousfield localization of model categories.) | true |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.internalIter_eq.match_1.eq_2 | Init.Data.Slice.List.Lemmas | ∀ (motive : Option ℕ → Sort u_1) (h_1 : (stop : ℕ) → motive (some stop)) (h_2 : Unit → motive none),
(match none with
| some stop => h_1 stop
| none => h_2 ()) =
h_2 () | null | true |
Ideal.exists_prime_and_absNorm_eq_pow | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Module.Free ℤ S] [Module.Finite ℤ S]
(P : Ideal S) [P.IsMaximal], ∃ p n, 0 < n ∧ ↑p ∈ P ∧ Nat.Prime p ∧ Ideal.absNorm P = p ^ n | The norm of a maximal ideal is a prime power.
The prime is `(P.under ℤ).absNorm` and the exponent is `(P.under ℤ).inertialDeg P`.
See `Ideal.absNorm_pow_inertiaDeg`. | true |
_private.Init.Data.Int.LemmasAux.0.Int.blt'_eq_true._proof_1_4 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬(a_1 < a ↔ Int.negSucc a < Int.negSucc a_1) → False | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.sum_erase._proof_1_1 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_2} {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) {f : ι → M} {a : ι},
f a = 0 → ∀ x ∈ s, x ∉ s \ {a} → f x = 0 | null | false |
CategoryTheory.SubmonoidFunctor.lift_ι_assoc | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M M' : CategoryTheory.Functor C MonCat} (p : M ⟶ M')
(S' : CategoryTheory.SubmonoidFunctor M') (hp : CategoryTheory.SubmonoidFunctor.image p ⊤ ≤ S')
{Z : CategoryTheory.Functor C MonCat} (h : M' ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Subm... | null | true |
RingEquiv.noConfusionType | Mathlib.Algebra.Ring.Equiv | Sort u →
{R : Type u_7} →
{S : Type u_8} →
[inst : Mul R] →
[inst_1 : Mul S] →
[inst_2 : Add R] →
[inst_3 : Add S] →
R ≃+* S →
{R' : Type u_7} →
{S' : Type u_8} →
[inst' : Mul R'] → [inst'_1 : Mul S'] → [inst'_... | null | false |
TopCat.adj₂._proof_3 | Mathlib.Topology.Category.TopCat.Adjunctions | ∀ (Y : Type u_1),
CategoryTheory.CategoryStruct.comp
({ app := fun X => TopCat.ofHom { toFun := id, continuous_toFun := ⋯ }, naturality := TopCat.adj₂._proof_1 }.app
(TopCat.trivial.obj Y))
(TopCat.trivial.map
((CategoryTheory.CategoryStruct.id (TopCat.trivial.comp (CategoryTheory.forget T... | null | false |
Fin.xor | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n | Bitwise xor (“exclusive or”).
| true |
TestFunction.toBoundedContinuousFunctionCLM._proof_7 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], IsBoundedSMul 𝕜 F | null | false |
Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdx!_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ {i : ℕ} [inst : Inhabited (α × β)],
Std.DTreeMap.Internal.Impl.Const.entryAtIdx! t₁ i = Std.DTreeMap.Internal.Impl.Const.entryAtIdx! t₂ i | null | true |
Pi.opensMeasurableSpace_of_subsingleton | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {ι : Type u_6} {X : ι → Type u_7} [Subsingleton ι] [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), OpensMeasurableSpace (X i)],
OpensMeasurableSpace ((i : ι) → X i) | This is not covered by `Pi.opensMeasurableSpace` as it does not require second countability. | true |
Matrix.isParabolic_conj_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : CommRing R] {m : Matrix (Fin 2) (Fin 2) R} (g : GL (Fin 2) R),
(↑g * m * (↑g)⁻¹).IsParabolic = m.IsParabolic | null | false |
Zsqrtd.Nonsquare.mk._flat_ctor | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {x : ℕ}, (∀ (n : ℕ), x ≠ n * n) → Zsqrtd.Nonsquare x | null | false |
Lean.Lsp.DocumentSymbolAux.detail?._default | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Option String | null | false |
Multiset.powersetCardAux_eq_map_coe | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {n : ℕ} {l : List α}, Multiset.powersetCardAux n l = List.map Multiset.ofList (List.sublistsLen n l) | null | true |
CategoryTheory.shiftFunctorAdd_zero_add_hom_app | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (a : A) (X : C),
(CategoryTheory.shiftFunctorAdd C 0 a).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
((CategoryTheory.shiftFunctor C a).map ((C... | null | true |
Polynomial.eraseLead_C | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (r : R), (Polynomial.C r).eraseLead = 0 | null | true |
MeasureTheory.Martingale.congr | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] {f g : ι → Ω → E}
{ℱ : MeasureTheory.Filtration ι m0} [CompleteSpace E],
MeasureTheory.Martingale f ℱ μ →
MeasureTheory.StronglyA... | null | true |
Set.ncard_eq_ncard_iff_ncard_sdiff_eq_ncard_sdiff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
autoParam s.Finite Set.ncard_eq_ncard_iff_ncard_sdiff_eq_ncard_sdiff._auto_1 →
autoParam t.Finite Set.ncard_eq_ncard_iff_ncard_sdiff_eq_ncard_sdiff._auto_3 →
(s.ncard = t.ncard ↔ (s \ t).ncard = (t \ s).ncard) | null | true |
ContinuousLinearMap.reApplyInnerSelf_apply | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (x : E), T.reApplyInnerSelf x = RCLike.re (inner 𝕜 (T x) x) | null | true |
CategoryTheory.Limits.biproduct.ι_matrix | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_2} [inst : Finite J] {K : Type} [inst_1 : Finite K] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {f : J → C} {g : K → C} (m : (j : J) → (k : K) → f j ⟶ g k)
(j : J),
CategoryTheor... | null | true |
WeierstrassCurve.Projective.Point.instAddCommGroup | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {F : Type u} → [inst : Field F] → {W : WeierstrassCurve.Projective F} → AddCommGroup W.Point | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.normalizerCondition_iff_only_full_group_self_normalizing._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
_private.Mathlib.RingTheory.Localization.Basic.0.IsLocalization.commutes._simp_1_2 | Mathlib.RingTheory.Localization.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | null | false |
CategoryTheory.Mat.comp_def | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (R : Type u) [inst : Semiring R] {M N K : CategoryTheory.Mat R} (f : M ⟶ N) (g : N ⟶ K),
CategoryTheory.CategoryStruct.comp f g = fun i k => ∑ j, f i j * g j k | null | true |
RingEquiv.toSemiRingCatIso_inv | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u} [inst : Semiring R] [inst_1 : Semiring S] (e : R ≃+* S),
e.toSemiRingCatIso.inv = SemiRingCat.ofHom ↑e.symm | null | true |
CategoryTheory.MonoidalCategory.ofBifunctor.Triangle.firstMap_app_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(tensor : CategoryTheory.Functor C (CategoryTheory.Functor C C)) (unit : C)
(associator : CategoryTheory.bifunctorComp₁₂ tensor tensor ≅ CategoryTheory.bifunctorComp₂₃ tensor tensor)
(leftUnitor : tensor.obj unit ≅ CategoryTheory.Functor.id C) (X X_1 ... | null | true |
Lean.Compiler.LCNF.Simp.JpCasesAlt.mk._flat_ctor | Lean.Compiler.LCNF.Simp.JpCases | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure → Bool → Bool → Lean.Compiler.LCNF.Simp.JpCasesAlt | null | false |
FreeAlgebra.Rel.below.add_compat_right | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R]
{motive : (a a_1 : FreeAlgebra.Pre R X) → FreeAlgebra.Rel R X a a_1 → Prop} {a b c : FreeAlgebra.Pre R X}
(a_1 : FreeAlgebra.Rel R X a b), FreeAlgebra.Rel.below a_1 → motive a b a_1 → FreeAlgebra.Rel.below ⋯ | null | true |
Mathlib.Tactic.Linarith.Comp.mk.noConfusion | Mathlib.Tactic.Linarith.Datatypes | {P : Sort u} →
{str : Mathlib.Ineq} →
{coeffs : Mathlib.Tactic.Linarith.Linexp} →
{str' : Mathlib.Ineq} →
{coeffs' : Mathlib.Tactic.Linarith.Linexp} →
{ str := str, coeffs := coeffs } = { str := str', coeffs := coeffs' } →
(str = str' → coeffs = coeffs' → P) → P | null | false |
Asymptotics.IsBigO.inv_rev | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {𝕜 : Type u_5} {𝕜' : Type u_6} [inst : NormedDivisionRing 𝕜] [inst_1 : NormedDivisionRing 𝕜']
{l : Filter α} {f : α → 𝕜} {g : α → 𝕜'},
f =O[l] g → (∀ᶠ (x : α) in l, f x = 0 → g x = 0) → (fun x => (g x)⁻¹) =O[l] fun x => (f x)⁻¹ | null | true |
Shelf.mk.noConfusion | Mathlib.Algebra.Quandle | {α : Type u} →
{P : Sort u_1} →
{act : α → α → α} →
{self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z)} →
{act' : α → α → α} →
{self_distrib' : ∀ {x y z : α}, act' x (act' y z) = act' (act' x y) (act' x z)} →
{ act := act, self_distrib := self_distrib } = ... | null | false |
Algebra.FinitePresentation.of_finitePresentation | Mathlib.RingTheory.Finiteness.ModuleFinitePresentation | ∀ (R : Type u) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Module.FinitePresentation R S], Algebra.FinitePresentation R S | If `S` is finitely presented as a module over `R`, it is finitely
presented as an algebra over `R`. | true |
ContinuousLinearEquiv.arrowCongrEquiv_apply | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_4}
... | null | true |
_private.Batteries.Data.String.Legacy.0.String.Legacy.foldlAux._unary._proof_1 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos i : String.Pos.Raw),
i < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s i).byteIdx < stopPos.byteIdx - i.byteIdx | null | false |
LieAlgebra.IsSimple.recOn | Mathlib.Algebra.Lie.Semisimple.Defs | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{motive : LieAlgebra.IsSimple R L → Sort u} →
(t : LieAlgebra.IsSimple R L) →
((eq_bot_or_eq_top : ∀ (I : LieIdeal R L), I = ⊥ ∨ I = ⊤) → (non_abelian : ¬IsL... | null | false |
Topology.RelCWComplex.iUnion_openCell_eq_skeletonLT | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D]
(n : ℕ∞), D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.openCell m j = ↑(Topology.RelCWComplex.skeletonLT C n) | A version of the definition of `skeletonLT` with open cells. | true |
LinearMap.compl₂.congr_simp | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_14} {R₂ : Type u_15} {R₃ : Type u_16} {R₄ : Type u_17} {R₅ : Type u_18} {M : Type u_19} {N : Type u_20}
{P : Type u_21} {Q : Type u_22} [inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
[inst_3 : Semiring R₄] [inst_4 : Semiring R₅] {σ₂₃ : R₂ →+* R₃} {σ₄₂ : R₄ →+* R₂} {σ₄₃ : R₄ →+* R₃}
... | null | true |
instIsAddHaarMeasureUnitAddCircleVolume | Mathlib.Analysis.Fourier.AddCircleMulti | MeasureTheory.volume.IsAddHaarMeasure | The measure on `ℝ / ℤ` is a Haar measure. | true |
Lean.Lsp.instFromJsonCodeActionLiteralSupportValueSet | Lean.Data.Lsp.CodeActions | Lean.FromJson Lean.Lsp.CodeActionLiteralSupportValueSet | null | true |
Rep.leftRegular | Mathlib.RepresentationTheory.Rep.Basic | (k : Type u) → (G : Type v) → [inst : Ring k] → [inst_1 : Monoid G] → Rep.{max u v, u, v} k G | The `k`-linear `G`-representation on `k[G]`, induced by left multiplication. | true |
Set.empty_sub | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s : Set α}, ∅ - s = ∅ | null | true |
ImportGraph.Lake.instHashableDate_importGraph | ImportGraph.Util.Modules | Hashable Lake.Date | null | true |
Matrix.entryAddMonoidHom_eq_comp | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_8} [inst : AddZeroClass α] {i : m} {j : n},
Matrix.entryAddMonoidHom α i j =
((Pi.evalAddMonoidHom (fun x => α) j).comp (Pi.evalAddMonoidHom (fun i => n → α) i)).comp ↑Matrix.ofAddEquiv.symm | null | true |
_private.Lean.Compiler.LCNF.FVarUtil.0.Lean.Compiler.LCNF.anyFVarM._sparseCasesOn_1 | Lean.Compiler.LCNF.FVarUtil | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Std.HashSet.get!_inter | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, (m₁ ∩ m₂).get! k = if k ∈ m₂ then m₁.get! k else default | null | true |
DMatrix.instAdd | Mathlib.Data.Matrix.DMatrix | {m : Type u_1} → {n : Type u_2} → {α : m → n → Type v} → [(i : m) → (j : n) → Add (α i j)] → Add (DMatrix m n α) | null | true |
Mathlib.Tactic.Ring.Common.mkCache | Mathlib.Tactic.Ring.Common | {u : Lean.Level} → {α : Q(Type u)} → (sα : Q(CommSemiring «$α»)) → Lean.MetaM (Mathlib.Tactic.Ring.Common.Cache sα) | Create a new cache for `α` by doing the necessary instance searches. | true |
AlgebraicGeometry.tilde.isUnit_algebraMap_end_basicOpen | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {M : (AlgebraicGeometry.Spec R).Modules} {U : (AlgebraicGeometry.Spec R).Opens} (f : ↑R),
U ≤ PrimeSpectrum.basicOpen f → IsUnit ((algebraMap (↑R) (Module.End ↑R ↑(M.presheaf.obj (Opposite.op U)))) f) | **Alias** of `AlgebraicGeometry.Scheme.Modules.isUnit_algebraMap_end_of_le_basicOpen`. | true |
AddSubgroup.saturated_iff_zsmul | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
H.NSMulSaturated ↔ ∀ (n : ℤ) (g : G), n • g ∈ H → n = 0 ∨ g ∈ H | null | true |
_private.Lean.Util.Path.0.Lean.initSearchPathInternal | Lean.Util.Path | IO Unit | null | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln.match_1.eq_9 | Mathlib.Computability.PartrecCode | ∀ (motive : ℕ → Nat.Partrec.Code → Sort u_1) (k : ℕ) (cf : Nat.Partrec.Code) (h_1 : (x : Nat.Partrec.Code) → motive 0 x)
(h_2 : (k : ℕ) → motive k.succ Nat.Partrec.Code.zero) (h_3 : (k : ℕ) → motive k.succ Nat.Partrec.Code.succ)
(h_4 : (k : ℕ) → motive k.succ Nat.Partrec.Code.left) (h_5 : (k : ℕ) → motive k.succ Na... | null | true |
Std.HashMap.Raw.getElem?_inter_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∩ m₂)[k]? = none | null | true |
Convex.toWeakSpace_closure | Mathlib.Analysis.LocallyConvex.WeakSpace | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Module ℝ E]
[IsScalarTower ℝ 𝕜 E] [inst_5 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[LocallyConvexSpace ℝ E] {s : Set E}, Convex ℝ s → ⇑(toWeakSpace 𝕜 E) '' closure s = closur... | If `E` is a locally convex space over `𝕜` (with `RCLike 𝕜`), and `s : Set E` is `ℝ`-convex, then
the closure of `s` and the weak closure of `s` coincide. More precisely, the topological closure
commutes with `toWeakSpace 𝕜 E`.
This holds more generally for any linear equivalence `e : E ≃ₗ[𝕜] F` between locally con... | true |
_private.Mathlib.Analysis.Complex.BorelCaratheodory.0.Complex.norm_two_mul_div_one_add_le | Mathlib.Analysis.Complex.BorelCaratheodory | ∀ {M : ℝ} {w : ℂ}, 0 < M → ‖w‖ < 1 → ‖2 * ↑M * w / (1 + w)‖ ≤ 2 * M * ‖w‖ / (1 - ‖w‖) | Norm inequality for the inverse Schwarz transform: if `‖w‖ < 1`, then
`‖2M * w / (1 + w)‖ ≤ 2M * ‖w‖ / (1 - ‖w‖)`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.