name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.jacobson_eq_top_iff.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} (x : Ideal R) (motive : x ∈ {J | I ≤ J ∧ J.IsMaximal} → Prop)
(x_1 : x ∈ {J | I ≤ J ∧ J.IsMaximal}), (∀ (hij : I ≤ x) (right : x.IsMaximal), motive ⋯) → motive x_1 | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.ctorElim | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Nat.NatOffset✝¹) → ctorIdx = Nat.NatOffset.ctorIdx✝ t → Nat.NatOffset.ctorElimType✝ ctorIdx → motive t | false |
CategoryTheory.Equivalence.counitInv_app_tensor_comp_functor_map_δ_inverse_assoc | 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 : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] (X Y : C) {Z : D}
(h :
e.functor.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj (e.functor.obj X))
(e.inverse.obj (e.functor.obj Y))) ⟶
Z),
CategoryTheory.CategoryStruct.comp
(e.counitInv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.functor.obj X) (e.functor.obj Y)))
(CategoryTheory.CategoryStruct.comp
(e.functor.map (CategoryTheory.Functor.OplaxMonoidal.δ e.inverse (e.functor.obj X) (e.functor.obj Y))) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ e.functor X Y)
(CategoryTheory.CategoryStruct.comp
(e.functor.map (CategoryTheory.MonoidalCategoryStruct.tensorHom (e.unitIso.hom.app X) (e.unitIso.hom.app Y))) h) | true |
Std.DTreeMap.Raw.min?_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Min α] [inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.WF → t.keys.min? = t.minKey? | true |
UpperSet.instAddCommMonoid._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a b : UpperSet α),
a + b = b + a | false |
IntermediateField.subsingleton_of_rank_adjoin_eq_one | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
(∀ (x : E), Module.rank F ↥F⟮x⟯ = 1) → Subsingleton (IntermediateField F E) | true |
Aesop.GoalWithMVars.ctorIdx | Aesop.Script.GoalWithMVars | Aesop.GoalWithMVars → ℕ | false |
AddUnits.leftOfAdd._proof_2 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M), a + b = ↑u → AddCommute a b → b + ↑(-u) + a = 0 | false |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.MulArchimedeanClass.orderHom_injective._simp_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk a = MulArchimedeanClass.mk b) = ((∃ m, |b|ₘ ≤ |a|ₘ ^ m) ∧ ∃ n, |a|ₘ ≤ |b|ₘ ^ n) | false |
Sum.Lex.denselyOrdered_of_noMaxOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMaxOrder α],
DenselyOrdered (Lex (α ⊕ β)) | true |
Lean.Lsp.FileChangeType._sizeOf_inst | Lean.Data.Lsp.Workspace | SizeOf Lean.Lsp.FileChangeType | false |
OrderAddMonoidHom.addCommute_inl_inr | Mathlib.Algebra.Order.Monoid.Lex | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (m : α) (n : β), AddCommute ((OrderAddMonoidHom.inl α β) m) ((OrderAddMonoidHom.inr α β) n) | true |
Subgroup.transferFocal.quotientKerMulEquivQuotientFocalSubroupOf._proof_1 | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} (P : Sylow p G), (↑P).focalSubgroupOf.Normal | false |
Std.DHashMap.Raw.getKey?_insert_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k | true |
sup_sdiff | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a ⊔ b) \ c = a \ c ⊔ b \ c | true |
Lean.Lsp.CompletionItemKind.enumMember | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItemKind | true |
Lean.Server.References.removeWorkerRefs | Lean.Server.References | Lean.Server.References → Lean.Name → Lean.Server.References | true |
_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) | false |
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 := ⋯ } | true |
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)) | true |
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 | true |
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‖ | true |
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 β | true |
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 | true |
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 | true |
Std.Time.Formats.leanDateTimeWithIdentifierAndNanos | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | true |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
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 | true |
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 | false |
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 | true |
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 | false |
_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 | false |
Ordinal.pred_le_self | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o.pred ≤ o | true |
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 | true |
Semiquot.mem_pure._simp_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) | false |
Ordnode.Valid'.rotateL_lemma₁ | Mathlib.Data.Ordmap.Ordset | ∀ {a b c : ℕ}, 3 * a ≤ b + c → c ≤ 3 * b → a ≤ 3 * b | true |
_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 | false |
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 | false |
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 | true |
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.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom (groupHomology.map f φ 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H0π A)) x) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.H0π B)) ((Rep.Hom.hom φ) x) | true |
MessageType.log.elim | Lean.Data.Lsp.Window | {motive : MessageType → Sort u} → (t : MessageType) → t.ctorIdx = 3 → motive MessageType.log → motive t | false |
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 | true |
_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 | false |
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 | true |
_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 | false |
_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 | false |
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 | true |
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) →+ γ | true |
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 := ⋯ } | false |
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) | true |
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 | false |
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) | true |
Order.Ideal.PrimePair.I_isPrime | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), IF.I.IsPrime | true |
_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 | false |
ENat.WithBot.add_le_add_one_left_iff | Mathlib.Data.ENat.Basic | ∀ {a b : WithBot ℕ∞}, 1 + a ≤ 1 + b ↔ a ≤ b | true |
_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) | false |
Pi.mulZeroOneClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), a * 1 = a | false |
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 | true |
CommBialgCat.Hom | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → [inst : CommRing R] → CommBialgCat R → CommBialgCat R → Type v | true |
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) | true |
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)))
⋯)
⋯ | true |
Action.diagonalOneIsoLeftRegular | Mathlib.CategoryTheory.Action.Concrete | (G : Type u_1) → [inst : Monoid G] → Action.diagonal G 1 ≅ Action.leftRegular G | true |
Int.le_iff_lt_or_eq | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b ↔ a < b ∨ a = b | true |
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) | true |
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') → ℕ | false |
Lean.Elab.AutoBoundImplicitContext.mk | Lean.Elab.AutoBound | Bool → Lean.PArray Lean.Expr → Lean.Elab.AutoBoundImplicitContext | true |
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) | true |
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) | true |
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 | false |
_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 | false |
_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) | false |
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 | false |
ZNum.decidableLT | Mathlib.Data.Num.Basic | DecidableLT ZNum | true |
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 | true |
_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 | false |
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) | true |
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 | true |
NonUnitalNonAssocRing.toHasDistribNeg._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : α), - -a = a | false |
FundamentalGroupoid.instSubsingletonHomPUnit | Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit | ∀ {x y : FundamentalGroupoid PUnit.{u_1 + 1}}, Subsingleton (x ⟶ y) | true |
_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) | false |
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 | true |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.coverMincard_le_netMaxcard._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
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) | true |
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' | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_le._proof_1_1 | Init.Data.BitVec.Lemmas | ¬1 < 2 → False | false |
Lean.StructureDescr.fields | Lean.Structure | Lean.StructureDescr → Array Lean.StructureFieldInfo | true |
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 | true |
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 | true |
_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 | true |
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 | true |
_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 ⋯ | false |
_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 | false |
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 | true |
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 | true |
_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 | false |
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' | false |
TopologicalSpace.instWellFoundedLTClosedsOfNoetherianSpace | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α],
WellFoundedLT (TopologicalSpace.Closeds α) | true |
Finset.erase_val | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), (s.erase a).val = s.val.erase a | true |
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 α | false |
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 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.