name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Data.List.Cycle.0.Cycle.next_reverse_eq_prev._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (hs : s.Nodup) (x : α) (hx : x ∈ s),
s.next hs x hx = s.reverse.prev ⋯ x ⋯ |
CategoryTheory.monoidalUnopUnop._proof_14 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᵒᵖᵒᵖ} (X' : Cᵒᵖᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' X)))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.unopUnop C).obj X')
((CategoryTheory.unopUnop C).map f)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.unopUnop C).map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' Y))) |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | @Orientation.definition✝ = @Orientation.definition✝ |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [a], x => h_2 a x
| a :: b :: xs, le => h_3 a b xs le) =
h_2 a x |
CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) |
TrivSqZeroExt.instL1NormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] (a b : TrivSqZeroExt R M),
a + b = b + a |
_private.Init.Data.Array.Range.0.Array.mem_zipIdx._proof_1 | Init.Data.Array.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : Array α} {k : ℕ},
k ≤ (x, i).2 → (x, i).2 < k + xs.size → ¬i - k < xs.size → False |
HomogeneousIdeal.instMax._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (I.toIdeal ⊔ J.toIdeal) |
Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElim | Lean.Elab.GuardMsgs | {motive : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElimType ctorIdx → motive t |
SimpleGraph.induceHomOfLE | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → (G : SimpleGraph V) → {s s' : Set V} → s ≤ s' → SimpleGraph.induce s G ↪g SimpleGraph.induce s' G |
Monoid.CoprodI.Word.rcons_eq_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (p : Monoid.CoprodI.Word.Pair M i),
Monoid.CoprodI.Word.rcons p = Monoid.CoprodI.of p.head • p.tail |
AlgEquiv.isTranscendenceBasis | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
IsTranscendenceBasis R x → IsTranscendenceBasis R (⇑e ∘ x) |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.instIsIsoInvApp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (U : TopologicalSpace.Opens ↑↑X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp f U) |
Std.TreeMap.getKeyD_eq_fallback | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getKeyD a fallback = fallback |
BoxIntegral.Box.coe_subset_coe._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (↑I ⊆ ↑J) = (I ≤ J) |
OrderTopology.t5Space | Mathlib.Topology.Order.T5 | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X], T5Space X |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(X Y Z : P.FullSubcategory),
P
(CategoryTheory.MonoidalCategoryStruct.tensorObj X.obj
{ obj := CategoryTheory.MonoidalCategoryStruct.tensorObj Y.obj Z.obj, property := ⋯ }.obj) |
Std.DHashMap.Internal.Raw₀.contains_insertMany_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List ((a : α) × β a)} {k : α},
(↑(m.insertMany l)).contains k = (m.contains k || (List.map Sigma.fst l).contains k) |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerResultType.resultTypeForArity._sparseCasesOn_2 | Lean.Compiler.LCNF.ToImpure | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Lean.Server.Rpc.RequestHandling.0.Lean.Server.wrapRpcProcedure.match_1 | Lean.Server.Rpc.RequestHandling | (paramType : Type) →
(motive : Id (Except String paramType) → Sort u_1) →
(x : Id (Except String paramType)) →
((v : paramType) → motive (Except.ok v)) → ((e : String) → motive (Except.error e)) → motive x |
convexHullAddMonoidHom | Mathlib.Analysis.Convex.Combination | (R : Type u_1) →
(E : Type u_3) →
[inst : Field R] →
[inst_1 : AddCommGroup E] → [Module R E] → [inst_3 : LinearOrder R] → [IsStrictOrderedRing R] → Set E →+ Set E |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.instMulActionLeftTransversal._simp_1 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.e | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → Lean.Expr |
HomotopicalAlgebra.instIsStableUnderBaseChangeFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C)],
(HomotopicalAlgebra.fibrations C).IsStableUnderBaseChange |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.getElem?_toList_eq.match_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (next : α), x = some next → motive (some next)) → motive x |
CategoryTheory.Idempotents.Karoubi.decompId_p._proof_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ }.p
(CategoryTheory.CategoryStruct.comp P.p P.p) =
P.p |
Std.DTreeMap.Internal.Impl.get!_eq_getValueCast! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [instBEq : BEq α] [inst : Ord α] [inst_1 : Std.LawfulBEqOrd α] [Std.TransOrd α]
[inst_3 : Std.LawfulEqOrd α] {k : α} [inst_4 : Inhabited (β k)] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get! k = Std.Internal.List.getValueCast! k t.toListModel |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sheafedSpace_pullback_fst_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (CategoryTheory.Limits.pullback.fst g f) |
CategoryTheory.FreeBicategory.comp_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g |
Pi.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) → {n : (i : I) → Zero (f i)} → [(i : I) → SMulZeroClass α (f i)] → SMulZeroClass α ((i : I) → f i) |
Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {hd : α} {tl : List α},
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity (hd :: tl)) =
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertIfNew hd ()) tl) |
Fin.partialProd_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_3} [inst : Monoid G] {n : ℕ} (g : Fin (n + 1) → G) (a : Fin (n + 1)),
Fin.partialProd (a.contractNth (fun x1 x2 => x1 * x2) g) = Fin.partialProd g ∘ a.succ.succAbove |
uniqueMDiffWithinAt_iff_uniqueDiffWithinAt | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E},
UniqueMDiffWithinAt (modelWithCornersSelf 𝕜 E) s x ↔ UniqueDiffWithinAt 𝕜 s x |
Topology.WithLawson.isOpen_preimage_ofLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] {S : Set α},
IsOpen (⇑Topology.WithLawson.ofLawson ⁻¹' S) ↔ TopologicalSpace.IsOpen S |
«term{}» | Init.Core | Lean.ParserDescr |
Lean.Meta.Match.mkAppDiscrEqs | Lean.Meta.Match.MatchEqs | Lean.Expr → Array Lean.Expr → ℕ → Lean.MetaM Lean.Expr |
Std.Packages.LinearPreorderOfLEArgs._proof_5 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (le : LE α), (∀ (a b : α), a ≤ b ∨ b ≤ a) → ∀ (a : α), a ≤ a |
_private.Lean.Compiler.LCNF.SplitSCC.0.Lean.Compiler.LCNF.SplitScc.findSccCalls.goCode.match_1 | Lean.Compiler.LCNF.SplitSCC | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(x : Lean.Compiler.LCNF.LetValue pu) →
((name : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.pure) Lean.Compiler.LCNF.LetValue._auto_3) →
motive (Lean.Compiler.LCNF.LetValue.const name us args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_13) →
motive (Lean.Compiler.LCNF.LetValue.fap name args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15) →
motive (Lean.Compiler.LCNF.LetValue.pap name args h)) →
((x : Lean.Compiler.LCNF.LetValue pu) → motive x) → motive x |
Polynomial.derivation_ext | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ |
WType.Listα.nil.elim | Mathlib.Data.W.Constructions | {γ : Type u} →
{motive : WType.Listα γ → Sort u_1} → (t : WType.Listα γ) → t.ctorIdx = 0 → motive WType.Listα.nil → motive t |
SSet.Truncated.Edge.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })} →
{motive : SSet.Truncated.Edge x₀ x₁ → Sort u_1} →
((edge : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.Edge._proof_2 })) →
(src_eq :
X.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op edge =
x₀) →
(tgt_eq :
X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op
edge =
x₁) →
motive { edge := edge, src_eq := src_eq, tgt_eq := tgt_eq }) →
(t : SSet.Truncated.Edge x₀ x₁) → motive t |
CategoryTheory.Classifier.hom_comp_hom | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (𝒞₁ 𝒞₂ 𝒞₃ : CategoryTheory.Classifier C),
CategoryTheory.CategoryStruct.comp (𝒞₁.hom 𝒞₂) (𝒞₂.hom 𝒞₃) = 𝒞₁.hom 𝒞₃ |
AbsoluteValue.LiesOver.casesOn | Mathlib.Analysis.Normed.Ring.WithAbs | {K : Type u_3} →
{L : Type u_4} →
{S : Type u_5} →
[inst : CommRing K] →
[inst_1 : IsSimpleRing K] →
[inst_2 : CommRing L] →
[inst_3 : Algebra K L] →
[inst_4 : PartialOrder S] →
[inst_5 : Nontrivial L] →
[inst_6 : Semiring S] →
{w : AbsoluteValue L S} →
{v : AbsoluteValue K S} →
{motive : w.LiesOver v → Sort u} →
(t : w.LiesOver v) → ((comp_eq : w.comp ⋯ = v) → motive ⋯) → motive t |
differentiableAt_const._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True |
AddSemigrp.hom_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y T : AddSemigrp} (f : X ⟶ Y) (g : Y ⟶ T),
AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddSemigrp.Hom.hom g).comp (AddSemigrp.Hom.hom f) |
UInt8.reduceBinPred._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Name → ℕ → (UInt8 → UInt8 → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step |
Matrix.IsDiag.submatrix | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {n : Type u_4} {m : Type u_5} [inst : Zero α] {A : Matrix n n α},
A.IsDiag → ∀ {f : m → n}, Function.Injective f → (A.submatrix f f).IsDiag |
PMF.toMeasure_inj._simp_1 | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {p q : PMF α},
(p.toMeasure = q.toMeasure) = (p = q) |
ProbabilityTheory.Kernel.rnDeriv_pos | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[ProbabilityTheory.IsFiniteKernel η] {a : α}, (κ a).AbsolutelyContinuous (η a) → ∀ᵐ (x : γ) ∂κ a, 0 < κ.rnDeriv η a x |
ProbabilityTheory.gaussianPDF | Mathlib.Probability.Distributions.Gaussian.Real | ℝ → NNReal → ℝ → ENNReal |
Pi.nonUnitalNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalNormedRing (R i)]
{x y : (i : ι) → R i}, dist x y = 0 → x = y |
Subgroup.commutator_eq_self | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [hH : Group.IsPerfect ↥H], ⁅H, H⁆ = H |
FirstOrder.Language.BoundedFormula.equal.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 1 →
({n : ℕ} → (t₁ t₂ : L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.equal t₁ t₂)) →
motive a t |
instAddInt64 | Init.Data.SInt.Basic | Add Int64 |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.findInt?.go | Lean.Meta.Tactic.Grind.Arith.Linear.Search | Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℤ → ℤ → Option ℚ |
EMetric.diam_one | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : One X], Metric.ediam 1 = 0 |
ProbabilityTheory.integrable_rpow_abs_of_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
0 ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => |X ω| ^ p) μ |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.solveSomeLocalFVarIdCnstr?.go._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Alt →
List (Lean.Expr × Lean.Expr) → Lean.MetaM (Option (Lean.FVarId × Lean.Expr) × List (Lean.Expr × Lean.Expr)) |
CategoryTheory.mop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).mop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.mop { unmop := X } |
Std.Internal.UV.Signal.cancel | Std.Internal.UV.Signal | Std.Internal.UV.Signal → IO Unit |
MvPolynomial.pderiv._proof_1 | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R], IsScalarTower R (MvPolynomial σ R) (MvPolynomial σ R) |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.evalTactic.match_9 | Lean.Elab.Tactic.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive ex |
List.zipWith_eq_nil_iff | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {l : List α} {l' : List β},
List.zipWith f l l' = [] ↔ l = [] ∨ l' = [] |
CategoryTheory.Limits.widePushoutShapeOp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type w) →
CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ |
Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.217797861._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO
(Lean.PersistentEnvExtension Lean.Name (Lean.Name × Lean.Linter.IgnoreFunction)
(List Lean.Name × Array Lean.Linter.IgnoreFunction)) |
PresheafOfModules.presheaf._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (X : Cᵒᵖ),
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.CategoryStruct.id X))) ⋯) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X)) |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.initializeState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.StructInstM✝ Unit |
CompletelyDistribLattice.MinimalAxioms.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(toCompleteLattice : CompleteLattice α) →
(∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice.MinimalAxioms α |
Lean.instForInMVarIdSetMVarIdOfMonad | Lean.Expr | {m : Type u_1 → Type u_2} → [Monad m] → ForIn m Lean.MVarIdSet Lean.MVarId |
_private.Mathlib.Order.Sublocale.0.Sublocale.giAux._proof_3 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : ↥S), x ≤ Sublocale.restrictAux✝ S ↑x |
CategoryTheory.Functor.map_braiding_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_6 : F.Braided] {Z : D}
(h : F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y X) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (β_ X Y).hom) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ F X Y)
(CategoryTheory.CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F Y X) h)) |
Lean.Parser.anyOfFn._unsafe_rec | Lean.Parser.Basic | List Lean.Parser.Parser → Lean.Parser.ParserFn |
Subring.range_snd | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S], (RingHom.snd R S).rangeS = ⊤ |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.loop | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array Lean.Expr →
List Lean.FVarId →
Lean.Expr →
ℕ → ℕ → List Lean.Meta.RefinedDiscrTree.StackEntry → Lean.MetaM (List Lean.Meta.RefinedDiscrTree.StackEntry) |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_filter_eq_false_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {f : α → β → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter f m)).isEmpty = false ↔
∃ k, ∃ (h : m.contains k = true), f (m.getKey k h) (Std.DHashMap.Internal.Raw₀.Const.get m k h) = true) |
Dyadic.toRat_le_toRat_iff._simp_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.toRat ≤ y.toRat) = (x ≤ y) |
MeasureTheory.Measure.pi_noAtoms | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (i : ι)
[MeasureTheory.NoAtoms (μ i)], MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ) |
InnerProductSpace.bounded_harmonic_on_complex_plane_is_constant | Mathlib.Analysis.Complex.Harmonic.Liouville | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f : ℂ → E),
InnerProductSpace.HarmonicOnNhd f Set.univ → Bornology.IsBounded (Set.range f) → ∀ (z w : ℂ), f z = f w |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | (B : Type u₁) →
[inst : CategoryTheory.Bicategory B] →
(C : Type u₂) → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.Bicategory (CategoryTheory.OplaxFunctor B C) |
OrderDual.instModule' | Mathlib.Algebra.Order.Module.Synonym | {α : Type u_1} → {β : Type u_2} → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α βᵒᵈ |
CStarMatrix.instAddCommGroupWithOne._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_2} {A : Type u_1} [inst : DecidableEq n] [inst_1 : AddCommGroupWithOne A], ↑0 = 0 |
Nonneg.semiring._proof_16 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α] [inst_3 : AddLeftMono α]
[inst_4 : PosMulMono α] (n : ℕ), ↑(n + 1) = ↑n + 1 |
CategoryTheory.ShortComplex.Splitting.unop_r | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.Splitting), h.unop.r = h.s.unop |
Std.ExtTreeMap.maxKey?_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {km : α},
t.maxKey? = some km → km ∈ t |
Lean.Server.Watchdog.WorkerEvent.crashed.injEq | Lean.Server.Watchdog | ∀ (exitCode exitCode_1 : UInt32),
(Lean.Server.Watchdog.WorkerEvent.crashed exitCode = Lean.Server.Watchdog.WorkerEvent.crashed exitCode_1) =
(exitCode = exitCode_1) |
Lean.Doc.Syntax.metadataContents | Lean.DocString.Syntax | Lean.Parser.Parser |
Monoid.exponent_multiplicative | Mathlib.GroupTheory.Exponent | ∀ {G : Type u_1} [inst : AddMonoid G], Monoid.exponent (Multiplicative G) = AddMonoid.exponent G |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atTop_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g |
Array.forall_mem_ne' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (∀ a' ∈ xs, ¬a' = a) ↔ a ∉ xs |
Real.RingHom.unique._proof_2 | Mathlib.Data.Real.CompleteField | ∀ (f : ℝ →+* ℝ), { toRingHom := f, monotone' := ⋯ }.toRingHom = default.toRingHom |
Std.HashMap.keys | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List α |
Std.Net.IPAddr.family.match_1 | Std.Net.Addr | (motive : Std.Net.IPAddr → Sort u_1) →
(x : Std.Net.IPAddr) →
((addr : Std.Net.IPv4Addr) → motive (Std.Net.IPAddr.v4 addr)) →
((addr : Std.Net.IPv6Addr) → motive (Std.Net.IPAddr.v6 addr)) → motive x |
BitVec.reduceGE._regBuiltin.BitVec.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.776923109._hygCtx._hyg.25 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
DirichletCharacter.convolution_twist_vonMangoldt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N),
(LSeries.convolution ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) fun n => χ ↑n) =
(fun n => χ ↑n) * fun n => Complex.log ↑n |
Lean.Language.Lean.HeaderParsedSnapshot.mk | Lean.Language.Lean.Types | Lean.Language.Snapshot →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Lean.Parser.InputContext →
Lean.Syntax → Option Lean.Language.Lean.HeaderParsedState → Lean.Language.Lean.HeaderParsedSnapshot |
LocallyFinite.Realizer.recOn | Mathlib.Data.Analysis.Topology | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
{F : Ctop.Realizer α} →
{f : β → Set α} →
{motive : LocallyFinite.Realizer F f → Sort u} →
(t : LocallyFinite.Realizer F f) →
((bas : (a : α) → { s // a ∈ F.F.f s }) →
(sets : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas x)).Nonempty}) →
motive { bas := bas, sets := sets }) →
motive t |
AlgebraicGeometry.structurePresheafInModuleCat | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [Module R M] → TopCat.Presheaf (ModuleCat R) (AlgebraicGeometry.PrimeSpectrum.Top R) |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'.match_1_11 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : StarMul R] [inst_2 : CommRing S] [inst_3 : Algebra S R]
(u v : ↥(unitary R)) (motive : (∃ y, y • 1 = star ↑v * ↑u) → Prop) (x : ∃ y, y • 1 = star ↑v * ↑u),
(∀ (y : S) (h : y • 1 = star ↑v * ↑u), motive ⋯) → motive x |
Lean.Parser.Term.inaccessible._regBuiltin.Lean.Parser.Term.inaccessible_1 | Lean.Parser.Term | IO Unit |
Monoid.CoprodI.Word.equivPair._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] (i : ι) (w : Monoid.CoprodI.Word M),
Monoid.CoprodI.Word.rcons ↑(Monoid.CoprodI.Word.equivPairAux✝ i w) = w |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.