name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FirstOrder.Language.LHom.substructureReduct._proof_4 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(φ : L →ᴸ L') [inst_2 : φ.IsExpansionOn M] (S T : L'.Substructure M),
(fun S => { carrier := ↑S, fun_mem := ⋯ }) S = (fun S => { carrier := ↑S, fun_mem := ⋯ }) T → S = T | null | false |
CategoryTheory.ComposableArrows.Exact.cokerToKer'._proof_1 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)}, S.Exact → S.IsComplex | null | false |
USize.toUInt8_ofBitVec | Init.Data.UInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), { toBitVec := b }.toUInt8 = { toBitVec := BitVec.setWidth 8 b } | null | true |
ProjectiveSpectrum.mem_vanishingIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (t : Set (ProjectiveSpectrum 𝒜)) (f : A),
f ∈ ProjectiveSpectrum.vanishingIdeal t ↔ ∀ x ∈ t, f ∈ x.asHomogeneousIdeal | null | true |
NormedAddGroupHom.opNorm_le_bound | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂) {M : ℝ}, 0 ≤ M → (∀ (x : V₁), ‖f x‖ ≤ M * ‖x‖) → ‖f‖ ≤ M | If one controls the norm of every `f x`, then one controls the norm of `f`. | true |
List.instLawfulTraversable | Mathlib.Control.Traversable.Instances | LawfulTraversable List | null | true |
Lean.Server.instInhabitedDocumentMeta.default | Lean.Server.Utils | Lean.Server.DocumentMeta | null | true |
Int16.toISize_ofIntLE | Init.Data.SInt.Lemmas | ∀ {n : ℤ} (h₁ : Int16.minValue.toInt ≤ n) (h₂ : n ≤ Int16.maxValue.toInt),
(Int16.ofIntLE n h₁ h₂).toISize = ISize.ofIntLE n ⋯ ⋯ | null | true |
Int64.toUInt64_or | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ||| b).toUInt64 = a.toUInt64 ||| b.toUInt64 | null | true |
Finset.sum_Ioc_consecutive | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : AddCommMonoid M] (f : ℕ → M) {m n k : ℕ},
m ≤ n → n ≤ k → ∑ i ∈ Finset.Ioc m n, f i + ∑ i ∈ Finset.Ioc n k, f i = ∑ i ∈ Finset.Ioc m k, f i | null | true |
IntermediateField.map_sup | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
[inst_3 : Field K] [inst_4 : Algebra F K] (s t : IntermediateField F E) (f : E →ₐ[F] K),
IntermediateField.map f (s ⊔ t) = IntermediateField.map f s ⊔ IntermediateField.map f t | null | true |
neg_lt_neg_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b : α} [AddRightStrictMono α],
-a < -b ↔ b < a | null | true |
AddSubgroup.coe_copy | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) (s : Set G) (hs : s = ↑K), ↑(K.copy s hs) = s | null | true |
instBracketSubtypeMemLieIdeal._proof_1 | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u_2) (L : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
AddSubgroupClass (LieSubmodule R L L) L | null | false |
Std.PRange.LawfulUpwardEnumerableLE.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : LE α] →
{motive : Std.PRange.LawfulUpwardEnumerableLE α → Sort u_1} →
(t : Std.PRange.LawfulUpwardEnumerableLE α) →
((le_iff : ∀ (a b : α), a ≤ b ↔ Std.PRange.UpwardEnumerable.LE a b) → motive ⋯) → motive t | null | false |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.introN.match_1 | Mathlib.Tactic.GCongr.Core | (motive : List Lean.MVarId × List (Lean.TSyntax `rintroPat) → Sort u_1) →
(x : List Lean.MVarId × List (Lean.TSyntax `rintroPat)) →
((goals : List Lean.MVarId) → (patterns : List (Lean.TSyntax `rintroPat)) → motive (goals, patterns)) → motive x | null | false |
RingHom.Flat.ofLocalizationSpanTarget | Mathlib.RingTheory.RingHom.Flat | RingHom.OfLocalizationSpanTarget fun {R S} [CommRing R] [CommRing S] => RingHom.Flat | null | true |
Num.castNum_shiftLeft | Mathlib.Data.Num.Lemmas | ∀ (m : Num) (n : ℕ), ↑(m <<< n) = ↑m <<< n | null | true |
Polynomial.monic_toSubring._simp_1 | Mathlib.RingTheory.Polynomial.Subring | ∀ {R : Type u_1} [inst : Ring R] (p : Polynomial R) (T : Subring R) (hp : ↑p.coeffs ⊆ ↑T),
(p.toSubring T hp).Monic = p.Monic | null | false |
IsSymmetricAlgebra.lift.eq_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A'),
h.lift g = (Symme... | null | true |
IntermediateField.relrank_mul_relrank | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B C : IntermediateField F E},
A ≤ B → B ≤ C → A.relrank B * B.relrank C = A.relrank C | null | true |
HomologicalComplex.XIsoOfEq | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (K : HomologicalComplex V c) → {p q : ι} → p = q → (K.X p ≅ K.X q) | The obvious isomorphism `K.X p ≅ K.X q` when `p = q`. | true |
Array.filterMap_some_fun | Init.Data.Array.Lemmas | ∀ {α : Type u_1}, (fun as => Array.filterMap some as) = id | null | true |
CochainComplex.ιTruncLE_naturality_assoc | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : ∀ (i : ℤ), HomologicalComplex.HasHomology K i] [inst_4 : ∀ (i : ℤ), HomologicalComplex.HasHomology L i]... | null | true |
LightProfinite.Extend.functorOp_map | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {F : CategoryTheory.Functor ℕᵒᵖ FintypeCat} (c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toLightProfinite))
{X Y : ℕ} (f : X ⟶ Y),
(LightProfinite.Extend.functorOp c).map f = CategoryTheory.CostructuredArrow.homMk (F.map f.op).op ⋯ | null | true |
Lean.Grind.AddRightCancel.mk._flat_ctor | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Add M], (∀ (a b c : M), a + c = b + c → a = b) → Lean.Grind.AddRightCancel M | null | false |
Language.mem_add | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α) (x : List α), x ∈ l + m ↔ x ∈ l ∨ x ∈ m | null | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (p p_1 : Lean.Grind.CommRing.Poly),
(Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input p = Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input p_1) =
(p = p_1) | null | true |
Part.notMem_none._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (a : α), (a ∈ Part.none) = False | null | false |
RingQuot.definition._proof_4._@.Mathlib.Algebra.RingQuot.3469094938._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (x y : R),
{ toQuot := Quot.mk (RingQuot.Rel r) (x + y) } =
{ toQuot := Quot.mk (RingQuot.Rel r) x } + { toQuot := Quot.mk (RingQuot.Rel r) y } | null | false |
CategoryTheory.Square.toArrowArrowFunctor'._proof_1 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp φ.τ₁ Y.f₁₂ = CategoryTheory.CategoryStruct.comp X.f₁₂ φ.τ₂ | null | false |
Pell.pellZd_sub | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) {m n : ℕ}, n ≤ m → Pell.pellZd a1 (m - n) = Pell.pellZd a1 m * star (Pell.pellZd a1 n) | null | true |
List.pmap_attachWith | Init.Data.List.Attach | ∀ {α : Type u_1} {q : α → Prop} {β : Type u_2} {l : List α} {p : { x // q x } → Prop} {f : (a : { x // q x }) → p a → β}
(H₁ : ∀ x ∈ l, q x) (H₂ : ∀ a ∈ l.attachWith q H₁, p a),
List.pmap f (l.attachWith q H₁) H₂ = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ | null | true |
Lean.protectedExt | Lean.Modifiers | Lean.TagDeclarationExtension | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.casesOn | Mathlib.CategoryTheory.Presentable.Directed | {J : Type w} →
[inst : CategoryTheory.SmallCategory J] →
{κ : Cardinal.{w}} →
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} →
{e : J} →
{motive : D.IsTerminal e → Sort u} →
(t : D.IsTerminal e) →
((prop_id : D.W (CategoryTheory.Categ... | null | false |
Std.Do.SPred.and_or_right | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, P ∧ Q ∨ R ⊣⊢ₛ (P ∨ R) ∧ (Q ∨ R) | null | true |
_private.Mathlib.Topology.Separation.Regular.0.IsCompact.nhdsSet_basis_isCompact_isClosed.match_1_2 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X} (U : Set X) (motive : IsOpen U ∧ K ⊆ U → Prop)
(h : IsOpen U ∧ K ⊆ U), (∀ (hU : IsOpen U) (h_KU : K ⊆ U), motive ⋯) → motive h | null | false |
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsPos.cons_iff | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ {hd : ℝ} {tl : Tactic.ComputeAsymptotics.UnitMonomial},
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsPos (hd :: tl) ↔ 0 < hd ∨ hd = 0 ∧ tl.FirstNonzeroIsPos | null | true |
CategoryTheory.CatCenter.mul_app | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x y : CategoryTheory.CatCenter C) (X : C),
(x * y).app X = CategoryTheory.CategoryStruct.comp (x.app X) (y.app X) | null | true |
Int8.xor_neg_one | Init.Data.SInt.Bitwise | ∀ {a : Int8}, a ^^^ -1 = ~~~a | null | true |
Subarray.toArray_mkSlice_rio | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {hi : ℕ},
Std.Slice.toArray (Std.Rio.Sliceable.mkSlice xs *...hi) = (Std.Slice.toArray xs).extract 0 hi | null | true |
_private.Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing.0.AlgebraicGeometry.SheafedSpace.GlueData.«term𝖣» | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | Lean.ParserDescr | null | true |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.exists_nontrivial_weightSpace_of_isSolvable.match_1_1 | Mathlib.Algebra.Lie.LieTheorem | ∀ (k : Type u_1) [inst : Field k] (V : Type u_2) [inst_1 : AddCommGroup V] [inst_2 : Module k V]
(imL : LieSubalgebra k (Module.End k V)) (motive : (∃ χ, Nontrivial ↥(LieModule.weightSpace V ⇑χ)) → Prop)
(x : ∃ χ, Nontrivial ↥(LieModule.weightSpace V ⇑χ)),
(∀ (χ : Module.Dual k ↥imL) (h : Nontrivial ↥(LieModule.w... | null | false |
CategoryTheory.ShortComplex.unop_f | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex Cᵒᵖ), S.unop.f = S.g.unop | null | true |
TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace.recOn | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
{motive : TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace X → Sort u} →
(t : TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace X) →
([toPseudoMetricSpace : PseudoMetricSpace X] →
[toCompleteSpace : CompleteSpace X] →
motive { toPseudoMetricSpace := ... | null | false |
CategoryTheory.Limits.Cocone.functoriality.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D),
CategoryTheory.Limits.Cocone.functoriality F G =
{ obj := fun A... | null | true |
Valuation.ltAddSubgroup._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
(γ : Γ₀ˣ) {x y : R}, x ∈ {x | v x < ↑γ} → y ∈ {x | v x < ↑γ} → v (x + y) < ↑γ | null | false |
Antitone.rightLim_le | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Antitone f → ∀ {x y : α}, y ≤ x → Function.rightLim f x ≤ f y | null | true |
ApproximatesLinearOn.toOpenPartialHomeomorph_source | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} (s : Set E) {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (... | null | true |
MeasureTheory.measure_smul_eq_zero_iff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
{μ : MeasureTheory.Measure α} [MeasureTheory.SMulInvariantMeasure G α μ] {s : Set α} (c : G), μ (c • s) = 0 ↔ μ s = 0 | null | true |
Subfield.charP | Mathlib.Algebra.CharP.Algebra | ∀ {R : Type u_1} [inst : DivisionRing R] (L : Subfield R) (p : ℕ) [CharP R p], CharP (↥L) p | null | true |
Lean.instToJsonImport.toJson | Lean.Setup | Lean.Import → Lean.Json | null | true |
SimplexCategory.orderIsoOfIso.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (e : x ≅ y),
SimplexCategory.orderIsoOfIso e =
{ toFun := ⇑(SimplexCategory.Hom.toOrderHom e.hom), invFun := ⇑(SimplexCategory.Hom.toOrderHom e.inv),
left_inv := ⋯, right_inv := ⋯ }.toOrderIso
⋯ ⋯ | null | true |
CochainComplex.ConnectData.mk.sizeOf_spec | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} [inst_2 : SizeOf C] (d₀ : K.X 0 ⟶ L.X 0)
(comp_d₀ : CategoryTheory.CategoryStruct.comp (K.d 1 0) d₀ = 0)
(d₀_comp : CategoryTheory.CategoryStruct.comp d₀ (L.... | null | true |
ProbabilityTheory.IsGaussianProcess.hasGaussianLaw_fun_add | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Basic | ∀ {T : Type u_2} {Ω : Type u_3} {E : Type u_4} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : T → Ω → E}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] [inst_3 : NormedSpace ℝ E]
[SecondCountableTopology E],
ProbabilityTheory.IsGaussianProcess X P → ∀ {s t : T}, Probability... | null | true |
NONote.instMul | Mathlib.SetTheory.Ordinal.Notation | Mul NONote | Multiplication of ordinal notations | true |
MeasureTheory.IsLocallyFiniteMeasure.recOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
[inst : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.IsLocallyFiniteMeasure μ → Sort u} →
(t : MeasureTheory.IsLocallyFiniteMeasure μ) →
((finiteAtNhds : ∀ (x : α), μ.FiniteAtFilter (nhds x)) → motive ... | null | false |
Lean.Meta.Sym.Arith.evalInt? | Lean.Meta.Sym.Arith.EvalNum | Lean.Expr → Lean.Meta.Sym.SymM (Option ℤ) | null | true |
Algebra.Presentation.instCommRingCore._proof_45 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ},
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
IsEllipticNet.rel_eq | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (W : ℤ → R) (p q r s : ℤ),
IsEllipticNet.rel W p q r s = IsEllipticNet.atomRel W (2 * p + s) (2 * q + s) (2 * r + s) s | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.decodeSigma_encodeSigma.match_1_1 | Batteries.Data.Fin.Coding | ∀ (f : Fin 0 → ℕ) (motive : (i : Fin 0) × Fin (f i) → Prop) (x : (i : Fin 0) × Fin (f i)), motive x | null | false |
UInt32.le_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt32}, a ≤ b → b ≤ c → a ≤ c | null | true |
HasFDerivWithinAt.finset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_4} {𝔸' : Type u_6} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι]... | **Alias** of `HasFDerivWithinAt.finsetProd`. | true |
SSet.sd._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subdivision | CategoryTheory.Functor.HasLeftKanExtension SSet.stdSimplex SimplexCategory.sd | null | false |
Lean.Server.GoToKind.ctorElimType | Lean.Server.GoTo | {motive : Lean.Server.GoToKind → Sort u} → ℕ → Sort (max 1 u) | null | false |
AddOpposite.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a : Rᵃᵒᵖ), a * 0 = 0 | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.mk.inj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
{φK : h₁.K ⟶ h₂.K} {φH : h₁.H ⟶ h₂.H}
{commi :
autoParam (CategoryTheory.CategoryStruct... | null | true |
CategoryTheory.HasCardinalFilteredGenerator.toLocallySmall | Mathlib.CategoryTheory.Presentable.CardinalFilteredPresentation | ∀ {C : Type u} {hC : CategoryTheory.Category.{v, u} C} (κ : Cardinal.{w}) {hκ : Fact κ.IsRegular}
[self : CategoryTheory.HasCardinalFilteredGenerator C κ], CategoryTheory.LocallySmall.{w, v, u} C | null | true |
CategoryTheory.Equivalence.symmEquivInverse.eq_1 | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D],
CategoryTheory.Equivalence.symmEquivInverse C D =
{ obj := fun e => Opposite.op e.symm,
map := fun {e f} α =>
(CategoryTheory.Equivalence.mkHom
((Categor... | null | true |
NumberField.mixedEmbedding.instDiscreteTopologySubtypeMixedSpaceMemSubmoduleIntIntegerLattice | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], DiscreteTopology ↥(NumberField.mixedEmbedding.integerLattice K) | null | true |
AlgHom.toAddMonoidHom_injective | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], Function.Injective AddMonoidHom.ofClass | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.inner_right_finsupp._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
CategoryTheory.CountableCategory.recOn | Mathlib.CategoryTheory.Countable | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{motive : CategoryTheory.CountableCategory J → Sort u} →
(t : CategoryTheory.CountableCategory J) →
((countableObj : Countable J) → (countableHom : ∀ (j j' : J), Countable (j ⟶ j')) → motive ⋯) → motive t | null | false |
Lean.AsyncList.below_1 | Lean.Server.AsyncList | {ε : Type u} →
{α : Type v} →
{motive_1 : Lean.AsyncList ε α → Sort u_1} →
{motive_2 : Lean.Server.ServerTask (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_3 : Task (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_4 : Except ε (Lean.AsyncList ε α) → Sort u_1} →
Lea... | null | false |
Algebra.Presentation.instCommRingCore._proof_62 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} (a b c : P.Core), (a + b) * c = a * c + b * c | null | false |
LieAlgebra.SemiDirectSum.neg_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x : K ⋊⁅ψ⁆ L),
-x = { left := -x.left, right := -x.right } | null | true |
Lean.Elab.MacroStackElem.after | Lean.Elab.Util | Lean.Elab.MacroStackElem → Lean.Syntax | null | true |
Real.rpowIntegrand₀₁_eq_sub | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p t : ℝ}, p ≠ 1 → 0 < t → p.rpowIntegrand₀₁ t = fun x => t ^ (p - 1) - t ^ p * (t + x)⁻¹ | null | true |
instSubsingletonAddMonoidHom | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZero M] [inst_1 : AddZero N] [Subsingleton M], Subsingleton (M →+ N) | null | true |
ProbabilityTheory.Kernel.parallelComp_self_comp_copy | Mathlib.Probability.Kernel.Deterministic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsDeterministic κ],
(κ.parallelComp κ).comp (ProbabilityTheory.Kernel.copy α) = (ProbabilityTheory.Kernel.copy β).comp κ | null | true |
CategoryTheory.Subobject.mapIsoToOrderIso._proof_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y), CategoryTheory.Mono e.hom | null | false |
Std.ExtDTreeMap.le_maxKey?_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k km : α} (hc : k ∈ t), t.maxKey?.get ⋯ = km → (cmp k km).isLE = true | null | true |
selfAdjoint.val_mul | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x * y) = ↑x * ↑y | null | true |
MvPolynomial.eval_eq' | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : Fintype σ] (X : σ → R) (f : MvPolynomial σ R),
(MvPolynomial.eval X) f = ∑ d ∈ f.support, f.coeff d * ∏ i, X i ^ d i | null | true |
Algebra.TensorProduct.basisAux_map_smul | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (a : A)
(x : TensorProduct R A M), (Algebra.TensorProduct.basisAux A b) (a • x) = a • (Algebra.TensorProduct.basi... | null | true |
IsAlgClosed.mk | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k], (∀ (p : Polynomial k), p.Splits) → IsAlgClosed k | null | true |
Monoid.Coprod.instGroup._proof_3 | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] (n : ℕ) (a : Monoid.Coprod G H),
a ^ ↑n.succ = a ^ ↑n * a | null | false |
Std.Iterators.HetT.property_bind | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type w → Type w'} {α : Type u} {β : Type v} [inst : Monad m] [LawfulMonad m] {x : Std.Iterators.HetT m α}
{f : α → Std.Iterators.HetT m β}, (x.bind f).Property = fun b => ∃ a, x.Property a ∧ (f a).Property b | null | true |
Lean.Name.toStringWithSep | Init.Data.ToString.Name | String → Bool → Lean.Name → (optParam (String → Bool) fun x => false) → String | Uses the separator `sep` (usually `"."`) to combine the components of the `Name` into a string.
See the documentation for `Name.toStringWithToken` for an explanation of `escape` and `isToken`.
| true |
Std.Http.Trailer._sizeOf_1 | Std.Http.Data.Chunk | Std.Http.Trailer → ℕ | null | false |
Quaternion.instDivisionRing._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (x : ℚ) (x_1 : Quaternion R), x • x_1 = ↑x * x_1 | null | false |
iSup_add_le | Mathlib.Order.CompleteLattice.Group | ∀ {α : Type u_1} {ι : Sort u_2} [inst : CompleteLattice α] [inst_1 : Add α] [AddLeftMono α] [AddRightMono α]
(u v : ι → α), ⨆ i, u i + v i ≤ (⨆ i, u i) + ⨆ i, v i | null | true |
Filter.Germ.instRightCancelSemigroup.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : RightCancelSemigroup M],
Filter.Germ.instRightCancelSemigroup = { toSemigroup := Filter.Germ.instSemigroup, toIsRightCancelMul := ⋯ } | null | true |
CategoryTheory.ComposableArrows.map'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Deriv.0.Real.logDeriv_const_rpow._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
ContinuousLinearEquiv.ofBijective_symm_apply_apply | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜'] {σ : 𝕜 →+* 𝕜'}
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {F : Type u_4}
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜' F] {σ' : 𝕜' →+* 𝕜} [inst_6 : RingHomInv... | null | true |
OrderHom.prodₘ | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] → [inst_1 : Preorder β] → [inst_2 : Preorder γ] → (α →o β) →o (α →o γ) →o α →o β × γ | Given two bundled monotone maps `f`, `g`, `f.prod g` is the map `x ↦ (f x, g x)` bundled as a
`OrderHom`. This is a fully bundled version. | true |
Matrix.mem_range_scalar_iff_commute_single' | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_3} {α : Type u_7} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring α] {M : Matrix n n α},
M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), Commute (Matrix.single i j 1) M | `M` is a scalar matrix if and only if it commutes with every `single`. | true |
CategoryTheory.extensiveCoverage.eq_1 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C],
CategoryTheory.extensiveCoverage C =
{
coverings := fun B =>
{S |
∃ α,
∃ (x : Finite α),
∃ X π,
S = CategoryTheory.Presieve.ofArrows X ... | null | true |
ProbabilityTheory.Kernel.densityProcess_mono_set | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)}
{ν : ProbabilityTheory.Kernel α γ},
κ.fst ≤ ν →
∀ (n : ℕ) (a : α) (x : γ) {s s' : Set β}, s ⊆ s' → κ.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.