name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ProfiniteAddGrp.coe_comp | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y Z : ProfiniteAddGrp.{u_1}} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(ProfiniteAddGrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(ProfiniteAddGrp.Hom.hom g) ∘ ⇑(ProfiniteAddGrp.Hom.hom f) | true |
ContinuousLinearMap.ringInverse_eq_inverse | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_1} {M : Type u_2} [inst : TopologicalSpace M] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], Ring.inverse = ContinuousLinearMap.inverse | true |
Equiv.functionSwap._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ (α : Sort u_1) (β : Sort u_2) (γ : α → β → Sort u_3), Function.RightInverse Function.swap Function.swap | false |
MeasurableEquiv.Set.rangeInr._proof_2 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_2} {β : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β],
Measurable fun x => ⟨Sum.inr x, ⋯⟩ | false |
ENat.add_one_eq_coe_top_iff._simp_1 | Mathlib.Data.ENat.Basic | ∀ {n : WithTop ℕ∞}, (n + 1 = ↑⊤) = (n = ↑⊤) | false |
GroupExtension.Equiv._sizeOf_1 | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
{inst : Group N} →
{inst_1 : Group E} →
{inst_2 : Group G} →
{S : GroupExtension N E G} →
{E' : Type u_4} →
{inst_3 : Group E'} →
{S' : GroupExtension N E' G} → [SizeOf N] → [Size... | false |
Batteries.RBSet.upperBound?_ge | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x y : α} {t : Batteries.RBSet α cmp},
t.upperBound? x = some y → cmp x y ≠ Ordering.gt | true |
Mathlib.Meta.FunProp.LambdaTheorem.mk.noConfusion | Mathlib.Tactic.FunProp.Theorems | {P : Sort u} →
{funPropName thmName : Lean.Name} →
{thmArgs : Mathlib.Meta.FunProp.LambdaTheoremArgs} →
{funPropName' thmName' : Lean.Name} →
{thmArgs' : Mathlib.Meta.FunProp.LambdaTheoremArgs} →
{ funPropName := funPropName, thmName := thmName, thmArgs := thmArgs } =
{ funPr... | false |
CategoryTheory.Functor.preservesHomology_of_map_exact | Mathlib.CategoryTheory.Abelian.Exact | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Abelian A] [inst_3 : CategoryTheory.Abelian B] (L : CategoryTheory.Functor A B)
[inst_4 : L.PreservesZeroMorphisms],
(∀ (S : CategoryTheory.ShortComplex A), S.Exact → (S... | true |
CategoryTheory.Limits.WalkingReflexivePair.Hom.id.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {P : Sort u} →
{X X' : CategoryTheory.Limits.WalkingReflexivePair} →
X = X' →
X = X' →
CategoryTheory.Limits.WalkingReflexivePair.Hom.id X ≍ CategoryTheory.Limits.WalkingReflexivePair.Hom.id X' →
(X = X' → P) → P | false |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.IsMulFreimanHom.prodMap._simp_1_4 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u} {β : Type v} {x y : α × β}, (x = y) = (x.1 = y.1 ∧ x.2 = y.2) | false |
Lean.Meta.Contradiction.Config.searchFuel | Lean.Meta.Tactic.Contradiction | Lean.Meta.Contradiction.Config → ℕ | true |
MagmaCat.recOn | Mathlib.Algebra.Category.Semigrp.Basic | {motive : MagmaCat → Sort u_1} →
(t : MagmaCat) → ((carrier : Type u) → [str : Mul carrier] → motive { carrier := carrier, str := str }) → motive t | false |
comap_subtype_coe_apply | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {_m0 : MeasurableSpace α} {s : Set α},
MeasurableSet s →
∀ (μ : MeasureTheory.Measure α) (t : Set ↑s), (MeasureTheory.Measure.comap Subtype.val μ) t = μ (Subtype.val '' t) | true |
IsGreatest.nonempty | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, IsGreatest s a → s.Nonempty | true |
_private.Mathlib.Data.W.Cardinal.0.WType.cardinalMk_le_of_le'._simp_1_3 | Mathlib.Data.W.Cardinal | ∀ {ι : Type u_2} (f : ι → Type u_1), (Cardinal.sum fun i => Cardinal.mk (f i)) = Cardinal.mk ((i : ι) × f i) | false |
instLawfulOrderLTInt16 | Init.Data.SInt.Lemmas | Std.LawfulOrderLT Int16 | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getLsbD_extractAndExtend_of_lt | Init.Data.BitVec.Bitblast | ∀ {w k v pos : ℕ} {x : BitVec w},
k < v → (BitVec.extractAndExtend v x).getLsbD (pos * v + k) = (BitVec.extractAndExtendBit pos v x).getLsbD k | true |
_private.Init.Data.Int.LemmasAux.0.Int.neg_mul_le_mul._proof_1_5 | Init.Data.Int.LemmasAux | ∀ {x y : ℤ} {s : ℕ} {t : ℕ}, ¬0 ≤ ↑s → False | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to1.tr_respects.match_1_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} [inst : Inhabited Γ] (motive : Turing.TM1.Cfg Γ Λ σ → Prop)
(x : Turing.TM1.Cfg Γ Λ σ),
(∀ (l₁ : Option Λ) (v : σ) (T : Turing.Tape Γ), motive { l := l₁, var := v, Tape := T }) → motive x | false |
Subsemigroup.coe_prod._simp_2 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (s : Subsemigroup M) (t : Subsemigroup N),
↑s ×ˢ ↑t = ↑(s.prod t) | false |
ContinuousLinearMap.ring._proof_4 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : IsTopologicalAddGroup M] (n : ℕ) (a : M →L[R] M),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a | false |
Multiset.filter_nsmul | Mathlib.Algebra.Order.Group.Multiset | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α) (n : ℕ),
Multiset.filter p (n • s) = n • Multiset.filter p s | true |
AlgEquivClass.toRingEquivClass | Mathlib.Algebra.Algebra.Equiv | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Semiring B} {inst_3 : Algebra R A} {inst_4 : Algebra R B} {inst_5 : EquivLike F A B}
[self : AlgEquivClass F R A B], RingEquivClass F A B | true |
CategoryTheory.Limits.biproduct.fromSubtype_eq_lift | 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)] [inst_4 : DecidablePred p],
CategoryTheory.Limit... | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_11 | Lean.Meta.Tactic.FunInd | (motive : Option (Lean.DefinitionVal × Subarray Lean.DefinitionVal) → Sort u_1) →
(x : Option (Lean.DefinitionVal × Subarray Lean.DefinitionVal)) →
(Unit → motive none) →
((info : Lean.DefinitionVal) → (s' : Subarray Lean.DefinitionVal) → motive (some (info, s'))) → motive x | false |
Equiv.Perm.Basis.toCentralizer.eq_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis),
a.toCentralizer = { toFun := fun τ => ⟨a.ofPermHom τ, ⋯⟩, map_one' := ⋯, map_mul' := ⋯ } | true |
CategoryTheory.Bicategory.yoneda₀ | Mathlib.CategoryTheory.Bicategory.Yoneda | {B : Type u} → [inst : CategoryTheory.Bicategory B] → B → CategoryTheory.Pseudofunctor Bᵒᵖ CategoryTheory.Cat | true |
gc_upperClosure_coe | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α],
GaloisConnection (⇑OrderDual.toDual ∘ upperClosure) (SetLike.coe ∘ ⇑OrderDual.ofDual) | true |
SimplexCategory.mkOfLe.match_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | (motive : Fin (1 + 1) → Sort u_1) → (x : Fin (1 + 1)) → (Unit → motive 0) → (Unit → motive 1) → motive x | false |
CategoryTheory.Cat.Hom₂.eqToHom_toNatTrans | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} {F G : C ⟶ D} (h : F = G), (CategoryTheory.eqToHom h).toNatTrans = CategoryTheory.eqToHom ⋯ | true |
Lean.Kernel.Exception.typeExpected.noConfusion | Lean.Environment | {P : Sort u} →
{env : Lean.Kernel.Environment} →
{lctx : Lean.LocalContext} →
{expr : Lean.Expr} →
{env' : Lean.Kernel.Environment} →
{lctx' : Lean.LocalContext} →
{expr' : Lean.Expr} →
Lean.Kernel.Exception.typeExpected env lctx expr = Lean.Kernel.Exception.typeE... | false |
ext_nat | Mathlib.Data.Nat.Cast.Basic | ∀ {R : Type u_3} {F : Type u_5} [inst : NonAssocSemiring R] [inst_1 : FunLike F ℕ R] [RingHomClass F ℕ R] (f g : F),
f = g | true |
SummationFilter.HasSupport.rec | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_2} →
{L : SummationFilter β} →
{motive : L.HasSupport → Sort u} →
((eventually_le_support : ∀ᶠ (s : Finset β) in L.filter, ↑s ⊆ L.support) → motive ⋯) →
(t : L.HasSupport) → motive t | false |
StarSubalgebra.to_cstarRing | Mathlib.Analysis.CStarAlgebra.Basic | ∀ {R : Type u_4} {A : Type u_5} [inst : CommRing R] [inst_1 : StarRing R] [inst_2 : NormedRing A] [inst_3 : StarRing A]
[CStarRing A] [inst_5 : Algebra R A] [inst_6 : StarModule R A] (S : StarSubalgebra R A), CStarRing ↥S | true |
List.wbtw_pair | Mathlib.Analysis.Convex.BetweenList | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] (p₁ p₂ : P), List.Wbtw R [p₁, p₂] | true |
Lean.Language.Lean.LeanProcessingContext.noConfusionType | Lean.Language.Lean | Sort u → Lean.Language.Lean.LeanProcessingContext → Lean.Language.Lean.LeanProcessingContext → Sort u | false |
Function.Embedding.instAddAction | Mathlib.GroupTheory.GroupAction.Embedding | {G : Type u_1} → {α : Type u_3} → {β : Type u_4} → [inst : AddGroup G] → [AddAction G β] → AddAction G (α ↪ β) | true |
CategoryTheory.Limits.Cofork.isColimitCoforkPushoutEquivIsColimitForkUnopPullback._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasPushout f.unop f.unop],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f.unop f.unop).op f.unop.op =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.... | false |
_private.Mathlib.Analysis.SpecialFunctions.Bernstein.0.bernsteinApproximation_uniform._simp_1_12 | Mathlib.Analysis.SpecialFunctions.Bernstein | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c | false |
compare_gt_iff_gt | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, compare a b = Ordering.gt ↔ b < a | true |
Prod.instPartialOrder._proof_1 | Mathlib.Order.Basic | ∀ (α : Type u_1) (β : Type u_2) [inst : PartialOrder α] [inst_1 : PartialOrder β] (x x_1 : α × β),
x ≤ x_1 → x_1 ≤ x → x = x_1 | false |
SimpleGraph.Walk.isChain_adj_cons_support._f | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (x : G.Walk v w)
(f : SimpleGraph.Walk.below (motive := fun {v w} x => ∀ {u : V}, G.Adj u v → List.IsChain G.Adj (u :: x.support)) x)
{u : V}, G.Adj u v → List.IsChain G.Adj (u :: x.support) | false |
SemidirectProduct.rightHom_comp_map | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_4} {G₁ : Type u_5} {N₂ : Type u_6} {G₂ : Type u_7} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} {φ₂ : G₂ →* MulAut N₂} (fn : N₁ →* N₂) (fg : G₁ →* G₂)
(h : ∀ (g : G₁), fn.comp (MulEquiv.toMonoidHom (φ₁ g)) = (MulEquiv.toMonoidHom (φ₂ (fg g))).co... | true |
_private.Mathlib.NumberTheory.Multiplicity.0.padicValNat.pow_add_pow._simp_1_2 | Mathlib.NumberTheory.Multiplicity | ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a b : α},
(0 < a + b) = (0 < a ∨ 0 < b) | false |
intrinsicFrontier_subset_intrinsicClosure | Mathlib.Analysis.Convex.Intrinsic | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] {s : Set P}, intrinsicFrontier 𝕜 s ⊆ intrinsicClosure 𝕜 s | true |
_private.Mathlib.Topology.Order.0.isClosed_iSup_iff._simp_1_1 | Mathlib.Topology.Order | ∀ {α : Type u} {ι : Sort v} {t : ι → TopologicalSpace α} {s : Set α}, IsOpen s = ∀ (i : ι), IsOpen s | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.ExSum.eq._sparseCasesOn_1 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{motive_3 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExSum BaseType sα e → Sort u} →
{e : Q(«$α»)} →
(t : Mathlib.Tactic.Ring.Common.ExSum BaseType sα e) →
motive_3 ... | false |
FixedPoints.subsemiring._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Operations | ∀ (B' : Type u_1) [inst : Semiring B'] (G : Type u_2) [inst_1 : Monoid G] [inst_2 : MulSemiringAction G B'],
0 ∈ (FixedPoints.addSubmonoid G B').carrier | false |
List.Perm.flatten | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List (List α)}, l₁.Perm l₂ → l₁.flatten.Perm l₂.flatten | true |
UV.compress | Mathlib.Combinatorics.SetFamily.Compression.UV | {α : Type u_1} → [inst : GeneralizedBooleanAlgebra α] → [DecidableRel Disjoint] → [DecidableLE α] → α → α → α → α | true |
HahnSeries.«_aux_Mathlib_RingTheory_HahnSeries_Basic___macroRules_HahnSeries_term__⟦_⟧_1» | Mathlib.RingTheory.HahnSeries.Basic | Lean.Macro | false |
Lean.Meta.Grind.Arith.CommRing.MonadSetTermId.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | {m : Type → Type} → Lean.Meta.Grind.Arith.CommRing.MonadSetTermId m → ℕ | false |
ConvexCone.toPreorder._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {G : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup G]
[inst_3 : SMul R G] (C : ConvexCone R G), C.Pointed → ∀ (x : G), x - x ∈ C | false |
CategoryTheory.Square.IsPullback.isLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {sq : CategoryTheory.Square C},
sq.IsPullback → CategoryTheory.CategoryStruct.comp sq.f₁₂ sq.f₂₄ = CategoryTheory.CategoryStruct.comp sq.f₁₃ sq.f₃₄ | false |
Pi.Lex.instCompleteLinearOrderLexForall._proof_14 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] (a b c : Lex ((i : ι) → α i)), a \ b ≤ c ↔ a ≤ max b c | false |
CategoryTheory.Localization.Monoidal.tensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.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] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | true |
Module.IsNoetherian.finite | Mathlib.RingTheory.Noetherian.Basic | ∀ (R : Type u_1) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [IsNoetherian R M],
Module.Finite R M | true |
Std.DTreeMap.Internal.Impl.getKey_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k a : α} {v : β k}
{h₁ : Std.DTreeMap.Internal.Impl.contains a (Std.DTreeMap.Internal.Impl.insert! k v t) = true},
(Std.DTreeMap.Internal.Impl.insert! k v t).getKey a h₁ = if h₂ : compare k a... | true |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk._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]
{𝓕 : TopCat.Presheaf C X} {c : C} (f : 𝓕 ⟶ skyscraperPresheaf p₀ c) (U V : (TopologicalSpace.OpenNhds p₀)ᵒᵖ)
(inc :... | false |
Lean.Meta.Simp.BuiltinSimprocs.noConfusionType | Lean.Meta.Tactic.Simp.Simproc | Sort u → Lean.Meta.Simp.BuiltinSimprocs → Lean.Meta.Simp.BuiltinSimprocs → Sort u | false |
SubringClass.toRing._proof_8 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {S : Type u_2} {R : Type u_1} [inst : Ring R] [inst_1 : SetLike S R] [SubringClass S R], SubsemiringClass S R | false |
MeasurableSpace.mk | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_7} →
(MeasurableSet' : Set α → Prop) →
MeasurableSet' ∅ →
(∀ (s : Set α), MeasurableSet' s → MeasurableSet' sᶜ) →
(∀ (f : ℕ → Set α), (∀ (i : ℕ), MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)) → MeasurableSpace α | true |
Lean.Meta.Grind.SymbolPriorityEntry.noConfusionType | Lean.Meta.Tactic.Grind.EMatchTheorem | Sort u → Lean.Meta.Grind.SymbolPriorityEntry → Lean.Meta.Grind.SymbolPriorityEntry → Sort u | false |
AddSubgroup.mem_addSubgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} {h : ↥K}, h ∈ H.addSubgroupOf K ↔ ↑h ∈ H | true |
Function._aux_Mathlib_Logic_Function_Basic___unexpand_Function_HasUncurry_uncurry_1 | Mathlib.Logic.Function.Basic | Lean.PrettyPrinter.Unexpander | false |
Subsemiring.comap._proof_8 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S)
(s : Subsemiring S), 0 ∈ (AddSubmonoid.comap (↑f) s.toAddSubmonoid).carrier | false |
TopCat.instCategoryPresheaf._proof_8 | Mathlib.Topology.Sheaves.Presheaf | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] (X : TopCat),
autoParam
(∀ {X_1 Y : TopCat.Presheaf C X} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | false |
CategoryTheory.LocalizerMorphism.smallHomMap'_comp | Mathlib.CategoryTheory.Localization.SmallHom | ∀ {C₁ : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C₁] {W₁ : CategoryTheory.MorphismProperty C₁} {C₂ : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₂ : CategoryTheory.MorphismProperty C₂}
(Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {X Y Z : C₁}
[inst_2 : CategoryTheory.Localization.HasSmallLo... | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorShiftTargetBlastRotateRight._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α),
¬aig.decls.size ≤ aig.decls.size → False | false |
Filter.seq_mem_seq | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α → β)} {g : Filter α} {s : Set (α → β)} {t : Set α},
s ∈ f → t ∈ g → s.seq t ∈ f.seq g | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionUnitIso_inv_naturality_assoc | 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.MonoidalLeftAction C D] {d d' : D} (f : d ⟶ d') {Z : D}
(h :
CategoryTheory.MonoidalCategory.Mono... | true |
Pi.isOrderedMonoid | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {Z : ι → Type u_7} [inst : (i : ι) → CommMonoid (Z i)] [inst_1 : (i : ι) → Preorder (Z i)]
[∀ (i : ι), IsOrderedMonoid (Z i)], IsOrderedMonoid ((i : ι) → Z i) | true |
CategoryTheory.Limits.CokernelCofork.isColimitOfIsColimitOfIff'._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.CokernelCofork f} {X' : C} (f' : X' ⟶ Y),
(∀ ⦃W : C⦄ (φ : Y ⟶ W), CategoryTheory.CategoryStruct.comp f φ = 0 ↔ CategoryTheory.CategoryStruct.comp f' φ =... | false |
groupHomology.cyclesOfIsCycle₁_coe | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (x : G →₀ A) (hx : groupHomology.IsCycle₁ x),
↑(groupHomology.cyclesOfIsCycle₁ x hx) = x | true |
TopologicalSpace.Opens.instChartedSpace | Mathlib.Geometry.Manifold.HasGroupoid | {H : Type u} →
{M : Type u_2} →
[inst : TopologicalSpace H] →
[inst_1 : TopologicalSpace M] → [ChartedSpace H M] → (s : TopologicalSpace.Opens M) → ChartedSpace H ↥s | true |
Lean.PersistentEnvExtensionDescrCore.name._autoParam | Lean.Environment | Lean.Syntax | false |
MulArchimedean.recOn | Mathlib.Algebra.Order.Archimedean.Basic | {M : Type u_5} →
[inst : CommMonoid M] →
[inst_1 : PartialOrder M] →
{motive : MulArchimedean M → Sort u} →
(t : MulArchimedean M) → ((arch : ∀ (x : M) {y : M}, 1 < y → ∃ n, x ≤ y ^ n) → motive ⋯) → motive t | false |
_private.Mathlib.MeasureTheory.PiSystem.0.isPiSystem_Ico_mem.match_1_1 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (motive : (Set.Ico a b).Nonempty → Prop) (x : (Set.Ico a b).Nonempty),
(∀ (w : α) (hax : a ≤ w) (hxb : w < b), motive ⋯) → motive x | false |
_private.Init.Data.ULift.0.instSubsingletonULift.match_1 | Init.Data.ULift | ∀ {α : Type u_2} (motive : ULift.{u_1, u_2} α → Prop) (x : ULift.{u_1, u_2} α),
(∀ (b : α), motive { down := b }) → motive x | false |
List.prev_eq_getElem?_idxOf_pred_of_ne_head._f | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {l : List α}
(f : List.below (motive := fun {l} => ∀ (ha : a ∈ l), a ≠ l.head ⋯ → some (l.prev a ha) = l[List.idxOf a l - 1]?) l)
(ha : a ∈ l), a ≠ l.head ⋯ → some (l.prev a ha) = l[List.idxOf a l - 1]? | false |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorArbitraryShiftTargetBlastShiftLeft | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.ArbitraryShiftTarget fun {len} =>
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft | true |
Module.Basis.dualBasis | Mathlib.LinearAlgebra.Dual.Basis | {R : Type uR} →
{M : Type uM} →
{ι : Type uι} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → [DecidableEq ι] → Module.Basis ι R M → [Finite ι] → Module.Basis ι R (Module.Dual R M) | true |
CommRingCat.limitCommRing._proof_19 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt),
a * b * c = ... | false |
Real.differentiableAt_cosh._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {x : ℝ}, DifferentiableAt ℝ Real.cosh x = True | false |
_private.Init.Prelude.0.Nat.lt_or_ge.match_1_5 | Init.Prelude | ∀ (motive : ℕ → Prop) (m : ℕ), (∀ (a : Unit), motive Nat.zero) → (∀ (m : ℕ), motive m.succ) → motive m | false |
LinearOrderedCommMonoidWithZero.toIsOrderedMonoid | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α], IsOrderedMonoid α | true |
RingCat.moduleCatRestrictScalarsPseudofunctor_obj | Mathlib.Algebra.Category.ModuleCat.Pseudofunctor | ∀ (b : CategoryTheory.LocallyDiscrete RingCatᵒᵖ),
RingCat.moduleCatRestrictScalarsPseudofunctor.obj b = CategoryTheory.Cat.of (ModuleCat ↑(Opposite.unop b.as)) | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.eq_4 | Init.Data.String.Decode | ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize✝ ByteArray.utf8DecodeChar?.FirstByte.twoMore = 3 | true |
WithBot.addSemigroup._proof_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u_1} [inst : AddSemigroup α] (a b c : WithBot α), a + b + c = a + (b + c) | false |
Lean.MetavarContext.MkBinding.instToStringException.match_1 | Lean.MetavarContext | (motive : Lean.MetavarContext.MkBinding.Exception → Sort u_1) →
(x : Lean.MetavarContext.MkBinding.Exception) →
((mctx : Lean.MetavarContext) →
(lctx : Lean.LocalContext) →
(toRevert : Array Lean.Expr) →
(varName : String) →
motive (Lean.MetavarContext.MkBinding.Excepti... | false |
CategoryTheory.Limits.IndObjectPresentation.extend_ι_app_app | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type v)}
(P : CategoryTheory.Limits.IndObjectPresentation A) (η : A ⟶ B) [inst_1 : CategoryTheory.IsIso η] (X : P.I)
(X_1 : Cᵒᵖ) (a : ((P.F.comp CategoryTheory.yoneda).obj X).obj X_1),
((P.extend η).ι.app X).app X_1 a = η.... | true |
Array.foldlM.loop._unsafe_rec | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (β → α → m β) → (as : Array α) → (stop : ℕ) → stop ≤ as.size → ℕ → ℕ → β → m β | false |
_private.Mathlib.Topology.Bornology.BoundedOperation.0.instBoundedAddOfLipschitzAdd.match_6 | Mathlib.Topology.Bornology.BoundedOperation | ∀ {R : Type u_1} [inst : AddMonoid R] {s t : Set R} (p : R) (motive : (∃ a b, (a ∈ s ∧ b ∈ t) ∧ a + b = p) → Prop)
(h : ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a + b = p),
(∀ (a b : R) (a_in_s : a ∈ s) (b_in_t : b ∈ t) (eq_p : a + b = p), motive ⋯) → motive h | false |
StarMulEquiv.mk.sizeOf_spec | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_6} {B : Type u_7} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] [inst_4 : SizeOf A]
[inst_5 : SizeOf B] (toMulEquiv : A ≃* B)
(map_star' : ∀ (a : A), toMulEquiv.toFun (star a) = star (toMulEquiv.toFun a)),
sizeOf { toMulEquiv := toMulEquiv, map_star' := map_star' } = 1 + sizeOf... | true |
ContinuousAlternatingMap.isClosed_range_toContinuousMultilinearMap | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {ι : Type u_4} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [inst_7 : IsTopologicalAddGroup F] [ContinuousSMul 𝕜 E] [T2Space F],
... | true |
_private.Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric.0.ordinaryHypergeometricSeries_radius_eq_one._simp_1_7 | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
Std.DTreeMap.Internal.Impl.Const.get?ₘ.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (l : Std.DTreeMap.Internal.Impl α fun x => β) (k : α),
Std.DTreeMap.Internal.Impl.Const.get?ₘ l k =
Std.DTreeMap.Internal.Impl.applyCell k l fun c x => Std.DTreeMap.Internal.Cell.Const.get? c | true |
LinearMap.tensorEqLocus | Mathlib.RingTheory.Flat.Equalizer | {R : Type u_1} →
(S : Type u_2) →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(M : Type u_3) →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : Module S M] →
[inst_6 : IsScalarTower R S M] →... | true |
Std.DTreeMap.Internal.Impl.minKey?_erase_eq_of_not_compare_eq_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α},
(∀ {km : α}, t.minKey? = some km → ¬compare k km = Ordering.eq) →
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey? = t.minKey? | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.