name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris.0.CategoryTheory.GrothendieckTopology.MayerVietorisSquare.fromBiprod_δ._proof_1_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris | ∀ (n₀ n₁ : ℕ), ¬1 + 2 ≤ 5 → False |
AEMeasurable.map_map_of_aemeasurable | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {g : β → γ} {f : α → β},
AEMeasurable g (MeasureTheory.Measure.map f μ) →
AEMeasurable f μ → MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) = MeasureTheory.Measure.map (g ∘ f) μ |
CategoryTheory.FreeBicategory.Hom₂.associator_inv | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c d : CategoryTheory.FreeBicategory B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
CategoryTheory.FreeBicategory.Hom₂
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h) |
Std.TreeMap.Raw.getElem?_eq_some_getD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α} {fallback : β}, t.contains a = true → t[a]? = some (t.getD a fallback) |
Lean.Elab.Term.Quotation.precheckAttribute._regBuiltin.Lean.Elab.Term.Quotation.precheckAttribute.declRange_3 | Lean.Elab.Quotation.Precheck | IO Unit |
Module.DirectLimit.lift_of'._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_3} [inst : Semiring R] {ι : Type u_1} [inst_1 : Preorder ι] {G : ι → Type u_2}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] (i j : ι) (hij : i ≤ j) (x : G i),
(Module.DirectLimit.of R ι G f j) ((f i j hij) x) = (Module.DirectLimit.of R ι G f i) x |
Lean.Firefox.Profile.meta | Lean.Util.Profiler | Lean.Firefox.Profile → Lean.Firefox.ProfileMeta |
Rack.PreEnvelGroupRel'.trans.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 2 →
({a b c : Rack.PreEnvelGroup R} →
(hab : Rack.PreEnvelGroupRel' R a b) →
(hbc : Rack.PreEnvelGroupRel' R b c) → motive a c (hab.trans hbc)) →
motive a a_1 t |
Sublattice.le_prod_iff | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] {L : Sublattice α} {M : Sublattice β}
{N : Sublattice (α × β)}, N ≤ L.prod M ↔ N ≤ Sublattice.comap LatticeHom.fst L ∧ N ≤ Sublattice.comap LatticeHom.snd M |
CategoryTheory.Functor.IsDenseSubsite.hasWeakSheafify_of_isEquivalence | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) (A : Type u_4)
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] [inst_3 : CategoryTheory.Functor.IsDenseSubsite J K G]
[(G.sheafPushforwardContinuous A J K).IsEquivalence] [CategoryTheory.HasWeakSheafify J A],
CategoryTheory.HasWeakSheafify K A |
instPreservesFiniteProductsOppositeYonedaPresheafOfPreservesFiniteCoproductsTopCat | Mathlib.Condensed.TopComparison | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (G : CategoryTheory.Functor C TopCat) (X : Type w')
[inst_1 : TopologicalSpace X] [CategoryTheory.Limits.PreservesFiniteCoproducts G],
CategoryTheory.Limits.PreservesFiniteProducts (ContinuousMap.yonedaPresheaf G X) |
CategoryTheory.Limits.MonoFactorisation.copy_m | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
(F : CategoryTheory.Limits.MonoFactorisation f) (m : F.I ⟶ Y) (e : X ⟶ F.I)
(hm : autoParam (m = F.m) CategoryTheory.Limits.MonoFactorisation.copy._auto_1)
(he : autoParam (e = F.e) CategoryTheory.Limits.MonoFactorisation.copy._auto_3), (F.copy m e hm he).m = m |
Filter.Germ.coeRingHom._proof_3 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {R : Type u_1} [inst : Semiring R] (l : Filter α), (↑(Filter.Germ.coeAddHom l)).toFun 0 = 0 |
Subgroup.instMulDistribMulActionSubtypeMemNormalizer._proof_3 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (r : ↥H.normalizer) (x y : ↥H), r • (x * y) = r • x * r • y |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_3 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
Std.TreeMap.minKeyD_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β}
{fallback : α}, (t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' |
ENNReal.limsup_const_mul | Mathlib.Order.Filter.ENNReal | ∀ {α : Type u_1} {f : Filter α} [CountableInterFilter f] {u : α → ENNReal} {a : ENNReal},
Filter.limsup (fun x => a * u x) f = a * Filter.limsup u f |
Encodable.decodeSum._sparseCasesOn_1.else_eq | Mathlib.Logic.Encodable.Basic | ∀ {motive : Bool → Sort u} (t : Bool) (false : motive false) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Encodable.decodeSum._sparseCasesOn_1 t false «else» = «else» h |
_private.Mathlib.Algebra.Order.SuccPred.PartialSups.0.partialSups_add_one'._simp_1_1 | Mathlib.Algebra.Order.SuccPred.PartialSups | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Add α] [inst_2 : One α] [inst_3 : SuccAddOrder α] (x : α),
x + 1 = Order.succ x |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path._simp_1_3 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} (l : List (Option α)), (l.reduceOption = []) = ∃ n, l = List.replicate n none |
IsAtom.of_compl | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {a : α}, IsAtom aᶜ → IsCoatom a |
CategoryTheory.conjugateEquiv_adjunction_id_symm | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {L R : CategoryTheory.Functor C C} (adj : L ⊣ R)
(α : R ⟶ CategoryTheory.Functor.id C) (c : C),
((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id).symm α).app c =
CategoryTheory.CategoryStruct.comp (adj.unit.app c) (α.app (L.obj c)) |
Lean.ParametricAttributeExtra.mk._flat_ctor | Batteries.Lean.AttributeExtra | {α : Type} → Lean.ParametricAttribute α → Std.HashMap Lean.Name α → Lean.ParametricAttributeExtra α |
_private.Mathlib.RingTheory.Etale.Pi.0.Algebra.FormallyEtale.pi_iff._simp_1_1 | Mathlib.RingTheory.Etale.Pi | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.FormallyEtale R A = (Algebra.FormallyUnramified R A ∧ Algebra.FormallySmooth R A) |
Lists'.mem_of_subset | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁ → a ∈ l₂ |
_private.Mathlib.Analysis.Complex.Arg.0.Complex.sameRay_iff._simp_1_6 | Mathlib.Analysis.Complex.Arg | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
_private.Mathlib.LinearAlgebra.Matrix.ToLinearEquiv.0.Matrix.det_ne_zero_of_sum_col_pos._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a < s.sup' H f) = ∃ b ∈ s, a < f b |
LocallyConstant.mapAddMonoidHom.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {Z : Type u_6} [inst_1 : AddZeroClass Y]
[inst_2 : AddZeroClass Z] (f : Y →+ Z),
LocallyConstant.mapAddMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_zero' := ⋯, map_add' := ⋯ } |
Filter.comap_sup | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g₁ g₂ : Filter β} {m : α → β},
Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂ |
IsRelUpperSet.mem_of_le | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {s : Set α} {a b : α} {P : α → Prop} [inst : LE α], IsRelUpperSet s P → a ∈ s → a ≤ b → P b → b ∈ s |
Pell.yn_modEq_a_sub_one | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 n ≡ n [MOD a - 1] |
AddEquiv.prodAssoc.match_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_2} {N : Type u_1} {P : Type u_3} (motive : (M × N) × P → Prop) (x : (M × N) × P),
(∀ (fst : M × N) (snd : P), motive (fst, snd)) → motive x |
Ordinal.succ_iSup_eq_lsub_iff | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (f : ι → Ordinal.{max u_5 u_4}), Order.succ (iSup f) = Ordinal.lsub f ↔ ∃ i, f i = iSup f |
UInt8.toUInt32_le._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a.toUInt32 ≤ b.toUInt32) = (a ≤ b) |
Std.ExtHashMap.getKey!_eq_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, k ∈ m → m.getKey! k = k |
AddMemClass.subtype._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_2} [inst : Add M] [inst_1 : SetLike A M] [hA : AddMemClass A M] (S' : A) (x x_1 : ↥S'),
↑(x + x_1) = ↑(x + x_1) |
UInt32.recOn._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.395 | Mathlib.Util.CompileInductive | {motive : UInt32 → Sort u} → (t : UInt32) → ((toBitVec : BitVec 32) → motive { toBitVec := toBitVec }) → motive t |
Lean.Elab.Do.Context._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.Context |
bernoulli'_zero | Mathlib.NumberTheory.Bernoulli | bernoulli' 0 = 1 |
lTensor.inverse._proof_1 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {N : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : AddCommGroup P]
[inst_3 : Module R N] [inst_4 : Module R P] {g : N →ₗ[R] P} (hg : Function.Surjective ⇑g),
Function.RightInverse (Function.surjInv hg) ⇑g |
Polynomial.trinomial_leading_coeff' | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {R : Type u_1} [inst : Semiring R] {k m n : ℕ} {u v w : R},
k < m → m < n → (Polynomial.trinomial k m n u v w).coeff n = w |
SemilatSupCat.of.sizeOf_spec | Mathlib.Order.Category.Semilat | ∀ (X : Type u) [isSemilatticeSup : SemilatticeSup X] [isOrderBot : OrderBot X],
sizeOf { X := X, isSemilatticeSup := isSemilatticeSup, isOrderBot := isOrderBot } =
1 + sizeOf X + sizeOf isSemilatticeSup + sizeOf isOrderBot |
AddGroupFilterBasis.instInhabited._proof_1 | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u_1} [inst : AddGroup G] {x y : Set G}, x ∈ {{0}} → y ∈ {{0}} → ∃ z ∈ {{0}}, z ⊆ x ∩ y |
_private.Lean.Elab.Command.0.Lean.Elab.Command.withScope.match_1 | Lean.Elab.Command | (motive : List Lean.Elab.Command.Scope → Sort u_1) →
(x : List Lean.Elab.Command.Scope) →
(Unit → motive []) →
((h : Lean.Elab.Command.Scope) → (t : List Lean.Elab.Command.Scope) → motive (h :: t)) → motive x |
Bool.not_rightInverse | Mathlib.Logic.Equiv.Bool | Function.RightInverse not not |
Polynomial.coeff_ofNat_mul | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {a k : ℕ} [inst_1 : a.AtLeastTwo],
(OfNat.ofNat a * p).coeff k = OfNat.ofNat a * p.coeff k |
AddMonoidHom.fst.eq_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_3) (N : Type u_4) [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoidHom.fst M N = { toFun := Prod.fst, map_zero' := ⋯, map_add' := ⋯ } |
CategoryTheory.NatTrans.retractArrowApp._proof_5 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) {X Y : C}
(h : CategoryTheory.Retract X Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.homMk (F.map h.i) (G.map h.i) ⋯)
(CategoryTheory.Arrow.homMk (F.map h.r) (G.map h.r) ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Arrow.mk (τ.app X)) |
Std.DTreeMap.getKey_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{l : List ((a : α) × β a)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → ∀ {h' : k' ∈ t.insertMany l}, (t.insertMany l).getKey k' h' = k |
Lean.SimplePersistentEnvExtensionDescr.addImportedFn | Lean.EnvExtension | {α σ : Type} → Lean.SimplePersistentEnvExtensionDescr α σ → Array (Array α) → σ |
Fin.insertNthOrderIso_zero | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)],
Fin.insertNthOrderIso α 0 = Fin.consOrderIso α |
CategoryTheory.Functor.mapAction_map_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
{X Y : Action V G} (f : X ⟶ Y), ((F.mapAction G).map f).hom = F.map f.hom |
HomologicalComplex.IsSupported.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : 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'},
(∀ (i' : ι'), (∀ (i : ι), e.f i ≠ i') → K.ExactAt i') → K.IsSupported e |
Prefunctor.symmetrify | Mathlib.Combinatorics.Quiver.Symmetric | {U : Type u_1} →
{V : Type u_2} → [inst : Quiver U] → [inst_1 : Quiver V] → U ⥤q V → Quiver.Symmetrify U ⥤q Quiver.Symmetrify V |
OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge' | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α) (z : β),
(∀ (j i : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z |
Lean.Server.Test.Runner.Client.InfoPopup.mk | Lean.Server.Test.Runner | Option (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
Option (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
Option String → Lean.Server.Test.Runner.Client.InfoPopup |
FreeAddGroup.lift._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β] (f : α → β),
(fun g => ⇑g ∘ FreeAddGroup.of) ((fun f => AddMonoidHom.mk' (Quot.lift (FreeAddGroup.Lift.aux f) ⋯) ⋯) f) = f |
_private.Lean.Parser.Basic.0.Lean.Parser.longestMatchFn._sparseCasesOn_1 | Lean.Parser.Basic | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Left.mul_lt_one' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftMono α] {a b : α}, a < 1 → b < 1 → a * b < 1 |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
[BEq α] →
(annihilator zero : α) →
(op : α → α → α) →
autoParam (∀ (x : α), op x annihilator = zero)
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator._auto_1 →
Lean.Compiler.LCNF.Simp.ConstantFold.Folder |
String.Legacy.Iterator.nextn._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator |
MulHom.ofDense.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_3} {N : Type u_4} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y),
MulHom.ofDense f hs hmul = { toFun := f, map_mul' := ⋯ } |
CategoryTheory.SingleFunctors.instIsIsoFunctorHom | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} (f : F ⟶ G)
[CategoryTheory.IsIso f] (n : A), CategoryTheory.IsIso (f.hom n) |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso._auto_3),
(X.kernelSequenceOpcyclesEIso f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).inv.τ₂ = (X.opcyclesIso f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).hom |
List.Subperm.idxInj._proof_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {xs ys : List α},
xs.Subperm ys → ∀ (i : Fin xs.length), List.idxOfNth xs[↑i] ys (List.countBefore xs[i] xs ↑i) < ys.length |
Lean.SubExpr.GoalsLocation.mk | Lean.SubExpr | Lean.MVarId → Lean.SubExpr.GoalLocation → Lean.SubExpr.GoalsLocation |
Nat.eq_sq_add_sq_iff_eq_sq_mul | Mathlib.NumberTheory.SumTwoSquares | ∀ {n : ℕ}, (∃ x y, n = x ^ 2 + y ^ 2) ↔ ∃ a b, n = a ^ 2 * b ∧ IsSquare (-1) |
Lean.Firefox.SampleUnits.threadCPUDelta._default | Lean.Util.Profiler | String |
ae_lt_of_lt_essInf | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : ConditionallyCompleteLinearOrder β] {x : β} {f : α → β},
x < essInf f μ →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) (MeasureTheory.ae μ) f) ae_lt_of_lt_essInf._auto_1 →
∀ᵐ (y : α) ∂μ, x < f y |
String.contains_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (c : Char), String.Legacy.contains s c = true ↔ c ∈ s.toList |
CategoryTheory.Adjunction.CoreHomEquiv.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{P : Sort u} →
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} →
{homEquiv_naturality_left_symm :
autoParam
(∀ {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
(homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (F.map f) ((homEquiv X Y).symm g))
CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left_symm._autoParam} →
{homEquiv_naturality_right :
autoParam
(∀ {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
(homEquiv X Y') (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp ((homEquiv X Y) f) (G.map g))
CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right._autoParam} →
{homEquiv' : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} →
{homEquiv_naturality_left_symm' :
autoParam
(∀ {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
(homEquiv' X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (F.map f) ((homEquiv' X Y).symm g))
CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left_symm._autoParam} →
{homEquiv_naturality_right' :
autoParam
(∀ {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
(homEquiv' X Y') (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp ((homEquiv' X Y) f) (G.map g))
CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right._autoParam} →
{ homEquiv := homEquiv, homEquiv_naturality_left_symm := homEquiv_naturality_left_symm,
homEquiv_naturality_right := homEquiv_naturality_right } =
{ homEquiv := homEquiv', homEquiv_naturality_left_symm := homEquiv_naturality_left_symm',
homEquiv_naturality_right := homEquiv_naturality_right' } →
(homEquiv ≍ homEquiv' → P) → P |
CompleteLat.casesOn | Mathlib.Order.Category.CompleteLat | {motive : CompleteLat → Sort u} →
(t : CompleteLat) →
((carrier : Type u_1) → [str : CompleteLattice carrier] → motive { carrier := carrier, str := str }) → motive t |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Semiring R] {ι : Type u_3}
(f : ι → MvPowerSeries σ R) (u : Filter ι) (g : MvPowerSeries σ R),
Filter.Tendsto f u (nhds g) =
∀ (d : σ →₀ ℕ), Filter.Tendsto (fun i => (MvPowerSeries.coeff d) (f i)) u (nhds ((MvPowerSeries.coeff d) g)) |
Module.annihilator_eq_bot | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_4} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.annihilator R M = ⊥ ↔ FaithfulSMul R M |
AlgebraicGeometry.LocallyRingedSpace.evaluation_eq_zero_iff_notMem_basicOpen | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) {U : TopologicalSpace.Opens ↑X.toTopCat} (x : ↥U)
(f : ↑(X.presheaf.obj (Opposite.op U))),
(CategoryTheory.ConcreteCategory.hom (X.evaluation x)) f = 0 ↔ ↑x ∉ X.toRingedSpace.basicOpen f |
ModularForm | Mathlib.NumberTheory.ModularForms.Basic | Subgroup (GL (Fin 2) ℝ) → ℤ → Type |
Cardinal.lift_iSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι : Type v} {f : ι → Cardinal.{w}},
BddAbove (Set.range f) → Cardinal.lift.{u, w} (iSup f) = ⨆ i, Cardinal.lift.{u, w} (f i) |
_private.Mathlib.Tactic.NormNum.NatFib.0.Mathlib.Meta.NormNum.proveNatFibAux.match_1 | Mathlib.Tactic.NormNum.NatFib | (en : Q(ℕ)) →
(motive : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'») → Sort u_1) →
(x : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'»)) →
((ea eb : Q(ℕ)) → (H : Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea» «$eb»)) → motive ⟨ea, ⟨eb, H⟩⟩) → motive x |
ConvexCone.instAddCommSemigroup._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (x x_1 x_2 : ConvexCone R M), x + x_1 + x_2 = x + (x_1 + x_2) |
CategoryTheory.BraidedCategory.tensorLeftIsoTensorRight | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] →
(X : C) → CategoryTheory.MonoidalCategory.tensorLeft X ≅ CategoryTheory.MonoidalCategory.tensorRight X |
List.isSome_minOn?_iff | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α},
(List.minOn? f xs).isSome = true ↔ xs ≠ [] |
_private.Lean.Language.Basic.0.Lean.Language.withHeaderExceptions.match_1 | Lean.Language.Basic | {α : Type} →
(motive : Except IO.Error α → Sort u_1) →
(__do_lift : Except IO.Error α) →
((e : IO.Error) → motive (Except.error e)) → ((a : α) → motive (Except.ok a)) → motive __do_lift |
CategoryTheory.MorphismProperty.multiplicativeClosure.below | Mathlib.CategoryTheory.MorphismProperty.Composition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure x → Prop} →
{X Y : C} → {x : X ⟶ Y} → W.multiplicativeClosure x → Prop |
LinearIsometry.isEmbedding | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E₂ : Type u_6} {F : Type u_9} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E₂] [inst_3 : Module R₂ E₂] [inst_4 : NormedAddCommGroup F]
[inst_5 : Module R F] (f : F →ₛₗᵢ[σ₁₂] E₂), Topology.IsEmbedding ⇑f |
Sublocale.carrier.instCompleteLattice._proof_9 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {S : Sublocale X} (s : Set ↥S), IsGLB s (sInf s) |
Std.ExtTreeSet.get!_inter_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, k ∉ t₁ → (t₁ ∩ t₂).get! k = default |
AnalyticOnNhd.is_constant_or_isOpen | Mathlib.Analysis.Complex.OpenMapping | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set E} {g : E → ℂ},
AnalyticOnNhd ℂ g U → IsPreconnected U → (∃ w, ∀ z ∈ U, g z = w) ∨ ∀ s ⊆ U, IsOpen s → IsOpen (g '' s) |
Lean.Elab.Tactic.evalApply._regBuiltin.Lean.Elab.Tactic.evalApply_1 | Lean.Elab.Tactic.ElabTerm | IO Unit |
CochainComplex.HomComplex.Cocycle.isKernel._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m : ℤ) (hm : n + 1 = m) (s : CategoryTheory.Limits.Fork ((K.HomComplex L).d n m) 0),
CategoryTheory.CategoryStruct.comp
((fun s =>
AddCommGrpCat.ofHom
{ toFun := fun x => ⟨(CategoryTheory.ConcreteCategory.hom s.ι) x, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ })
s)
(CategoryTheory.Limits.Fork.ι
(CategoryTheory.Limits.KernelFork.ofι
(AddCommGrpCat.ofHom (CochainComplex.HomComplex.Cocycle.toCochainAddMonoidHom K L n)) ⋯)) =
s.ι |
_private.Init.Data.Format.Basic.0.Std.Format.WorkItem.mk._flat_ctor | Init.Data.Format.Basic | Std.Format → ℤ → ℕ → Std.Format.WorkItem✝ |
CategoryTheory.Localization.Construction.LocQuiver.ctorIdx | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{W : CategoryTheory.MorphismProperty C} → CategoryTheory.Localization.Construction.LocQuiver W → ℕ |
_private.Mathlib.RingTheory.Smooth.AdicCompletion.0.Algebra.FormallySmooth.liftAdicCompletionAux | Mathlib.RingTheory.Smooth.AdicCompletion | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{S : Type u_3} →
[inst_3 : CommRing S] →
[inst_4 : Algebra R S] →
(I : Ideal S) → (A →ₐ[R] S ⧸ I) → [Algebra.FormallySmooth R A] → (m : ℕ) → A →ₐ[R] S ⧸ I ^ m |
CommGroupWithZero.instNormalizedGCDMonoid._proof_9 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] (a b : G₀),
¬(a = 0 ∧ b = 0) → normalize (if a = 0 ∧ b = 0 then 0 else 1) = if a = 0 ∧ b = 0 then 0 else 1 |
_private.Mathlib.Data.Set.Accumulate.0.Set.exists_accumulate_eq_univ_iff_of_directed._proof_1_3 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u_1} {s : ℕ → Set α},
(∀ (n : ℕ), s n ≠ Set.univ) → ∀ (n m : ℕ), Set.accumulate s n ⊆ s m → ¬Set.accumulate s n = Set.univ |
_private.Mathlib.Order.Category.Preord.0.Preord.Hom.mk.injEq | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (hom' hom'_1 : ↑X →o ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) |
LieSubmodule.mk._flat_ctor | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : LieRingModule L M] →
(carrier : Set M) →
(∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) →
0 ∈ carrier →
(∀ (c : R) {x : M}, x ∈ carrier → c • x ∈ carrier) →
(∀ {x : L} {m : M}, m ∈ carrier → ⁅x, m⁆ ∈ carrier) → LieSubmodule R L M |
Int.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Int | IsCompl {n | Even n} {n | Odd n} |
MeasureTheory.L1.SimpleFunc.setToL1SCLM._proof_2 | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T : Set α → E →L[ℝ] F} {C : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C →
∀ (c : ℝ) (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
MeasureTheory.L1.SimpleFunc.setToL1S T (c • f) = c • MeasureTheory.L1.SimpleFunc.setToL1S T f |
CompHausLike.coproductIsColimit._proof_2 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) (s : CategoryTheory.Limits.BinaryCofan X Y),
Continuous (Sum.elim ⇑(CategoryTheory.ConcreteCategory.hom s.inl) ⇑(CategoryTheory.ConcreteCategory.hom s.inr)) |
AffineMap.pi_apply | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V1 : Type u_3} {P1 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : AddTorsor V1 P1]
[inst_3 : Module k V1] {ι : Type u_9} {φv : ι → Type u_10} {φp : ι → Type u_11}
[inst_4 : (i : ι) → AddCommGroup (φv i)] [inst_5 : (i : ι) → Module k (φv i)]
[inst_6 : (i : ι) → AddTorsor (φv i) (φp i)] (fp : (i : ι) → P1 →ᵃ[k] φp i) (c : P1) (i : ι),
(AffineMap.pi fp) c i = (fp i) c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.