name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_4 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] (M : Type u_1) [inst_4 : AddCommGroup M]
[inst_5 : Module R M] [inst_6 : LieRingModule L M] [inst_7 : LieModule R L M] {χ₁ χ₂ χ₃ : ↥H → R} (hχ : χ₁ + χ₂ = χ₃)
... | null | false |
Ideal.instMulActionElemPrimesOver._proof_3 | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
{G : Type u_3} [inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] (σ τ : G)
(Q : ↑(p.primesOver B)), (σ * τ) • Q = σ • τ • Q | null | false |
Mathlib.Meta.NormNum.isNat_lt_false | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {a b : α} {a' b' : ℕ},
Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.ble a' = true → ¬a < b | null | true |
WithZero.coe_zpow | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℤ] (a : α) (n : ℤ), ↑(a ^ n) = ↑a ^ n | null | true |
HasFDerivAt.tendsto_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : 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} {x : E},
HasFDerivAt f f' x → (∃ C, AntilipschitzWith C ⇑f') → Filter.Tendsto f ... | null | true |
Lean.Lsp.WorkspaceSymbolParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.WorkspaceSymbolParams} → t = t' → Lean.Lsp.WorkspaceSymbolParams.noConfusionType P t t' | null | false |
AlgebraicGeometry.localRingHom_comp_stalkIso | Mathlib.AlgebraicGeometry.Spec | ∀ {R S : CommRingCat} (f : R ⟶ S) (p : PrimeSpectrum ↑S),
CategoryTheory.CategoryStruct.comp
(CommRingCat.ofHom
(AlgebraicGeometry.StructureSheaf.stalkIso (↑R)
(PrimeSpectrum.comap (CommRingCat.Hom.hom f) p)).symm.toRingEquiv.toRingHom)
(CategoryTheory.CategoryStruct.comp
(... | Under the isomorphisms `stalkIso`, the map `stalkMap (Spec.sheafedSpaceMap f) p` corresponds
to the induced local ring homomorphism `Localization.localRingHom`.
| true |
_private.Mathlib.CategoryTheory.Preadditive.CommGrp_.0.CategoryTheory.Preadditive.instGrpObj._simp_3 | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X : C),
CategoryTheory.SemiCartesianMonoidalCategory.fst X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom | null | false |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun P => ↧↑P.toProfinite.toTop, map := fun {X Y} f => GrpCat.ofHom (ProfiniteGrp.Hom.hom f).toMonoidHom,
map_id :=
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_1,
map_comp :=
@ProfiniteGrp.instHasF... | null | false |
ImportGraph.Lake.instReprBaseWorkspace.repr | ImportGraph.WorkspaceModel.Base | ImportGraph.Lake.BaseWorkspace → ℕ → Std.Format | null | true |
Lean.Elab.Term.LValResolution.const.elim | Lean.Elab.App | {motive : Lean.Elab.Term.LValResolution → Sort u} →
(t : Lean.Elab.Term.LValResolution) →
t.ctorIdx = 2 →
((baseStructName structName constName : Lean.Name) →
(levels : List Lean.Level) →
motive (Lean.Elab.Term.LValResolution.const baseStructName structName constName levels)) →
... | null | false |
Nat.log2 | Init.Data.Nat.Log2 | ℕ → ℕ | Base-two logarithm of natural numbers. Returns `⌊max 0 (log₂ n)⌋`.
This function is overridden at runtime with an efficient implementation. This definition is
the logical model.
Examples:
* `Nat.log2 0 = 0`
* `Nat.log2 1 = 0`
* `Nat.log2 2 = 1`
* `Nat.log2 4 = 2`
* `Nat.log2 7 = 2`
* `Nat.log2 8 = 3`
| true |
MeasureTheory.OuterMeasure.instPartialOrder._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} (x : MeasureTheory.OuterMeasure α) (x_1 : Set α), x x_1 ≤ x x_1 | null | false |
Set.biInter_finsetSigma' | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : Type u_3} (s : Finset ι) (t : (i : ι) → Finset (α i))
(f : (i : ι) → α i → Set β), ⋂ i ∈ s, ⋂ j ∈ t i, f i j = ⋂ ij ∈ s.sigma t, f ij.fst ij.snd | null | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic.0.MeasureTheory.charFun_prod._simp_1_3 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {L : Type u_5} [inst_4 : RCLike L]
(f : α → L) (g : β → L), (∫ (x : α), f x ∂μ) * ∫ (y : β), g y ∂ν = ∫ (z : α × β),... | null | false |
ProfiniteGrp.toFiniteQuotientFunctor.eq_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}),
P.toFiniteQuotientFunctor =
{ obj := fun H => ↧(↑P.toProfinite.toTop ⧸ ↑H.toOpenSubgroup),
map := fun {X Y} fHK =>
FiniteGrp.ofHom
(QuotientGroup.map (↑X.toOpenSubgroup) (↑Y.toOpenSubgroup) (MonoidHom.id ↑P.toProfinite.toTop) ⋯),
map_id := ⋯, map_comp := ⋯... | null | true |
MeasurableSet.inf_eq_inter | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s t : { s // MeasurableSet s }), s ⊓ t = s ∩ t | null | true |
_private.Mathlib.MeasureTheory.Measure.CompleteLattice.0.MeasureTheory.Measure.lt_iff'._simp_1_2 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
Equiv.removeNoneAux | Mathlib.Logic.Equiv.Option | {α : Type u_1} → {β : Type u_2} → Option α ≃ Option β → α → β | If we have a value on one side of an `Equiv` of `Option`
we also have a value on the other side of the equivalence
| true |
essSup_eq_iSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
(∀ (a : α), μ {a} ≠ 0) → ∀ (f : α → β), essSup f μ = ⨆ i, f i | null | true |
_private.Batteries.Data.List.Basic.0.List.dropSliceTR.go.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (m a : ℕ) (a_1 : Array α), List.dropSliceTR.go✝ l m [] a a_1 = l | null | true |
Subgroup.upperCentralSeriesStep.hcongr_4 | Mathlib.GroupTheory.Nilpotent | ∀ (G G' : Type u_1),
G = G' →
∀ (inst : Group G) (inst' : Group G'),
inst ≍ inst' →
∀ (N : Subgroup G) (N' : Subgroup G'),
N ≍ N' →
∀ (inst_1 : N.Normal) (inst'_1 : N'.Normal),
inst_1 ≍ inst'_1 → N.upperCentralSeriesStep ≍ N'.upperCentralSeriesStep | null | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.meromorphicOrderAt_eq_top_iff._simp_1_4 | Mathlib.Analysis.Meromorphic.Order | ∀ {n : ℕ∞} {α : Type u_1} {f : ℕ → α}, (ENat.map f n = ⊤) = (n = ⊤) | null | false |
multiplicity_addValuation._proof_2 | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] {p : R}, Prime p → emultiplicity p 1 = 0 | null | false |
HahnEmbedding.ArchimedeanStrata.isInternal_stratum' | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] (u : HahnEmbedding.ArchimedeanStrata K M),
Di... | null | true |
CategoryTheory.GrothendieckTopology.mem_toCoverage_iff | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {S : CategoryTheory.Presieve X}
(J : CategoryTheory.GrothendieckTopology C), S ∈ J.toCoverage.coverings X ↔ CategoryTheory.Sieve.generate S ∈ J X | null | true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.InnerProductGeometry.sin_angle_eq_sin_angle_add_add_angle_add | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
x ≠ 0 →
y ≠ 0 →
Real.sin (InnerProductGeometry.angle x y) =
Real.sin (InnerProductGeometry.angle x (x + y) + InnerProductGeometry.angle y (y + x)) | The sine of the sum of two angles in a possibly degenerate
triangle (where two given sides are nonzero), vector angle form. | true |
Std.DHashMap.Internal.AssocList.getKey_eq | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : Std.DHashMap.Internal.AssocList α β} {a : α}
{h : Std.DHashMap.Internal.AssocList.contains a l = true},
Std.DHashMap.Internal.AssocList.getKey a l h = Std.Internal.List.getKey a l.toList ⋯ | null | true |
_private.Mathlib.Analysis.SpecificLimits.Fibonacci.0.tendsto_fib_succ_div_fib_atTop._simp_1_6 | Mathlib.Analysis.SpecificLimits.Fibonacci | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.GrothendieckTopology.liftToDiagramLimitObj._proof_1 | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
{X : C} {K : Ty... | null | false |
CartanMatrix.Realisation.mem_weyl | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : CommRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(rl : CartanMatrix.Realisation n R M N) (i : n), (rl.reflection i, rl.coreflection i) ∈ rl.w... | null | true |
ENNReal.measurable_of_tendsto | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : ℕ → α → ENNReal} {g : α → ENNReal},
(∀ (i : ℕ), Measurable (f i)) → Filter.Tendsto f Filter.atTop (nhds g) → Measurable g | A sequential limit of measurable `ℝ≥0∞`-valued functions is measurable. | true |
SSet.stdSimplex.objEquiv_symm_comp | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n n' : SimplexCategory} {m : SimplexCategoryᵒᵖ} (f : Opposite.unop m ⟶ n) (g : n ⟶ n'),
SSet.stdSimplex.objEquiv.symm (CategoryTheory.CategoryStruct.comp f g) =
(CategoryTheory.ConcreteCategory.hom ((SSet.stdSimplex.map g).app m)) (SSet.stdSimplex.objEquiv.symm f) | null | true |
LieModuleHom.instAddCommGroup._proof_3 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] (a : M →ₗ⁅R,L⁆ N), a + 0 = a | null | false |
Quot.map₂._proof_2 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_2} {γ : Sort u_1} {r : α → α → Prop} {t : γ → γ → Prop} (f : α → β → γ),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → t (f a₁ b) (f a₂ b)) →
∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → Quot.mk t (f a₁ b) = Quot.mk t (f a₂ b) | null | false |
CategoryTheory.constant_of_preserves_morphisms' | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsConnected J] {α : Type u₂} (F : J → α),
(∀ (j₁ j₂ : J) (x : j₁ ⟶ j₂), F j₁ = F j₂) → ∃ a, ∀ (j : J), F j = a | If `J` is connected, then given any function `F` such that the presence of a
morphism `j₁ ⟶ j₂` implies `F j₁ = F j₂`, there exists `a` such that `F j = a`
holds for any `j`. See `constant_of_preserves_morphisms` for a different
formulation of the fact that `F` is constant.
This can be thought of as a local-to-global p... | true |
Std.HashSet.get?_union_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | null | true |
Manifold._aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termMDiffAt___1 | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab | `MDiffAt f x` elaborates to `MDifferentiableAt I J f x`,
trying to determine `I` and `J` from the local context.
The argument `x` can be omitted. | false |
IsCyclic.card_mulAut | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (G : Type u_2) [inst : Group G] [Finite G] [h : IsCyclic G], Nat.card (MulAut G) = (Nat.card G).totient | null | true |
_private.Std.Tactic.BVDecide.Normalize.BitVec.0.Std.Tactic.BVDecide.Normalize.BitVec.le_ult._simp_1_1 | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {n : ℕ} {x y : BitVec n}, (x ≤ y) = (x.toNat ≤ y.toNat) | null | false |
Module.Presentation.CokernelData.mk.noConfusion | Mathlib.Algebra.Module.Presentation.Cokernel | {A : Type u} →
{inst : Ring A} →
{M₁ : Type v₁} →
{M₂ : Type v₂} →
{inst_1 : AddCommGroup M₁} →
{inst_2 : Module A M₁} →
{inst_3 : AddCommGroup M₂} →
{inst_4 : Module A M₂} →
{pres₂ : Module.Presentation A M₂} →
{f : M₁ →ₗ[A] M₂} ... | null | false |
Finsupp.subtypeDomain_extendDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_12} [inst : Zero M] {P : α → Prop} [inst_1 : DecidablePred P] (f : Subtype P →₀ M),
Finsupp.subtypeDomain P f.extendDomain = f | null | true |
ContinuousAlternatingMap.bounds_nonempty | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] {f : E [⋀^ι]→L[𝕜] F},
∃ c, c ∈ {c | 0 ≤ c ∧ ∀ (m : ι → E), ‖f m‖ ≤ c * ... | null | true |
ENNReal.instCompleteLinearOrder._aux_1 | Mathlib.Basic.ENNReal.Basic | Set ENNReal → ENNReal | null | false |
_private.Mathlib.Tactic.MinImports.0.Mathlib.Command.MinImports.previousInstName.match_5 | Mathlib.Tactic.MinImports | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((nm init : Lean.Name) → (tail : String) → (h : nm = init.str tail) → motive (namedPattern nm (init.str tail) h)) →
((nm : Lean.Name) → motive nm) → motive x | null | false |
Std.Internal.List.minKey_insertEntryIfNew_le_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k} {he : l.isEmpty = false},
(compare (Std.Internal.List.minKey (Std.Internal.List.insertEntryIfNew k v l) ⋯)
(S... | null | true |
FirstOrder.Language.Structure.noConfusionType | Mathlib.ModelTheory.Basic | Sort u_1 →
{L : FirstOrder.Language} →
{M : Type w} → L.Structure M → {L' : FirstOrder.Language} → {M' : Type w} → L'.Structure M' → Sort u_1 | null | false |
CategoryTheory.Limits.prod.lift' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y : C} →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] →
(f : W ⟶ X) →
(g : W ⟶ Y) →
{ l //
CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.prod.fst = f ∧
CategoryTh... | If the product of `X` and `Y` exists, then every pair of morphisms `f : W ⟶ X` and `g : W ⟶ Y`
induces a morphism `l : W ⟶ X ⨯ Y` satisfying `l ≫ Prod.fst = f` and `l ≫ Prod.snd = g`. | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_9 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (hs : table.size < pat.utf8ByteSize),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun table ht₀ =>
PSigma.casesOn ht₀ fun ht₀ ht =... | null | false |
Subalgebra.prod_toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (S : Subalgebra R A) (S₁ : Subalgebra R B),
Subalgebra.toSubmodule (S.prod S₁) = (Subalgebra.toSubmodule S).prod (Subalgebra.toSubmodule S₁) | null | true |
CategoryTheory.bifunctorComp₁₂ | Mathlib.CategoryTheory.Functor.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{C₁₂ : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_... | Given two bifunctors `F₁₂ : C₁ ⥤ C₂ ⥤ C₁₂` and `G : C₁₂ ⥤ C₃ ⥤ C₄`, this is
the trifunctor `C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` obtained by composition. | true |
Std.Tactic.BVDecide.BVUnOp.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} →
(t : Std.Tactic.BVDecide.BVUnOp) →
motive Std.Tactic.BVDecide.BVUnOp.not →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateLeft n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateRight n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.... | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState.mk | Lean.Elab.DocString | Lean.Doc.State →
Array (Lean.ScopedEnvExtension Lean.EnvExtensionEntry Lean.EnvExtensionEntry Lean.EnvExtensionState) →
Lean.Doc.ModuleDocstringState✝ | null | true |
Monoid.Coprod.mk | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} →
{N : Type u_2} → [inst : MulOneClass M] → [inst_1 : MulOneClass N] → FreeMonoid (M ⊕ N) →* Monoid.Coprod M N | The natural projection `FreeMonoid (M ⊕ N) →* M ∗ N`. | true |
MeasurableSMul₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [SMul M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop | We say that the action of `M` on `α` has `MeasurableSMul₂` if the map
`(c, x) ↦ c • x` is a measurable function. | true |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | null | false |
TensorProduct.instRepr | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Type u_5} →
{N : Type u_6} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → [Repr M] → [Repr N] → Repr (TensorProduct R M N) | Produces an arbitrary representation of the form `mₒ ⊗ₜ n₀ + ...`. | true |
CategoryTheory.ShortComplex.Hom.mk.sizeOf_spec | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : SizeOf C] (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂)
(τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ :
autoParam (CategoryTheory.CategoryStruct.comp τ₁ S₂.f = Catego... | null | true |
Aesop.GoalStats.forwardStateStats | Aesop.Stats.Basic | Aesop.GoalStats → Aesop.ForwardStateStats | null | true |
Polynomial.eval_le_zero_of_roots_le_of_leadingCoeff_nonpos | Mathlib.Analysis.Polynomial.Order | ∀ {P : Polynomial ℝ} {x : ℝ}, (∀ (y : ℝ), P.IsRoot y → y ≤ x) → P.leadingCoeff ≤ 0 → Polynomial.eval x P ≤ 0 | null | true |
LieAlgebra.IsKilling.corootSubmodule._proof_2 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_1} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] {H : LieSubalgebra K L},
AddSubmonoidClass (LieSubmodule K (↥H) L) L | null | false |
ByteArray.size_set | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), (a.set (↑i) v ⋯).size = a.size | null | true |
Homeomorph.instEquivLike._proof_2 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
Function.RightInverse h.invFun h.toFun | null | false |
CompHaus.toStonean | Mathlib.Topology.Category.Stonean.Basic | (X : CompHaus) → [CategoryTheory.Projective X] → Stonean | `Projective` implies `Stonean`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.mk.sizeOf_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} [inst_1 : SizeOf K]
(a b c : NumberField.RingOfIntegers K) (u : (NumberField.RingOfIntegers K)ˣ) (ha : ¬hζ.toInteger - 1 ∣ a)
(hb : ¬hζ.toInteger - 1 ∣ b) (hc : c ≠ 0) (coprime : IsCoprime a b) (hcdvd : hζ.toInteger - 1 ∣ c)
(H : a ^ 3 + b ^ 3 =... | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionHom_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' : C} {d d' : D} (f : c ⟶ c') (g : d ⟶ d'),
CategoryTheory.MonoidalCateg... | null | true |
add_neg' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftMono α], b < c → a < 0 → b + a < c | **Alias** of `Left.add_neg'`.
---
Assumes left covariance.
The lemma assuming right covariance is `Right.add_neg'`. | true |
Complex.arg_cos_add_sin_mul_I | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {θ : ℝ}, θ ∈ Set.Ioc (-Real.pi) Real.pi → (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg = θ | null | true |
biUnion_associatedPrimes_eq_zero_divisors | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsNoetherianRing R], ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r • x = 0} | null | true |
Bundle.Pretrivialization.restrictPreimage'._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {Z : Type u_1} {proj : Z → B} (s : Set B) (z : ↑(proj ⁻¹' s)), ↑z ∈ proj ⁻¹' s | null | false |
CategoryTheory.MorphismProperty.LeftFraction.ofHom.eq_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities],
CategoryTheory.MorphismProperty.LeftFraction.ofHom W f =
{ Y' := Y, f := f, s := CategoryTheory.CategoryStruct.id Y, hs := ⋯ } | null | true |
PositiveLinearMap.instAddCommGroupPreGNS._proof_18 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : PartialOrder A] [inst_2 : Module ℂ A] (f : A →ₚ[ℂ] ℂ),
autoParam (∀ (a b : f.PreGNS), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Set.countable_union | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Countable ↔ s.Countable ∧ t.Countable | null | true |
RootPairing.Equiv.weightEquiv_symm_conj_reflection | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
Std.TreeMap.Raw.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α Unit cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α} {k fallback : α}, k ∈ t → (t.insertManyIfNewUnit l).getKeyD k fallback = t.getKeyD k fallback | null | true |
Orientation.rotation_neg_orientation_eq_neg | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle), (-o).rotation θ = o.rotation (-θ) | Negating the orientation negates the angle in `rotation`. | true |
WithAbs.instSemiring._proof_8 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (a b : WithAbs v), a + b = b + a | null | false |
TopCat.Presheaf.germ | Mathlib.Topology.Sheaves.Stalks | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasColimits C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
(U : TopologicalSpace.Opens ↑X) → (x : ↑X) → x ∈ U → (F.obj (Opposite.op U) ⟶ F.stalk x) | The germ of a section of a presheaf over an open at a point of that open.
| true |
Valuation.RankOne.ofRankLeOneStruct._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] [ValuativeRel.IsNontrivial R],
(ValuativeRel.valuation R).IsNontrivial | null | false |
_private.Mathlib.Algebra.Order.ToIntervalMod.0.QuotientAddGroup.circularPreorder._simp_6 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} [hp' : Fact (0 < p)] {x₁ x₂ x₃ : α}, btw ↑x₁ ↑x₂ ↑x₃ = (toIcoMod ⋯ x₁ x₂ ≤ toIocMod ⋯ x₁ x₃) | null | false |
Int.sub_le_sub_left_iff | Init.Data.Int.Order | ∀ {a b c : ℤ}, c - a ≤ c - b ↔ b ≤ a | null | true |
CompositionAsSet.toComposition_length | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.toComposition.length = c.length | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Factorization.0.IsDedekindDomain.exists_add_spanSingleton_mul_eq._simp_1_7 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x : R), (FractionalIdeal.spanSingleton S) ((algebraMap R P) x) = ↑(Ideal.span {x}) | null | false |
Std.DHashMap.Internal.Raw₀.Const.insertListₘ._sunfold | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : Type v} →
[BEq α] →
[Hashable α] → (Std.DHashMap.Internal.Raw₀ α fun x => β) → List (α × β) → Std.DHashMap.Internal.Raw₀ α fun x => β | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.hcdvd | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3}
(self : FermatLastTheoremForThreeGen.Solution'✝ hζ), hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution'.c✝ self | null | true |
DivisibleHull.nsmul_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] (a : ℕ) (m : M) (s : ℕ+),
a • DivisibleHull.mk m s = DivisibleHull.mk (a • m) s | null | true |
CategoryTheory.PreservesFiniteLimitsOfFlat.uniq | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type v₁} [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
(F : CategoryTheory.Functor C D) [CategoryTheory.RepresentablyFlat F] {K : CategoryTheory.Functor J C}
{c :... | null | true |
CategoryTheory.Limits.Cocone.whisker_ι | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
(E : CategoryTheory.Functor K J) (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.Cocone.... | null | true |
Lean.Syntax.decodeStrLitAux._unsafe_rec | Init.Meta.Defs | String → String.Pos.Raw → String → Option String | null | false |
ProbabilityTheory.IsRatCondKernelCDFAux.isRatCondKernelCDF | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β} {f : α × β → ℚ → ℝ},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel ν],
Pr... | null | true |
LocallyConstant.piecewise._proof_3 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {C₁ C₂ : Set X}, ∀ x ∈ C₁ ∩ C₂, x ∈ C₂ | null | false |
_private.Aesop.BuiltinRules.0.Aesop.BuiltinRules.pEmpty_false.match_1_1 | Aesop.BuiltinRules | ∀ (motive : PEmpty.{u_1} → Prop) (h : PEmpty.{u_1}), motive h | null | false |
instCompleteLinearOrderENat._proof_6 | Mathlib.Data.ENat.Lattice | ∀ (s : Set ℕ∞), IsGLB s (sInf s) | null | false |
Std.Time.Millisecond.instLawfulEqOrdOffset | Std.Time.Time.Unit.Millisecond | Std.LawfulEqOrd Std.Time.Millisecond.Offset | null | true |
Lean.LocalDecl.replaceFVarId | Lean.LocalContext | Lean.FVarId → Lean.Expr → Lean.LocalDecl → Lean.LocalDecl | null | true |
MeasureTheory.JordanDecomposition.instSMul._proof_4 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (r : NNReal) (j : MeasureTheory.JordanDecomposition α),
(↑r • j.posPart).MutuallySingular (r • j.negPart) | null | false |
RBTree.RBSet.mergeWith | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → (α → α → α) → RBTree.RBSet α cmp → RBTree.RBSet α cmp → RBTree.RBSet α cmp | `O(n₂ * log (n₁ + n₂))`. Merges the maps `t₁` and `t₂`. If equal keys exist in both,
then use `mergeFn a₁ a₂` to produce the new merged value.
| true |
SaturatedAddSubmonoid._sizeOf_1 | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → {inst : AddZeroClass M} → [SizeOf M] → SaturatedAddSubmonoid M → ℕ | null | false |
FirstOrder.Language.Term.restrictVar | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → [inst : DecidableEq α] → (t : L.Term α) → (↥t.varFinset → β) → L.Term β | Restricts a term to use only a set of the given variables. | true |
ENNReal.nnreal_smul_lt_top_iff | Mathlib.Basic.ENNReal.Action | ∀ {x : NNReal} {y : ENNReal}, x ≠ 0 → (x • y < ⊤ ↔ y < ⊤) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.