name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniformEquiv.range_coe | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} [inst : UniformSpace α] [inst_1 : UniformSpace β] (h : α ≃ᵤ β), Set.range ⇑h = Set.univ | null | true |
CategoryTheory.typeEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (_α : Type u_1),
CategoryTheory.CategoryStruct.comp (TypeCat.ofHom fun f => (TypeCat.Hom.hom f) PUnit.unit)
(TypeCat.ofHom fun x => TypeCat.ofHom fun x_1 => x) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.yoneda'.comp
((CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendie... | null | false |
Turing.TM0to1.tr.eq_3 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Λ] (M : Turing.TM0.Machine Γ Λ) (a : Γ) (q : Λ),
Turing.TM0to1.tr M (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q) =
Turing.TM1.Stmt.write (fun x x_1 => a) (Turing.TM1.Stmt.goto fun x x_1 => Turing.TM0to1.Λ'.normal q) | null | true |
CategoryTheory.MonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Category___unexpand_CategoryTheory_MonoidalCategory_whiskerLeftIso_1 | Mathlib.CategoryTheory.Monoidal.Category | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.ObjectProperty.instIsClosedUnderSubobjectsOppositeOpOfIsClosedUnderQuotients | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderQuotients], P.op.IsClosedUnderSubobjects | null | true |
Std.Time.Duration.addSeconds | Std.Time.Duration | Std.Time.Duration → Std.Time.Second.Offset → Std.Time.Duration | Adds a `Second.Offset` to a `Duration`
| true |
Computation.liftRelAux_inr_inl | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {b : β} {ca : Computation α},
Computation.LiftRelAux R C (Sum.inr ca) (Sum.inl b) = ∃ a ∈ ca, R a b | null | true |
CategoryTheory.Functor.preimageIso._proof_4 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {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) {X Y : C} [inst_2 : F.Full]
[F.Faithful] (f : F.obj X ≅ F.obj Y),
CategoryTheory.CategoryStruct.comp (F.preimage f.inv) (F.preimage f.hom) = CategoryTheory... | null | false |
ClassGroup.mk0_eq_quotientMk | Mathlib.RingTheory.ClassGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDedekindDomain R]
(I : ↥(nonZeroDivisors (Ideal R))), ClassGroup.mk0 I = ↑((FractionalIdeal.mk0 (FractionRing R)) I) | `ClassGroup.mk0` factors through the canonical quotient projection on
`(FractionalIdeal R⁰ (FractionRing R))ˣ`. | true |
BddAbove.isBounded_inter | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s t : Set α} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α],
BddAbove s → BddBelow t → Bornology.IsBounded (s ∩ t) | null | true |
CategoryTheory.Triangulated.TStructure.instIsLEObjTruncGE | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} 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 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
AlgHom.cancel_left | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
{g₁ g₂ : A →ₐ[R] B} {f : B →ₐ[R] C}, Function.Injective ⇑f → (f.comp g₁ = f.comp g₂ ↔ g₁ = g₂) | null | true |
CommAlgCat.hasForgetToCommRingCat._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_1} [inst : CommRing R],
{ obj := fun A => ↧↑A, map := fun {X Y} f => CommRingCat.ofHom (CommAlgCat.Hom.hom f).toRingHom, map_id := ⋯,
map_comp := ⋯ }.comp
(CategoryTheory.forget CommRingCat) =
CategoryTheory.forget (CommAlgCat R) | null | false |
CategoryTheory.Comonad.Coalgebra.Hom.ext' | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (X Y : G.Coalgebra)
(f g : X ⟶ Y), f.f = g.f → f = g | null | true |
BoundedLatticeHom.mk.congr_simp | Mathlib.Order.Category.BddDistLat | ∀ {α : Type u_6} {β : Type u_7} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (toLatticeHom toLatticeHom_1 : LatticeHom α β)
(e_toLatticeHom : toLatticeHom = toLatticeHom_1) (map_top' : toLatticeHom.toFun ⊤ = ⊤)
(map_bot' : toLatticeHom.toFun ⊥ = ⊥),
{ toLatticeHom ... | null | true |
smulMonoidWithZeroHom._proof_3 | Mathlib.Algebra.GroupWithZero.Action.Basic | ∀ {M₀ : Type u_1} {N₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : MulZeroOneClass N₀]
[inst_2 : MulActionWithZero M₀ N₀] [inst_3 : IsScalarTower M₀ N₀ N₀] [inst_4 : SMulCommClass M₀ N₀ N₀]
(x y : M₀ × N₀), (↑smulMonoidHom).toFun (x * y) = (↑smulMonoidHom).toFun x * (↑smulMonoidHom).toFun y | null | false |
BddDistLat.Hom.noConfusion | Mathlib.Order.Category.BddDistLat | {P : Sort u_1} →
{X Y : BddDistLat} →
{t : X.Hom Y} →
{X' Y' : BddDistLat} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → BddDistLat.Hom.noConfusionType P t t' | null | false |
MonoidHom.noncommCoprod_apply' | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) (mn : M × N),
(f.noncommCoprod g comm) mn = g mn.2 * f mn.1 | Variant of `MonoidHom.noncommCoprod_apply` with the product written in the other direction. | true |
CategoryTheory.ObjectProperty.SerreClassLocalization.inverseImage_monomorphisms | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | null | true |
DoResultSBC.recOn | Init.Core | {α σ : Type u} →
{motive : DoResultSBC α σ → Sort u_1} →
(t : DoResultSBC α σ) →
((a : α) → (a_1 : σ) → motive (DoResultSBC.pureReturn a a_1)) →
((a : σ) → motive (DoResultSBC.break a)) → ((a : σ) → motive (DoResultSBC.continue a)) → motive t | null | false |
CategoryTheory.Limits.prod.braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(P Q : C) →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q] →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P] → P ⨯ Q ≅ Q ⨯ P | The braiding isomorphism which swaps a binary product. | true |
_private.Init.Data.Vector.Lemmas.0.Vector.sum_reverse._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] [inst_1 : Zero α] {xs : Vector α n}, xs.sum = xs.toList.sum | null | false |
Lean.Syntax.Traverser._sizeOf_inst | Lean.Syntax | SizeOf Lean.Syntax.Traverser | null | false |
HasSubset.Subset.diff_ssubset_of_nonempty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → s.Nonempty → t \ s ⊂ t | **Alias** of `LE.le.sdiff_ssubset_of_nonempty`. | true |
HahnSeries.SummableFamily.smul_apply | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
[inst_5 : VAdd Γ Γ'] [inst_6 : IsOrderedCancelVAdd Γ Γ'] {x : HahnSeries Γ R} {s : HahnSeries.SummableFam... | null | true |
NormedCommGroup.ofMulDist' | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} →
[inst : Norm E] →
[inst_1 : CommGroup E] →
[inst_2 : MetricSpace E] →
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist (z * x) (z * y) ≤ dist x y) → NormedCommGroup E | Construct a normed group from a multiplication-invariant pseudodistance. | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Preregular C]
[CategoryTheory.FinitaryExtensive C], CategoryTheory.Precoherent C | null | false |
CochainComplex.mappingConeCompTriangleh_comm₁_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.u... | null | true |
LeanSearchClient.SearchServer.rec | LeanSearchClient.Syntax | {motive : LeanSearchClient.SearchServer → Sort u} →
((name url cmd : String) →
(query : String → ℕ → Lean.MetaM (Array LeanSearchClient.SearchResult)) →
(queryNum : Lean.CoreM ℕ) →
motive { name := name, url := url, cmd := cmd, query := query, queryNum := queryNum }) →
(t : LeanSearchClien... | null | false |
Algebra.IsEffective.of_section | Mathlib.RingTheory.TensorProduct.IncludeLeftSubRight | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S] (g : S →ₐ[R] R),
Algebra.IsEffective R S | `IsEffective` is true for any `R`-algebra `S` having an `R`-algebra section of
`Algebra.ofId _ _ : R →ₐ[R] S`. | true |
_private.Init.Data.List.ToArray.0.Break.runK.match_1.splitter | Init.Data.List.ToArray | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.map_parallel._proof_1_10 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) ⦃c1 c2 : Computation β⦄,
(∃ l S,
c1 = Computation.map f (Computation.corec Computation.parallel.aux1✝ (l, S)) ∧
c2 =
Computation.corec Computation.parallel.aux1✝
(List.map (Computation.map f) l, Stream'.WSeq.map (Computation.map f) S)) →
... | null | false |
CategoryTheory.Limits.DiagramOfCones.conePoints_map | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (D : CategoryTheory.Limits.DiagramOfCones F) {X Y : J}
(f : X ⟶ Y... | null | true |
CategoryTheory.DifferentialObject.instHasShift._proof_1 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddCommGroupWithOne S] (C : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (m₁ m₂ m₃ : S)
(X : CategoryTheory.DifferentialObject S C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.... | null | false |
MonCat.Colimits.instInhabitedColimitType | Mathlib.Algebra.Category.MonCat.Colimits | {J : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} J] →
(F : CategoryTheory.Functor J MonCat) → Inhabited (MonCat.Colimits.ColimitType F) | null | true |
LinearMap.exists_mem_center_apply_eq_smul_of_forall_notLinearIndependent | Mathlib.LinearAlgebra.Center | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [IsDomain R] [StrongRankCondition R] [inst_3 : AddCommGroup V]
[inst_4 : Module R V] [Module.Free R V] {f : V →ₗ[R] V},
Module.finrank R V ≠ 1 → (∀ (v : V), ¬LinearIndependent R ![v, f v]) → ∃ a, f = a • 1 | Over a domain `R`, an endomorphism `f` of a free module `V`
of rank ≠ 1 such that `f v` and `v` are collinear, for all `v : V`,
consists of homotheties with central ratio.
When `R` does not satisfy `StrongRankCondition`, use
`LinearMap.exists_mem_center_apply_eq_smul_of_basis`.
When `finrank R V = 1`, up to a linear ... | true |
Polynomial.modByMonic_eq_sub_mul_div | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R), p %ₘ q = p - q * (p /ₘ q) | null | true |
Prod.map_comp_map | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ζ : Type u_6} (f : α → β) (f' : γ → δ)
(g : β → ε) (g' : δ → ζ), Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f') | Composing a `Prod.map` with another `Prod.map` is equal to
a single `Prod.map` of composed functions.
| true |
CategoryTheory.InjectiveResolution.definition._proof_2._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Injective.ι Z)
((CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1) =
0 | null | false |
Lean.Elab.InlayHintLabel | Lean.Elab.InfoTree.InlayHints | Type | null | true |
Std.WP.Variant._sizeOf_inst | Std.WP.Triple.SpecLemmas | (α : Type uα) →
(Pred : Type u) → {inst : Std.WP.Assertion Pred} → [SizeOf α] → [SizeOf Pred] → SizeOf (Std.WP.Variant α Pred) | null | false |
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val : ℤ} →
{x n : Lean.Grind.Linarith.Var} →
{c' : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val' : ℤ} →
{x' n' : Lean.Grind.Linarith.Var} →
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.can... | null | false |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.bind.match_14 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {β : Type u_3} {m : α → Filter β} (x : Set β) (σ : Type u_2) (F : CFilter (Set α) σ)
(motive :
(∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ },
∀ x_1 ∈ t, x ∈ m x_1) →
Prop)
(x_1 :
∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets ... | null | false |
Nonneg.linearOrderedCommGroupWithZero._proof_2 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α],
autoParam (∀ (a : Nonneg α), a ^ 0 = 1) DivInvMonoid.zpow_zero'._autoParam | null | false |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.elabSetLibrarySuggestions._regBuiltin.Lean.LibrarySuggestions.elabSetLibrarySuggestions_1 | Lean.LibrarySuggestions.Basic | IO Unit | null | false |
Int.Internal.Linear.Expr.toPoly'.go.eq_5 | Init.Data.Int.Linear | ∀ (coeff k : ℤ) (a : Int.Internal.Linear.Expr),
Int.Internal.Linear.Expr.toPoly'.go coeff (Int.Internal.Linear.Expr.mulL k a) =
bif k == 0 then id else Int.Internal.Linear.Expr.toPoly'.go (coeff.mul k) a | null | true |
CategoryTheory.LocalizerMorphism.liftingLocalizedFunctor._aux_1 | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u_1} →
{C₂ : Type u_8} →
{D₁ : Type u_6} →
{D₂ : Type u_3} →
[inst : CategoryTheory.Category.{u_4, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] →
[inst_2 : CategoryTheory.Category.{u_5, u_6} D₁] →
[inst_3 : CategoryTheory.Category.{u_2, u... | null | false |
OrthonormalBasis.fromOrthogonalSpanSingleton._proof_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(n : ℕ) [Fact (Module.finrank 𝕜 E = n + 1)], FiniteDimensional 𝕜 E | null | false |
isClosed_le_of_isClosed_nonneg | Mathlib.Analysis.Normed.Order.Lattice | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[ContinuousSub G], IsClosed {x | 0 ≤ x} → IsClosed {p | p.1 ≤ p.2} | null | true |
CategoryTheory.WideSubcategory.obj | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{_P : CategoryTheory.MorphismProperty C} → [inst_1 : _P.IsMultiplicative] → CategoryTheory.WideSubcategory _P → C | The category of which this is a wide subcategory | true |
nhdsSet_le_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {s t : Set X}, (nhdsSet s ≤ nhdsSet t) = (s ⊆ t) | null | false |
Lean.Server.StatefulRequestHandler.casesOn | Lean.Server.Requests | {motive : Lean.Server.StatefulRequestHandler → Sort u} →
(t : Lean.Server.StatefulRequestHandler) →
((fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(pureHandle : Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(handle... | null | false |
Sublattice.mem_mk._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {s : Set α} {a : α} (h_sup : SupClosed s) (h_inf : InfClosed s),
(a ∈ { carrier := s, supClosed' := h_sup, infClosed' := h_inf }) = (a ∈ s) | null | false |
Lean.Lsp.ResolveSupport | Lean.Data.Lsp.Basic | Type | null | true |
intervalIntegral.integral_derivWithin_Icc_of_contDiffOn_Icc | Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ} [CompleteSpace E],
ContDiffOn ℝ 1 f (Set.Icc a b) → a ≤ b → ∫ (x : ℝ) in a..b, derivWithin f (Set.Icc a b) x = f b - f a | Fundamental theorem of calculus-2: If `f : ℝ → E` is `C^1` on `[a, b]`,
then `∫ y in a..b, derivWithin f (Icc a b) y` equals `f b - f a`. | true |
GroupExtension.Equiv.trans_apply | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S')
{E'' : Type u_5} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S'') (a : E),... | null | true |
instOrderInfSetForall | Mathlib.Order.CompleteLattice.Basic | {α : Type u_8} →
{β : α → Type u_9} → [inst : (i : α) → Preorder (β i)] → [(i : α) → OrderInfSet (β i)] → OrderInfSet ((i : α) → β i) | null | true |
Part.elim_toOption | Mathlib.Data.Part | ∀ {α : Type u_4} {β : Type u_5} (a : Part α) [inst : Decidable a.Dom] (b : β) (f : α → β),
a.toOption.elim b f = if h : a.Dom then f (a.get h) else b | null | true |
SeminormFamily.basisSets_univ_mem | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι), Set.univ ∈ p.basisSets | null | true |
totallyDisconnectedSpace_iff_totallySeparatedSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] [WeaklyLocallyCompactSpace X],
TotallyDisconnectedSpace X ↔ TotallySeparatedSpace X | null | true |
Std.ExtHashMap.getKeyD_alter_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | null | true |
SemiNormedGrp.hom_id | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M : SemiNormedGrp}, SemiNormedGrp.Hom.hom (CategoryTheory.CategoryStruct.id M) = NormedAddGroupHom.id M.carrier | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesProd.match_5 | Lean.Meta.MkIffOfInductiveProp | (motive : Array Lean.Meta.CasesSubgoal → Sort u_1) →
(__x : Array Lean.Meta.CasesSubgoal) →
((sg : Lean.Meta.CasesSubgoal) → motive #[sg]) → ((x : Array Lean.Meta.CasesSubgoal) → motive x) → motive __x | null | false |
_private.Mathlib.Combinatorics.Schnirelmann.0.add_eq_univ_of_one_le_schirelmannDensity_add_schnirelmannDensity.match_1_1.splitter | Mathlib.Combinatorics.Schnirelmann | (motive : ℕ ⊕ ℕ → Sort u_1) → (x : ℕ ⊕ ℕ) → ((x : ℕ) → motive (Sum.inl x)) → ((y : ℕ) → motive (Sum.inr y)) → motive x | null | true |
TensorProduct.finsuppRight_symm_apply_single | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] {ι : Type u_5} [inst_9 : Decidable... | null | true |
Array.get!Internal | Init.Prelude | {α : Type u} → [Inhabited α] → Array α → ℕ → α | Use the indexing notation `a[i]!` instead.
Access an element from an array, or panic if the index is out of bounds.
| true |
Lean.SourceInfo.ctorIdx | Init.Prelude | Lean.SourceInfo → ℕ | null | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_7 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : Additive αᵒᵈ), ↑n.succ • a = ↑n • a + a | null | false |
EuclideanDomain.lcm | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [EuclideanDomain R] → [DecidableEq R] → R → R → R | `lcm a b` is a (non-unique) element such that `a ∣ lcm a b` `b ∣ lcm a b`, and for
any element `c` such that `a ∣ c` and `b ∣ c`, then `lcm a b ∣ c` | true |
NumberField.IsCMField.starRing | Mathlib.NumberTheory.NumberField.CMField | (K : Type u_1) →
[inst : Field K] → [inst_1 : CharZero K] → [NumberField.IsCMField K] → [Algebra.IsIntegral ℚ K] → StarRing K | null | true |
CategoryTheory.PreOneHypercover.inv_hom_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (e.hom.h₁ (e.inv.s₁ k)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso ⋯... | null | true |
Real.iteratedDerivWithin_cos_Ioo | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b x : ℝ}, x ∈ Set.Ioo a b → iteratedDerivWithin n Real.cos (Set.Ioo a b) x = iteratedDeriv n Real.cos x | null | true |
ModularGroup.eq_smul_self_of_mem_fdo_mem_fdo | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fdo → g • z ∈ ModularGroup.fdo → z = g • z | Second Fundamental Domain Lemma: if both `z` and `g • z` are in the open domain `𝒟ᵒ`,
where `z : ℍ` and `g : SL(2, ℤ)`, then `z = g • z`. | true |
MulEquiv.mk.inj | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} {inst : Mul M} {inst_1 : Mul N} {toEquiv : M ≃ N}
{map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y} {toEquiv_1 : M ≃ N}
{map_mul'_1 : ∀ (x y : M), toEquiv_1.toFun (x * y) = toEquiv_1.toFun x * toEquiv_1.toFun y},
{ toEquiv := toEquiv, map_mul' := ... | null | true |
_private.Lean.Meta.Instances.0.Lean.Meta.warnClassDefReducibility | Lean.Meta.Instances | Lean.Option Bool | null | true |
CategoryTheory.Limits.coneUnopOfCocone_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt | null | true |
CategoryTheory.FintypeCat.Action.isConnected_iff_transitive | Mathlib.CategoryTheory.Galois.Examples | ∀ (G : Type u) [inst : Group G] (X : Action FintypeCat G) [Nonempty X.V.obj],
CategoryTheory.PreGaloisCategory.IsConnected X ↔ MulAction.IsPretransitive G X.V.obj | A nonempty finite `G`-set is connected if and only if the `G`-action is transitive. | true |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPattern_1 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
PartialHomeomorph.image_source_eq_target | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialHomeomorph X Y),
↑e '' e.source = e.target | null | true |
Set.exists_min_image | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] (s : Set α) (f : α → β),
s.Finite → s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f a ≤ f b | null | true |
MulHom.prod_comp_prodMap | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N]
[inst_2 : Mul M'] [inst_3 : Mul N'] [inst_4 : Mul P] (f : P →ₙ* M) (g : P →ₙ* N) (f' : M →ₙ* M') (g' : N →ₙ* N'),
(f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.H | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Hour.Ordinal | null | true |
ONote.opowAux2.match_1 | Mathlib.SetTheory.Ordinal.Notation | (motive : ONote × ℕ → Sort u_1) →
(x : ONote × ℕ) → ((b : ONote) → motive (b, 0)) → ((b : ONote) → (k : ℕ) → motive (b, k.succ)) → motive x | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceCastLE.declare_186._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.4222132389._hygCtx._hyg.21 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
MvPolynomial.uniqueAlgEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (σ : Type u_2) [inst_1 : Unique σ] (p : MvPolynomial σ R),
(MvPolynomial.uniqueAlgEquiv R σ) p = MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X) p | null | true |
_private.Lean.Compiler.LCNF.ToDecl.0.Lean.Compiler.LCNF.toDecl.match_3 | Lean.Compiler.LCNF.ToDecl | (motive : Lean.Expr → Sort u_1) →
(currentExpr : Lean.Expr) →
((binderName : Lean.Name) →
(type body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName type body binderInfo)) →
((x : Lean.Expr) → motive x) → motive currentExpr | null | false |
Module.Basis.adjustToOrientation.congr_simp | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {ι : Type u_3} [inst_5 : Fintype ι] [inst_6 : DecidableEq ι]
[inst_7 : Nonempty ι] (e e_1 : Module.Basis ι R M),
e = e_1 → ∀ (x x_1 : Orientation R M ι), x ... | null | true |
_private.Mathlib.Logic.Relation.0.refl_iff_eq_le._proof_1_1 | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop}, Std.Refl r ↔ Eq ≤ r | null | false |
SetSemiring.instCompleteBooleanAlgebra._proof_20 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (x y z : SetSemiring α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ → ∀ (t : Set α), (∀ (g : G), g • t = t) → μ (t ... | null | true |
differentiable_neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜], Differentiable 𝕜 Neg.neg | null | true |
CategoryTheory.Functor.Final.rec | 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 C D} →
{motive : F.Final → Sort u} →
((out : ∀ (d : D), CategoryTheory.IsConnected (CategoryTheory.StructuredArrow d F)) → m... | null | false |
Units.val | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → αˣ → α | The underlying value in the base `Monoid`. | true |
_private.Init.Data.List.Find.0.List.find?_replicate_eq_none_iff._simp_1_1 | Init.Data.List.Find | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
CategoryTheory.PreZeroHypercover.pullbackIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S T : C} →
(f : S ⟶ T) →
(E : CategoryTheory.PreZeroHypercover T) →
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] →
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f] →
... | Pullback symmetry isomorphism. | true |
Set.iUnion_iUnion_eq_right | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : (x : β) → b = x → Set α}, ⋃ x, ⋃ (h : b = x), s x h = s b ⋯ | null | true |
Std.DHashMap.Internal.Raw.Const.get_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, Std.DHashMap.Raw.Const.get m a h = Std.DHashMap.Internal.Raw₀.Const.get ⟨m, ⋯⟩ a ⋯ | null | true |
toLexLinearEquiv | Mathlib.Algebra.Order.Module.Equiv | (α : Type u_1) →
(β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [inst_2 : Module α β] → β ≃ₗ[α] Lex β | `toLex` as a linear equivalence | true |
SupHom.recOn | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
(t : SupHom α β) →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_... | null | false |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatten._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a : α} {xss : Array (Array α)}, (a ∈ xss.flatten) = ∃ xs ∈ xss, a ∈ xs | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.