name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Lsp.CompletionItemKind.enumMember | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItemKind |
Lean.Server.References.removeWorkerRefs | Lean.Server.References | Lean.Server.References → Lean.Name → Lean.Server.References |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo._simp_1_6 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) |
AddOpposite.instSubtractionMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubtractionMonoid α],
AddOpposite.instSubtractionMonoid =
{ toSubNegMonoid := AddOpposite.instSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } |
CategoryTheory.Functor.OplaxMonoidal.comp_δ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_6 : F.OplaxMonoidal]
[inst_7 : G.OplaxMonoidal] (X Y : C),
CategoryTheory.Functor.OplaxMonoidal.δ (F.comp G) X Y =
CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Functor.OplaxMonoidal.δ F X Y))
(CategoryTheory.Functor.OplaxMonoidal.δ G (F.obj X) (F.obj Y)) |
Algebra.QuasiFinite.iff_finite_primesOver | Mathlib.RingTheory.QuasiFinite.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S], Algebra.QuasiFinite R S ↔ ∀ (I : Ideal R), I.IsPrime → (I.primesOver S).Finite |
dist_vadd_left | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (v : V) (x : P), dist (v +ᵥ x) x = ‖v‖ |
TopologicalSpace.CompactOpens.map | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : α → β) → Continuous f → IsOpenMap f → TopologicalSpace.CompactOpens α → TopologicalSpace.CompactOpens β |
InfiniteGalois.isOpen_and_normal_iff_finite_and_isGalois | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (L : IntermediateField k K)
[IsGalois k K], IsOpen L.fixingSubgroup.carrier ∧ L.fixingSubgroup.Normal ↔ FiniteDimensional k ↥L ∧ IsGalois k ↥L |
IsPrimitiveRoot.adjoinEquivRingOfIntegers_apply | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n) (a : ↥(Algebra.adjoin ℤ {ζ})),
hζ.adjoinEquivRingOfIntegers a = (IsIntegralClosure.lift ℤ (NumberField.RingOfIntegers K) K) a |
Std.Time.Formats.leanDateTimeWithIdentifierAndNanos | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax |
PartENat.lt_coe_iff | Mathlib.Data.Nat.PartENat | ∀ (x : PartENat) (n : ℕ), x < ↑n ↔ ∃ (h : x.Dom), x.get h < n |
Std.DHashMap.Raw.size_alter_eq_sub_one | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option (β k) → Option (β k)},
m.WF → k ∈ m → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1 |
Subtype.impEmbedding._proof_1 | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} (p q : α → Prop) (h : ∀ (x : α), p x → q x) (x y : { x // p x }),
(fun x => ⟨↑x, ⋯⟩) x = (fun x => ⟨↑x, ⋯⟩) y → x = y |
EquivLike.pairwise_comp_iff | Mathlib.Logic.Equiv.Pairwise | ∀ {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [inst : EquivLike F Y X] (f : F) (p : X → X → Prop),
Pairwise (Function.onFun p ⇑f) ↔ Pairwise p |
ContinuousMapZero.toContinuousMapHom._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R], ↑0 = ↑0 |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.PreZeroHypercover.Hom.ext'_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} {f g : E.Hom F}
(motive :
(∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) →
Prop)
(x :
∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)),
(∀ (hs : f.s₀ = g.s₀)
(hh : ∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)), motive ⋯) →
motive x |
Ordinal.pred_le_self | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o.pred ≤ o |
Squarefree.moebius_eq | Mathlib.RingTheory.UniqueFactorizationDomain.Moebius | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
Squarefree a → UniqueFactorizationMonoid.moebius a = (-1) ^ (UniqueFactorizationMonoid.factors a).card |
Semiquot.mem_pure._simp_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) |
Ordnode.Valid'.rotateL_lemma₁ | Mathlib.Data.Ordmap.Ordset | ∀ {a b c : ℕ}, 3 * a ≤ b + c → c ≤ 3 * b → a ≤ 3 * b |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_5 | Lean.Meta.Tactic.Grind.PropagateInj | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
PNat.find_eq_one._simp_1 | Mathlib.Data.PNat.Find | ∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (PNat.find h = 1) = p 1 |
Polynomial.eval₂_homogenize_of_eq_one | Mathlib.Algebra.Polynomial.Homogenize | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] {p : Polynomial R} {n : ℕ},
p.natDegree ≤ n →
∀ (f : R →+* S) (g : Fin 2 → S), g 1 = 1 → MvPolynomial.eval₂ f g (p.homogenize n) = Polynomial.eval₂ f (g 0) p |
groupHomology.H0π_comp_map_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep k G} {B : Rep k H} (f : G →* H)
(φ : A ⟶ (Action.res (ModuleCat k) f).obj B) (x : ↑A.V),
(CategoryTheory.ConcreteCategory.hom (groupHomology.map f φ 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H0π A)) x) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.H0π B)) ((CategoryTheory.ConcreteCategory.hom φ.hom) x) |
MessageType.log.elim | Lean.Data.Lsp.Window | {motive : MessageType → Sort u} → (t : MessageType) → t.ctorIdx = 3 → motive MessageType.log → motive t |
Std.DHashMap.Internal.Raw₀.getKeyD_insertMany_emptyWithCapacity_list_of_contains_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k fallback : α},
(List.map Sigma.fst l).contains k = false →
(↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertMany l)).getKeyD k fallback = fallback |
_private.Mathlib.Algebra.Order.Group.Unbundled.Int.0.Int.ediv_eq_zero_of_lt_abs.match_1_1 | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ {a : ℤ} (motive : (b x : ℤ) → x = ↑b.natAbs → a < x → Prop) (b x : ℤ) (x_1 : x = ↑b.natAbs) (H2 : a < x),
(∀ (n : ℕ) (H2 : a < ↑(↑n).natAbs), motive (Int.ofNat n) ↑(↑n).natAbs ⋯ H2) →
(∀ (n : ℕ) (H2 : a < ↑(Int.negSucc n).natAbs), motive (Int.negSucc n) ↑(Int.negSucc n).natAbs ⋯ H2) →
motive b x x_1 H2 |
AddSubmonoid.coe_multiset_sum | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset ↥S),
↑m.sum = (Multiset.map Subtype.val m).sum |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Basic.0.irreducible_iff_prime_of_existsUnique_irreducible_factors.match_1_3 | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (p : α) (fa fb : Multiset α)
(motive : (∃ b ∈ fa + fb, Associated p b) → Prop) (x : ∃ b ∈ fa + fb, Associated p b),
(∀ (q : α) (hqf : q ∈ fa + fb) (hq : Associated p q), motive ⋯) → motive x |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser._aux_Aesop_Frontend_Command___elabRules_Aesop_Frontend_Parser_addRules_1.match_1 | Aesop.Frontend.Command | (motive : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName → Sort u_1) →
(x : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName) →
((rule : Aesop.GlobalRuleSetMember) → (rsNames : Array Aesop.RuleSetName) → motive (rule, rsNames)) → motive x |
CategoryTheory.ObjectProperty.IsStrongGenerator.isDense_colimitsCardinalClosure_ι | Mathlib.CategoryTheory.Presentable.StrongGenerator | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
{P : CategoryTheory.ObjectProperty C} [CategoryTheory.ObjectProperty.Small.{w, v, u} P],
P.IsStrongGenerator → P ≤ CategoryTheory.isCardinalPresentable C κ → (P.colimitsCardinalClosure κ).ι.IsDense |
MvPolynomial.smulCommClass | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring S₂] [inst_1 : SMulZeroClass R S₂]
[inst_2 : SMulZeroClass S₁ S₂] [SMulCommClass R S₁ S₂], SMulCommClass R S₁ (MvPolynomial σ S₂) |
DirectSum.toAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (DirectSum ι fun i => β i) →+ γ |
CategoryTheory.Limits.isTerminalEquivUnique._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C),
Function.LeftInverse (fun u => { lift := fun s => default, fac := ⋯, uniq := ⋯ }) fun t X =>
{
default :=
t.lift
{ pt := X,
π := { app := fun X_1 => id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim), naturality := ⋯ } },
uniq := ⋯ } |
Sigma.Lex.boundedOrder | Mathlib.Data.Sigma.Order | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : PartialOrder ι] →
[inst_1 : BoundedOrder ι] →
[inst_2 : (i : ι) → Preorder (α i)] → [OrderBot (α ⊥)] → [OrderTop (α ⊤)] → BoundedOrder (Σₗ (i : ι), α i) |
Representation.finsuppLEquivFreeAsModule._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Monoid G] (α : Type u_3),
Function.LeftInverse (AddEquiv.refl (α →₀ MonoidAlgebra k G)).invFun (AddEquiv.refl (α →₀ MonoidAlgebra k G)).toFun |
Std.DTreeMap.Internal.Cell.ofOption | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → Option (β k) → Std.DTreeMap.Internal.Cell α β (compare k) |
Order.Ideal.PrimePair.I_isPrime | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), IF.I.IsPrime |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_linearEquiv_eq_graph._simp_1_2 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x |
ENat.WithBot.add_le_add_one_left_iff | Mathlib.Data.ENat.Basic | ∀ {a b : WithBot ℕ∞}, 1 + a ≤ 1 + b ↔ a ≤ b |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
Pi.mulZeroOneClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), a * 1 = a |
IsStronglyTranscendental.iff_of_isLocalization | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] {M : Submonoid S},
M ≤ nonZeroDivisors S →
∀ [IsLocalization M T] [IsScalarTower R S T] {x : S},
IsStronglyTranscendental R ((algebraMap S T) x) ↔ IsStronglyTranscendental R x |
CommBialgCat.Hom | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → [inst : CommRing R] → CommBialgCat R → CommBialgCat R → Type v |
CategoryTheory.MonoidalCategory.MonoidalRightAction.hom_inv_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {x y : D} (f : x ≅ y) (z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f.hom z)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f.inv z) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj x z) |
CategoryTheory.InjectiveResolution.extMk_hom | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y)
[inst_3 : HasDerivedCategory C] {n : ℕ} (f : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f (R.cocomplex.d n m) = 0),
(R.extMk f m hm hf).hom =
(CategoryTheory.ShiftedHom.mk₀ 0 ⋯ ((DerivedCategory.singleFunctorIsoCompQ C 0).hom.app X)).comp
((CategoryTheory.ShiftedHom.map
(CochainComplex.HomComplex.Cocycle.equivHomShift.symm
(CochainComplex.HomComplex.Cocycle.fromSingleMk
(CategoryTheory.CategoryStruct.comp f (R.cochainComplexXIso (↑n) n ⋯).inv) ⋯ ↑m ⋯ ⋯))
DerivedCategory.Q).comp
(CategoryTheory.ShiftedHom.mk₀ 0 ⋯
(CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (DerivedCategory.Q.map R.ι'))
((DerivedCategory.singleFunctorIsoCompQ C 0).inv.app Y)))
⋯)
⋯ |
Action.diagonalOneIsoLeftRegular | Mathlib.CategoryTheory.Action.Concrete | (G : Type u_1) → [inst : Monoid G] → Action.diagonal G 1 ≅ Action.leftRegular G |
Int.le_iff_lt_or_eq | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b ↔ a < b ∨ a = b |
CategoryTheory.Idempotents.instIsIdempotentCompleteCosimplicialObject | Mathlib.CategoryTheory.Idempotents.SimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsIdempotentComplete C],
CategoryTheory.IsIdempotentComplete (CategoryTheory.CosimplicialObject C) |
LieHom._sizeOf_1 | Mathlib.Algebra.Lie.Basic | {R : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : LieRing L'} →
{inst_4 : LieAlgebra R L'} → [SizeOf R] → [SizeOf L] → [SizeOf L'] → (L →ₗ⁅R⁆ L') → ℕ |
Lean.Elab.AutoBoundImplicitContext.mk | Lean.Elab.AutoBound | Bool → Lean.PArray Lean.Expr → Lean.Elab.AutoBoundImplicitContext |
Vector.zipWith_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {α_1 : Type u_3} {f : α → β → α_1} {a : α} {b : β} {n : ℕ},
Vector.zipWith f (Vector.replicate n a) (Vector.replicate n b) = Vector.replicate n (f a b) |
IsSelfAdjoint.conjugate' | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Semigroup R] [inst_1 : StarMul R] {x : R},
IsSelfAdjoint x → ∀ (z : R), IsSelfAdjoint (star z * x * z) |
Int.reduceNe._regBuiltin.Int.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.625502844._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.noConfusionType | Lean.Meta.Tactic.Grind.MBTC | Sort u → Lean.Meta.Grind.Key✝ → Lean.Meta.Grind.Key✝ → Sort u |
_private.Mathlib.RingTheory.Unramified.Locus.0.Algebra.unramifiedLocus_eq_compl_support._simp_1_2 | Mathlib.RingTheory.Unramified.Locus | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∉ Module.support R M) = Subsingleton (LocalizedModule p.asIdeal.primeCompl M) |
String.Pos.Raw.instLinearOrderPackage._proof_1 | Init.Data.String.OrderInstances | let this := inferInstance;
let this_1 :=
let this := inferInstance;
inferInstance;
∀ (a b : String.Pos.Raw), a < b ↔ a ≤ b ∧ ¬b ≤ a |
ZNum.decidableLT | Mathlib.Data.Num.Basic | DecidableLT ZNum |
CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r)
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))),
CategoryTheory.CategoryStruct.comp (X.mapIso (CompHausLike.LocallyConstant.sigmaIso r).op).hom
(CategoryTheory.CategoryStruct.comp
(CompHausLike.sigmaComparison X fun a => ↑(CompHausLike.LocallyConstant.fiber r a).toTop) fun g => g a) =
X.map (CompHausLike.LocallyConstant.sigmaIncl r a).op |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift |
Array.range'_append_1 | Init.Data.Array.Range | ∀ {s m n : ℕ}, Array.range' s m ++ Array.range' (s + m) n = Array.range' s (m + n) |
Finset.prod_prod_Ioi_mul_eq_prod_prod_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∏ i, ∏ j ∈ Finset.Ioi i, f j i * f i j = ∏ i, ∏ j ∈ {i}ᶜ, f j i |
NonUnitalNonAssocRing.toHasDistribNeg._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : α), - -a = a |
FundamentalGroupoid.instSubsingletonHomPUnit | Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit | ∀ {x y : FundamentalGroupoid PUnit.{u_1 + 1}}, Subsingleton (x ⟶ y) |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.Monotone.tendsto_le_alternating_series._simp_1_2 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a - c ≤ b) = (a ≤ b + c) |
Submonoid.LocalizationMap.mulEquivOfMulEquiv | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{T : Submonoid P} →
{Q : Type u_4} →
[inst_3 : CommMonoid Q] →
T.LocalizationMap Q → {j : M ≃* P} → Submonoid.map j.toMonoidHom S = T → N ≃* Q |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.coverMincard_le_netMaxcard._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) |
Submodule.finiteDimensional_iSup | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule K V) [∀ (i : ι), FiniteDimensional K ↥(S i)], FiniteDimensional K ↥(⨆ i, S i) |
LieSubmodule.ext | 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] (N N' : LieSubmodule R L M), (∀ (m : M), m ∈ N ↔ m ∈ N') → N = N' |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_le._proof_1_1 | Init.Data.BitVec.Lemmas | ¬1 < 2 → False |
Lean.StructureDescr.fields | Lean.Structure | Lean.StructureDescr → Array Lean.StructureFieldInfo |
FirstOrder.Language.DirectLimit.inductionOn | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
{f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)} [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι]
{C : FirstOrder.Language.DirectLimit G f → Prop} (z : FirstOrder.Language.DirectLimit G f),
(∀ (i : ι) (x : G i), C ((FirstOrder.Language.DirectLimit.of L ι G f i) x)) → C z |
mul_mem_ball_iff_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedCommGroup E] {a b : E} {r : ℝ}, a * b ∈ Metric.ball a r ↔ ‖b‖ < r |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.instDecidableEqIterator.decEq.match_1.splitter | Batteries.Data.String.Lemmas | (motive : String.Legacy.Iterator → String.Legacy.Iterator → Sort u_1) →
(x x_1 : String.Legacy.Iterator) →
((a : String) →
(a_1 : String.Pos.Raw) →
(b : String) → (b_1 : String.Pos.Raw) → motive { s := a, i := a_1 } { s := b, i := b_1 }) →
motive x x_1 |
CategoryTheory.Limits.Types.TypeMax.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type (max v u))) → CategoryTheory.Limits.Cocone F |
_private.Std.Data.Iterators.Lemmas.Equivalence.HetT.0.Std.Iterators.HetT.pmap_map._simp_1_1 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms._regBuiltin._private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms_1 | Lean.Elab.Tactic.Grind.ShowState | IO Unit |
CategoryTheory.Localization.inverts | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [L.IsLocalization W], W.IsInvertedBy L |
Set.iUnion₂_inter | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_8} (s : (i : ι) → κ i → Set α) (t : Set α),
(⋃ i, ⋃ j, s i j) ∩ t = ⋃ i, ⋃ j, s i j ∩ t |
_private.Mathlib.Order.WithBot.0.WithBot.noMaxOrder.match_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α) (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (b : α) (hba : a < b), motive ⋯) → motive x |
CategoryTheory.Functor.OplaxRightLinear.noConfusion | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {P : Sort u} →
{D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{inst_3 : CategoryTheory.MonoidalCategory C} →
{inst_4 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D} →
{inst_5 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D'} →
{t : F.OplaxRightLinear C} →
{D'_1 : Type u_1} →
{D'' : Type u_2} →
{inst' : CategoryTheory.Category.{v_1, u_1} D'_1} →
{inst'_1 : CategoryTheory.Category.{v_2, u_2} D''} →
{F' : CategoryTheory.Functor D'_1 D''} →
{C' : Type u_3} →
{inst'_2 : CategoryTheory.Category.{v_3, u_3} C'} →
{inst'_3 : CategoryTheory.MonoidalCategory C'} →
{inst'_4 : CategoryTheory.MonoidalCategory.MonoidalRightAction C' D'_1} →
{inst'_5 : CategoryTheory.MonoidalCategory.MonoidalRightAction C' D''} →
{t' : F'.OplaxRightLinear C'} →
D = D'_1 →
D' = D'' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
F ≍ F' →
C = C' →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 →
t ≍ t' →
CategoryTheory.Functor.OplaxRightLinear.noConfusionType
P t t' |
TopologicalSpace.instWellFoundedLTClosedsOfNoetherianSpace | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α],
WellFoundedLT (TopologicalSpace.Closeds α) |
Finset.erase_val | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), (s.erase a).val = s.val.erase a |
BddDistLat.Iso.mk._proof_3 | Mathlib.Order.Category.BddDistLat | ∀ {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat),
CategoryTheory.CategoryStruct.comp
(BddDistLat.ofHom
(let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }))
(BddDistLat.ofHom
(let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
{ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })) =
CategoryTheory.CategoryStruct.id α |
SimpleGraph.Walk.ofBoxProdLeft._proof_2 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {H : SimpleGraph β} {x : α × β} (v : α × β), H.Adj x.2 v.2 ∧ x.1 = v.1 → v.1 = x.1 |
List.isEqv.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x : α → α → Bool) (a : α) (as : List α) (b : α) (bs : List α),
(a :: as).isEqv (b :: bs) x = (x a b && as.isEqv bs x) |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.instHashableKey.hash.match_1 | Lean.Meta.Tactic.Grind.MBTC | (motive : Lean.Meta.Grind.Key✝ → Sort u_1) →
(x : Lean.Meta.Grind.Key✝¹) → ((a : Lean.Expr) → motive { mask := a }) → motive x |
AffineBasis.instInhabitedPUnit._proof_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {k : Type u_2} [inst : Ring k], affineSpan k (Set.range id) = ⊤ |
CategoryTheory.Abelian.im | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C |
MonoidHom.exists_nhds_isBounded | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
[IsTopologicalGroup G] [BorelSpace G] [LocallyCompactSpace G] [inst_6 : MeasurableSpace H]
[inst_7 : SeminormedGroup H] [OpensMeasurableSpace H] (f : G →* H),
Measurable ⇑f → ∀ (x : G), ∃ s ∈ nhds x, Bornology.IsBounded (⇑f '' s) |
QuotientGroup.equivQuotientZPowOfEquiv_symm | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : CommGroup A] [inst_1 : CommGroup B] (e : A ≃* B) (n : ℤ),
(QuotientGroup.equivQuotientZPowOfEquiv e n).symm = QuotientGroup.equivQuotientZPowOfEquiv e.symm n |
Lean.Lsp.RpcConnected.casesOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.RpcConnected → Sort u} →
(t : Lean.Lsp.RpcConnected) → ((sessionId : UInt64) → motive { sessionId := sessionId }) → motive t |
Measure.eq_prod_of_integral_prod_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {ι : Type u_1} {T : Type u_4} {X : ι → Type u_5} {mX : (i : ι) → MeasurableSpace (X i)}
[inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), BorelSpace (X i)] [∀ (i : ι), HasOuterApproxClosed (X i)]
{mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T] [HasOuterApproxClosed T] [inst_6 : Fintype ι]
{μ : MeasureTheory.Measure ((i : ι) → X i)} {ν : MeasureTheory.Measure T}
{ξ : MeasureTheory.Measure (((i : ι) → X i) × T)} [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
[MeasureTheory.IsFiniteMeasure ξ],
(∀ (f : (i : ι) → BoundedContinuousFunction (X i) ℝ) (g : BoundedContinuousFunction T ℝ),
∫ (p : ((i : ι) → X i) × T), (∏ i, (f i) (p.1 i)) * g p.2 ∂ξ =
(∫ (x : (i : ι) → X i), ∏ i, (f i) (x i) ∂μ) * ∫ (t : T), g t ∂ν) →
ξ = μ.prod ν |
IsApproximateSubgroup.subgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {S : Type u_2} [inst_1 : SetLike S G] [SubgroupClass S G] {H : S},
IsApproximateSubgroup 1 ↑H |
HomotopicalAlgebra.FibrantObject.HoCat.ιCompResolutionNatTrans._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.FibrantObject C) (f : x ⟶ x_1),
HomotopicalAlgebra.FibrantObject.toHoCat.map
(CategoryTheory.CategoryStruct.comp f
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iResolutionObj (HomotopicalAlgebra.FibrantObject.ι.obj x_1) }) =
HomotopicalAlgebra.FibrantObject.toHoCat.map
(CategoryTheory.CategoryStruct.comp
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iResolutionObj (HomotopicalAlgebra.FibrantObject.ι.obj x) }
(HomotopicalAlgebra.FibrantObject.homMk
(HomotopicalAlgebra.FibrantObject.HoCat.resolutionMap (HomotopicalAlgebra.FibrantObject.ι.map f)))) |
symmetrizeRel_subset_self | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (V : SetRel α α), symmetrizeRel V ⊆ V |
Sylow.mulEquivIteratedWreathProduct._proof_3 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (n : ℕ) (G : Type u_1) [Finite G], Finite (Fin n → G) |
LocallyFiniteOrder.toLocallyFiniteOrderBot._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α] [inst_2 : LocallyFiniteOrder α] (a x : α),
x ∈ Finset.Ico ⊥ a ↔ x < a |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.