name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.CategoryTheory.FiberedCategory.Cartesian.0.CategoryTheory.Functor.IsStronglyCartesian.comp.match_1 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R : 𝒮} {a b c : 𝒳} {φ : a ⟶ b}
{ψ : b ⟶ c} {a' : 𝒳} (h : p.obj a' ⟶ R) (τ : a' ⟶ c) (π' : a' ⟶ a)
(motive :
p.IsHomLift h π' ∧ CategoryTheory.CategoryStruct.comp π' (CategoryTheory.CategoryStruct.comp φ ψ) = τ → Prop)
(h_1 : p.IsHomLift h π' ∧ CategoryTheory.CategoryStruct.comp π' (CategoryTheory.CategoryStruct.comp φ ψ) = τ),
(∀ (hπ'₁ : p.IsHomLift h π')
(hπ'₂ : CategoryTheory.CategoryStruct.comp π' (CategoryTheory.CategoryStruct.comp φ ψ) = τ), motive ⋯) →
motive h_1 |
Rep.coinvariantsFunctor_map_hom | Mathlib.RepresentationTheory.Coinvariants | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Monoid G] {X Y : Rep k G} (f : X ⟶ Y),
ModuleCat.Hom.hom ((Rep.coinvariantsFunctor k G).map f) =
Representation.Coinvariants.map X.ρ Y.ρ (ModuleCat.Hom.hom f.hom) ⋯ |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_3 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it => h_2 it
| Std.IterStep.done => h_3 ()) =
h_3 () |
CategoryTheory.Functor.Final.preservesColimitsOfShape_of_final | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_4 : CategoryTheory.Category.{v₄, u₄} B] (H : CategoryTheory.Functor E B)
[CategoryTheory.Limits.PreservesColimitsOfShape C H], CategoryTheory.Limits.PreservesColimitsOfShape D H |
DFinsupp.support_update | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i) (i : ι) (b : β i)
[inst_3 : Decidable (b = 0)],
(f.update i b).support = if b = 0 then (DFinsupp.erase i f).support else insert i f.support |
AlgebraicGeometry.IsIntegral.mk._flat_ctor | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (Nonempty ↥X) AlgebraicGeometry.IsIntegral.nonempty._autoParam →
autoParam (∀ (U : X.Opens) [Nonempty ↥↑U], IsDomain ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsIntegral.component_integral._autoParam →
AlgebraicGeometry.IsIntegral X |
DualNumber.lift._proof_6 | Mathlib.Algebra.DualNumber | ∀ {R : Type u_3} {B : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B]
(fg :
{ fg //
(∀ (x y : A), fg.2 x * fg.2 y = 0) ∧
(∀ (r x : A), fg.2 (r • x) = fg.1 r * fg.2 x) ∧ ∀ (r x : A), fg.2 (MulOpposite.op r • x) = fg.2 x * fg.1 r })
(x : A), (↑fg).1 x * (↑fg).2 1 = (↑fg).2 x |
_private.Mathlib.Data.Set.Insert.0.Set.subset_singleton_iff_eq._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {x : α}, s ⊆ {x} ↔ s = ∅ ∨ s = {x} |
Ordnode.Any.decidable._proof_1 | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1} {P : α → Prop}, Ordnode.Any P Ordnode.nil → Ordnode.Any P Ordnode.nil |
Array.Matcher.Iterator.mk.sizeOf_spec | Batteries.Data.Array.Match | ∀ {σ : Type u_1} {n : Type u_1 → Type u_2} {α : Type u_1} [inst : BEq α] {m : Array.Matcher α}
[inst_1 : Std.Iterator σ n α] [inst_2 : SizeOf σ] [inst_3 : (a : Type u_1) → SizeOf (n a)] [inst_4 : SizeOf α]
(inner : Std.IterM n α) (state : Fin (m.table.size + 1)),
sizeOf { inner := inner, state := state } = 1 + sizeOf inner + sizeOf state |
Ordinal.iSup_pow | Mathlib.SetTheory.Ordinal.Exponential | ∀ {o : Ordinal.{u_1}}, 0 < o → ⨆ n, o ^ n = o ^ Ordinal.omega0 |
Int.max_self | Init.Data.Int.Order | ∀ (a : ℤ), max a a = a |
AlgebraicGeometry.AffineTargetMorphismProperty.diagonal_respectsIso | Mathlib.AlgebraicGeometry.Morphisms.Constructors | ∀ (P : AlgebraicGeometry.AffineTargetMorphismProperty) [P.toProperty.RespectsIso], P.diagonal.toProperty.RespectsIso |
Units.mulRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {M : Type u_3} [inst : Monoid M] (u : Mˣ),
u.mulRight = { toFun := fun x => x * ↑u, invFun := fun x => x * ↑u⁻¹, left_inv := ⋯, right_inv := ⋯ } |
Ordnode.splitMax'._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → α → Ordnode α → Ordnode α × α |
IsUnifLocDoublingMeasure.one_le_scalingConstantOf._simp_1 | Mathlib.MeasureTheory.Measure.Doubling | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α)
[inst_2 : IsUnifLocDoublingMeasure μ] (K : ℝ), (1 ≤ IsUnifLocDoublingMeasure.scalingConstantOf μ K) = True |
_private.Init.Meta.Defs.0.Lean.instQuoteNameMkStr1.match_1 | Init.Meta.Defs | (motive : Option (List String) → Sort u_1) →
(x : Option (List String)) → ((ss : List String) → motive (some ss)) → (Unit → motive none) → motive x |
directedOn_pair' | Mathlib.Order.Directed | ∀ {α : Type u} {r : α → α → Prop}, Reflexive r → ∀ {a b : α}, r a b → DirectedOn r {b, a} |
MulArchimedeanClass.forall | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M]
{p : MulArchimedeanClass M → Prop}, (∀ (A : MulArchimedeanClass M), p A) ↔ ∀ (a : M), p (MulArchimedeanClass.mk a) |
_private.Init.Data.Slice.Lemmas.0.Std.Slice.foldlM_toList._simp_1_1 | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
{s : Std.Slice γ} {init : δ} {f : δ → β → m δ},
Std.Slice.foldlM f init s = Std.Iter.foldM f init (Std.Slice.Internal.iter s) |
LinearIsometryEquiv.conjStarAlgEquiv_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K) (x : H →L[𝕜] H),
e.conjStarAlgEquiv x = (↑e.toContinuousLinearEquiv).comp (x.comp ↑e.symm.toContinuousLinearEquiv) |
CategoryTheory.uliftYoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))) |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntryD.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → (a : α) × β a → Sort u_3)
(fallback : (a : α) × β a) (h_1 : (fallback : (a : α) × β a) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Impl α β) →
(x : (a : α) × β a) →
motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r) x)
(h_3 :
(size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r : Std.DTreeMap.Internal.Impl α β) →
l = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r →
(r_1 : Std.DTreeMap.Internal.Impl α β) →
(fallback : (a : α) × β a) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) r_1)
fallback),
(match Std.DTreeMap.Internal.Impl.leaf, fallback with
| Std.DTreeMap.Internal.Impl.leaf, fallback => h_1 fallback
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => h_2 size k v r x
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1,
fallback => h_3 size k v l size_1 k_1 v_1 l_1 r h r_1 fallback) =
h_1 fallback |
_private.Mathlib.Analysis.Normed.Operator.Banach.0.ContinuousLinearMap.isUnit_iff_bijective._simp_1_2 | Mathlib.Analysis.Normed.Operator.Banach | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, (f.ker = ⊥) = Function.Injective ⇑f |
Metric.hausdorffEDist_le_of_mem_edist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α} {r : ENNReal},
(∀ x ∈ s, ∃ y ∈ t, edist x y ≤ r) → (∀ x ∈ t, ∃ y ∈ s, edist x y ≤ r) → Metric.hausdorffEDist s t ≤ r |
MapClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → {ι : Type u_3} → X → Filter ι → (ι → X) → Prop |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {h : Lean.Expr} {x : Int.Linear.Var} {e' : Int.Linear.Expr} {p : Int.Linear.Poly}
{re : Lean.Meta.Grind.Arith.CommRing.RingExpr} {rp : Lean.Grind.CommRing.Poly} {p' : Int.Linear.Poly}
{h_1 : Lean.Expr} {x_1 : Int.Linear.Var} {e'_1 : Int.Linear.Expr} {p_1 : Int.Linear.Poly}
{re_1 : Lean.Meta.Grind.Arith.CommRing.RingExpr} {rp_1 : Lean.Grind.CommRing.Poly} {p'_1 : Int.Linear.Poly},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing h x e' p re rp p' =
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing h_1 x_1 e'_1 p_1 re_1 rp_1 p'_1 →
h = h_1 ∧ x = x_1 ∧ e' = e'_1 ∧ p = p_1 ∧ re = re_1 ∧ rp = rp_1 ∧ p' = p'_1 |
_private.Mathlib.Tactic.FinCases.0.Lean.Elab.Tactic.getMemType._sparseCasesOn_2 | Mathlib.Tactic.FinCases | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
CategoryTheory.Limits.comp_preservesFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) [CategoryTheory.Limits.PreservesFiniteLimits F]
[CategoryTheory.Limits.PreservesFiniteLimits G], CategoryTheory.Limits.PreservesFiniteLimits (F.comp G) |
Equiv.Perm.sameCycle_apply_right._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, f.SameCycle x (f y) = f.SameCycle x y |
intervalIntegral.integrableOn_Ioo_cpow_iff | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {s : ℂ} {t : ℝ}, 0 < t → (MeasureTheory.IntegrableOn (fun x => ↑x ^ s) (Set.Ioo 0 t) MeasureTheory.volume ↔ -1 < s.re) |
FiniteMultiplicity.not_of_one_left | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] (b : α), ¬FiniteMultiplicity 1 b |
Std.Time.Day.instOrdOrdinal | Std.Time.Date.Unit.Day | Ord Std.Time.Day.Ordinal |
AlgebraicGeometry.affineLocally | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) →
CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme |
_private.Mathlib.Order.Category.Frm.0.Frm.Hom.mk.noConfusion | Mathlib.Order.Category.Frm | {X Y : Frm} →
{P : Sort u_1} → {hom' hom'' : FrameHom ↑X ↑Y} → { hom' := hom' } = { hom' := hom'' } → (hom' ≍ hom'' → P) → P |
_private.Mathlib.SetTheory.Cardinal.ENat.0.Cardinal.toENatAux_eq_nat._simp_1_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) |
add_neg_of_nonpos_of_neg | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftStrictMono α] {a b : α},
a ≤ 0 → b < 0 → a + b < 0 |
SimpleGraph.Walk.darts_dropUntil_subset | Mathlib.Combinatorics.SimpleGraph.Walks.Decomp | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support),
(p.dropUntil u h).darts ⊆ p.darts |
IsCusp.smul | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {c : OnePoint ℝ} {𝒢 : Subgroup (GL (Fin 2) ℝ)},
IsCusp c 𝒢 → ∀ (g : GL (Fin 2) ℝ), IsCusp (g • c) (ConjAct.toConjAct g • 𝒢) |
RingCon.instCommRingQuotient._proof_4 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : CommRing R] (c : RingCon R) (x : R) (x_1 : ℕ),
Quotient.mk'' (x ^ x_1) = Quotient.mk'' (x ^ x_1) |
FP.nextUpPos | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → (e : ℤ) → (m : ℕ) → FP.ValidFinite e m → FP.Float |
CategoryTheory.IsGrothendieckAbelian.mono_of_isColimit_monoOver | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Subobject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X : C} {J : Type w} [inst_3 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J (CategoryTheory.MonoOver X)) [CategoryTheory.IsFiltered J]
{c : CategoryTheory.Limits.Cocone (F.comp ((CategoryTheory.MonoOver.forget X).comp (CategoryTheory.Over.forget X)))}
(hc : CategoryTheory.Limits.IsColimit c) (f : c.pt ⟶ X),
(∀ (j : J), CategoryTheory.CategoryStruct.comp (c.ι.app j) f = (F.obj j).obj.hom) → CategoryTheory.Mono f |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.HighlightedMsgEmbed.traceChildrenOfMsgEmbed.match_1 | Lean.Server.FileWorker.WidgetRequests | (motive :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u_1) →
(x :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) →
((cs : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) → motive (Lean.Widget.StrictOrLazy.strict cs)) →
((cs : Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) → motive (Lean.Widget.StrictOrLazy.lazy cs)) →
motive x |
toMul_list_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {M : Type u_3} [inst : Monoid M] (s : List (Additive M)), Additive.toMul s.sum = (List.map (⇑Additive.toMul) s).prod |
CategoryTheory.Dial.whiskerLeft_f | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X x x_1 : CategoryTheory.Dial C) (f : x ⟶ x_1),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).f =
CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X.src) f.f |
star_nsmul | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : AddMonoid R] [inst_1 : StarAddMonoid R] (n : ℕ) (x : R), star (n • x) = n • star x |
mem_coclosed_Lindelof' | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
s ∈ Filter.coclosedLindelof X ↔ ∃ t, IsClosed t ∧ IsLindelof t ∧ sᶜ ⊆ t |
BoundedContinuousFunction.const | Mathlib.Topology.ContinuousMap.Bounded.Basic | (α : Type u) →
{β : Type v} → [inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → β → BoundedContinuousFunction α β |
USize.upwardEnumerableLT_ofBitVec | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec System.Platform.numBits},
Std.PRange.UpwardEnumerable.LT { toBitVec := x } { toBitVec := y } ↔ Std.PRange.UpwardEnumerable.LT x y |
Lean.Meta.Tactic.TryThis.Suggestion.noConfusion | Lean.Meta.TryThis | {P : Sort u} →
{t t' : Lean.Meta.Tactic.TryThis.Suggestion} → t = t' → Lean.Meta.Tactic.TryThis.Suggestion.noConfusionType P t t' |
_private.Mathlib.Data.Nat.Bits.0.Nat.bit_lt_bit._proof_1_3 | Mathlib.Data.Nat.Bits | ∀ {n : ℕ}, 2 * n ≤ 2 * n |
_private.Mathlib.Util.Superscript.0.Mathlib.Tactic.Superscript.partitionPoint._unary._proof_1 | Mathlib.Util.Superscript | ∀ {α : Type u_1} (as : Array α),
WellFounded (invImage (fun x => PSigma.casesOn x fun lo hi => (hi, hi - lo)) Prod.instWellFoundedRelation).1 |
CategoryTheory.RegularEpi.unop._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {f : X ⟶ Y}
(hf : CategoryTheory.RegularEpi f),
CategoryTheory.CategoryStruct.comp hf.left f = CategoryTheory.CategoryStruct.comp hf.right f |
Equiv.trans_toPartialEquiv | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (e' : β ≃ γ),
(e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv |
StarHomClass.isSelfAdjoint | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : InvolutiveStar R]
[inst_2 : AddCommMonoid E] [inst_3 : Module R E] [inst_4 : StarAddMonoid E] [inst_5 : StarModule R E]
[inst_6 : AddCommMonoid F] [inst_7 : Module R F] [inst_8 : StarAddMonoid F] [inst_9 : StarModule R F] {S : Type u_4}
[inst_10 : FunLike S E F] [inst_11 : LinearMapClass S R E F] [StarHomClass S E F] {f : S},
IsSelfAdjoint (WithConv.toConv ↑f) |
pi_nnnorm_const' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {E : Type u_2} [inst : Fintype ι] [inst_1 : SeminormedGroup E] [Nonempty ι] (a : E),
‖fun _i => a‖₊ = ‖a‖₊ |
Std.ExtTreeMap.ext_contains_unit | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
{t₁ t₂ : Std.ExtTreeMap α Unit cmp}, (∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_7 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
MeasureTheory.AEEqFun.instAddCommGroup._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : AddCommGroup γ] [IsTopologicalAddGroup γ], ContinuousAdd γ |
AddSubgroup.normal_addSubgroupOf_of_le_normalizer | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H N : AddSubgroup G}, H ≤ N.normalizer → (N.addSubgroupOf H).Normal |
StarSubalgebra.one_mem'._inherited_default | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : StarRing R} {inst_2 : Semiring A} {inst_3 : StarRing A}
{inst_4 : Algebra R A} {inst_5 : StarModule R A} (carrier : Set A),
(∀ (r : R), (algebraMap R A) r ∈ carrier) → 1 ∈ carrier |
Prod.instNeg | Mathlib.Algebra.Notation.Prod | {G : Type u_8} → {H : Type u_9} → [Neg G] → [Neg H] → Neg (G × H) |
AddSubsemigroup.unop_closure | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (s : Set Mᵃᵒᵖ),
(AddSubsemigroup.closure s).unop = AddSubsemigroup.closure (AddOpposite.op ⁻¹' s) |
asymm | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} {a b : α} [Std.Asymm r], r a b → ¬r b a |
CategoryTheory.Limits.Cofan.combPairIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {ι₁ : Type u_1} {ι₂ : Type u_2} {f₁ : ι₁ → C}
{f₂ : ι₂ → C} {c₁ : CategoryTheory.Limits.Cofan f₁} {c₂ : CategoryTheory.Limits.Cofan f₂}
{bc : CategoryTheory.Limits.BinaryCofan c₁.pt c₂.pt} (h₁ : CategoryTheory.Limits.IsColimit c₁)
(h₂ : CategoryTheory.Limits.IsColimit c₂) (h : CategoryTheory.Limits.IsColimit bc)
(s : CategoryTheory.Limits.Cofan (Sum.elim f₁ f₂))
(m : (CategoryTheory.Limits.Cofan.mk bc.pt (c₁.combPairHoms c₂ bc)).pt ⟶ s.pt),
(∀ (j : ι₁ ⊕ ι₂),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.Cofan.mk bc.pt (c₁.combPairHoms c₂ bc)).inj j) m =
s.inj j) →
m =
CategoryTheory.Limits.Cofan.IsColimit.desc h fun i =>
CategoryTheory.Limits.WalkingPair.casesOn (motive := fun t =>
i = t → (CategoryTheory.Limits.WalkingPair.casesOn i c₁.pt c₂.pt ⟶ s.pt)) i
(fun h => ⋯ ▸ CategoryTheory.Limits.Cofan.IsColimit.desc h₁ fun a => s.inj (Sum.inl a))
(fun h => ⋯ ▸ CategoryTheory.Limits.Cofan.IsColimit.desc h₂ fun a => s.inj (Sum.inr a)) ⋯ |
Std.DTreeMap.Internal.Impl.minKey?._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 |
PrimeSpectrum.closure_image_comap_zeroLocus | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (I : Ideal S),
closure (PrimeSpectrum.comap f '' PrimeSpectrum.zeroLocus ↑I) = PrimeSpectrum.zeroLocus ↑(Ideal.comap f I) |
Std.Iter.toArray_ensureTermination | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterators.Finite α Id] {it : Std.Iter β},
it.ensureTermination.toArray = it.toArray |
AddSubgroup.quotient_finite_of_isOpen | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [SeparatelyContinuousAdd G] [CompactSpace G]
(U : AddSubgroup G), IsOpen ↑U → Finite (G ⧸ U) |
lt_self_iff_false._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False |
CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda_hom_app_hom_app | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{max w v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] (X : C) (X_1 : Cᵒᵖ)
(a :
((CategoryTheory.sheafToPresheaf J (Type (max v w))).obj
((CategoryTheory.GrothendieckTopology.uliftYoneda.{w, max v w, u} J).obj X)).obj
X_1),
(J.uliftYonedaIsoYoneda.hom.app X).hom.app X_1 a = a.down |
Option.pmap_some' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : Option α} {a : α} {p : α → Prop} {f : (a : α) → p a → β} (he : x = some a)
{h : ∀ (a : α), x = some a → p a}, Option.pmap f x h = some (f a ⋯) |
DividedPowers.IsSubDPIdeal.dpow_eq_of_mem | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI : DividedPowers I) {J : Ideal A} (hJ : hI.IsSubDPIdeal J)
[inst_1 : (x : A) → Decidable (x ∈ J)] {n : ℕ} {a : A},
a ∈ J → (DividedPowers.IsSubDPIdeal.dividedPowers hI hJ).dpow n a = hI.dpow n a |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_2 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) |
Mathlib.Meta.Positivity.PositivityExt.rec | Mathlib.Tactic.Positivity.Core | {motive : Mathlib.Meta.Positivity.PositivityExt → Sort u} →
((eval :
{u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) → (e : Q(«$α»)) → Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e)) →
motive { eval := eval }) →
(t : Mathlib.Meta.Positivity.PositivityExt) → motive t |
biSup_le_eq_of_monotone | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ (b : β), ⨆ b', ⨆ (_ : b' ≤ b), f b' = f b |
ProbabilityTheory.setBernoulli_ae_subset | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {u : Set ι} {p : ↑unitInterval} [Countable ι],
∀ᵐ (s : Set ι) ∂ProbabilityTheory.setBernoulli u p, s ⊆ u |
Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k a : α} {v : β k}, a ∈ (Std.DTreeMap.Internal.Impl.insertIfNew k v t ⋯).impl → compare k a ≠ Ordering.eq → a ∈ t |
Std.DHashMap.Internal.Raw₀.Const.Equiv.beq | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[LawfulHashable α] [EquivBEq α] [inst_4 : BEq β] [ReflBEq β],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → Std.DHashMap.Internal.Raw₀.Const.beq m₁ m₂ = true |
_private.Mathlib.Data.Seq.Computation.0.Computation.lift_eq_iff_equiv.match_1_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} (c₁ c₂ : Computation α) (motive : Computation.LiftRel (fun x1 x2 => x1 = x2) c₁ c₂ → Prop)
(x : Computation.LiftRel (fun x1 x2 => x1 = x2) c₁ c₂),
(∀ (h1 : ∀ {a : α}, a ∈ c₁ → ∃ b ∈ c₂, (fun x1 x2 => x1 = x2) a b)
(h2 : ∀ {b : α}, b ∈ c₂ → ∃ a ∈ c₁, (fun x1 x2 => x1 = x2) a b), motive ⋯) →
motive x |
Lean.instReprConstantKind.repr | Lean.Environment | Lean.ConstantKind → ℕ → Std.Format |
_private.Init.Data.List.Lemmas.0.List.getLast?_dropLast._simp_1_3 | Init.Data.List.Lemmas | ∀ (a b c : ℕ), a - b - c = a - (b + c) |
_private.Mathlib.Data.Nat.Nth.0.Nat.image_nth_Iio_card._simp_1_1 | Mathlib.Data.Nat.Nth | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
StarAlgHom.realContinuousMapOfNNReal._proof_4 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A]
[inst_3 : Algebra ℝ A] (φ : C(X, NNReal) →⋆ₐ[NNReal] A) (f g : C(X, ℝ)),
φ (f + g).toNNReal - φ (-(f + g)).toNNReal = φ f.toNNReal - φ (-f).toNNReal + (φ g.toNNReal - φ (-g).toNNReal) |
_private.Lean.Compiler.LCNF.Simp.InlineCandidate.0.Lean.Compiler.LCNF.Simp.inlineCandidate?._sparseCasesOn_24 | Lean.Compiler.LCNF.Simp.InlineCandidate | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((fvarId : Lean.FVarId) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) → motive (Lean.Compiler.LCNF.LetValue.fvar fvarId args)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIso._proof_3 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.forget AddCommGrpCat) |
ClassGroup.mkMMem_surjective | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_1} {S : Type u_2} [inst : EuclideanDomain R] [inst_1 : CommRing S] [inst_2 : IsDomain S]
[inst_3 : Algebra R S] {abv : AbsoluteValue R ℤ} {ι : Type u_5} [inst_4 : DecidableEq ι] [inst_5 : Fintype ι]
(bS : Module.Basis ι R S) (adm : abv.IsAdmissible) [inst_6 : Infinite R] [inst_7 : DecidableEq R]
[inst_8 : IsDedekindDomain S] [Algebra.IsAlgebraic R S], Function.Surjective (ClassGroup.mkMMem bS adm) |
Num.oneBits | Mathlib.Data.Num.Bitwise | Num → List ℕ |
Std.Internal.List.isNone_maxKey?_eq_isEmpty | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {l : List ((a : α) × β a)},
(Std.Internal.List.maxKey? l).isNone = l.isEmpty |
Set.powersetCard.coe_compl | Mathlib.Data.Set.PowersetCard | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] [inst_1 : Fintype α] {m : ℕ} {hm : m + n = Fintype.card α}
{s : ↑(Set.powersetCard α n)}, ↑((Set.powersetCard.compl hm) s) = (↑s)ᶜ |
Finset.mem_shatterer | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α}, s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s |
_private.Init.Data.String.Basic.0.String.utf8ByteSize_push._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, s.utf8ByteSize = s.toByteArray.size |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processConstApprox.defaultCase | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool |
CategoryTheory.Idempotents.Karoubi.mk._flat_ctor | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(X : C) →
(p : X ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp p p = p) CategoryTheory.Idempotents.Karoubi.idem._autoParam →
CategoryTheory.Idempotents.Karoubi C |
RootPairing.Equiv.coweightEquiv | Mathlib.LinearAlgebra.RootSystem.Hom | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{ι₂ : Type u_5} →
{M₂ : Type u_6} →
{N₂ : Type u_7} →
[inst_5 : AddCommGroup M₂] →
[inst_6 : Module R M₂] →
[inst_7 : AddCommGroup N₂] →
[inst_8 : Module R N₂] →
(P : RootPairing ι R M N) → (Q : RootPairing ι₂ R M₂ N₂) → P.Equiv Q → N₂ ≃ₗ[R] N |
WeierstrassCurve.j_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [inst_1 : W.IsElliptic], W.c₄ = 0 → W.j = 0 |
Std.ExtDHashMap.mem_of_getKey?_eq_some | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α}, m.getKey? k = some k' → k' ∈ m |
Std.DTreeMap.Raw.Equiv.getEntryLTD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : (a : α) × β a}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLTD k fallback = t₂.getEntryLTD k fallback |
NumberField.mixedEmbedding.normAtAllPlaces_normAtAllPlaces | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] (x : NumberField.mixedEmbedding.mixedSpace K),
NumberField.mixedEmbedding.normAtAllPlaces
(NumberField.mixedEmbedding.mixedSpaceOfRealSpace (NumberField.mixedEmbedding.normAtAllPlaces x)) =
NumberField.mixedEmbedding.normAtAllPlaces x |
_private.Mathlib.Analysis.ODE.PicardLindelof.0.ContDiffAt.exists_forall_mem_closedBall_exists_eq_forall_mem_Ioo_hasDerivAt₀.match_1_1 | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → E} {x₀ : E} (t₀ ε : ℝ)
(motive : (∃ α, α t₀ = x₀ ∧ ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t) → Prop)
(x : ∃ α, α t₀ = x₀ ∧ ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t),
(∀ (α : ℝ → E) (hα1 : α t₀ = x₀) (hα2 : ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t), motive ⋯) →
motive x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.