name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.PersistentArray.Stats.mk.inj | Lean.Data.PersistentArray | ∀ {numNodes depth tailSize numNodes_1 depth_1 tailSize_1 : ℕ},
{ numNodes := numNodes, depth := depth, tailSize := tailSize } =
{ numNodes := numNodes_1, depth := depth_1, tailSize := tailSize_1 } →
numNodes = numNodes_1 ∧ depth = depth_1 ∧ tailSize = tailSize_1 |
CategoryTheory.Abelian.Ext.mk₀_id_comp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n),
(CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.id X)).comp α ⋯ = α |
Set.MapsTo.extendDomain | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {p : β → Prop} [inst : DecidablePred p] {f : α ≃ Subtype p} {g : Equiv.Perm α}
{s t : Set α}, Set.MapsTo (⇑g) s t → Set.MapsTo (⇑(g.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t) |
Lean.Lsp.instFromJsonLeanFileProgressKind._sparseCasesOn_1 | Lean.Data.Lsp.Extra | {ε : Type u} →
{α : Type v} →
{motive : Except ε α → Sort u_1} →
(t : Except ε α) → ((a : α) → motive (Except.ok a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ChosenPullbacksAlong.Over.leftUnitor_inv_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
(Z : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor Z).inv.left
(CategoryTheory.ChosenPullbacksAlong.fst (CategoryTheory.CategoryStruct.id X) Z.hom) =
Z.hom |
Std.DTreeMap.Internal.Impl.alter._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced) (d : Std.DTreeMap.Internal.Impl α β)
(hd : d.Balanced) (hd'₁ : l'.size - 1 ≤ d.size) (hd'₂ : d.size ≤ l'.size + 1),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').size - 1 ≤
(Std.DTreeMap.Internal.Impl.balance k' v' d r' ⋯ ⋯ ⋯).size |
Vector.getElem_ofFn | Init.Data.Vector.OfFn | ∀ {i : ℕ} {α : Type u_1} {n : ℕ} {f : Fin n → α} (h : i < n), (Vector.ofFn f)[i] = f ⟨i, h⟩ |
ByteArray.extract_add_left | Init.Data.ByteArray.Lemmas | ∀ {b : ByteArray} {i j : ℕ}, b.extract (i + j) i = ByteArray.empty |
CategoryTheory.Discrete.sumEquiv.match_3 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_2} →
{K : Type u_1} →
(motive : CategoryTheory.Discrete (J ⊕ K) → Sort u_3) →
(x : CategoryTheory.Discrete (J ⊕ K)) → ((x : J ⊕ K) → motive { as := x }) → motive x |
RingHom.smulOneHom_eq_algebraMap | Mathlib.Algebra.Algebra.Defs | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
RingHom.smulOneHom = algebraMap R A |
Nat.prime_five | Mathlib.Data.Nat.Prime.Defs | Nat.Prime 5 |
Lean.Diff.instBEqAction | Lean.Util.Diff | BEq Lean.Diff.Action |
MeasureTheory.Measure.measure_subtype_coe_eq_zero_of_comap_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet s μ →
∀ {t : Set ↑s}, (MeasureTheory.Measure.comap Subtype.val μ) t = 0 → μ (Subtype.val '' t) = 0 |
UInt16.ofNatLT_finVal | Init.Data.UInt.Lemmas | ∀ (n : Fin UInt16.size), UInt16.ofNatLT ↑n ⋯ = UInt16.ofFin n |
_private.Mathlib.Tactic.Order.Preprocessing.0.Mathlib.Tactic.Order.preprocessFacts.match_1 | Mathlib.Tactic.Order.Preprocessing | (motive : Mathlib.Tactic.Order.OrderType → Sort u_1) →
(orderType : Mathlib.Tactic.Order.OrderType) →
(Unit → motive Mathlib.Tactic.Order.OrderType.pre) →
(Unit → motive Mathlib.Tactic.Order.OrderType.part) →
(Unit → motive Mathlib.Tactic.Order.OrderType.lin) → motive orderType |
MeasureTheory.integral_div_right_eq_self | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_4} {E : Type u_5} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure G} [inst_3 : Group G] [MeasurableMul G] [μ.IsMulRightInvariant] (f : G → E) (g : G),
∫ (x : G), f (x / g) ∂μ = ∫ (x : G), f x ∂μ |
CategoryTheory.IndParallelPairPresentation._sizeOf_1 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
{f g : A ⟶ B} → [SizeOf C] → CategoryTheory.IndParallelPairPresentation f g → ℕ |
CocompactMap.comp_apply | Mathlib.Topology.ContinuousMap.CocompactMap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : CocompactMap β γ) (g : CocompactMap α β) (a : α), (f.comp g) a = f (g a) |
_private.Mathlib.RingTheory.GradedAlgebra.TensorProduct.0.GradedAlgebra.baseChange._simp_1 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Set M}
{p : Submodule R M}, (Submodule.span R s ≤ p) = (s ⊆ ↑p) |
AddSubmonoid.toSubmonoid._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {A : Type u_1} [inst : AddZeroClass A] (x : Submonoid (Multiplicative A)),
(fun S => { carrier := ⇑Multiplicative.toAdd ⁻¹' ↑S, mul_mem' := ⋯, one_mem' := ⋯ })
((fun S => { carrier := ⇑Multiplicative.ofAdd ⁻¹' ↑S, add_mem' := ⋯, zero_mem' := ⋯ }) x) =
x |
continuous_of_discreteTopology | Mathlib.Topology.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [DiscreteTopology α] {β : Type u_2} [inst_2 : TopologicalSpace β]
{f : α → β}, Continuous f |
_private.Mathlib.Data.PNat.Find.0.PNat.find_le_iff._simp_1_1 | Mathlib.Data.PNat.Find | ∀ {a b : ℕ+}, (a ≤ b) = (a < b + 1) |
_private.Lean.DocString.Extension.0.Lean.builtinDocStrings._proof_1 | Lean.DocString.Extension | Nonempty (ST.Ref IO.RealWorld (Lean.NameMap String)) |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.instInhabited | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} → Inhabited (Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) |
Sigma.instVAddAssocClassOfVAdd | Mathlib.Algebra.Group.Action.Sigma | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → VAdd M (α i)]
[inst_1 : (i : ι) → VAdd N (α i)] [inst_2 : VAdd M N] [∀ (i : ι), VAddAssocClass M N (α i)],
VAddAssocClass M N ((i : ι) × α i) |
Lean.Elab.RecKind.noConfusion | Lean.Elab.DeclModifiers | {P : Sort v✝} → {x y : Lean.Elab.RecKind} → x = y → Lean.Elab.RecKind.noConfusionType P x y |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.haarScalarFactor_eq_mul._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {n m : NNReal}, (↑n = ↑m) = (n = m) |
Representation.Equiv.symm_apply_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
{ρ : Representation A G V} {σ : Representation A G W} (φ : ρ.Equiv σ) (v : V), φ.symm (φ v) = v |
Antivary.add_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : AddCommGroup β] [inst_2 : LinearOrder β]
[IsOrderedAddMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Antivary f g₂ → Antivary f (g₁ + g₂) |
PowerSeries.«_aux_Mathlib_RingTheory_PowerSeries_WeierstrassPreparation___macroRules_PowerSeries_term_/ʷ__1» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.Macro |
Function.iterate_fixed | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} {f : α → α} {x : α}, f x = x → ∀ (n : ℕ), f^[n] x = x |
CommGrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} CommGrpCat.uliftFunctor |
_private.Qq.Macro.0.Qq.Impl.makeZetaReduce.match_1 | Qq.Macro | (motive : Option (Option Lean.LocalContext) → Sort u_1) →
(x : Option (Option Lean.LocalContext)) →
(Unit → motive none) → ((a : Option Lean.LocalContext) → motive (some a)) → motive x |
List.mapDiagM.go._unsafe_rec | Batteries.Data.List.Basic | {m : Type u_1 → Type u_2} → {α : Type u_3} → {β : Type u_1} → [Monad m] → (α → α → m β) → List α → Array β → m (List β) |
Rep.invariantsAdjunction_homEquiv_apply_hom._proof_1 | Mathlib.RepresentationTheory.Invariants | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G] {X : ModuleCat k} {Y : Rep k G}
(f : (Rep.trivialFunctor k G).obj X ⟶ Y) (c : ↑((Rep.trivialFunctor k G).obj X).V),
(ModuleCat.Hom.hom f.hom) c ∈ Y.ρ.invariants |
Nat.Linear.instBEqPolyCnstr.beq_spec_2 | Init.Data.Nat.Linear | ∀ (x x_1 : Nat.Linear.PolyCnstr),
(∀ (a : Bool) (a_1 a_2 : Nat.Linear.Poly) (b : Bool) (b_1 b_2 : Nat.Linear.Poly),
x = { eq := a, lhs := a_1, rhs := a_2 } → x_1 = { eq := b, lhs := b_1, rhs := b_2 } → False) →
(x == x_1) = false |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.D₂_totalShift₁XIso_hom._proof_1_2 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (x n₀ n₁ n₀' n₁' : ℤ), n₀ + x = n₀' → n₁ + x = n₁' → n₀ + 1 = n₁ → ∀ (p q : ℤ), p + q = n₀ → p + x + (q + 1) = n₁' |
Array.mkArray8 | Init.Prelude | {α : Type u} → α → α → α → α → α → α → α → α → Array α |
MonomialOrder.degree_X | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] [Nontrivial R] {s : σ},
m.degree (MvPolynomial.X s) = fun₀ | s => 1 |
CategoryTheory.Aut.isoPerm._proof_9 | Mathlib.Algebra.Category.Grp.Basic | ∀ {α : Type u_1},
CategoryTheory.CategoryStruct.comp
(GrpCat.ofHom { toFun := fun g => CategoryTheory.Iso.toEquiv g, map_one' := ⋯, map_mul' := ⋯ })
(GrpCat.ofHom { toFun := fun g => Equiv.toIso g, map_one' := ⋯, map_mul' := ⋯ }) =
CategoryTheory.CategoryStruct.id (GrpCat.of (CategoryTheory.Aut α)) |
Lean.Elab.Tactic.Do.countUsesDecl._unsafe_rec | Lean.Elab.Tactic.Do.LetElim | Lean.FVarId →
Lean.Expr →
Option Lean.Expr →
Lean.Elab.Tactic.Do.FVarUses →
optParam (Array Lean.FVarId) #[] → Lean.MetaM (Lean.Expr × Option Lean.Expr × Lean.Elab.Tactic.Do.FVarUses) |
Lean.Grind.ToInt.LE.rec | Init.Grind.ToInt | {α : Type u} →
[inst : LE α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.LE α I → Sort u_1} →
((le_iff : ∀ (x y : α), x ≤ y ↔ ↑x ≤ ↑y) → motive ⋯) → (t : Lean.Grind.ToInt.LE α I) → motive t |
LightCondensed.lanLightCondSet | Mathlib.Condensed.Discrete.Colimit | Type u → LightCondSet |
Lean.PersistentHashMap.Entry.recOn | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
(t : Lean.PersistentHashMap.Entry α β σ) →
((key : α) → (val : β) → motive (Lean.PersistentHashMap.Entry.entry key val)) →
((node : σ) → motive (Lean.PersistentHashMap.Entry.ref node)) →
motive Lean.PersistentHashMap.Entry.null → motive t |
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_hom_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B)
(L : CategoryTheory.Functor A C) [inst_4 : G.PreservesPointwiseLeftKanExtension F L]
[inst_5 : L.HasPointwiseLeftKanExtension F] (a : A),
CategoryTheory.CategoryStruct.comp (G.map ((L.pointwiseLeftKanExtensionUnit F).app a))
((G.pointwiseLeftKanExtensionCompIsoOfPreserves F L).hom.app (L.obj a)) =
(L.pointwiseLeftKanExtensionUnit (F.comp G)).app a |
FirstOrder.Language.BoundedFormula.iSup | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → {n : ℕ} → [Finite β] → (β → L.BoundedFormula α n) → L.BoundedFormula α n |
cmp_compares | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), (cmp a b).Compares a b |
Mathlib.Tactic.Abel.AbelNF.Config.contextual._inherited_default | Mathlib.Tactic.Abel | Bool |
CategoryTheory.Comma.toPUnitIdEquiv_functor_iso | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A]
{L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1})}
{R : CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{u_2 + 1}) (CategoryTheory.Discrete PUnit.{u_1 + 1})},
(CategoryTheory.Comma.toPUnitIdEquiv L R).functor = CategoryTheory.Comma.fst L R |
Std.DTreeMap.Internal.Impl.Const.size_filter!_le_size | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
{f : α → β → Bool}, t.WF → (Std.DTreeMap.Internal.Impl.filter! f t).size ≤ t.size |
mem_nonZeroDivisorsLeft_iff._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, (x ∈ nonZeroDivisorsLeft M₀) = ∀ (y : M₀), x * y = 0 → y = 0 |
_private.Lean.Widget.UserWidget.0.Lean.Widget.getWidgets.match_1 | Lean.Widget.UserWidget | (motive : Option Lean.Elab.InfoTree → Sort u_1) →
(x : Option Lean.Elab.InfoTree) →
((infoTree : Lean.Elab.InfoTree) →
(cc : Lean.Elab.CommandContextInfo) →
(t : Lean.Elab.InfoTree) →
(h : infoTree = Lean.Elab.InfoTree.context (Lean.Elab.PartialContextInfo.commandCtx cc) t) →
motive
(some
(namedPattern infoTree (Lean.Elab.InfoTree.context (Lean.Elab.PartialContextInfo.commandCtx cc) t)
h))) →
((x : Option Lean.Elab.InfoTree) → motive x) → motive x |
CategoryTheory.Comma.eqToHom_left | 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] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) (X Y : CategoryTheory.Comma L R) (H : X = Y),
(CategoryTheory.eqToHom H).left = CategoryTheory.eqToHom ⋯ |
IsTopologicalAddGroup.rightUniformSpace._proof_3 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G],
∀ U ∈ nhds 0,
U ∈ Filter.map (fun p => p.2 + -p.1) ((Filter.comap (fun p => p.2 + -p.1) (nhds 0)).lift' fun s => SetRel.comp s s) |
Submodule.module.hcongr_6 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ (R R' : Type u),
R = R' →
∀ (M M' : Type v),
M = M' →
∀ (inst : Semiring R) (inst' : Semiring R'),
inst ≍ inst' →
∀ (inst_1 : AddCommMonoid M) (inst'_1 : AddCommMonoid M'),
inst_1 ≍ inst'_1 →
∀ (module_M : Module R M) (module_M' : Module R' M'),
module_M ≍ module_M' → ∀ (p : Submodule R M) (p' : Submodule R' M'), p ≍ p' → p.module ≍ p'.module |
div_le_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c d : α}, a / b ≤ c / d ↔ a * d ≤ c * b |
LipschitzWith.norm_sub_le_of_le | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] {f : E → F}
{C : NNReal} {a b : E} {r : ℝ}, LipschitzWith C f → ‖a - b‖ ≤ r → ‖f a - f b‖ ≤ ↑C * r |
Subgroup.periods.eq_1 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.periods = 𝒢.adjoinNegOne.strictPeriods |
Filter.tendsto_image_smallSets._simp_1 | Mathlib.Order.Filter.SmallSets | ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {f : α → β},
Filter.Tendsto (fun x => f '' x) la.smallSets lb.smallSets = Filter.Tendsto f la lb |
_private.Mathlib.Algebra.Order.Star.Prod.0.Prod.instStarOrderedRing._simp_6 | Mathlib.Algebra.Order.Star.Prod | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) |
CategoryTheory.Limits.PreservesColimit₂.of_preservesColimit₂_flip | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C] {K₁ : CategoryTheory.Functor J₁ C₁}
{K₂ : CategoryTheory.Functor J₂ C₂} (G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C))
[CategoryTheory.Limits.PreservesColimit₂ K₁ K₂ G], CategoryTheory.Limits.PreservesColimit₂ K₂ K₁ G.flip |
CategoryTheory.conjugateEquiv_mateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor A B}
{R₂ : CategoryTheory.Functor B A} {L₃ : CategoryTheory.Functor C D} {R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁)
(adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : L₂ ⟶ L₁) (β : CategoryTheory.TwoSquare G L₂ L₃ H),
(CategoryTheory.mateEquiv adj₁ adj₃) (β.whiskerLeft α) =
((CategoryTheory.mateEquiv adj₂ adj₃) β).whiskerTop ((CategoryTheory.conjugateEquiv adj₁ adj₂) α) |
Turing.ToPartrec.Cfg.halt.elim | Mathlib.Computability.TMConfig | {motive : Turing.ToPartrec.Cfg → Sort u} →
(t : Turing.ToPartrec.Cfg) → t.ctorIdx = 0 → ((a : List ℕ) → motive (Turing.ToPartrec.Cfg.halt a)) → motive t |
SubfieldClass.toField._proof_7 | Mathlib.Algebra.Field.Subfield.Defs | ∀ (S : Type u_1) {K : Type u_2} [inst : Field K] [inst_1 : SetLike S K] [SubfieldClass S K], OneMemClass S K |
DFinsupp.instZero | Mathlib.Data.DFinsupp.Defs | {ι : Type u} → {β : ι → Type v} → [inst : (i : ι) → Zero (β i)] → Zero (Π₀ (i : ι), β i) |
absorbs_iff_eventually_cobounded_mapsTo | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t ↔ ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s |
Std.ExtDHashMap.getKey?.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β), m = m_1 → ∀ (a a_1 : α), a = a_1 → m.getKey? a = m_1.getKey? a_1 |
List.Matcher.find? | Batteries.Data.List.Matcher | {α : Type u_1} → [BEq α] → List.Matcher α → List α → Option (ℕ × ℕ) |
CategoryTheory.Regular.frobeniusStrongEpiMonoFactorisation._proof_3 | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Regular C] {A B : C} (f : A ⟶ B)
(A' : CategoryTheory.Subobject A) (B' : CategoryTheory.Subobject B),
CategoryTheory.StrongEpi (CategoryTheory.Regular.frobeniusMorphism f A' B') |
Lean.Lsp.LeanDeclIdent.mk.injEq | Lean.Data.Lsp.Internal | ∀ (module decl module_1 decl_1 : Lean.Name),
({ module := module, decl := decl } = { module := module_1, decl := decl_1 }) = (module = module_1 ∧ decl = decl_1) |
Monotone.iSup_comp_eq | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ {s : ι → β}, (∀ (x : β), ∃ i, x ≤ s i) → ⨆ x, f (s x) = ⨆ y, f y |
MonoidHom.compAddChar_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddMonoid A] [inst_1 : Monoid M] [inst_2 : Monoid N] (f : M →* N)
(φ : AddChar A M), ⇑(f.compAddChar φ) = ⇑f ∘ ⇑φ |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite._proof_6 | Mathlib.CategoryTheory.Sites.CartesianClosed | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} A]
(F : (CategoryTheory.sheafToPresheaf J A).EssImageSubcategory), CategoryTheory.Presheaf.IsSheaf J F.obj |
AddOpposite.instSemiring._proof_6 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (x : Rᵃᵒᵖ), Monoid.npow (n + 1) x = Monoid.npow n x * x |
_private.Mathlib.Data.Finset.Basic.0.Finset.disjoint_union_right._simp_1_2 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) |
CategoryTheory.HasShift.mkShiftCoreOp._proof_6 | Mathlib.CategoryTheory.Shift.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (A : Type u_3) [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (n : A) (X : Cᵒᵖ),
(CategoryTheory.shiftFunctor C (0 + n)).op.obj X =
(CategoryTheory.shiftFunctor C n).op.obj ((CategoryTheory.Functor.id Cᵒᵖ).obj X) |
ContinuousOn.cfcₙ' | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {X : Type u_1} {𝕜 : Type u_2} {A : Type u_3} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[ContinuousStar A] [inst_7 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] [inst_8 : TopologicalSpace X]
{s : Set 𝕜},
IsCompact s →
∀ (f : 𝕜 → 𝕜) {a : X → A} {t : Set X},
ContinuousOn a t →
(∀ x ∈ t, quasispectrum 𝕜 (a x) ⊆ s) →
(∀ x ∈ t, p (a x)) →
autoParam (ContinuousOn f s) ContinuousOn.cfcₙ'._auto_1 →
autoParam (f 0 = 0) ContinuousOn.cfcₙ'._auto_3 → ContinuousOn (fun x => cfcₙ f (a x)) t |
Batteries.RBNode.Path.del._unsafe_rec | Batteries.Data.RBMap.Basic | {α : Type u_1} → Batteries.RBNode.Path α → Batteries.RBNode α → Batteries.RBColor → Batteries.RBNode α |
Finsupp.lmapDomain_linearCombination | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{α' : Type u_7} {M' : Type u_8} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {v : α → M} {v' : α' → M'}
(f : α → α') (g : M →ₗ[R] M'),
(∀ (i : α), g (v i) = v' (f i)) →
Finsupp.linearCombination R v' ∘ₗ Finsupp.lmapDomain R R f = g ∘ₗ Finsupp.linearCombination R v |
Lean.Elab.Term.Op.elabDefaultOrNonempty._regBuiltin.Lean.Elab.Term.Op.elabDefaultOrNonempty.declRange_3 | Lean.Elab.Extra | IO Unit |
zpow_one_sub_natCast | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℕ), a ^ (1 - ↑n) = a / a ^ n |
CategoryTheory.Oplax.OplaxTrans.naturality_id_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) (a : B) {Z : F.obj a ⟶ G.obj a}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryTheory.CategoryStruct.id (G.obj a)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.naturality (CategoryTheory.CategoryStruct.id a))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.app a) (G.mapId a)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapId a) (self.app a))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (self.app a)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (self.app a)).inv h)) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_filterMap._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
EuclideanGeometry.oangle_rotate_sign | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [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)]
(p₁ p₂ p₃ : P), (EuclideanGeometry.oangle p₂ p₃ p₁).sign = (EuclideanGeometry.oangle p₁ p₂ p₃).sign |
Set.graphOn_nonempty | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, (Set.graphOn f s).Nonempty ↔ s.Nonempty |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalMax.match_6 | Mathlib.Tactic.Positivity.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(b : Q(«$α»)) →
(motive : Mathlib.Meta.Positivity.Strictness zα pα b → Sort u_1) →
(rb : Mathlib.Meta.Positivity.Strictness zα pα b) →
((pb : Q(0 < «$b»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pb)) →
((pb : Q(0 ≤ «$b»)) → motive (Mathlib.Meta.Positivity.Strictness.nonnegative pb)) →
((pb : Q(«$b» ≠ 0)) → motive (Mathlib.Meta.Positivity.Strictness.nonzero pb)) →
((x : Mathlib.Meta.Positivity.Strictness zα pα b) → motive x) → motive rb |
Std.HashMap.getElem!_diff_of_not_mem_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], k ∉ m₂ → (m₁ \ m₂)[k]! = m₁[k]! |
Real.normedField._proof_11 | Mathlib.Analysis.Normed.Field.Basic | ∀ (x : ℝ), Semiring.npow 0 x = 1 |
HomologicalComplex.instEpiFπTruncGE | Mathlib.Algebra.Homology.Embedding.TruncGE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncGE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 : CategoryTheory.Limits.HasZeroObject C] (i' : ι'), CategoryTheory.Epi ((K.πTruncGE e).f i') |
GradedRingHom.copy | Mathlib.RingTheory.GradedAlgebra.RingHom | {ι : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_6} →
{τ : Type u_7} →
[inst : Semiring A] →
[inst_1 : Semiring B] →
[inst_2 : SetLike σ A] →
[inst_3 : SetLike τ B] → {𝒜 : ι → σ} → {ℬ : ι → τ} → (f : 𝒜 →+*ᵍ ℬ) → (f' : A → B) → f' = ⇑f → 𝒜 →+*ᵍ ℬ |
IO.FS.SystemTime.mk.sizeOf_spec | Init.System.IO | ∀ (sec : ℤ) (nsec : UInt32), sizeOf { sec := sec, nsec := nsec } = 1 + sizeOf sec + sizeOf nsec |
CategoryTheory.Limits.biproduct.ι_fromSubtype_assoc | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
(p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] (j : Subtype p) {Z : C}
(h : ⨁ f ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι (Subtype.restrict p f) j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.fromSubtype f p) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f ↑j) h |
Monoid.CoprodI.Word.smul_eq_of_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 : ι} (m : M i) (w : Monoid.CoprodI.Word M), m • w = Monoid.CoprodI.of m • w |
Batteries.AssocList.toList_modify | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} [inst : BEq α] (a : α) (l : Batteries.AssocList α β),
(Batteries.AssocList.modify a f l).toList =
List.replaceF
(fun x =>
match x with
| (k, v) => bif k == a then some (a, f k v) else none)
l.toList |
CategoryTheory.Injective.instOfNonempty | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ (X : Type u₁) [Nonempty X], CategoryTheory.Injective X |
SMulCommClass.recOn | Mathlib.Algebra.Group.Action.Defs | {M : Type u_9} →
{N : Type u_10} →
{α : Type u_11} →
[inst : SMul M α] →
[inst_1 : SMul N α] →
{motive : SMulCommClass M N α → Sort u} →
(t : SMulCommClass M N α) →
((smul_comm : ∀ (m : M) (n : N) (a : α), m • n • a = n • m • a) → motive ⋯) → motive t |
Submonoid.map_bot | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F), Submonoid.map f ⊥ = ⊥ |
OrderIso.map_atTop | Mathlib.Order.Filter.AtTopBot.Map | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
Filter.map (⇑e) Filter.atTop = Filter.atTop |
Polynomial.squarefree_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], Squarefree (Polynomial.cyclotomic n K) |
StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf._proof_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] {𝓕 : TopCat.Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c)
(U V : (TopologicalSpace.Opens ↑X)ᵒᵖ) (inc : U ⟶ V),
CategoryTheory.CategoryStruct.comp (𝓕.map inc)
(if h : p₀ ∈ Opposite.unop V then
CategoryTheory.CategoryStruct.comp (𝓕.germ (Opposite.unop V) p₀ h)
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom ⋯))
else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from (𝓕.obj V)) =
CategoryTheory.CategoryStruct.comp
(if h : p₀ ∈ Opposite.unop U then
CategoryTheory.CategoryStruct.comp (𝓕.germ (Opposite.unop U) p₀ h)
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom ⋯))
else (⋯ ▸ CategoryTheory.Limits.terminalIsTerminal).from (𝓕.obj U))
((skyscraperPresheaf p₀ c).map inc) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.