name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Submodule.starProjection_singleton | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{v : E} (w : E), (𝕜 ∙ v).starProjection w = (inner 𝕜 v w / ↑(‖v‖ ^ 2)) • v | Formula for orthogonal projection onto a single vector. | true |
Lean.Lsp.InlayHintOptions.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressOptions : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider? : Option Bool} →
{toWorkDoneProgressOptions' : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider?' : Option Bool} →
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions, resolveProvider... | null | false |
Finset.measurable_range_sup' | Mathlib.MeasureTheory.Order.Lattice | ∀ {α : Type u_2} {m : MeasurableSpace α} {δ : Type u_3} [inst : MeasurableSpace δ] [inst_1 : SemilatticeSup α]
[MeasurableSup₂ α] {f : ℕ → δ → α} {n : ℕ}, (∀ k ≤ n, Measurable (f k)) → Measurable ((Finset.range (n + 1)).sup' ⋯ f) | null | true |
AddSubgroup.coe_add_of_left_le_normalizer_right | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (H N : AddSubgroup G), H ≤ AddSubgroup.normalizer ↑N → ↑(H ⊔ N) = ↑H + ↑N | The carrier of `H ⊔ N` is just `↑H + ↑N` (pointwise set addition)
when `H` is a subgroup of the normalizer of `N` in `G`. | true |
CategoryTheory.ShiftedHom.homEquiv | Mathlib.CategoryTheory.Shift.ShiftedHom | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{M : Type u_4} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
{X Y : C} → (m₀ : M) → m₀ = 0 → (X ⟶ Y) ≃ CategoryTheory.ShiftedHom X Y m₀ | The bijection `(X ⟶ Y) ≃ ShiftedHom X Y m₀` when `m₀ = 0`. | true |
ContinuousMapZero.instStarRing._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_2} {R : Type u_1} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : StarRing R] [inst_5 : ContinuousStar R] (x : ContinuousMapZero X R),
(star ↑{ toContinuousMap := star ↑x, map_zero' := ⋯ }) 0 = 0 | null | false |
_private.Mathlib.Order.Filter.Cofinite.0.Filter.coprodᵢ_cofinite._simp_1_1 | Mathlib.Order.Filter.Cofinite | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)},
(sᶜ ∈ Filter.coprodᵢ f) = ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i | null | false |
Mathlib.Tactic.BicategoryLike.AtomIso.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.AtomIso → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.AtomIso) →
((e : Lean.Expr) → (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁) → motive { e := e, src := src, tgt := tgt }) →
motive t | null | false |
MeasureTheory.Integrable.integral_norm_condDistrib_map | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | null | true |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.objSuccIso | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : Type u} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
{j : J} →
¬IsMax j →
(F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
(X : C) → CategoryTheory.SmallObject.SuccStruct... | The isomorphism `obj F X ⟨Order.succ j, _⟩ ≅ X`. | true |
SchwartzMap.smulLeftCLM.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} (F : Type u_6) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] (g : E → 𝕜),
SchwartzMap.smulLeftCLM F g =
if hg ... | null | true |
DerivedCategory.instIsTriangulated | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.IsTriangulated (DerivedCategory C) | null | true |
EuclideanGeometry.concyclic_singleton | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (p : P), EuclideanGeometry.Concyclic {p} | A single point is concyclic. | true |
_private.Mathlib.Logic.Denumerable.0.Nat.Subtype.le_succ_of_forall_lt_le._proof_1_2 | Mathlib.Logic.Denumerable | ∀ {s : Set ℕ} [inst : DecidablePred fun x => x ∈ s] {y : ↑s} (hx : ∃ m, ↑y + m + 1 ∈ s), ↑y < ↑y + Nat.find hx + 1 | null | false |
Perfection.instCommRing | Mathlib.RingTheory.Perfection | (R : Type u_1) → [inst : CommRing R] → (p : ℕ) → [hp : Fact (Nat.Prime p)] → [CharP R p] → CommRing (Perfection R p) | null | true |
Nat.Partrec.Code.primrec_pappAck | Mathlib.Computability.Ackermann | Primrec Nat.Partrec.Code.pappAck | null | true |
_private.Mathlib.Data.ZMod.Basic.0.Nat.range_mul_add._simp_1_6 | Mathlib.Data.ZMod.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.y | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution✝ hζ → NumberField.RingOfIntegers K | Given `S : Solution`, we let `S.y` be any element such that `S.a + η * S.b = λ * S.y` | true |
ProbabilityTheory.geometricPMFRealSum | Mathlib.Probability.Distributions.Geometric | ∀ {p : ℝ}, 0 < p → p ≤ 1 → HasSum (fun n => ProbabilityTheory.geometricPMFReal p n) 1 | null | true |
sInf_add | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sInf (s + t) = sInf s + sInf t | null | true |
SSet.RelativeMorphism.botEquiv | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | {X Y : SSet} → SSet.RelativeMorphism ⊥ ⊥ (SSet.Subcomplex.isInitialBot.to ⊥.toSSet) ≃ (X ⟶ Y) | Morphisms relatively to the `⊥` subcomplexes of `X` and `Y`
identify to morphisms `X ⟶ Y`. | true |
ContMDiff.piecewise_Iic | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {n : WithTop ℕ∞} {E : Type u_11} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_12}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type u_13} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] {f g : ℝ → M} {s : ℝ},
ContMDiff (modelWithCornersSelf ℝ ℝ) I n f →
C... | Given two `C^n` functions `f` and `g` from `ℝ` to a real manifold which coincide locally
around a point `s`, then the piecewise function using `f` before `t` and `g` after is `C^n`. | true |
CategoryTheory.Adjunction.functorialityCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] (K : CategoryTheory.Functor J C)
(c : Categor... | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt.match_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ (motive : (n : ℕ) → {lo hi : BitVec n} → n > 0 → Prop) (n : ℕ) {lo hi : BitVec n} (h : n > 0),
(∀ (lo hi : BitVec 0) (h : 0 > 0), motive 0 h) →
(∀ (n : ℕ) (lo hi : BitVec (n + 1)) (h : n + 1 > 0), motive n.succ h) → motive n h | null | false |
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor.0.CategoryTheory.MonoidalCategory.DayFunctor.hom_ext._proof_1_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {V : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {F G : CategoryTheory.MonoidalCategory.DayFunctor C V}
(natTrans natTrans_1 : F.functor ⟶ G.functo... | null | false |
Submodule.map_comap_subtype | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p p' : Submodule R M), Submodule.map p.subtype (Submodule.comap p.subtype p') = p ⊓ p' | null | true |
LinearPMap.adjointDomainMkCLMExtend._proof_6 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ContinuousConstSMul 𝕜 𝕜 | null | false |
CategoryTheory.FreeBicategory.Hom₂ | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} → [inst : Quiver B] → {a b : CategoryTheory.FreeBicategory B} → (a ⟶ b) → (a ⟶ b) → Type (max u v) | Representatives of 2-morphisms in the free bicategory. | true |
CategoryTheory.Adjunction.mkOfUnitCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (Y : D),
CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) ... | null | false |
instIsLeftAdjointSSetTopCatToTop | Mathlib.AlgebraicTopology.SingularSet | SSet.toTop.IsLeftAdjoint | null | true |
AEMeasurable.snd | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {f : α → β × γ},
AEMeasurable f μ → AEMeasurable (fun x => (f x).2) μ | null | true |
RegularExpression.char.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 2 → ((a : α) → motive (RegularExpression.char a)) → motive t | null | false |
not_injective_infinite_finite | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_4} {β : Sort u_5} [Infinite α] [Finite β] (f : α → β), ¬Function.Injective f | null | true |
Lean.Parser.Command.importPath | Lean.Parser.Command | Lean.Parser.Parser | `#import_path Foo` prints the transitive import chain that brings the declaration `Foo`
into the current file's scope.
| true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w n : ℕ} (aig : Std.Sat.AIG α) (distance : aig.RefVec n)
(curr : ℕ) (acc : aig.RefVec w),
curr < n - 1 →
∀
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, ... | null | false |
_private.Mathlib.Data.List.PeriodicityLemma.0.List.HasPeriod.factor._proof_1_6 | Mathlib.Data.List.PeriodicityLemma | ∀ {α : Type u_1} {u : List α} {p : ℕ} (j : ℕ), u.length ≤ j + u.length + p | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.inclusion.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J),
AlgebraicGeometry.Scheme.IdealSheafData.inclusion h = AlgebraicGeometry.Scheme.IdealSheafData.inclusion h | null | true |
Std.Sat.AIG.IsPrefix_push._simp_1 | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decl : Std.Sat.AIG.Decl α} {decls : Array (Std.Sat.AIG.Decl α)},
Std.Sat.AIG.IsPrefix decls (decls.push decl) = True | null | false |
IsSl2Triple.HasPrimitiveVectorWith.mk._flat_ctor | Mathlib.Algebra.Lie.Sl2 | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {h e f : L} {t : IsSl2Triple h e f} {m : M} {μ : R},
m ≠ 0 → ⁅h, m⁆ = μ • m → ⁅e, m⁆ = 0 → t.HasPrimitiveVectorWith m μ | null | false |
toIcoDiv_ofNat_mul_add | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (OfNat.ofNat m * p + b) = OfNat.ofNat m + toIcoDiv hp a b | null | true |
Mathlib.Tactic.BicategoryCoherence.LiftHom.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
(CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicategory.of.obj b) →
Mathlib.Tactic.BicategoryCoherence.LiftHom f | null | false |
Stream'.Seq.BisimO._sparseCasesOn_2.else_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Stream'.Seq.BisimO._sparseCasesOn_2 t some «else» = «else» h | null | false |
IsRegular.mem_nonZeroDivisors | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀}, IsRegular r → r ∈ nonZeroDivisors M₀ | null | true |
FreeAddGroup.instAddGroup._proof_8 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (n : ℕ) (a : FreeAddGroup α), zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | null | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_InfinitePlace_Ramification___unexpand_MulAction_stabilizer_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | Lean.PrettyPrinter.Unexpander | null | false |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.Context.casesOn | Lean.Server.Completion.CompletionCollectors | {motive : Lean.Server.Completion.Context✝ → Sort u} →
(t : Lean.Server.Completion.Context✝) →
((uri : Lean.Lsp.DocumentUri) →
(pos : Lean.Lsp.Position) →
(completionInfoPos : ℕ) → motive { uri := uri, pos := pos, completionInfoPos := completionInfoPos }) →
motive t | null | false |
ZSpan.quotientEquiv_apply_mk | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (x : E),
(ZSpan.quotientEquiv b) (Submodule.Quotient.mk x)... | null | true |
iteratedDeriv_fun_const_zero | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜}, iteratedDeriv n (fun x => 0) x = 0 | null | true |
Std.TreeMap.Raw.minKey?_insertIfNew_le_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] (h : t.WF)
{k : α} {v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
SeparationQuotient.instCommSemigroup._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : CommSemigroup M] [inst_2 : ContinuousMul M]
(a b : SeparationQuotient M), a * b = b * a | null | false |
Bornology.isCobounded_compl_iff | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsCobounded sᶜ ↔ Bornology.IsBounded s | null | true |
CategoryTheory.Mon.instZeroHom | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] → (M N : CategoryTheory.Mon D) → Zero (M ⟶ N) | null | true |
Lean.Elab.Do.ControlStack.mk.injEq | Lean.Elab.Do.Control | ∀ (description : Unit → Lean.MessageData) (m : Lean.Elab.Do.DoElabM Lean.Expr)
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr)
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont)
(description_1 : Unit → Lean.MessageData) (m_1 : Lean.Elab.Do.DoElabM Lean.Expr)
(stM... | null | true |
Batteries.Tactic.tactic_ | Batteries.Tactic.Init | Lean.ParserDescr | `_` in tactic position acts like the `done` tactic: it fails and gives the list
of goals if there are any. It is useful as a placeholder after starting a tactic block
such as `by _` to make it syntactically correct and show the current goal.
| true |
WithZero.instDivisionMonoid | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid (WithZero α) | null | true |
Nat.clog | Mathlib.Data.Nat.Log | ℕ → ℕ → ℕ | `clog b n`, is the upper logarithm of natural number `n` in base `b`. It returns the smallest
`k : ℕ` such that `n ≤ b^k`, so if `b^k = n`, it returns exactly `k`. | true |
_private.Mathlib.Geometry.Convex.Set.0.Convexity.IsConvexSet.singleton._simp_1_2 | Mathlib.Geometry.Convex.Set | ∀ {α : Type u_1} {s : Finset α} {a : α}, (↑s ⊆ {a}) = (s ⊆ {a}) | null | false |
ArithmeticFunction.instAlgebra._proof_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (x : R)
(f g : ArithmeticFunction S), x • f * g = x • (f * g) | null | false |
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | ∀ {Γ₀ : Type v} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_1) [inst_1 : Field K] (v : Valuation K Γ₀),
v.leSubmodule 0 = ⊥ | null | true |
SheafOfModules.instIsRightAdjointPushforward | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackContinuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
... | null | true |
Array.idRun_ofFnM | Init.Data.Array.OfFn | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → Id α}, (Array.ofFnM f).run = Array.ofFn fun i => (f i).run | null | true |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | {obj : Type u} → [toQuiver : Quiver obj] → ((X : obj) → X ⟶ X) → CategoryTheory.ReflQuiver obj | null | true |
Std.ExtDHashMap.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} {fallback : β k}, (m₁ ∪ m₂).getD k fallback = m₂.getD k (m₁.getD k fallback) | null | true |
CochainComplex.HomComplex.instAddCommGroupCochain._aux_12 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(F G : CochainComplex C ℤ) →
(n : ℤ) → CochainComplex.HomComplex.Cochain F G n → CochainComplex.HomComplex.Cochain F G n | null | false |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | Function.Bijective Real.arsinh | null | true |
Submonoid.comap_strictMono_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F}, Function.Surjective ⇑f → StrictMono (Submonoid.comap f) | null | true |
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace ℝ E] [inst_4 : NormedSpace ℂ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℂ 𝕜 F] [inst_7 : FiniteDimensional ℝ E] [inst_8 : MeasurableSpace E] [in... | null | true |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (a : M),
(AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a | null | true |
MeasureTheory.setLIntegral_trim_ae | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) {f : α → ENNReal},
AEMeasurable f (μ.trim hm) →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (x : α) in s, f x ∂μ.trim hm = ∫⁻ (x : α) in s, f x ∂μ | null | true |
Lean.CollectLevelParams.visitExpr | Lean.Util.CollectLevelParams | Lean.Expr → Lean.CollectLevelParams.Visitor | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData_H | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
CategoryTheory.Pi.laxMonoidalPi._proof_4 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_5} [inst : (i : I) → CategoryTheory.Category.{u_4, u_5} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_3}
[inst_2 : (i : I) → CategoryTheory.Category.{u_1, u_3} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → Cate... | null | false |
Std.Http.Protocol.H1.PulledChunk.ctorIdx | Std.Http.Protocol.H1 | Std.Http.Protocol.H1.PulledChunk → ℕ | null | false |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (toSubsemigroup : Subsemigroup M) (one_mem' : 1 ∈ toSubsemigroup.carrier),
({ toSubsemigroup := toSubsemigroup, one_mem' := one_mem' } = ⊤) = (toSubsemigroup = ⊤) | null | false |
Lean.withoutModifyingEnv | Lean.MonadEnv | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [MonadFinally m] → {α : Type} → m α → m α | null | true |
sInf_within_of_ordConnected | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {s : Set α} [hs : s.OrdConnected] ⦃t : Set ↑s⦄,
t.Nonempty → BddBelow t → sInf (Subtype.val '' t) ∈ s | The `sInf` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
order takes values within `s`, for all nonempty bounded-below subsets of `s`. | true |
Real.arccos_eq_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arccos x = Real.pi / 2 ↔ x = 0 | null | true |
_private.Mathlib.Data.Nat.ChineseRemainder.0.Nat.modEq_list_map_prod_iff._simp_1_5 | Mathlib.Data.Nat.ChineseRemainder | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.eq_bot_iff_isIsolated._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {v : V}, G.IsIsolated v = (G.neighborSet v = ∅) | null | false |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {γ : Type w} {f : α → β → Option γ} {l : List ((_ : α) × β)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (List.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) l) =
if h : Std.Internal.List.contain... | null | true |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | null | true |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
CategoryTheory.Limits.LimitPresentation J X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →... | null | false |
InnerProductSpace.Core.normSq.eq_1 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), InnerProductSpace.Core.normSq x = RCLike.re (inner 𝕜 x x) | null | true |
Bornology.isBounded_univ | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} [inst : Bornology α], Bornology.IsBounded Set.univ ↔ BoundedSpace α | null | true |
Cardinal.lt_one_iff_zero | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 | **Alias** of `Cardinal.lt_one_iff`. | true |
Std.Rxi.Iterator.instIteratorLoop.loop.eq_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b) (acc : γ) (next... | null | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
(⨆ i, ⨆ j, f i j ≤ a) = ∀ (i : ι) (j : κ i), f i j ≤ a | null | false |
Equiv.group._proof_3 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Group β] (x : α), e (e.symm (e x)⁻¹) = (e x)⁻¹ | null | false |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] {ι : Type u_4} [Finite ι] (f : ι → S),
∃ b, ∀ (i : ι), IsLocalization.IsInteger R (↑b • f i) | We can clear the denominators of a finite indexed family of fractions. | true |
_private.Mathlib.Data.Set.List.0.Option.getD.match_1.eq_1 | Mathlib.Data.Set.List | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | null | true |
Metric.gluePremetric._proof_5 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {Φ : Z → X} {Ψ : Z → Y}
(x : X ⊕ Y), Metric.glueDist Φ Ψ 0 x x = 0 | null | false |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
[∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.ma... | For an additive functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact then
`0 ⟶ F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact.
- `F` preserves exact sequences, i.e. if `A ⟶ B ⟶ C` is exact then `F(A) ⟶ F(B) ⟶ F(C)` is exact.
- `F` ... | true |
ContinuousAddEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Add M]
[inst_3 : Add N] (e : M ≃ₜ+ N) {x : N} {y : M}, e.symm x = y ↔ x = e y | null | true |
PreAbstractSimplicialComplex.instSupSet | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → SupSet (PreAbstractSimplicialComplex ι) | null | true |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool} {dropping : Bool},
(Std.IterM.Intermediate.dropWhile P dropping it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterSte... | null | true |
Set.IicExtend | Mathlib.Order.Interval.Set.ProjIcc | {α : Type u_1} → {β : Type u_2} → [inst : LinearOrder α] → {b : α} → (↑(Set.Iic b) → β) → α → β | Extend a function `(-∞, b] → β` to a map `α → β`. | true |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : AddMonoid M] (a : l.Germ M), a + 0 = a | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedState →
Lean.Syntax →
Option Lean.Expr →
Bool → List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Term.TermElab) → Lean.Elab.TermElabM Lean.Expr | null | false |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r | null | true |
CuspForm.discriminantEquiv._proof_2 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {k : ℤ} (f : CuspForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k),
∀ x ∈ (Matrix.SpecialLinearGroup.mapGL ℝ).range,
(SlashAction.map (k - 12) x fun z => f z / ModularForm.discriminant z) = fun z => f z / ModularForm.discriminant z | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.