name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.MonoidalCategory.MonoidalRightAction.action_exchange | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {w x : D} {y z : C} (f : w ⟶ x) (g : y ⟶ z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight w g)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f z) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f y)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight x g) |
PartOrdEmb.Hom.noConfusion | Mathlib.Order.Category.PartOrdEmb | {P : Sort u_1} →
{X Y : PartOrdEmb} →
{t : X.Hom Y} →
{X' Y' : PartOrdEmb} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → PartOrdEmb.Hom.noConfusionType P t t' |
LinearMap.eq_adjoint_iff_basis_left | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : FiniteDimensional 𝕜 E] [inst_6 : FiniteDimensional 𝕜 F] {ι : Type u_5} (b : Module.Basis ι 𝕜 E)
(A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E),
A = LinearMap.adjoint B ↔ ∀ (i : ι) (y : F), inner 𝕜 (A (b i)) y = inner 𝕜 (b i) (B y) |
AlgebraicGeometry.Scheme.IdealSheafData.instIsPreimmersionSubschemeι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData), AlgebraicGeometry.IsPreimmersion I.subschemeι |
Unitization.instCStarAlgebra | Mathlib.Analysis.CStarAlgebra.Unitization | {A : Type u_3} → [NonUnitalCStarAlgebra A] → CStarAlgebra (Unitization ℂ A) |
CategoryTheory.Pretriangulated.id_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ |
_private.Init.Data.Range.Polymorphic.UInt.0.USize.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) |
ZFSet.coeEquiv._proof_3 | Mathlib.SetTheory.ZFC.Class | Function.Injective fun x => ⟨↑x, ⋯⟩ |
PrimeSpectrum.BasicConstructibleSetData.map.eq_1 | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (φ : R →+* S)
(C : PrimeSpectrum.BasicConstructibleSetData R),
PrimeSpectrum.BasicConstructibleSetData.map φ C = { f := φ C.f, n := C.n, g := ⇑φ ∘ C.g } |
Lean.Meta.Match.Example.var.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : Lean.FVarId), (Lean.Meta.Match.Example.var a = Lean.Meta.Match.Example.var a_1) = (a = a_1) |
CategoryTheory.TransfiniteCompositionOfShape.iic._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : OrderBot J] (j : J), ⊥ ≤ j |
Std.Internal.UV.TCP.Socket.cancelAccept | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Unit |
Matroid.IsRkFinite.indep_of_encard_le_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.IsRkFinite I → I.encard ≤ M.eRk I → M.Indep I |
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χ : χ₁ + χ₂ = χ₃)
(t : R) (x : ↥(LieAlgebra.rootSpace H χ₁)),
{ toFun := fun m => ⟨⁅↑(t • x), ↑m⁆, ⋯⟩, map_add' := ⋯, map_smul' := ⋯ } =
(RingHom.id R) t • { toFun := fun m => ⟨⁅↑x, ↑m⁆, ⋯⟩, map_add' := ⋯, map_smul' := ⋯ } |
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 |
Lean.IR.EmitC.emitCtorScalarSize | Lean.Compiler.IR.EmitC | ℕ → ℕ → Lean.IR.EmitC.M Unit |
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 |
WithZero.coe_zpow | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℤ] (a : α) (n : ℤ), ↑(a ^ n) = ↑a ^ n |
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 (nhdsWithin x {x}ᶜ) (nhdsWithin (f x) {f x}ᶜ) |
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' |
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
(CommRingCat.ofHom
(Localization.localRingHom (PrimeSpectrum.comap (CommRingCat.Hom.hom f) p).asIdeal p.asIdeal
(CommRingCat.Hom.hom f) ⋯))
(CommRingCat.ofHom (AlgebraicGeometry.StructureSheaf.stalkIso (↑S) p).toRingEquiv.toRingHom)) =
AlgebraicGeometry.PresheafedSpace.Hom.stalkMap (AlgebraicGeometry.Spec.sheafedSpaceMap f).hom p |
_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 |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun P => GrpCat.of ↑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.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_2 }.comp
(CategoryTheory.forget GrpCat) =
CategoryTheory.forget ProfiniteGrp.{u_1} |
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) →
motive (Lean.Elab.Term.LValResolution.const baseStructName structName constName)) →
motive t |
Nat.log2 | Init.Data.Nat.Log2 | ℕ → ℕ |
MeasureTheory.OuterMeasure.instPartialOrder._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} (x : MeasureTheory.OuterMeasure α) (x_1 : Set α), x x_1 ≤ x x_1 |
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 |
_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 : α × β), f z.1 * g z.2 ∂μ.prod ν |
MeasurableSet.inf_eq_inter | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s t : { s // MeasurableSet s }), s ⊓ t = s ∩ t |
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 |
_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 = ⊤) |
multiplicity_addValuation._proof_2 | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] {p : R}, Prime p → emultiplicity p 1 = 0 |
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),
DirectSum.IsInternal u.stratum' |
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 |
_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)) |
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 ⋯ |
_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 |
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 : Type u_5} [inst_3 : CategoryTheory.SmallCategory K] [inst_4 : CategoryTheory.Limits.HasLimitsOfShape K D]
{W : (J.Cover X)ᵒᵖ} (F : CategoryTheory.Functor K (CategoryTheory.Functor Cᵒᵖ D))
(E :
CategoryTheory.Limits.Cone
(F.comp ((J.diagramFunctor D X).comp ((CategoryTheory.evaluation (J.Cover X)ᵒᵖ D).obj W))))
(b : (Opposite.unop W).shape.R),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GrothendieckTopology.liftToDiagramLimitObjAux F E ((Opposite.unop W).shape.fst b))
(((Opposite.unop W).index (CategoryTheory.Limits.limit F)).fst b) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GrothendieckTopology.liftToDiagramLimitObjAux F E ((Opposite.unop W).shape.snd b))
(((Opposite.unop W).index (CategoryTheory.Limits.limit F)).snd b) |
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 |
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) =
(SSet.stdSimplex.map g).app m (SSet.stdSimplex.objEquiv.symm f) |
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) |
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 |
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 |
Manifold._aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termMDiffAt___1 | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab |
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 |
_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) |
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₂} →
{ι : Type w₁} →
{g₁ : ι → M₁} →
{P : Sort u_1} →
{lift : ι → pres₂.G →₀ A} →
{π_lift : ∀ (i : ι), pres₂.π (lift i) = f (g₁ i)} →
{lift' : ι → pres₂.G →₀ A} →
{π_lift' : ∀ (i : ι), pres₂.π (lift' i) = f (g₁ i)} →
{ lift := lift, π_lift := π_lift } = { lift := lift', π_lift := π_lift' } →
(lift ≍ lift' → P) → P |
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 |
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 * ∏ i, ‖m i‖} |
_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 |
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) ⋯)
(Std.Internal.List.minKey l he)).isLE =
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 |
CategoryTheory.Limits.prod.lift' | Mathlib.CategoryTheory.Limits.Shapes.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 ∧
CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.prod.snd = g } |
_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 => PSigma.casesOn ht fun ht h => pat.utf8ByteSize - table.size)
⟨table.push
↑(String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat
(pat.getUTF8Byte { byteIdx := table.size } hs) table ht h table[table.size - 1] ⋯),
⟨⋯, ⟨⋯, ⋯⟩⟩⟩
⟨table, ⟨ht₀, ⟨ht, h⟩⟩⟩ |
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₁) |
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_3 : CategoryTheory.Category.{v_4, u_4} C₄] →
[inst_4 : CategoryTheory.Category.{v_5, u_5} C₁₂] →
CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂) →
CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄) →
CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄)) |
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.BVUnOp.arithShiftRightConst n)) →
motive Std.Tactic.BVDecide.BVUnOp.reverse → motive Std.Tactic.BVDecide.BVUnOp.clz → motive t |
_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✝ |
Tree._sizeOf_inst | Mathlib.Data.Tree.Basic | (α : Type u) → [SizeOf α] → SizeOf (Tree α) |
_private.Mathlib.Data.Real.ConjExponents.0.ENNReal.HolderTriple.toNNReal_iff._simp_1_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, p.HolderTriple q r = (↑p).HolderTriple ↑q ↑r |
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 |
MeasurableSMul₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [SMul M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax |
TensorProduct.instRepr | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Type u_7} →
{N : Type u_8} →
[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) |
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 = CategoryTheory.CategoryStruct.comp S₁.f τ₂)
CategoryTheory.ShortComplex.Hom.comm₁₂._autoParam)
(comm₂₃ :
autoParam (CategoryTheory.CategoryStruct.comp τ₂ S₂.g = CategoryTheory.CategoryStruct.comp S₁.g τ₃)
CategoryTheory.ShortComplex.Hom.comm₂₃._autoParam),
sizeOf { τ₁ := τ₁, τ₂ := τ₂, τ₃ := τ₃, comm₁₂ := comm₁₂, comm₂₃ := comm₂₃ } =
1 + sizeOf τ₁ + sizeOf τ₂ + sizeOf τ₃ + sizeOf comm₁₂ + sizeOf comm₂₃ |
Aesop.GoalStats.forwardStateStats | Aesop.Stats.Basic | Aesop.GoalStats → Aesop.ForwardStateStats |
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 |
ByteArray.size_set | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), (a.set (↑i) v ⋯).size = a.size |
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 |
CompHaus.toStonean | Mathlib.Topology.Category.Stonean.Basic | (X : CompHaus) → [CategoryTheory.Projective X] → Stonean |
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.MonoidalCategory.MonoidalLeftActionStruct.actionHom f.op g.op =
Opposite.op (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom f g) |
add_neg' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftMono α] {a b : α}, a < 0 → b < 0 → a + b < 0 |
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 = θ |
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} |
CategoryTheory.Mon_Class.ofRepresentableBy_yonedaMonObjRepresentableBy | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.MonObj M],
CategoryTheory.MonObj.ofRepresentableBy M (CategoryTheory.yonedaMonObj M)
(CategoryTheory.yonedaMonObjRepresentableBy M) =
inst_2 |
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 |
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 := ⋯ } |
Set.countable_union | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Countable ↔ s.Countable ∧ t.Countable |
Int.Linear.cooper_right_split_dvd_cert | Init.Data.Int.Linear | Int.Linear.Poly → Int.Linear.Poly → ℤ → ℤ → Bool |
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 |
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 (-θ) |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.match_1.splitter | Lean.Meta.Tactic.AC.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → (Unit → motive none) → ((inst : Lean.Expr) → motive (some inst)) → motive __do_lift |
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) |
Valuation.RankOne.ofRankLeOneStruct._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] [ValuativeRel.IsNontrivial R],
(ValuativeRel.valuation R).IsNontrivial |
_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₃) |
Int.sub_le_sub_left_iff | Init.Data.Int.Order | ∀ {a b c : ℤ}, c - a ≤ c - b ↔ b ≤ a |
CompositionAsSet.toComposition_length | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.toComposition.length = c.length |
_private.Mathlib.RingTheory.DedekindDomain.Factorization.0.IsDedekindDomain.exists_add_spanSingleton_mul_eq._simp_1_7 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (x : ↥(nonZeroDivisors M₀)), (↑x = 0) = 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 => β |
StarAlgEquiv.symm_to_ringEquiv | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A] [inst_3 : Mul B]
[inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] (e : A ≃⋆ₐ[R] B), ↑e.symm = (↑e).symm |
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 |
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 : CategoryTheory.Limits.Cone K} (hc : CategoryTheory.Limits.IsLimit c) (s : CategoryTheory.Limits.Cone (K.comp F))
(f₁ f₂ : s.pt ⟶ F.obj c.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp f₁ ((F.mapCone c).π.app j) = s.π.app j) →
(∀ (j : J), CategoryTheory.CategoryStruct.comp f₂ ((F.mapCone c).π.app j) = s.π.app j) → f₁ = f₂ |
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.whisker E c).ι = E.whiskerLeft c.ι |
Lean.Syntax.decodeStrLitAux._unsafe_rec | Init.Meta.Defs | String → String.Pos.Raw → String → Option String |
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 ν],
ProbabilityTheory.IsRatCondKernelCDF f κ ν |
LocallyConstant.piecewise._proof_3 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {C₁ C₂ : Set X}, ∀ x ∈ C₁ ∩ C₂, x ∈ C₂ |
_private.Aesop.BuiltinRules.0.Aesop.BuiltinRules.pEmpty_false.match_1_1 | Aesop.BuiltinRules | ∀ (motive : PEmpty.{u_1} → Prop) (h : PEmpty.{u_1}), motive h |
Std.Time.Millisecond.instLawfulEqOrdOffset | Std.Time.Time.Unit.Millisecond | Std.LawfulEqOrd Std.Time.Millisecond.Offset |
Lean.LocalDecl.replaceFVarId | Lean.LocalContext | Lean.FVarId → Lean.Expr → Lean.LocalDecl → Lean.LocalDecl |
MeasureTheory.JordanDecomposition.instSMul._proof_4 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | IsScalarTower ENNReal ENNReal ENNReal |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.