name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Bundle.Trivialization.prod.eq_1 | Mathlib.Topology.VectorBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_2} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_3}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_5} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization F₁ Bundle.TotalSpace.proj) (e₂ : Bundle.Trivialization F₂ Bundle.TotalSpace.proj)
[inst_5 : (x : B) → Zero (E₁ x)] [inst_6 : (x : B) → Zero (E₂ x)],
e₁.prod e₂ =
{ toFun := Bundle.Trivialization.Prod.toFun' e₁ e₂, invFun := Bundle.Trivialization.Prod.invFun' e₁ e₂,
source := Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet), target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ,
map_source' := ⋯, map_target' := ⋯, left_inv' := ⋯, right_inv' := ⋯, open_source := ⋯, open_target := ⋯,
continuousOn_toFun := ⋯, continuousOn_invFun := ⋯, baseSet := e₁.baseSet ∩ e₂.baseSet, open_baseSet := ⋯,
source_eq := ⋯, target_eq := ⋯, proj_toFun := ⋯ } |
CategoryTheory.Comma.mapLeftComp_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ L₃ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂) (l' : L₂ ⟶ L₃) (X : CategoryTheory.Comma L₃ R),
((CategoryTheory.Comma.mapLeftComp R l l').hom.app X).right = CategoryTheory.CategoryStruct.id X.right |
HNNExtension.NormalWord.instMulAction | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} → {d : HNNExtension.NormalWord.TransversalPair G A B} → MulAction G (HNNExtension.NormalWord d) |
CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair F).hom.app x =
match x with
| CategoryTheory.Limits.WalkingReflexivePair.zero =>
CategoryTheory.CategoryStruct.id (F.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
| CategoryTheory.Limits.WalkingReflexivePair.one =>
CategoryTheory.CategoryStruct.id (F.obj CategoryTheory.Limits.WalkingReflexivePair.one) |
Topology.IsEmbedding.prodMap | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
Topology.IsEmbedding f → Topology.IsEmbedding g → Topology.IsEmbedding (Prod.map f g) |
Std.DTreeMap.Internal.Impl.maxEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Internal.Impl α β) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf)) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(h : r = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r_1) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v l
(namedPattern r (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r_1) h))) →
motive x |
HasFDerivWithinAt.const_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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} {s : Set E},
HasFDerivWithinAt f f' s x → ∀ (c : F), HasFDerivWithinAt (fun x => c - f x) (-f') s x |
Std.DHashMap.Raw.Equiv.size_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.size = m₂.size |
CoxeterSystem.mk.noConfusion | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{M : CoxeterMatrix B} →
{W : Type u_2} →
{inst : Group W} →
{P : Sort u} →
{mulEquiv mulEquiv' : W ≃* M.Group} →
{ mulEquiv := mulEquiv } = { mulEquiv := mulEquiv' } → (mulEquiv ≍ mulEquiv' → P) → P |
Submonoid.isScalarTower | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MulOneClass M'] [inst_1 : SMul α β] [inst_2 : SMul M' α]
[inst_3 : SMul M' β] [IsScalarTower M' α β] (S : Submonoid M'), IsScalarTower (↥S) α β |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a) (b : ℕ) (b_1 : BitVec b),
¬a = b → { n := a, value := a_1 } = { n := b, value := b_1 } → False |
Lean.Lsp.DeleteFile.Options.ignoreIfNotExists | Lean.Data.Lsp.Basic | Lean.Lsp.DeleteFile.Options → Bool |
LieAlgebra.IsEngelian._proof_2 | Mathlib.Algebra.Lie.Engel | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M |
Rat.mk'_pow._proof_2 | Mathlib.Data.Rat.Defs | ∀ (den : ℕ), den ≠ 0 → ∀ (n : ℕ), den ^ n ≠ 0 |
_private.Mathlib.Algebra.Lie.OfAssociative.0.termφ | Mathlib.Algebra.Lie.OfAssociative | Lean.ParserDescr |
List.pmap.eq_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (x_2 : ∀ a ∈ [], P a), List.pmap f [] x_2 = [] |
Int64.instLawfulOrderOrd | Init.Data.Ord.SInt | Std.LawfulOrderOrd Int64 |
EuclideanGeometry.Sphere.orthRadius_eq_orthRadius_iff._simp_1 | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p q : P}, (s.orthRadius p = s.orthRadius q) = (p = q) |
Lean.Meta.SizeOfSpecNested.Context.recOn | Lean.Meta.SizeOf | {motive : Lean.Meta.SizeOfSpecNested.Context → Sort u} →
(t : Lean.Meta.SizeOfSpecNested.Context) →
((indInfo : Lean.InductiveVal) →
(sizeOfFns : Array Lean.Name) →
(ctorName : Lean.Name) →
(params localInsts : Array Lean.Expr) →
(recMap : Lean.NameMap Lean.Name) →
motive
{ indInfo := indInfo, sizeOfFns := sizeOfFns, ctorName := ctorName, params := params,
localInsts := localInsts, recMap := recMap }) →
motive t |
Lean.Grind.CommRing.Poly.denote_insert | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (m : Lean.Grind.CommRing.Mon)
(p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.insert k m p) =
↑k * Lean.Grind.CommRing.Mon.denote ctx m + Lean.Grind.CommRing.Poly.denote ctx p |
DyckStep.D | Mathlib.Combinatorics.Enumerative.DyckWord | DyckStep |
ProbabilityTheory.gaussianPDF_def | Mathlib.Probability.Distributions.Gaussian.Real | ∀ (μ : ℝ) (v : NNReal),
ProbabilityTheory.gaussianPDF μ v = fun x => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x) |
ContinuousOn.strictAntiOn_of_injOn_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b → f b ≤ f a → ContinuousOn f (Set.Icc a b) → Set.InjOn f (Set.Icc a b) → StrictAntiOn f (Set.Icc a b) |
Ideal.idealProdEquiv.match_1 | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (motive : Ideal R × Ideal S → Prop)
(x : Ideal R × Ideal S), (∀ (I : Ideal R) (J : Ideal S), motive (I, J)) → motive x |
Mathlib.Tactic.Abel.abelNFConv | Mathlib.Tactic.Abel | Lean.ParserDescr |
_private.Lean.CoreM.0.Lean.Core.wrapAsync.match_3 | Lean.CoreM | (motive : Lean.NameGenerator × Lean.NameGenerator → Sort u_1) →
(x : Lean.NameGenerator × Lean.NameGenerator) →
((childNGen parentNGen : Lean.NameGenerator) → motive (childNGen, parentNGen)) → motive x |
CategoryTheory.CatCenter.smul_iso_hom_eq | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (z : (CategoryTheory.CatCenter C)ˣ) {X Y : C} (f : X ≅ Y),
(z • f).hom = CategoryTheory.CategoryStruct.comp f.hom ((↑z).app Y) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
-2 ^ (w + 1) ≤ 2 * x.toInt →
2 * x.toInt < 2 ^ (w + 1) →
-2 ^ (w + 1) ≤ 2 * y.toInt →
2 * y.toInt < 2 ^ (w + 1) →
(-2 ^ (w + 1) ≤ x.toInt - y.toInt →
x.toInt - y.toInt < 2 ^ (w + 1) →
((x.toInt - y.toInt).bmod (2 ^ (w + 1)) < 0 ↔
-(2 ^ (w + 1) / 2) ≤ x.toInt - y.toInt ∧ x.toInt - y.toInt < 0 ∨
(2 ^ (w + 1) + 1) / 2 ≤ x.toInt - y.toInt)) →
0 ≤ x.toInt ∧ y.toInt < 0 ∧ (x.toInt - y.toInt).bmod (2 ^ (w + 1)) < 0 → ¬2 ^ w ≤ x.toInt - y.toInt → False |
Int.Linear.Expr.var.injEq | Init.Data.Int.Linear | ∀ (i i_1 : Int.Linear.Var), (Int.Linear.Expr.var i = Int.Linear.Expr.var i_1) = (i = i_1) |
CategoryTheory.Abelian.comp_epiDesc | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[inst_2 : CategoryTheory.Epi f] {T : C} (g : X ⟶ T)
(hg : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) g = 0),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Abelian.epiDesc f g hg) = g |
Algebra.intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | (A : Type u_1) →
(K : Type u_2) →
(L : Type u_3) →
(B : Type u_6) →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Field K] →
[inst_4 : Field L] →
[inst_5 : Algebra A K] →
[IsFractionRing A K] →
[inst_7 : Algebra K L] →
[inst_8 : Algebra A L] →
[IsScalarTower A K L] →
[inst_10 : Algebra B L] →
[IsScalarTower A B L] →
[IsIntegralClosure B A L] → [FiniteDimensional K L] → [IsIntegrallyClosed A] → B →ₗ[A] A |
LinearEquiv.isUnit_det' | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f : M ≃ₗ[A] M),
IsUnit (LinearMap.det ↑f) |
BoxIntegral.Prepartition.filter | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → BoxIntegral.Prepartition I → (BoxIntegral.Box ι → Prop) → BoxIntegral.Prepartition I |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
↑(2 ^ w) ≤ x.toInt - y.toInt → ¬-(↑(2 ^ (w + 1)) / 2) ≤ x.toInt - y.toInt - ↑(2 ^ (w + 1)) → False |
bddAbove_iff_exists_ge | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeSup γ] {s : Set γ} (x₀ : γ), BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x |
PowerSeries.derivativeFun | Mathlib.RingTheory.PowerSeries.Derivative | {R : Type u_1} → [CommSemiring R] → PowerSeries R → PowerSeries R |
Std.LinearOrderPackage.ctorIdx | Init.Data.Order.PackageFactories | {α : Type u} → Std.LinearOrderPackage α → ℕ |
CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g] {Z_1 : C}
(h : Opposite.unop (CategoryTheory.Limits.pullback f.op g.op) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f.op g.op).unop h |
EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_3} {P : Type u_4} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → p₂ ∈ s → p₁ ≠ p₂ → dist p₁ p₂ / (EuclideanGeometry.oangle p₂ p₁ s.center).cos = 2 * s.radius |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C (CategoryTheory.Mon D)} (α : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one { app := fun X_1 => (α.app X_1).hom, naturality := ⋯ } =
CategoryTheory.MonObj.one |
FreeAddMagma | Mathlib.Algebra.Free | Type u → Type u |
CategoryTheory.PreOneHypercover.sieve₁_inter | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] {i j : E.I₀ × F.I₀} {W : C}
{p₁ : W ⟶ CategoryTheory.Limits.pullback (E.f i.1) (F.f i.2)}
{p₂ : W ⟶ CategoryTheory.Limits.pullback (E.f j.1) (F.f j.2)},
CategoryTheory.CategoryStruct.comp p₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (E.f i.1) (F.f i.2)) (E.f i.1)) =
CategoryTheory.CategoryStruct.comp p₂
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (E.f j.1) (F.f j.2)) (E.f j.1)) →
(E.inter F).sieve₁ p₁ p₂ =
CategoryTheory.Sieve.bind
(E.sieve₁ (CategoryTheory.CategoryStruct.comp p₁ (CategoryTheory.Limits.pullback.fst (E.f i.1) (F.f i.2)))
(CategoryTheory.CategoryStruct.comp p₂ (CategoryTheory.Limits.pullback.fst (E.f j.1) (F.f j.2)))).arrows
fun x f x_1 =>
CategoryTheory.Sieve.pullback f
(F.sieve₁ (CategoryTheory.CategoryStruct.comp p₁ (CategoryTheory.Limits.pullback.snd (E.f i.1) (F.f i.2)))
(CategoryTheory.CategoryStruct.comp p₂ (CategoryTheory.Limits.pullback.snd (E.f j.1) (F.f j.2)))) |
Module.Basis.mk._proof_1 | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) |
_private.Lean.Meta.Tactic.Grind.Ctor.0.Lean.Meta.Grind.propagateCtorHetero._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Ctor | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
iInf_ite | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (p : ι → Prop) [inst_1 : DecidablePred p] (f g : ι → α),
(⨅ i, if p i then f i else g i) = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), g i |
CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R), CategoryTheory.IsCofilteredOrEmpty D |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore_length._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True |
ProbabilityTheory.geometricPMFReal | Mathlib.Probability.Distributions.Geometric | ℝ → ℕ → ℝ |
continuousAt_jacobiTheta₂ | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z : ℂ) {τ : ℂ}, 0 < τ.im → ContinuousAt (fun p => jacobiTheta₂ p.1 p.2) (z, τ) |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (x x_1 : (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ)
(x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl F).op.comp CategoryTheory.coyoneda).map x_2)
(match x_1 with
| Opposite.op { obj := A, pt := a, isGalois := isGalois } =>
{ app := fun X f => (CategoryTheory.ConcreteCategory.hom (F.map f)) a, naturality := ⋯ }) =
CategoryTheory.CategoryStruct.comp
(match x with
| Opposite.op { obj := A, pt := a, isGalois := isGalois } =>
{ app := fun X f => (CategoryTheory.ConcreteCategory.hom (F.map f)) a, naturality := ⋯ })
(((CategoryTheory.Functor.const (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ).obj
(F.comp FintypeCat.incl)).map
x_2) |
ComplexShape.down.congr_simp | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : Add α] [inst_1 : IsRightCancelAdd α] [inst_2 : One α],
ComplexShape.down α = ComplexShape.down α |
Array.back_scanl? | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {f : β → α → β} {as : Array α},
(Array.scanl f init as).back? = some (Array.foldl f init as) |
LieDerivation.mk.injEq | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(toLinearMap : L →ₗ[R] M) (leibniz' : ∀ (a b : L), toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, toLinearMap a⁆)
(toLinearMap_1 : L →ₗ[R] M)
(leibniz'_1 : ∀ (a b : L), toLinearMap_1 ⁅a, b⁆ = ⁅a, toLinearMap_1 b⁆ - ⁅b, toLinearMap_1 a⁆),
({ toLinearMap := toLinearMap, leibniz' := leibniz' } = { toLinearMap := toLinearMap_1, leibniz' := leibniz'_1 }) =
(toLinearMap = toLinearMap_1) |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) |
Lean.Meta.LazyDiscrTree.Key.fvar.injEq | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.FVarId) (a_1 : ℕ) (a_2 : Lean.FVarId) (a_3 : ℕ),
(Lean.Meta.LazyDiscrTree.Key.fvar a a_1 = Lean.Meta.LazyDiscrTree.Key.fvar a_2 a_3) = (a = a_2 ∧ a_1 = a_3) |
CategoryTheory.Limits.Fork.IsLimit.lift' | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{s : CategoryTheory.Limits.Fork f g} →
CategoryTheory.Limits.IsLimit s →
{W : C} →
(k : W ⟶ X) →
CategoryTheory.CategoryStruct.comp k f = CategoryTheory.CategoryStruct.comp k g →
{ l // CategoryTheory.CategoryStruct.comp l s.ι = k } |
Polynomial.eval_mul_X_pow | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R} {k : ℕ},
Polynomial.eval x (p * Polynomial.X ^ k) = Polynomial.eval x p * x ^ k |
_private.Mathlib.Analysis.Calculus.Taylor.0.hasDerivAt_taylorWithinEval_succ._simp_1_6 | Mathlib.Analysis.Calculus.Taylor | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
Std.HashMap.get?_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, k ∉ m₁ → (m₁ ∪ m₂).get? k = m₂.get? k |
WeierstrassCurve.Projective.Nonsingular | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → Prop |
MeasurableSpace.DynkinSystem.mk.sizeOf_spec | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_4} [inst : SizeOf α] (Has : Set α → Prop) (has_empty : Has ∅) (has_compl : ∀ {a : Set α}, Has a → Has aᶜ)
(has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Function.onFun Disjoint f) → (∀ (i : ℕ), Has (f i)) → Has (⋃ i, f i)),
sizeOf { Has := Has, has_empty := has_empty, has_compl := has_compl, has_iUnion_nat := has_iUnion_nat } =
1 + sizeOf has_empty |
RCLike.I_to_real | Mathlib.Analysis.RCLike.Basic | RCLike.I = 0 |
IsAddRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsCancelAdd R] (g : R), IsAddRegular g |
Int64.toISize_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int64.ofNat n).toISize = ISize.ofNat n |
AffineMap.instAddCommGroup._proof_4 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] (x : P1 →ᵃ[k] V2)
(x_1 : ℕ), ⇑(x_1 • x) = x_1 • ⇑x |
MeasureTheory.AEEqFun.instMonoid | Mathlib.MeasureTheory.Function.AEEqFun | {α : Type u_1} →
{γ : Type u_3} →
[inst : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_1 : TopologicalSpace γ] → [inst_2 : Monoid γ] → [ContinuousMul γ] → Monoid (α →ₘ[μ] γ) |
CommRingCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(s : CategoryTheory.Limits.Cocone F) → CommRingCat.Colimits.Prequotient F → ↑s.pt |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
l'.size ≤ d.size → d.size ≤ l'.size + 1 → ¬d.size + 1 + r'.size ≤ l'.size + 1 + r'.size + 1 → False |
ENat.iInf_toNat | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} {f : ι → ℕ}, (⨅ i, ↑(f i)).toNat = ⨅ i, f i |
Int.ModEq.mul_left | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (c : ℤ), a ≡ b [ZMOD n] → c * a ≡ c * b [ZMOD n] |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_three._simp_1_3 | Init.Data.ByteArray.Lemmas | ∀ {l l' : List UInt8}, l.toByteArray ++ l'.toByteArray = (l ++ l').toByteArray |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.toExpr.go._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr |
CategoryTheory.TwoSquare.mk | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
(T : CategoryTheory.Functor C₁ C₂) →
(L : CategoryTheory.Functor C₁ C₃) →
(R : CategoryTheory.Functor C₂ C₄) →
(B : CategoryTheory.Functor C₃ C₄) → (T.comp R ⟶ L.comp B) → CategoryTheory.TwoSquare T L R B |
Kronecker.«_aux_Mathlib_LinearAlgebra_Matrix_Kronecker___macroRules_Kronecker_term_⊗ₖₜ[_]__1» | Mathlib.LinearAlgebra.Matrix.Kronecker | Lean.Macro |
Topology.WithGeneratedByTopology.isClosed_iff | Mathlib.Topology.Convenient.GeneratedBy | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [tY : TopologicalSpace Y]
{U : Set (Topology.WithGeneratedByTopology X Y)},
IsClosed U ↔ ∀ ⦃i : ι⦄ (f : C(X i, Y)), IsClosed (⇑f ⁻¹' (⇑Topology.WithGeneratedByTopology.equiv.symm ⁻¹' U)) |
RootPairing.IsIrreducible.mk' | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] {K : Type u_5}
[inst_2 : Field K] [inst_3 : Module K M] [inst_4 : Module K N] [Nontrivial M] (P : RootPairing ι K M N),
(∀ (q : Submodule K M), (∀ (i : ι), q ∈ Module.End.invtSubmodule ↑(P.reflection i)) → q ≠ ⊥ → q = ⊤) → P.IsIrreducible |
BooleanSubalgebra.subtype_comp_inclusion | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L M : BooleanSubalgebra α} (h : L ≤ M),
M.subtype.comp (BooleanSubalgebra.inclusion h) = L.subtype |
FiniteIndexNormalAddSubgroup.rec | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
{motive : FiniteIndexNormalAddSubgroup G → Sort u} →
((toAddSubgroup : AddSubgroup G) →
(isNormal' : toAddSubgroup.Normal) →
(isFiniteIndex' : toAddSubgroup.FiniteIndex) →
motive { toAddSubgroup := toAddSubgroup, isNormal' := isNormal', isFiniteIndex' := isFiniteIndex' }) →
(t : FiniteIndexNormalAddSubgroup G) → motive t |
_private.Mathlib.Topology.Order.0.TopologicalSpace.nhds_mkOfNhds_single._simp_1_2 | Mathlib.Topology.Order | ∀ {α : Type u_1} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) = p a |
continuousAt_gauge_zero | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} [inst_2 : TopologicalSpace E]
[ContinuousSMul ℝ E], s ∈ nhds 0 → ContinuousAt (gauge s) 0 |
CategoryTheory.SimplicialObject.IsCoskeletal.isRightKanExtension | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : CategoryTheory.SimplicialObject C} {n : ℕ}
[self : X.IsCoskeletal n],
CategoryTheory.Functor.IsRightKanExtension X
(CategoryTheory.CategoryStruct.id ((SimplexCategory.Truncated.inclusion n).op.comp X)) |
Lean.Meta.SimpAll.M | Lean.Meta.Tactic.Simp.SimpAll | Type → Type |
Differentiable.fun_add_iff_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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 g : E → F},
Differentiable 𝕜 f → ((Differentiable 𝕜 fun i => f i + g i) ↔ Differentiable 𝕜 g) |
List.untrop_prod | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} [inst : AddMonoid R] (l : List (Tropical R)), Tropical.untrop l.prod = (List.map Tropical.untrop l).sum |
MeasureTheory.llr.eq_1 | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) (x : α),
MeasureTheory.llr μ ν x = Real.log (μ.rnDeriv ν x).toReal |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_ultrafilter._simp_1_2 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
SemistandardYoungTableau.col_strict' | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (self : SemistandardYoungTableau μ) {i1 i2 j : ℕ},
i1 < i2 → (i2, j) ∈ μ → self.entry i1 j < self.entry i2 j |
FirstOrder.Language.instUniqueStructureEmpty | Mathlib.ModelTheory.Basic | {M : Type w} → Unique (FirstOrder.Language.empty.Structure M) |
CategoryTheory.SmallObject.SuccStruct.mk | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
C → (succ : C → C) → ((X : C) → X ⟶ succ X) → CategoryTheory.SmallObject.SuccStruct C |
ContinuousMonoidHom.comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
{C : Type u_4} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : Monoid C] →
[inst_3 : TopologicalSpace A] →
[inst_4 : TopologicalSpace B] → [inst_5 : TopologicalSpace C] → (B →ₜ* C) → (A →ₜ* B) → A →ₜ* C |
Lean.JsonRpc.Message.noConfusion | Lean.Data.JsonRpc | {P : Sort u} → {t t' : Lean.JsonRpc.Message} → t = t' → Lean.JsonRpc.Message.noConfusionType P t t' |
MvPolynomial.restrictSupportIdeal.congr_simp | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {σ : Type u} (R : Type v) [inst : CommSemiring R] (s s_1 : Set (σ →₀ ℕ)) (e_s : s = s_1) (hs : IsUpperSet s),
MvPolynomial.restrictSupportIdeal R s hs = MvPolynomial.restrictSupportIdeal R s_1 ⋯ |
UniformSpace.Completion.mapRingEquiv_symm_apply | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
{β : Type u} [inst_4 : UniformSpace β] [inst_5 : Ring β] [inst_6 : IsUniformAddGroup β] [inst_7 : IsTopologicalRing β]
(f : α ≃+* β) (hf : Continuous ⇑f) (hf' : Continuous ⇑f.symm) (a : UniformSpace.Completion β),
(UniformSpace.Completion.mapRingEquiv f hf hf').symm a = UniformSpace.Completion.map (⇑f.symm) a |
Lean.Grind.Bool.or_eq_of_eq_true_left | Init.Grind.Lemmas | ∀ {a b : Bool}, a = true → (a || b) = true |
HilbertBasis.hasSum_repr_symm | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (b : HilbertBasis ι 𝕜 E) (f : ↥(lp (fun i => 𝕜) 2)),
HasSum (fun i => ↑f i • b i) (b.repr.symm f) |
Std.Format.MonadPrettyFormat.mk | Init.Data.Format.Basic | {m : Type → Type} →
(String → m Unit) → (ℕ → m Unit) → m ℕ → (ℕ → m Unit) → (ℕ → m Unit) → Std.Format.MonadPrettyFormat m |
Lean.ErrorExplanation.rec | Lean.ErrorExplanation | {motive : Lean.ErrorExplanation → Sort u} →
((doc : String) →
(metadata : Lean.ErrorExplanation.Metadata) →
(declLoc? : Option Lean.DeclarationLocation) →
motive { doc := doc, metadata := metadata, declLoc? := declLoc? }) →
(t : Lean.ErrorExplanation) → motive t |
Real.HolderTriple.pos' | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → 0 < r |
Algebra.PreSubmersivePresentation.differential._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u_1} {S : Type u_4} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ), SMulCommClass P.Ring P.Ring (σ → P.Ring) |
AddUnits.mk_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (u : AddUnits α) (y : α) (h₁ : ↑u + y = 0) (h₂ : y + ↑u = 0),
{ val := ↑u, neg := y, val_neg := h₁, neg_val := h₂ } = u |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.