name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1 | Mathlib.Algebra.Homology.ExactSequenceFour | Lean.Syntax |
NNRat.cast_inj._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, (↑p = ↑q) = (p = q) |
UpperHalfPlane.atImInfty.eq_1 | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | UpperHalfPlane.atImInfty = Filter.comap UpperHalfPlane.im Filter.atTop |
Cardinal.mk_sum | Mathlib.SetTheory.Cardinal.Defs | ∀ (α : Type u) (β : Type v),
Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) |
MeasureTheory.Measure.instRegularOfIsHaarMeasureOfCompactSpace | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[BorelSpace G] [CompactSpace G] (μ : MeasureTheory.Measure G) [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ], μ.Regular |
LinearIsometryEquiv.piLpCongrRight._proof_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {𝕜 : Type u_4} {ι : Type u_1} {α : ι → Type u_3} {β : ι → Type u_2} [hp : Fact (1 ≤ p)]
[inst : Fintype ι] [inst_1 : Semiring 𝕜] [inst_2 : (i : ι) → SeminormedAddCommGroup (α i)]
[inst_3 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_4 : (i : ι) → Module 𝕜 (α i)]
[inst_5 : (i : ι) → Module 𝕜 (β i)] (e : (i : ι) → α i ≃ₗᵢ[𝕜] β i) (x : (i : ι) → α i),
‖((WithLp.linearEquiv p 𝕜 ((i : ι) → α i) ≪≫ₗ LinearEquiv.piCongrRight fun i => (e i).toLinearEquiv) ≪≫ₗ
(WithLp.linearEquiv p 𝕜 ((i : ι) → β i)).symm)
((WithLp.linearEquiv p 𝕜 ((i : ι) → α i)).symm x)‖ =
‖(WithLp.linearEquiv p 𝕜 ((i : ι) → α i)).symm x‖ |
Lean.Widget.instFromJsonRpcEncodablePacket.fromJson._@.Lean.Widget.Types.3328362917._hygCtx._hyg.14 | Lean.Widget.Types | Lean.Json → Except String Lean.Widget.RpcEncodablePacket✝ |
preordToCat._proof_1 | Mathlib.Order.Category.Preord | ∀ (X : Preord), ⋯.functor.toCatHom = CategoryTheory.CategoryStruct.id (CategoryTheory.Cat.of ↑X) |
CategoryTheory.IsSplitEpi.exists_splitEpi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.IsSplitEpi f],
Nonempty (CategoryTheory.SplitEpi f) |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.mkIterator.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.mkIterator s = { s := s, i := 0 } |
Lean.Environment.AddConstAsyncResult.mainEnv | Lean.Environment | Lean.Environment.AddConstAsyncResult → Lean.Environment |
Lean.Meta.Grind.TopSort.State.permMark._default | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr |
linearIndepOn_finset_iff | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} {s : Finset ι}, LinearIndepOn R v ↑s ↔ ∀ (f : ι → R), ∑ i ∈ s, f i • v i = 0 → ∀ i ∈ s, f i = 0 |
Lean.Server.TransientWorkerILean.hasRefs | Lean.Server.References | Lean.Server.TransientWorkerILean → Bool |
Polynomial.derivRootWeight.eq_1 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ (P : Polynomial ℂ) (z w : ℂ),
P.derivRootWeight z w =
if Polynomial.eval z P = 0 then Pi.single z 1 w else ↑(Polynomial.rootMultiplicity w P) / ‖z - w‖ ^ 2 |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._simp_1_4 | Mathlib.Topology.Sets.VietorisTopology | ∀ {β : Type u_2} {ι : Sort u_5} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i |
Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → (m₁.diff m₂ ⋯).getKeyD k fallback = m₁.getKeyD k fallback |
UniformFun.lipschitzWith_ofFun_iff | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace γ] [inst_1 : PseudoEMetricSpace β]
{f : γ → α → β} {K : NNReal},
(LipschitzWith K fun x => UniformFun.ofFun (f x)) ↔ ∀ (c : α), LipschitzWith K fun x => f x c |
Std.DTreeMap.Internal.Cell.ofEq.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (k' : α) (v' : β k')
(hcmp : ∀ [Std.OrientedOrd α], k k' = Ordering.eq),
Std.DTreeMap.Internal.Cell.ofEq k' v' hcmp = { inner := some ⟨k', v'⟩, property := ⋯ } |
Std.ExtDTreeMap.Const.size_le_size_insertMany_list | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)}, t.size ≤ (Std.ExtDTreeMap.Const.insertMany t l).size |
_private.Mathlib.RingTheory.IsPrimary.0.Submodule.isPrimary_iff_zero_divisor_quotient_imp_nilpotent_smul._simp_1_3 | Mathlib.RingTheory.IsPrimary | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) |
LocallyFiniteOrder.toLocallyFiniteOrderTop._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : OrderTop α] (a x : α),
x ∈ Finset.Icc a ⊤ ↔ a ≤ x |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.0.SimpleGraph.chromaticNumber_le_of_forall_imp._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBMap.contains_iff_find?._simp_1_2 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) |
Prod.continuousNeg | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {H : Type x} [inst : TopologicalSpace G] [inst_1 : Neg G] [ContinuousNeg G] [inst_3 : TopologicalSpace H]
[inst_4 : Neg H] [ContinuousNeg H], ContinuousNeg (G × H) |
_private.Init.System.IO.0.System.FilePath.isDir.match_1 | Init.System.IO | (motive : Except IO.Error IO.FS.Metadata → Sort u_1) →
(__do_lift : Except IO.Error IO.FS.Metadata) →
((m : IO.FS.Metadata) → motive (Except.ok m)) → ((a : IO.Error) → motive (Except.error a)) → motive __do_lift |
Lean.Meta.Grind.Action.andAlso | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Action → Lean.Meta.Grind.Action → Lean.Meta.Grind.Action |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.iff_exists_tensorProduct._simp_1_4 | Mathlib.RingTheory.Unramified.Finite | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
KaehlerDifferential.ideal R S = Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) |
_private.Lean.Elab.Tactic.Do.ProofMode.RenameI.0.Lean.Elab.Tactic.Do.ProofMode.elabMRenameI | Lean.Elab.Tactic.Do.ProofMode.RenameI | Lean.Elab.Tactic.Tactic |
SimpleGraph.Connected.rec | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{G : SimpleGraph V} →
{motive : G.Connected → Sort u_1} →
((preconnected : G.Preconnected) → [nonempty : Nonempty V] → motive ⋯) → (t : G.Connected) → motive t |
Functor.supp.eq_1 | Mathlib.Data.PFunctor.Univariate.Basic | ∀ {F : Type u → Type v} [inst : Functor F] {α : Type u} (x : F α),
Functor.supp x = {y | ∀ ⦃p : α → Prop⦄, Functor.Liftp p x → p y} |
CategoryTheory.Limits.colimitHomIsoLimitYoneda_inv_comp_π_assoc | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(F : CategoryTheory.Functor I C) [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) {Z : Type u₂}
(h : (CategoryTheory.yoneda.obj A).obj (Opposite.op (F.obj i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitHomIsoLimitYoneda F A).inv
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj A).map (CategoryTheory.Limits.colimit.ι F i).op)
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.π (F.op.comp (CategoryTheory.yoneda.obj A)) (Opposite.op i)) h |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNames.loop.match_1 | Batteries.Lean.Meta.UnusedNames | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n |
CategoryTheory.Limits.Cocone.category._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F : CategoryTheory.Functor J C}
{W X Y Z : CategoryTheory.Limits.Cocone F} (f : CategoryTheory.Limits.CoconeMorphism W X)
(g : CategoryTheory.Limits.CoconeMorphism X Y) (h : CategoryTheory.Limits.CoconeMorphism Y Z),
{
hom :=
CategoryTheory.CategoryStruct.comp { hom := CategoryTheory.CategoryStruct.comp f.hom g.hom, w := ⋯ }.hom h.hom,
w := ⋯ } =
{
hom :=
CategoryTheory.CategoryStruct.comp f.hom { hom := CategoryTheory.CategoryStruct.comp g.hom h.hom, w := ⋯ }.hom,
w := ⋯ } |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist a' b' ≠ 0 → dist a b / dist a' b' = dist b c / dist b' c' → dist a b = dist a b / dist a' b' * dist a' b' |
Mathlib.Tactic.Translate.instToMessageDataReorder | Mathlib.Tactic.Translate.Reorder | Lean.ToMessageData Mathlib.Tactic.Translate.Reorder |
instCountablePLift | Mathlib.Data.Countable.Defs | ∀ {α : Sort u} [Countable α], Countable (PLift α) |
generatePiSystem_subset_self | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)}, IsPiSystem S → generatePiSystem S ⊆ S |
Mathlib.Linter.linter.style.longLine | Mathlib.Tactic.Linter.Style | Lean.Option Bool |
Lean.Elab.macroAttribute._regBuiltin.Lean.Elab.macroAttribute.declRange_3 | Lean.Elab.Util | IO Unit |
_private.Mathlib.Analysis.Distribution.TestFunction.0.TestFunction.instIsTopologicalAddGroup.match_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (x : TopologicalSpace (TestFunction Ω F n))
(motive :
x ∈
{t |
TestFunction.originalTop Ω F n ≤ t ∧
IsTopologicalAddGroup (TestFunction Ω F n) ∧
ContinuousSMul ℝ (TestFunction Ω F n) ∧ LocallyConvexSpace ℝ (TestFunction Ω F n)} →
Prop)
(x_1 :
x ∈
{t |
TestFunction.originalTop Ω F n ≤ t ∧
IsTopologicalAddGroup (TestFunction Ω F n) ∧
ContinuousSMul ℝ (TestFunction Ω F n) ∧ LocallyConvexSpace ℝ (TestFunction Ω F n)}),
(∀ (left : TestFunction.originalTop Ω F n ≤ x) (ht : IsTopologicalAddGroup (TestFunction Ω F n))
(left_1 : ContinuousSMul ℝ (TestFunction Ω F n)) (right : LocallyConvexSpace ℝ (TestFunction Ω F n)), motive ⋯) →
motive x_1 |
ProbabilityTheory.Kernel.iIndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
∀ (g : (i : ι) → β i → γ i),
(∀ (i : ι), Measurable (g i)) → ProbabilityTheory.Kernel.iIndepFun (fun i => g i ∘ f i) κ μ |
CategoryTheory.Limits.isTerminalEquivUnique._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C) (u : (X : C) → Unique (X ⟶ Y))
(s : CategoryTheory.Limits.Cone F) (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp default
({ pt := Y,
π := { app := fun X => id (CategoryTheory.Discrete.casesOn X fun as => ⋯.elim), naturality := ⋯ } }.π.app
j) =
s.π.app j |
PFunctor.Approx.sCorec._unsafe_rec | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type w} → (X → ↑F X) → X → (n : ℕ) → PFunctor.Approx.CofixA F n |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.EdgeDisjointTriangles.card_edgeFinset_le._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.step_cons_of_isLT | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β}
{it : Std.DTreeMap.Internal.Zipper α β} [inst : Ord α] {upper : α} {h : (compare k upper).isLT = true},
{ iter := Std.DTreeMap.Internal.Zipper.cons k v t it, upper := upper }.step =
Std.IterStep.yield { internalState := { iter := Std.DTreeMap.Internal.Zipper.prependMap t it, upper := upper } }
⟨k, v⟩ |
Finset.finsuppAntidiag_insert.match_3 | Mathlib.Algebra.Order.Antidiag.Finsupp | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] [inst_2 : Finset.HasAntidiagonal μ]
[inst_3 : DecidableEq μ] {a : ι} {s : Finset ι} (p : μ × μ) (x : ↥(s.finsuppAntidiag p.2))
(motive : (x_1 : ↥(s.finsuppAntidiag p.2)) → (fun f => (↑f).update a p.1) x_1 = (fun f => (↑f).update a p.1) x → Prop)
(x_1 : ↥(s.finsuppAntidiag p.2)) (hfg : (fun f => (↑f).update a p.1) x_1 = (fun f => (↑f).update a p.1) x),
(∀ (f : ι →₀ μ) (hf : f ∈ s.finsuppAntidiag p.2)
(hfg : (fun f => (↑f).update a p.1) ⟨f, hf⟩ = (fun f => (↑f).update a p.1) x), motive ⟨f, hf⟩ hfg) →
motive x_1 hfg |
neg_lt_sub_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] [AddRightStrictMono α] {a b c : α},
-a < b - c ↔ c < a + b |
Finsupp.basisSingleOne | Mathlib.LinearAlgebra.Finsupp.VectorSpace | {R : Type u_1} → {ι : Type u_3} → [inst : Semiring R] → Module.Basis ι R (ι →₀ R) |
Aesop.Frontend.Priority.int.elim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Priority → Sort u} →
(t : Aesop.Frontend.Priority) → t.ctorIdx = 0 → ((i : ℤ) → motive (Aesop.Frontend.Priority.int i)) → motive t |
Lean.Elab.mkMessageCore | Lean.Elab.Exception | String → Lean.FileMap → Lean.MessageData → Lean.MessageSeverity → String.Pos.Raw → String.Pos.Raw → Lean.Message |
Int.decidableLELT._proof_3 | Mathlib.Data.Int.Range | ∀ (P : ℤ → Prop) (m n : ℤ), (∀ r ∈ m.range n, P r) ↔ ∀ (r : ℤ), m ≤ r → r < n → P r |
TopCommRingCat.instConcreteCategorySubtypeRingHomαContinuousCoe._proof_3 | Mathlib.Topology.Category.TopCommRingCat | ∀ {X : TopCommRingCat} (x : X.α), (CategoryTheory.CategoryStruct.id X) x = x |
Lean.Elab.Do.withDeadCode | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.CodeLiveness → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α |
CategoryTheory.ShortComplex.instMonoICycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], CategoryTheory.Mono S.iCycles |
instMulOneClassWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_2} [inst : MulOneClass α] (a : WithConv (Matrix m n α)), 1 * a = a |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.loopyOn_isLoopless_iff._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α}, M.Loopless = ∀ e ∈ M.E, ¬M.IsLoop e |
CategoryTheory.SmallObject.ιFunctorObj_eq | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y) (j : κ.ord.ToType),
CategoryTheory.SmallObject.ιFunctorObj I.homFamily
(((CategoryTheory.SmallObject.iterationFunctor I κ).obj j).obj (CategoryTheory.Arrow.mk f)).hom =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.SmallObject.relativeCellComplexιObj I κ f).F.map (CategoryTheory.homOfLE ⋯))
(CategoryTheory.SmallObject.relativeCellComplexιObjFObjSuccIso I κ f j).hom |
CategoryTheory.Mon.limit._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (i j : J) (f : i ⟶ j),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const J).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj c.1 c.1)).map f)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom (c.π.app j) (c.π.app j))
CategoryTheory.MonObj.mul) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom (c.π.app i) (c.π.app i))
CategoryTheory.MonObj.mul)
((F.comp (CategoryTheory.Mon.forget C)).map f) |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {y : α} [inst_1 : DecidableLT α] [inst_2 : LocallyFiniteOrder α]
(a b : { x // y < x }), b ∈ Finset.subtype (fun x => y < x) (Finset.Ioc y ↑a) ↔ b ≤ a |
RingPreordering.supportAddSubgroup._proof_2 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (P : RingPreordering R) {a b : R}, a ∈ ↑P ∩ -↑P → b ∈ ↑P ∩ -↑P → a + b ∈ ↑P ∩ -↑P |
Subgroup.map_subtype_le_map_subtype | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {G' : Subgroup G} {H K : Subgroup ↥G'},
Subgroup.map G'.subtype H ≤ Subgroup.map G'.subtype K ↔ H ≤ K |
LucasLehmer.X.add_snd | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (x y : LucasLehmer.X q), (x + y).2 = x.2 + y.2 |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_2 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_2 () |
Lean.Expr.updateForall! | Lean.Expr | Lean.Expr → Lean.BinderInfo → Lean.Expr → Lean.Expr → Lean.Expr |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_190 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1) <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length |
HahnSeries.SummableFamily.embDomain | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
{β : Type u_6} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] → HahnSeries.SummableFamily Γ R α → (α ↪ β) → HahnSeries.SummableFamily Γ R β |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.filter_single._proof_1_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (p : ι → Prop)
[inst_2 : DecidablePred p] (i : ι) (x : β i) (j : ι),
((if p i then fun₀ | i => x else 0) j = if p i then (fun₀ | i => x) j else 0) →
(DFinsupp.filter p fun₀ | i => x) j = (if p i then fun₀ | i => x else 0) j |
StarSubalgebra.ofClass._proof_4 | Mathlib.Algebra.Star.Subalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [SubsemiringClass S A] (s : S), 0 ∈ s |
MeasureTheory.tendstoInDistribution_of_isEmpty | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω : ι → Type u_5} {m : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [inst : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{m' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} [inst_1 : MeasureTheory.IsProbabilityMeasure μ']
{mE : MeasurableSpace E} {X : (i : ι) → Ω i → E} {Z : Ω' → E} {l : Filter ι} [inst_2 : TopologicalSpace E]
[inst_3 : IsEmpty E], MeasureTheory.TendstoInDistribution X l Z μ μ' |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : AddCommMonCat} (f : X ⟶ Y), { hom' := f.hom' } = f |
CategoryTheory.Limits.PreservesWellOrderContinuousOfShape.preservesColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Preorder | ∀ {C : Type u} {D : Type u'} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Category.{v', u'} D}
{J : Type w} {inst_2 : LinearOrder J} {G : CategoryTheory.Functor C D}
[self : CategoryTheory.Limits.PreservesWellOrderContinuousOfShape J G] (j : J),
Order.IsSuccLimit j → CategoryTheory.Limits.PreservesColimitsOfShape (↑(Set.Iio j)) G |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.IsPathGraph3Compl.pathGraph3ComplEmbedding.match_1.splitter | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | (motive : Fin 3 → Sort u_1) → (x : Fin 3) → (Unit → motive 0) → (Unit → motive 1) → (Unit → motive 2) → motive x |
Lean.EnvironmentHeader.imports._default | Lean.Environment | Array Lean.Import |
Lean.IR.instToFormatCtorInfo | Lean.Compiler.IR.Format | Std.ToFormat Lean.IR.CtorInfo |
Ordnode.mem.decidable | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [inst_1 : DecidableLE α] → (x : α) → (t : Ordnode α) → Decidable (x ∈ t) |
Complex.one_add_cpow_hasFPowerSeriesAt_zero | Mathlib.Analysis.Analytic.Binomial | ∀ {a : ℂ}, HasFPowerSeriesAt (fun x => (1 + x) ^ a) (binomialSeries ℂ a) 0 |
OrderHom.curry._proof_4 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(f : α × β →o γ) (x x_1 : α), x ≤ x_1 → ∀ (x_2 : β), f (x, x_2) ≤ f (x_1, x_2) |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_1.eq_1 | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms × Lean.Meta.Grind.PendingSolverPropagationsData✝ → Sort u_1)
(s : Lean.Meta.Grind.SolverTerms) (p : Lean.Meta.Grind.PendingSolverPropagationsData✝¹)
(h_1 : (s : Lean.Meta.Grind.SolverTerms) → (p : Lean.Meta.Grind.PendingSolverPropagationsData✝²) → motive (s, p)),
(match (s, p) with
| (s, p) => h_1 s p) =
h_1 s p |
CircleDeg1Lift.instLattice._proof_4 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) (x : ℝ), f x ≤ f x |
Lean.Lsp.DiagnosticWith.relatedInformation?._default | Lean.Data.Lsp.Diagnostics | {α : Type} → Option (Array Lean.Lsp.DiagnosticRelatedInformation) |
Subgroup.closure_pi | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [Finite η] {s : (i : η) → Set (f i)},
(∀ (i : η), 1 ∈ s i) →
Subgroup.closure (Set.univ.pi fun i => s i) = Subgroup.pi Set.univ fun i => Subgroup.closure (s i) |
MeasureTheory.MemLp.toLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] → (f : α → E) → MeasureTheory.MemLp f p μ → ↥(MeasureTheory.Lp E p μ) |
Lean.Syntax.SepArray.casesOn | Init.Prelude | {sep : String} →
{motive : Lean.Syntax.SepArray sep → Sort u} →
(t : Lean.Syntax.SepArray sep) →
((elemsAndSeps : Array Lean.Syntax) → motive { elemsAndSeps := elemsAndSeps }) → motive t |
ProofWidgets.MakeEditLinkProps.recOn | ProofWidgets.Component.MakeEditLink | {motive : ProofWidgets.MakeEditLinkProps → Sort u} →
(t : ProofWidgets.MakeEditLinkProps) →
((edit : Lean.Lsp.TextDocumentEdit) →
(newSelection? : Option Lean.Lsp.Range) →
(title? : Option String) → motive { edit := edit, newSelection? := newSelection?, title? := title? }) →
motive t |
Std.ExtDHashMap.filter_eq_self_iff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool}, Std.ExtDHashMap.filter f m = m ↔ ∀ (k : α) (h : k ∈ m), f k (m.get k h) = true |
CategoryTheory.ShortComplex.zero_assoc | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(self : CategoryTheory.ShortComplex C) {Z : C} (h : self.X₃ ⟶ Z),
CategoryTheory.CategoryStruct.comp self.f (CategoryTheory.CategoryStruct.comp self.g h) =
CategoryTheory.CategoryStruct.comp 0 h |
CategoryTheory.instCategoryMonad._proof_23 | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z : CategoryTheory.Monad C} (x : W ⟶ X)
(x_1 : X ⟶ Y) (x_2 : Y ⟶ Z),
{
app := fun X_1 =>
CategoryTheory.CategoryStruct.comp
({ app := fun X_2 => CategoryTheory.CategoryStruct.comp (x.app X_2) (x_1.app X_2), naturality := ⋯,
app_η := ⋯, app_μ := ⋯ }.app
X_1)
(x_2.app X_1),
naturality := ⋯, app_η := ⋯, app_μ := ⋯ } =
{
app := fun X_1 =>
CategoryTheory.CategoryStruct.comp (x.app X_1)
({ app := fun X_2 => CategoryTheory.CategoryStruct.comp (x_1.app X_2) (x_2.app X_2), naturality := ⋯,
app_η := ⋯, app_μ := ⋯ }.app
X_1),
naturality := ⋯, app_η := ⋯, app_μ := ⋯ } |
ArithmeticFunction.ppow_one | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R}, f.ppow 1 = f |
Std.DHashMap.Const.get?_inter_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → Std.DHashMap.Const.get? (m₁.inter m₂) k = none |
contMDiffWithinAt_pi_space | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {n : WithTop ℕ∞} {ι : Type u_16}
[inst_6 : Fintype ι] {Fi : ι → Type u_17} [inst_7 : (i : ι) → NormedAddCommGroup (Fi i)]
[inst_8 : (i : ι) → NormedSpace 𝕜 (Fi i)] {φ : M → (i : ι) → Fi i},
ContMDiffWithinAt I (modelWithCornersSelf 𝕜 ((i : ι) → Fi i)) n φ s x ↔
∀ (i : ι), ContMDiffWithinAt I (modelWithCornersSelf 𝕜 (Fi i)) n (fun x => φ x i) s x |
Equiv.semigroup | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Semigroup β] → Semigroup α |
Quaternion.mul_coe_eq_smul | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (r : R) (a : Quaternion R), a * ↑r = r • a |
Batteries.Tactic.DeclCache.casesOn | Batteries.Util.Cache | {α : Type} →
{motive : Batteries.Tactic.DeclCache α → Sort u} →
(t : Batteries.Tactic.DeclCache α) →
((cache : Batteries.Tactic.Cache α) →
(addDecl addLibraryDecl : Lean.Name → Lean.ConstantInfo → α → Lean.MetaM α) →
motive { cache := cache, addDecl := addDecl, addLibraryDecl := addLibraryDecl }) →
motive t |
List.mapM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (x : List α),
List.mapM' f x =
match x with
| [] => pure []
| a :: l => do
let __do_lift ← f a
let __do_lift_1 ← List.mapM' f l
pure (__do_lift :: __do_lift_1) |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction_actionUnitIso | 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.MonoidalRightAction C D] (x : Dᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso x =
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso (Opposite.unop x)).symm.op |
Bool.linearOrder._proof_9 | Mathlib.Data.Bool.Basic | ∀ (a b : Bool), compare a b = compareOfLessAndEq a b |
CategoryTheory.Pretriangulated.instSplitEpiCategory | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.SplitEpiCategory C |
CategoryTheory.SimplicialObject.Truncated._aux_Mathlib_AlgebraicTopology_SimplicialObject_Basic___macroRules_CategoryTheory_SimplicialObject_Truncated_mkNotation_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Macro |
Lean.Compiler.LCNF.ReduceJpArity.reduce | Lean.Compiler.LCNF.ReduceJpArity | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.ReduceJpArity.ReduceM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.